The agent that grows with you
Python aiai-agentai-agentsanthropicchatgptclaudeclaude-codecodexhermeshermes-agentllmnous-researchopenai
import type { LoopSnapshot, SessionControlSnapshot } from '@hermes/shared/gateway-events'
import { useStore } from '@nanostores/react'
import { atom } from 'nanostores'
import { useEffect, useState } from 'react'
import { applyGoalSnapshot } from './goalStatus.js'
import { $uiState } from './uiStore.js'
// The session's standing /loop, as `session.control.read` / `session.control.update` report it.
// The gateway publishes on set/pause/resume/stop, when a wakeup fires and when it completes, so the
// snapshot's `next_due_at` is always the live anchor; the countdown itself is computed here.
export const $loopSnapshot = atom<{ loop: LoopSnapshot | null; sid: string | null }>({ loop: null, sid: null })
export function applyLoopSnapshot(sid: string | null, loop: LoopSnapshot | null = null) {
const previous = $loopSnapshot.get()
if (previous.sid !== sid || JSON.stringify(previous.loop) !== JSON.stringify(loop)) {
$loopSnapshot.set({ loop, sid })
}
}
/** Both bars' state from one `session.control.read` / `session.control.update` payload. */
export function applyControlSnapshot(sid: string | null, control?: null | SessionControlSnapshot) {
applyGoalSnapshot(sid, control?.goal ?? null)
applyLoopSnapshot(sid, control?.loop ?? null)
}
export interface LoopLine {
detail: string
glyph: string
label: string
prompt: string
}
/** Rounded UP: whole minutes (`1h05m`, `44m`) until the last minute, then seconds. Minute steps keep
* an idle TUI to one repaint a minute for a long wait. */
export function countdown(seconds: number): string {
const left = Math.max(0, Math.ceil(seconds))
if (left < 60) {
return `${left}s`
}
const minutes = Math.ceil(left / 60)
const hours = Math.floor(minutes / 60)
return hours ? `${hours}h${String(minutes % 60).padStart(2, '0')}m` : `${minutes}m`
}
const cadence = (loop: LoopSnapshot) => {
if (loop.mode === 'self_paced') {
return 'self-paced'
}
const s = loop.interval_seconds
const every = s % 3600 === 0 ? `${s / 3600}h` : s % 60 === 0 ? `${s / 60}m` : `${s}s`
return `every ${every}`
}
/** `↻ loop · every 45m · 2 runs · next in 44m` for an active loop, `⏸ loop paused` with its reason
* while held, `null` once it is done or cleared (the transcript carries the verdict). */
export function loopLine(loop: LoopSnapshot | null, nowMs = Date.now()): LoopLine | null {
if (!loop || (loop.status !== 'active' && loop.status !== 'paused')) {
return null
}
const runs = loop.times
? `${loop.ticks_fired}/${loop.times} runs`
: `${loop.ticks_fired} run${loop.ticks_fired === 1 ? '' : 's'}`
if (loop.status === 'paused') {
const reason = loop.paused_reason ? `${loop.paused_reason} · ` : ''
return { detail: `${reason}${runs}`, glyph: '⏸', label: 'loop paused', prompt: loop.prompt }
}
const remaining = loop.next_due_at - nowMs / 1000
const when = loop.awaiting_response
? 'running now'
: loop.deferred_by_goal
? 'deferred to the goal'
: remaining > 0
? `next in ${countdown(remaining)}`
: 'due, waiting for idle'
return { detail: `${cadence(loop)} · ${runs} · ${when}`, glyph: '↻', label: 'loop', prompt: loop.prompt }
}
/** The current session's loop line, re-derived every second while a countdown is showing. `loopLine`
* only changes text at minute steps (seconds in the last one), and React drops identical strings, so
* the bar repaints at that rate, not every second. */
export function useLoopLine(): LoopLine | null {
const snapshot = useStore($loopSnapshot)
const { sid } = useStore($uiState)
const loop = snapshot.sid === sid ? snapshot.loop : null
const ticking = loop?.status === 'active' && !loop.awaiting_response
const [line, setLine] = useState(() => loopLine(loop))
useEffect(() => {
const update = () =>
setLine(previous => {
const next = loopLine(loop)
return JSON.stringify(previous) === JSON.stringify(next) ? previous : next
})
update()
if (!ticking) {
return
}
const timer = setInterval(update, 1000)
return () => clearInterval(timer)
}, [loop, ticking])
return line
}