@gotcos/glasses-server 6.47.0 → 6.48.1

package/server/lib/thread-turn-queue-store.ts

@@ -13,11 +13,17 @@ import { closeSync, constants, existsSync, fstatSync, mkdirSync, openSync, readd
 import { join } from 'node:path'
 import { atomicWriteFileSync } from './atomic-fs.js'
 import { dataPath } from './data-dir.js'
-import { draftsFromLine, type SessionStreamProvider } from './session-stream-events.js'
+import { turnFromTail, type SessionStreamProvider, type TurnFromTail } from './session-stream-events.js'
 import { pruneQueue, type QueuedThreadTurn } from './thread-turn-queue.js'
 
-/** Bytes of transcript tail read to decide whether the last turn ended. */
-export const TURN_END_TAIL_BYTES = 64 * 1024
+/**
+ * Bytes of transcript tail read to decide whether the last turn ended. 512 KiB, not 64:
+ * on the release Mac 3 of the 10 newest Desktop transcripts end in a ~76 KB bookkeeping
+ * row (a `prompt_snapshot` attachment) AFTER the terminal record, and a 64 KiB tail read
+ * only that row, saw no conversation record, and held the queue for the 30 s backstop
+ * (QA, 2026-09-15). The read is one `pread` per decision; nothing here streams.
+ */
+export const TURN_END_TAIL_BYTES = 512 * 1024
 
 function queueDir(): string {
   const dir = dataPath('thread-turn-queue')
@@ -62,6 +68,46 @@ export function writeQueue(provider: string, threadId: string, queue: readonly Q
   atomicWriteFileSync(queuePath(provider, threadId), `${JSON.stringify(queue, null, 2)}\n`)
 }
 
+/**
+ * How many WAITING follow-ups a list/detail row should show (6.48.1).
+ *
+ * Queue files are named with the native thread id (often a full UUID). Claude
+ * list rows stay on the registry's 8-character form until a transcript match
+ * expands them. An exact match always wins; an 8-character id is allowed to
+ * count a unique prefix among waiting queues of that provider, and an
+ * ambiguous prefix counts as zero rather than guessing.
+ *
+ * PURE: the store builds the input from disk; this decides the number.
+ */
+export function queuedWaitingForSession(
+  queues: ReadonlyArray<{ provider: string; threadId: string; waiting: number }>,
+  provider: string, sessionId: string,
+): number {
+  const id = sessionId.toLowerCase()
+  const rows = queues.filter(q => q.provider === provider && q.waiting > 0)
+  const exact = rows.find(q => q.threadId.toLowerCase() === id)
+  if (exact) return exact.waiting
+  if (id.length !== 8) return 0
+  const prefixed = rows.filter(q => q.threadId.toLowerCase().startsWith(id))
+  const owners = new Set(prefixed.map(q => q.threadId.toLowerCase()))
+  if (owners.size !== 1) return 0
+  return prefixed[0]!.waiting
+}
+
+/** One lookup for a whole list/search request: one directory read, then O(1) per row. */
+export function queuedWaitingLookup(now: number): (provider: string, sessionId: string) => number {
+  const queues = queuedThreadKeys().map(({ provider, threadId }) => ({
+    provider,
+    threadId,
+    waiting: readQueue(provider, threadId, now).filter(t => t.status === 'waiting').length,
+  }))
+  return (provider, sessionId) => queuedWaitingForSession(queues, provider, sessionId)
+}
+
+export function queuedTurnsFields(count: number): { queued_turns?: number } {
+  return count > 0 ? { queued_turns: count } : {}
+}
+
 /** Every thread with a queue file, for the drain sweep. */
 export function queuedThreadKeys(): Array<{ provider: string; threadId: string }> {
   try {
@@ -83,24 +129,32 @@ export function queuedThreadKeys(): Array<{ provider: string; threadId: string }
 /**
  * Did the holder's last turn END?
  *
- * REUSES `draftsFromLine`, the same parser the live stream uses, so "the turn ended"
- * means exactly here what it means there. Hand-rolling a second `type === 'result'`
- * check is how two definitions of done drift apart.
+ * 6.48.1: decided by `turnFromTail`, the transcript's own rule (a terminal
+ * `stop_reason` with no tool_use awaiting its result, a `result` row, or a user
+ * interrupt). It replaced the status-draft loop here because a Desktop transcript
+ * writes no `result` row, so the old rule could only ever say "ended" for a
+ * `claude -p` run and every Desktop Continue waited the 30 s idle backstop (measured
+ * 2026-09-15: 0 of 30 newest transcripts carry one). The live feed still narrates
+ * from `draftsFromLine`; the two are pinned to agree on recorded tails.
  *
  * Reads a bounded tail, newest record wins. Returns false on any doubt -- an
  * unreadable transcript is not evidence a turn finished, and false only means the
  * queue HOLDS, which is always the safe answer.
  */
+/** The full tail verdict, for callers that need to know OPEN as well as ended. Null on any doubt. */
+export function transcriptTurnVerdict(provider: SessionStreamProvider, path: string | null): TurnFromTail | null {
+  const lines = readTail(path)
+  return lines === null ? null : turnFromTail(provider, lines)
+}
+
 export function transcriptTurnEnded(provider: SessionStreamProvider, path: string | null): boolean {
-  if (!path || !existsSync(path)) return false
+  return transcriptTurnVerdict(provider, path)?.ended === true
+}
+
+/** The bounded tail as lines, with the same two open flags; null when it cannot be read. */
+function readTail(path: string | null): string[] | null {
+  if (!path || !existsSync(path)) return null
   try {
-    // BOTH flags, and both are load-bearing -- hazard-invariants.test.ts enforces
-    // them and each is right on its own terms. O_NOFOLLOW: a symlinked `<id>.jsonl`
-    // could point at any file on disk and would be parsed here as a transcript.
-    // O_NONBLOCK: `openSync` on a FIFO with no writer NEVER RETURNS, and it is a
-    // synchronous syscall on Node's single thread, so one planted path would stop
-    // health, meeting save and transcribe-stream along with this drain. That one is
-    // recorded in the repo as three reproductions of the same bug, >34s to SIGKILL.
     const fd = openSync(path, constants.O_RDONLY | constants.O_NOFOLLOW | constants.O_NONBLOCK)
     try {
       const size = fstatSync(fd).size
@@ -110,18 +164,11 @@ export function transcriptTurnEnded(provider: SessionStreamProvider, path: strin
       const lines = buf.toString('utf-8').split('\n')
       // The first line of a tail read is almost always a fragment.
       if (start > 0) lines.shift()
-      let ended = false
-      for (const line of lines) {
-        if (!line.trim()) continue
-        for (const draft of draftsFromLine(provider, line)) {
-          if (draft.kind === 'status') ended = draft.state === 'done'
-        }
-      }
-      return ended
+      return lines
     } finally {
       closeSync(fd)
     }
   } catch {
-    return false
+    return null
   }
 }

package/server/lib/thread-turn-queue.ts

@@ -53,11 +53,15 @@
 // ---------------------------------------------------------------------------
 // Thirty seconds of transcript silence is the wrong trigger on its own: a long tool
 // call goes quiet mid-turn, and draining there would inject a message into the middle
-// of someone's reasoning. The precise signal is the turn ENDING, which is observable in
-// the transcript itself -- Claude writes a `result` record, Codex a `task_complete` /
+// of someone's reasoning. The precise signal is the turn ENDING. For Claude that is the
+// engine's own Stop hook followed by the registry flipping `idle` (6.48.1; a Desktop
+// transcript carries no `result` record, and the Stop alone is 12-38 s early while the
+// Stop hooks run), else the transcript's newest assistant record with a terminal
+// `stop_reason` and no pending tool (`turnFromTail`); Codex writes `task_complete` /
 // `turn_complete`. The idle clock stays as a BACKSTOP for a holder that dies or a
 // provider that writes no terminal record, so a queue cannot wedge forever on a missing
-// event. Same reasoning as the session-trail handoff, one layer down.
+// event, and positive evidence of an OPEN turn outranks it. Same reasoning as the
+// session-trail handoff, one layer down.
 
 /** Terminal-ish states a queued turn can reach. `waiting` is the only live one. */
 export type QueuedTurnStatus =
@@ -186,6 +190,14 @@ export interface DrainObservation {
   turnEnded: boolean
   /** The 30s transcript clock. `idle` is the backstop when no terminal record lands. */
   activity: 'working' | 'idle' | 'unknown'
+  /**
+   * 6.48.1: POSITIVE evidence the turn is still open (a tool_use awaiting its result, a
+   * prompt newer than the last reply, or the hooks saying the turn has not stopped),
+   * bounded by the caller to a recent window. It outranks the idle backstop: a 40 s tool
+   * leaves the transcript untouched for 40 s, and "idle for 30 s" used to deliver a
+   * follow-up straight into that live turn (measured 2026-09-15 on the 6.48.1 live proof).
+   */
+  turnOpen?: boolean
   /** The gate's reason when `attachable` is false. Carried ONLY so a fence -- the one
    *  hold a clock cannot end -- can be given a longer life than a busy thread. */
   reason?: string | null
@@ -218,6 +230,10 @@ export function drainDecision(
   // Turn-ended is the precise signal; idle is the backstop for a holder that wrote no
   // terminal record. `working` holds even when attachable, because attachable only says
   // no one else owns it -- it does not say a turn is not mid-flight.
+  // Positive evidence the turn is OPEN outranks a terminal record older than it: a prompt
+  // queued at the desk during the Stop hooks dequeues after them, and the tail's newest
+  // terminal record cannot see it (QA, 2026-09-15).
+  if (seen.turnOpen === true) return 'hold'
   if (seen.turnEnded) return 'deliver'
   return seen.activity === 'idle' ? 'deliver' : 'hold'
 }

package/server/routes/agent-session-stream.ts

@@ -2,15 +2,24 @@
 //
 // Server-sent events for ONE agent session. Each `data:` line is one JSON object:
 //
-//   {"seq":1,"at":1786890000000,"kind":"tool","verb":"read","target":"x.ts","detail":""}
-//   {"seq":2,"at":1786890001000,"kind":"prose","text":"..."}
-//   {"seq":3,"at":1786890002000,"kind":"status","state":"working"}
+//   {"seq":1,"at":1786890000000,"kind":"tool","verb":"read","target":"x.ts","detail":"","cursor":41,"epoch":1789...}
+//   {"seq":2,"at":1786890001000,"kind":"prose","text":"...","cursor":42,"epoch":1789...}
+//   {"seq":3,"at":1786890002000,"kind":"status","state":"working","agent_state":"running",...}
 //   {"seq":4,"at":1786890003000,"kind":"heartbeat"}
 //
 // `seq` is monotonic PER CONNECTION from 1, so a client detects loss from a gap. There
 // are no named SSE events and no comment keepalives: one shape, so a client needs one
 // handler and can never miss a keepalive it was not parsing.
 //
+// 6.48.1 adds, all ignorable by a client that reads `data:` lines and known fields:
+//   - `cursor` and `epoch` on every event the per-session ring remembers, and an SSE
+//     `id: <epoch>.<cursor>` line before it. `?after=<epoch>.<cursor>` (or the standard
+//     `Last-Event-ID` header) replays what that ring holds after the cursor, from the
+//     same server life only; anything else, and an empty replay, seeds as a fresh open.
+//   - `?seed=turn` seeds from the current turn's prompt instead of the last 7 steps.
+//   - the derived state fields on every `status` draft (`COS_SESSION_HOOK_SSE=0` omits
+//     them), and a `status` line on every change of that state.
+//
 // ---------------------------------------------------------------------------
 // A DEAD STREAM MUST DEGRADE TO THE POLL, NEVER TO A FROZEN SCREEN
 // ---------------------------------------------------------------------------
@@ -70,8 +79,13 @@ import {
   transcriptWatcherDegraded,
   readTranscriptSeedLines,
 } from '../lib/session-transcript-watcher.js'
-import { draftsFromLine } from '../lib/session-stream-events.js'
+import { draftsFromLine, statusDraftWithDerived, type DerivedStatusFields } from '../lib/session-stream-events.js'
 import type { SessionStreamState } from '../lib/session-stream-events.js'
+import { RING_EPOCH, replaySessionStream, ringBounds } from '../lib/session-stream-bus.js'
+import { claudeSessionsDir, readClaudePeerRecords, registryFacts } from './claude-sessions.js'
+import type { RegistryFacts } from '../lib/session-state-derive.js'
+import { deriveForRow, sessionHooksEnabled, sessionSignalStore } from '../lib/session-hooks-runtime.js'
+import { derivedStatusFields } from '../lib/session-state-derive.js'
 
 export const agentSessionStreamRouter = Router()
 
@@ -85,18 +99,92 @@ export function sessionStreamEnabled(env: NodeJS.ProcessEnv = process.env): bool
   return env.COS_SESSION_STREAM_ENABLED !== '0'
 }
 
+/**
+ * 6.48.1: the derived session state rides every `status` draft as extra fields (see
+ * `statusDraftWithDerived`). `COS_SESSION_HOOK_SSE=0` keeps the drafts exactly as 6.48.0
+ * wrote them; the hooks themselves are unaffected. Absent means on.
+ */
+export function sessionHookSseEnabled(env: NodeJS.ProcessEnv = process.env): boolean {
+  return env.COS_SESSION_HOOK_SSE !== '0' && sessionHooksEnabled()
+}
+
+/**
+ * The derived state for a Claude session the stream is showing, or nothing.
+ *
+ * SAME INPUTS AS THE ROWS (QA, 2026-09-15): the registry facts (so an Esc-interrupted
+ * turn and a stray SessionEnd are read the way the list reads them) and whether a COS
+ * turn is attached (which is `running`, whatever the tab's hooks last said). The
+ * registry is read once per connection and again at most every REGISTRY_REFRESH_MS.
+ */
+export const REGISTRY_REFRESH_MS = 5_000
+
+type RegistryReader = () => Promise<RegistryFacts | undefined>
+
+function derivedForStream(provider: AgentProvider, sessionId: string, key: string, registry: RegistryFacts | undefined): DerivedStatusFields | undefined {
+  if (provider !== 'claude' || !sessionHookSseEnabled()) return undefined
+  try {
+    const derived = deriveForRow({ sessionId, registry, remember: false, attachedTurn: isAttachedTurnActive(key) })
+    return derived ? derivedStatusFields(derived) : undefined
+  } catch {
+    return undefined
+  }
+}
+
+/** The registry record for a session, cached briefly; undefined when none names it. */
+function registryReaderFor(sessionId: string): RegistryReader {
+  const wanted = sessionId.toLowerCase()
+  let cached: { at: number; facts: RegistryFacts | undefined } | null = null
+  return async () => {
+    if (cached && Date.now() - cached.at < REGISTRY_REFRESH_MS) return cached.facts
+    let facts: RegistryFacts | undefined
+    try {
+      const record = (await readClaudePeerRecords(claudeSessionsDir())).find(p => p.sessionId === wanted || p.sessionId.startsWith(wanted))
+      facts = record ? registryFacts(record) : undefined
+    } catch {
+      facts = undefined
+    }
+    cached = { at: Date.now(), facts }
+    return facts
+  }
+}
+
+/**
+ * Whether a cursor can be replayed from a ring with these bounds: only when the ring
+ * still holds the event right after it (an evicted cursor would replay the whole ring
+ * with the gap unnoticed) and there IS one (a cursor at the newest has nothing to
+ * replay, and an empty replay must seed, never open an empty screen).
+ */
+export function cursorReplayable(after: number | null, bounds: { oldest: number; newest: number } | null): boolean {
+  if (after === null || bounds === null) return false
+  return bounds.oldest <= after + 1 && after < bounds.newest
+}
+
+/** `?after=<epoch>.<cursor>` (the `id:` line's shape) or a bare cursor from this epoch; null when absent or unusable. */
+export function parseAfterCursor(raw: unknown, epoch: number = RING_EPOCH): number | null {
+  if (typeof raw !== 'string') return null
+  const m = /^(?:(\d{1,16})\.)?(\d{1,12})$/.exec(raw.trim())
+  if (!m) return null
+  if (m[1] !== undefined && Number(m[1]) !== epoch) return null
+  return Number(m[2])
+}
+
+/** A turn-anchored seed (`?seed=turn`): the newest prompt and EVERY step after it, bounded. */
+export const TURN_SEED_MAX_STEPS = 500
+
 function asProvider(value: string): AgentProvider | null {
   if (value === 'claude' || value === 'codex' || value === 'cursor') return value
   return null
 }
 
 /**
- * The state to open with.
+ * The TRANSPORT's opening state, before the derived state is stamped over it.
  *
  * `working` when a COS turn is writing right now, or when the transcript was touched
  * inside the same 30s window the session list already uses to call a thread active.
- * Otherwise `idle`. Never `done`: this route cannot observe the end of a turn it did
- * not start, and claiming one would be an invention.
+ * Otherwise `idle`. Never `done` from HERE: this function cannot observe the end of a
+ * turn it did not start. Since 6.48.1 `write()` restates `state` from the deriver when
+ * the hooks are on, and an engine that said SessionEnd (with no live registry record
+ * behind the session) opens as `done`, which is the client's digest body and intended.
  */
 export async function openingState(
   key: string,
@@ -186,6 +274,12 @@ agentSessionStreamRouter.get('/agent-sessions/:provider/:sessionId/stream', asyn
 
   const state = await openingState(key, path, Date.now())
 
+  // The registry facts the feed derives with: read in the same pre-header window as the
+  // opening state (nothing awaits once the headers are out, so a close can never slip
+  // between a write and the `close` listener), refreshed at most every REGISTRY_REFRESH_MS.
+  const readRegistry = registryReaderFor(sessionId)
+  let registry: RegistryFacts | undefined = await readRegistry()
+
   res.writeHead(200, {
     'Content-Type': 'text/event-stream',
     'Cache-Control': 'no-cache',
@@ -205,19 +299,34 @@ agentSessionStreamRouter.get('/agent-sessions/:provider/:sessionId/stream', asyn
   let seq = 0
   let closed = false
 
+  let releaseSignals: (() => void) | null = null
+
   const teardown = (): void => {
     if (closed) return
     closed = true
     if (heartbeat !== null) clearInterval(heartbeat)
     unsubscribe()
     releaseWatcher?.()
+    releaseSignals?.()
     try { res.end() } catch { /* already gone */ }
   }
 
+  let lastStamp = ''
+  const stampOf = (d: DerivedStatusFields | undefined) => d ? `${d.agent_state}|${d.waiting_kind ?? ''}|${d.waiting_detail ?? ''}|${d.failure ?? ''}` : ''
+
   const write = (event: PublishedSessionEvent): void => {
     if (closed) return
     try {
-      res.write(`data: ${JSON.stringify({ seq: ++seq, ...event })}\n\n`)
+      // ONE stamping point for the derived state: every status draft this connection
+      // writes, opening or live, seeded or published, carries the same extra fields.
+      let out: PublishedSessionEvent = event
+      if (event.kind === 'status') {
+        const derived = derivedForStream(provider, sessionId, key, registry)
+        lastStamp = stampOf(derived)
+        out = { ...event, ...statusDraftWithDerived(event, derived) }
+      }
+      const idLine = typeof out.cursor === 'number' ? `id: ${out.epoch ?? RING_EPOCH}.${out.cursor}\n` : ''
+      res.write(`${idLine}data: ${JSON.stringify({ seq: ++seq, ...out })}\n\n`)
     } catch {
       // A failed write means the socket is gone. Close rather than swallow, so the
       // watcher and the subscription are released instead of leaking behind a dead
@@ -257,7 +366,25 @@ agentSessionStreamRouter.get('/agent-sessions/:provider/:sessionId/stream', asyn
   //
   // NEVER FATAL. A session whose history cannot be read still streams; it just starts
   // empty, exactly as it did before this existed.
-  if (path !== null && startOffset > 0) {
+  // 6.48.1 RECONNECT: `?after=<cursor>` replays from the session's ring instead of
+  // seeding, when the ring still reaches back that far. A ring that does not (server
+  // restarted, linger expired) falls through to the seed, and the client sees a cursor
+  // jump it treats as a reseed.
+  // The standard SSE header is honoured as the fallback for `?after=`; the shipped lens
+  // and Control both pass the query and read `data:` lines only.
+  const after = parseAfterCursor(req.query.after) ?? parseAfterCursor(req.get('last-event-id'))
+  const bounds = ringBounds(key)
+  // Replayable only when the cursor is from THIS epoch, the ring reaches back to it, it
+  // is not past the ring, and the ring actually holds something after it. A ring that
+  // holds nothing after the cursor (the sole client was away, so nothing was published
+  // while it was gone) seeds instead: an empty replay must never be an empty screen
+  // (QA, 2026-09-15).
+  const replay = after !== null && cursorReplayable(after, bounds) ? replaySessionStream(key, after) : []
+  const replayable = replay.length > 0
+  for (const event of replay) write(event)
+  const seedMode = String(req.query.seed ?? '') === 'turn' ? 'turn' : 'window'
+
+  if (!replayable && path !== null && startOffset > 0) {
     try {
       const lines = await readTranscriptSeedLines(path, startOffset)
       const drafts = lines.flatMap(line => draftsFromLine(provider, line))
@@ -275,11 +402,17 @@ agentSessionStreamRouter.get('/agent-sessions/:provider/:sessionId/stream', asyn
       // So the newest prompt in the whole read window is emitted FIRST, unconditionally,
       // and the step budget is spent entirely on steps. The client pins it rather than
       // listing it, so it costs nothing in the scrolling window.
-      const lastPrompt = [...drafts].reverse().find(d => d.kind === 'prompt')
+      const lastPromptIndex = drafts.map(d => d.kind).lastIndexOf('prompt')
+      const lastPrompt = lastPromptIndex >= 0 ? drafts[lastPromptIndex] : undefined
       if (lastPrompt) write({ ...lastPrompt, at: Date.now() })
 
+      // 6.48.1 `?seed=turn`: the whole current turn, oldest first, so a client opening
+      // mid-turn reads it top to bottom (Terminal V2's turn-anchored open). The default
+      // stays the last SEED_EVENTS steps, which is what shipped lenses were built for.
       const steps = drafts.filter(d => d.kind === 'tool' || d.kind === 'prose')
-      for (const draft of steps.slice(-SEED_EVENTS)) {
+      const turnSteps = lastPromptIndex >= 0 ? drafts.slice(lastPromptIndex + 1).filter(d => d.kind === 'tool' || d.kind === 'prose') : steps
+      const seeded = seedMode === 'turn' ? turnSteps.slice(-TURN_SEED_MAX_STEPS) : steps.slice(-SEED_EVENTS)
+      for (const draft of seeded) {
         // NOT tagged as seeded. A replayed step is a step that really happened, and a
         // second rendering style for it would be a distinction without a use. The one
         // consequence is that the client's "N ago" clock starts at open rather than at
@@ -298,6 +431,29 @@ agentSessionStreamRouter.get('/agent-sessions/:provider/:sessionId/stream', asyn
   for (const event of pending.splice(0)) write(event)
   deliver = write
 
+  // 6.48.1: every change to this session's hook signal is a live `status` draft, so the
+  // client's state line moves on the engine's own events (prompt, permission prompt,
+  // Stop, end) rather than on the transcript clock. Filtered to this session (the
+  // client may have addressed it by the registry's 8-character form).
+  if (provider === 'claude' && sessionHookSseEnabled() && !closed) {
+    const wanted = sessionId.toLowerCase()
+    // `lastStamp` is whatever the OPENING status actually wrote (set inside `write`), so a
+    // change during the seed read is emitted as the first live line, not lost.
+    releaseSignals = sessionSignalStore.subscribe(signal => {
+      if (closed) return
+      if (signal.sessionId !== wanted && !signal.sessionId.startsWith(wanted)) return
+      // The registry may have moved with the hooks (an Esc flips it idle); refresh it
+      // off the hot path and let the next event read the new facts.
+      void readRegistry().then(facts => { registry = facts })
+      const derived = derivedForStream(provider, sessionId, key, registry)
+      if (!derived) return
+      // Only a CHANGE of state is a line; tool events inside a running turn are narrated
+      // by the transcript tail and must not each repaint the state.
+      if (stampOf(derived) === lastStamp) return
+      write({ kind: 'status', state: 'working', at: Date.now() })
+    })
+  }
+
   releaseWatcher = path === null
     ? null
     : acquireTranscriptWatcher({ key, path, provider, offset: startOffset })
@@ -306,6 +462,8 @@ agentSessionStreamRouter.get('/agent-sessions/:provider/:sessionId/stream', asyn
   if (closed) {
     releaseWatcher?.()
     releaseWatcher = null
+    releaseSignals?.()
+    releaseSignals = null
     return
   }
 

package/server/routes/agent-sessions.ts

@@ -37,7 +37,12 @@ import {
   type AgentSessionSort,
 } from '../lib/agent-session-store.js'
 import { searchAgentSessions, type AgentSessionSearchHit } from '../lib/agent-session-search.js'
-import { claudeSessionNamesVisible, claudeSessionsDir, claudeSessionsEnabled, readClaudePeers } from './claude-sessions.js'
+import { claudeSessionNamesVisible, claudeSessionsDir, claudeSessionsEnabled, readClaudePeerRecords, registryFacts } from './claude-sessions.js'
+import type { ClaudePeerRecord } from '../lib/claude-session-registry.js'
+import { deriveForRow } from '../lib/session-hooks-runtime.js'
+import { derivedRowFields, type DerivedSessionState } from '../lib/session-state-derive.js'
+import { queuedTurnsFields, queuedWaitingLookup } from '../lib/thread-turn-queue-store.js'
+import { isAttachedTurnActive, sessionStreamKey } from '../lib/session-stream-bus.js'
 import { workspaceFromCwd } from '../lib/claude-session-registry.js'
 import {
   occupiedThreads,
@@ -75,9 +80,9 @@ function asSort(value: unknown): AgentSessionSort {
   return String(value ?? '').toLowerCase() === 'opened' ? 'opened' : 'updated'
 }
 
-function toSearchHit(row: AgentSessionSearchHit) {
+function toSearchHit(row: AgentSessionSearchHit, queuedTurns = 0, derived?: DerivedSessionState) {
   return {
-    ...toEntry(row),
+    ...toEntry(row, undefined, derived, queuedTurns),
     snippet: row.snippet,
     keywordScore: row.keywordScore,
     semanticScore: row.semanticScore,
@@ -261,7 +266,7 @@ function runningForThread(provider: AgentProvider, threadId: string, mtimeMs: nu
   }
 }
 
-function toEntry(row: AgentSessionRow, activity?: SessionActivity | null) {
+function toEntry(row: AgentSessionRow, activity?: SessionActivity | null, derived?: DerivedSessionState, queuedTurns = 0) {
   return {
     session_id: row.session_id,
     provider: row.provider,
@@ -286,12 +291,22 @@ function toEntry(row: AgentSessionRow, activity?: SessionActivity | null) {
     // unknown, so an older client and a Cursor row see exactly the payload they did.
     ...(activity?.lastActivityAt ? { last_activity_at: activity.lastActivityAt } : {}),
     ...(activity?.lastTool ? { last_tool: activity.lastTool } : {}),
+    // 6.48.0: the one derived state (hook > registry > transcript) with its provenance.
+    // Under a NEW key: `state` above is `running|recent` and Control renders any other
+    // value there as "Running". Omitted entirely when nothing is known, like the two above.
+    ...derivedRowFields(derived),
+    // 6.48.1: waiting follow-ups on this thread. Omitted at 0 so an older client
+    // and a quiet row look the same as 6.48.0.
+    ...queuedTurnsFields(queuedTurns),
   }
 }
 
-async function liveClaudeRows(): Promise<AgentSessionRow[]> {
+async function liveClaudePeerRecords(): Promise<ClaudePeerRecord[]> {
   if (!claudeSessionsEnabled()) return []
-  const peers = await readClaudePeers(claudeSessionsDir(), undefined, claudeSessionNamesVisible())
+  return readClaudePeerRecords(claudeSessionsDir(), undefined, claudeSessionNamesVisible())
+}
+
+function liveClaudeRows(peers: ClaudePeerRecord[]): AgentSessionRow[] {
   return peers.filter(peer => peer.alive).map(peer => ({
     session_id: peer.id,
     provider: 'claude' as const,
@@ -322,7 +337,8 @@ agentSessionsRouter.get('/agent-sessions', async (req, res) => {
     // ONE alias load per request, shared by the walk, every live row and every
     // held thread. Measured 2026-09-10: sixteen loads of 119 MB before this line.
     const aliases = await loadClaudeDesktopAliases(roots.claudeCodeSessions)
-    const live = await liveClaudeRows()
+    const peers = await liveClaudePeerRecords()
+    const live = liveClaudeRows(peers)
     const dropped = emptySessionListDropped()
     const sessions = await listAgentSessions(roots, new Date(), live, limit, sort, dropped, aliases)
     // 6.45.5: each row's last real activity, read from its transcript records. Memoized on
@@ -342,8 +358,37 @@ agentSessionsRouter.get('/agent-sessions', async (req, res) => {
       if (mtimeMs !== null) clocks.set(threadId, activityClockMs(mtimeMs, activityById.get(threadId)))
     }
     const running = withActiveRecently(scan, clocks, Date.now())
+    // Derived AFTER the walk: live rows carry the registry's eight-character id until
+    // `enrichLiveClaude` finds their transcript, and the deriver wants the full one where
+    // it exists. The registry facts are joined back by prefix; a transcript-only row (an
+    // ended job, a tab closed hours ago) still gets a state from its activity clock.
+    const now = Date.now()
+    // First wins, and `readClaudePeerRecords` sorts alive first: a dead predecessor's file
+    // (a resumed tab, a finished Continue child) must never shadow the live record.
+    const peersByPrefix = new Map<string, ClaudePeerRecord>()
+    for (const peer of peers) {
+      const prefix = peer.sessionId.slice(0, 8)
+      if (!peersByPrefix.has(prefix)) peersByPrefix.set(prefix, peer)
+    }
+    const derivedById = new Map<string, DerivedSessionState | undefined>()
+    for (const row of sessions) {
+      if (row.provider !== 'claude') continue
+      const peer = peersByPrefix.get(row.session_id.slice(0, 8).toLowerCase())
+      const hint = running.occupied.get(row.session_id)
+      derivedById.set(row.session_id, deriveForRow({
+        sessionId: row.session_id,
+        registry: peer ? registryFacts(peer) : undefined,
+        transcript: {
+          inFlight: hint?.activeRecently === true,
+          lastActivityAt: activityById.get(row.session_id)?.lastActivityAt ? Date.parse(activityById.get(row.session_id)!.lastActivityAt!) : null,
+        },
+        now,
+        attachedTurn: isAttachedTurnActive(sessionStreamKey('claude', row.session_id)),
+      }))
+    }
+    const queuedOf = queuedWaitingLookup(now)
     res.json({
-      sessions: sessions.map((row, index) => withRunning(toEntry(row, activity[index]), running)),
+      sessions: sessions.map((row, index) => withRunning(toEntry(row, activity[index], derivedById.get(row.session_id), queuedOf(row.provider, row.session_id)), running)),
       total: sessions.length,
       windowHours: AGENT_SESSION_WINDOW_HOURS,
       sort,
@@ -372,9 +417,29 @@ agentSessionsRouter.get('/agent-sessions/search', async (req, res) => {
   try {
     const limit = boundedInteger(req.query.limit, 20, 1, 50)
     const result = await searchAgentSessions({ query, limit })
+    const queuedOf = queuedWaitingLookup(Date.now())
+    // 6.48.1: search hits carry the same derived state as list rows (no list/search shape
+    // drift), from the registry and the hook signal; a hit has no transcript walk.
+    const peers = await liveClaudePeerRecords()
+    const peersByPrefix = new Map<string, ClaudePeerRecord>()
+    for (const peer of peers) {
+      const prefix = peer.sessionId.slice(0, 8)
+      if (!peersByPrefix.has(prefix)) peersByPrefix.set(prefix, peer)
+    }
+    const derivedFor = (hit: AgentSessionSearchHit): DerivedSessionState | undefined => {
+      if (hit.provider !== 'claude') return undefined
+      const peer = peersByPrefix.get(hit.session_id.slice(0, 8).toLowerCase())
+      return deriveForRow({
+        sessionId: hit.session_id,
+        registry: peer ? registryFacts(peer) : undefined,
+        transcript: hit.modified ? { inFlight: false, lastActivityAt: Date.parse(hit.modified) } : undefined,
+        attachedTurn: isAttachedTurnActive(sessionStreamKey('claude', hit.session_id)),
+        remember: false,
+      })
+    }
     res.json({
       ...result,
-      hits: result.hits.map(toSearchHit),
+      hits: result.hits.map(hit => toSearchHit(hit, queuedOf(hit.provider, hit.session_id), derivedFor(hit))),
     })
   } catch (error) {
     console.error(`[agent-sessions] search failed: ${error instanceof Error ? error.message : error}`)
@@ -417,8 +482,22 @@ agentSessionsRouter.get('/agent-sessions/:provider/:sessionId', async (req, res)
     const modified = st.mtime.toISOString()
     const activity = await readSessionActivity(provider, found)
     const running = runningForThread(provider, parsed.session_id, activityClockMs(st.mtimeMs, activity))
+    // 6.48.0: the detail carries the same derived state as its list row. The registry is
+    // read once here (a few hundred small files at most) because the detail has no walk.
+    let derived: DerivedSessionState | undefined
+    if (provider === 'claude') {
+      const peer = (await liveClaudePeerRecords()).find(p => p.sessionId === parsed.session_id.toLowerCase()) // alive first
+      derived = deriveForRow({
+        sessionId: parsed.session_id,
+        registry: peer ? registryFacts(peer) : undefined,
+        transcript: { inFlight: running.occupied.get(parsed.session_id)?.activeRecently === true, lastActivityAt: activity.lastActivityAt ? Date.parse(activity.lastActivityAt) : null },
+        attachedTurn: isAttachedTurnActive(sessionStreamKey('claude', parsed.session_id)),
+      })
+    }
     res.json({
       ...withRunning({ session_id: parsed.session_id }, running),
+      ...derivedRowFields(derived),
+      ...queuedTurnsFields(queuedWaitingLookup(Date.now())(provider, parsed.session_id)),
       // The client must be able to tell "this server stamped nothing" from "this
       // server stamped false", because the two demand opposite behaviour: an old
       // server's silence means keep using the hint borrowed from the list row, and