@gotcos/glasses-server 6.48.0 → 6.48.2

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

@@ -41,6 +41,8 @@ import { claudeSessionNamesVisible, claudeSessionsDir, claudeSessionsEnabled, re
 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,
@@ -78,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,
@@ -264,7 +266,7 @@ function runningForThread(provider: AgentProvider, threadId: string, mtimeMs: nu
   }
 }
 
-function toEntry(row: AgentSessionRow, activity?: SessionActivity | null, derived?: DerivedSessionState) {
+function toEntry(row: AgentSessionRow, activity?: SessionActivity | null, derived?: DerivedSessionState, queuedTurns = 0) {
   return {
     session_id: row.session_id,
     provider: row.provider,
@@ -293,6 +295,9 @@ function toEntry(row: AgentSessionRow, activity?: SessionActivity | null, derive
     // 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),
   }
 }
 
@@ -378,10 +383,12 @@ agentSessionsRouter.get('/agent-sessions', async (req, res) => {
           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], derivedById.get(row.session_id)), 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,
@@ -410,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}`)
@@ -464,11 +491,13 @@ agentSessionsRouter.get('/agent-sessions/:provider/:sessionId', async (req, res)
         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

package/server/routes/claude-sessions.ts

@@ -18,8 +18,7 @@
 import { Router } from 'express'
 import { existsSync } from 'node:fs'
 import { lstat, readdir, readFile, stat } from 'node:fs/promises'
-import { homedir } from 'node:os'
-import { join, resolve } from 'node:path'
+import { join } from 'node:path'
 import {
   REGISTRY_FILENAME,
   countPeers,
@@ -31,9 +30,12 @@ import {
   type ClaudePeerRecord,
   peerRecordFacts,
   toWirePeer,
+  claudeSessionsDir,
 } from '../lib/claude-session-registry.js'
 import { deriveForRow } from '../lib/session-hooks-runtime.js'
 import { derivedRowFields, type RegistryFacts } 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'
 
 export const claudeSessionsRouter = Router()
 
@@ -61,20 +63,8 @@ export function claudeSessionNamesVisible(): boolean {
   return process.env.COS_CLAUDE_SESSIONS_SHOW_NAMES === '1'
 }
 
-/**
- * Where the registry lives.
- *
- * `COS_CLAUDE_SESSIONS_DIR` first because it is both the override for a non-standard
- * install AND the test seam — `homedir()` is not mockable, so without an env hook the
- * only testable path would be the real one. Then CLAUDE_CONFIG_DIR, which real
- * installs do set; hardcoding ~/.claude breaks those.
- */
-export function claudeSessionsDir(): string {
-  const explicit = process.env.COS_CLAUDE_SESSIONS_DIR
-  if (explicit) return resolve(explicit)
-  const configDir = process.env.CLAUDE_CONFIG_DIR
-  return join(configDir ? resolve(configDir) : join(homedir(), '.claude'), 'sessions')
-}
+/** Where the registry lives; the definition moved to the registry lib in 6.48.1. */
+export { claudeSessionsDir }
 
 const realProbes: PeerProbes = {
   isAlive: pid => {
@@ -170,13 +160,17 @@ claudeSessionsRouter.get('/claude-sessions', async (req, res) => {
     const limit = boundedInteger(req.query.limit, 30, 1, 100)
     const records = await readClaudePeerRecords(claudeSessionsDir())
     const peers = records.map(toWirePeer)
+    const queuedOf = queuedWaitingLookup(Date.now())
     // 6.48.0: the same derived state every surface reads, stamped ADDITIVELY on the wire
     // peer. `toPeer` stays byte-identical (its key set is pinned); the eight extra keys
     // come from the signal store and the registry facts an older client never sees.
+    // 6.48.1: queued_turns joins here too so a peer-only row (no agent-sessions hit)
+    // still shows a follow-up waiting.
     res.json({
       peers: records.slice(0, limit).map(record => ({
         ...toWirePeer(record),
-        ...derivedRowFields(deriveForRow({ sessionId: record.sessionId, registry: registryFacts(record) })),
+        ...derivedRowFields(deriveForRow({ sessionId: record.sessionId, registry: registryFacts(record), attachedTurn: isAttachedTurnActive(sessionStreamKey('claude', record.sessionId)) })),
+        ...queuedTurnsFields(queuedOf('claude', record.sessionId)),
       })),
       counts: countPeers(peers),
       enabled: true,

package/server/routes/session-hooks.ts

@@ -11,6 +11,11 @@ import { installClaudeHooks, uninstallClaudeHooks } from '../lib/claude-hooks-in
 import { deskIdleSeconds, invalidateHookStatus, sessionHooksHealthFields, sessionSignalStore } from '../lib/session-hooks-runtime.js'
 import { workspaceFromCwd } from '../lib/claude-session-registry.js'
 
+/** The registry entrypoints a person sits at; everything else (`sdk-cli`, unknown) may be a job. */
+export function isInteractiveEntrypoint(entrypoint: string | null): boolean {
+  return entrypoint === 'claude-desktop' || entrypoint === 'cli'
+}
+
 export function createSessionHooksRouter(options: { port: number }): Router {
   const router = Router()
 
@@ -47,11 +52,16 @@ export function createSessionHooksRouter(options: { port: number }): Router {
     res.set('Cache-Control', 'private, no-store')
     const since = Number(req.query.since)
     const sinceMs = Number.isFinite(since) && since > 0 ? since : Date.now() - 24 * 60 * 60_000
+    // A Desktop tab or a terminal session is not a run (6.48.1): the ledger wants the
+    // `claude -p` jobs (`sdk-cli`). `?all=1` lists every session the hooks saw.
+    const all = req.query.all === '1'
     const runs: Array<Record<string, unknown>> = []
     for (const signal of sessionSignalStore.snapshot()) {
       if (signal.firstSeenAt < sinceMs && !(signal.ended && signal.ended.at >= sinceMs)) continue
+      if (!all && isInteractiveEntrypoint(signal.entrypoint)) continue
       runs.push({
         session_id: signal.sessionId,
+        entrypoint: signal.entrypoint,
         started_at: new Date(signal.firstSeenAt).toISOString(),
         ended_at: signal.ended ? new Date(signal.ended.at).toISOString() : null,
         end_reason: signal.ended?.reason ?? null,

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

@@ -16,6 +16,7 @@
 // EVERY DEPENDENCY IS INJECTED so the whole path is testable without a live server.
 
 import { Router, type Request, type Response } from 'express'
+import { COS_SESSION_ID_RE } from './agent-session-bindings.js'
 import {
   admitToQueue, drainDecision, queueableRefusal, queuePosition,
   MAX_DELIVERY_ATTEMPTS, type DrainObservation, type QueuedThreadTurn,
@@ -27,6 +28,8 @@ export interface ThreadTurnQueueDeps {
   occupancy: (provider: string, threadId: string) => { attachable: boolean; reason: string | null }
   /** Did the holder's last transcript record end a turn? */
   turnEnded: (provider: string, threadId: string) => boolean
+  /** 6.48.1, optional: is the holder's turn positively OPEN right now (see DrainObservation.turnOpen)? */
+  turnOpen?: (provider: string, threadId: string) => boolean
   /** The 30s transcript clock, as a backstop. */
   activity: (provider: string, threadId: string) => 'working' | 'idle' | 'unknown'
   /**
@@ -77,6 +80,11 @@ function publicRow(turn: QueuedThreadTurn, position: number): Record<string, unk
  * return false and spend an attempt. A new refusal added upstream is therefore bounded
  * by default rather than silently retried forever.
  */
+/** A throwing turnOpen probe is not evidence either way. */
+function safeTurnOpen(deps: ThreadTurnQueueDeps, provider: string, threadId: string): boolean | undefined {
+  try { return deps.turnOpen!(provider, threadId) } catch { return undefined }
+}
+
 function isRetryableDelivery(outcome: { reason?: string; serverRetryable?: boolean }): boolean {
   // The turn route publishes its own verdict; it outranks our inference either way.
   if (outcome.serverRetryable === false) return false
@@ -116,6 +124,7 @@ export async function drainThread(
     const seen: DrainObservation = {
       attachable: gate.attachable,
       turnEnded: deps.turnEnded(provider, threadId),
+      turnOpen: deps.turnOpen ? safeTurnOpen(deps, provider, threadId) : undefined,
       activity: deps.activity(provider, threadId),
       reason: gate.reason,
     }
@@ -212,6 +221,12 @@ export function createThreadTurnQueueRouter(deps: ThreadTurnQueueDeps): Router {
     if (!clientTurnId || !cosSessionId || !prompt.trim()) {
       return res.status(400).json({ error: 'invalid_request' })
     }
+    // 6.48.1: the attach route refuses an id outside COS_SESSION_ID_RE as invalid_request,
+    // which the drainer treats as retryable, so a bad id used to sit in the queue for the
+    // whole TTL. Refuse it here, where the client can still fix it.
+    if (!COS_SESSION_ID_RE.test(cosSessionId)) {
+      return res.status(400).json({ error: 'invalid_request', reason: 'invalid_cos_session_id' })
+    }
 
     if (provider === 'cursor') {
       return res.status(423).json({ error: 'unsupported_provider', queueable: false })