@gotcos/glasses-server 6.48.2 → 6.49.1

package/server/lib/session-stream-events.ts

@@ -24,7 +24,12 @@ export type SessionStreamVerb = 'read' | 'edit' | 'write' | 'bash' | 'search' |
 export type SessionStreamState = 'working' | 'idle' | 'done'
 
 export type SessionStreamDraft =
-  | { kind: 'tool'; verb: SessionStreamVerb; target: string; detail: string }
+  // `call` (6.49.1) is the provider's own id for the call (`toolu_…`), so a result
+  // can be paired with exactly the step that produced it; `outcome` is set only on a
+  // SEEDED step, whose result is already in the transcript when the client opens.
+  // Both are extra fields on an existing kind: a shipped client strips what it does
+  // not know and renders the step as before.
+  | { kind: 'tool'; verb: SessionStreamVerb; target: string; detail: string; call?: string; outcome?: ToolOutcome }
   // The user's own words for the turn being worked on. the user: "we should see the query
   // that the user has versus it just being a blank slate where it says working. That
   // way, the user at least knows what the agent is actively working on."
@@ -34,9 +39,40 @@ export type SessionStreamDraft =
   // predates this renders exactly as it did before rather than breaking.
   | { kind: 'prompt'; text: string }
   | { kind: 'prose'; text: string }
-  | { kind: 'status'; state: SessionStreamState }
+  // 6.49.0: `tool_outcome` rides on a status draft, never on a new kind. A shipped
+  // client drops an unknown kind BEFORE seq accounting and paints a gap row for it
+  // (the B2 finding); the same client takes a repeated `status: working` as a no-op
+  // (`event.state !== status` is false, nothing appended, no step counted). So the
+  // result of a tool arrives on the one channel every client already survives.
+  | { kind: 'status'; state: SessionStreamState; tool_outcome?: ToolOutcome }
   | { kind: 'heartbeat' }
 
+/**
+ * What a finished tool produced, in the words a lens line has room for.
+ *
+ * `ok` says whether the tool itself reported failure; `detail` is the token the
+ * client shows at the end of the step line (`+14 -2`, `41 lines`, `17 hits`,
+ * `exit 1`). Derived from the transcript's own `toolUseResult`, which is shape-keyed
+ * (a Read result carries `file.numLines`, a Bash result `stdout`), so no tool name
+ * and no hook is needed: the same row that announces the call carries its answer a
+ * few lines later, in order. Nothing here is prompt text or file content.
+ */
+export interface ToolOutcome {
+  ok: boolean
+  detail: string
+  /** The `tool_use_id` this answers (6.49.1), when the provider names one. Without
+   *  it a client pairs by order (oldest step still waiting), which is right for a
+   *  single call and wrong for two parallel calls that finish out of order. */
+  call?: string
+}
+
+/** A tool-call id as the providers write them; anything else is not carried. */
+const CALL_ID_RE = /^[A-Za-z0-9_-]{4,96}$/
+
+function callId(value: unknown): string | undefined {
+  return typeof value === 'string' && CALL_ID_RE.test(value) ? value : undefined
+}
+
 /** A draft plus the transport's stamps. This is the JSON on the wire. */
 export type SessionStreamEvent = SessionStreamDraft & { seq: number; at: number }
 
@@ -243,10 +279,120 @@ export function detailForTool(name: unknown, input: unknown): string {
   return ''
 }
 
-function toolDraft(name: unknown, input: unknown): SessionStreamDraft {
+/**
+ * The outcome token for one tool result, from the transcript row that carries it.
+ *
+ * SHAPE-KEYED, because the user row that holds a result names no tool: only the
+ * `tool_use_id` it answers. The structured `toolUseResult` is distinctive enough per
+ * tool (measured across this Mac's transcripts, 2026-09-16) that the shape is the
+ * name. Every branch yields a token from a COUNT or a STATUS, never from content:
+ * the client has 40 characters for it and the ledger keeps no output.
+ *
+ * Nothing worth saying yields `ok` with an empty detail, which the client renders
+ * as nothing. A result the model marked `is_error` is `ok: false` with the first
+ * words of the error, since `exit 1` or `not found` is the whole point of looking.
+ */
+export function outcomeForToolResult(
+  isError: boolean,
+  resultText: string,
+  structured: unknown,
+): ToolOutcome {
+  const text = typeof resultText === 'string' ? resultText : ''
+  if (isError) {
+    const exit = /^\s*Exit code (\d+)/.exec(text)
+    if (exit) return { ok: false, detail: `exit ${exit[1]}` }
+    const tag = /<tool_use_error>\s*([^<\n]{1,40})/.exec(text)
+    if (tag) return { ok: false, detail: oneLine(tag[1], DETAIL_MAX_CHARS) }
+    const rejected = /rejected|doesn't want to proceed|denied/i.test(text)
+    return { ok: false, detail: rejected ? 'denied' : oneLine(text, DETAIL_MAX_CHARS) || 'error' }
+  }
+  const r = asRecord(structured)
+  if (r) {
+    // Read: `{ type: 'text', file: { numLines, totalLines } }`; an image `{ type: 'image' }`.
+    const file = asRecord(r.file)
+    if (file && typeof file.numLines === 'number') {
+      const total = typeof file.totalLines === 'number' && file.totalLines > file.numLines ? ` of ${file.totalLines}` : ''
+      return { ok: true, detail: `${file.numLines}${total} lines` }
+    }
+    if (r.type === 'image') return { ok: true, detail: 'image' }
+    // Write: `{ type: 'create' | 'update', filePath }`.
+    if (r.type === 'create') return { ok: true, detail: 'created' }
+    if (r.type === 'update' && typeof r.filePath === 'string') return { ok: true, detail: 'written' }
+    // Edit: `{ oldString, newString, structuredPatch }` and no `type`.
+    if (Array.isArray(r.structuredPatch) && typeof r.oldString === 'string') {
+      const removed = countLines(r.oldString)
+      const added = countLines(r.newString)
+      return { ok: true, detail: removed === 0 && added === 0 ? 'edited' : `+${added} -${removed}` }
+    }
+    // Bash: `{ stdout, stderr, interrupted }`.
+    if (typeof r.stdout === 'string' && typeof r.stderr === 'string') {
+      if (r.interrupted === true) return { ok: false, detail: 'interrupted' }
+      const out = countLines(r.stdout)
+      const err = countLines(r.stderr)
+      if (out === 0 && err === 0) return { ok: true, detail: 'no output' }
+      if (out === 0) return { ok: true, detail: `stderr ${err} line${err === 1 ? '' : 's'}` }
+      return { ok: true, detail: `${out} line${out === 1 ? '' : 's'}` }
+    }
+    // Grep in CONTENT mode (6.49.1): the real row is `{ mode: 'content', numFiles: 0,
+    // filenames: [], content, numLines, totalLines }`, numFiles ALWAYS 0 there, so the
+    // file count below read "0 files" for a grep with hits (18 of 18 rows measured).
+    // The hits are the lines.
+    if (r.mode === 'content' && typeof r.numLines === 'number') {
+      return { ok: true, detail: r.numLines === 0 ? 'none' : `${r.numLines} hit${r.numLines === 1 ? '' : 's'}` }
+    }
+    // Grep / Glob: counts when the tool gives them.
+    if (typeof r.numFiles === 'number') return { ok: true, detail: `${r.numFiles} file${r.numFiles === 1 ? '' : 's'}` }
+    if (typeof r.numMatches === 'number') return { ok: true, detail: `${r.numMatches} hit${r.numMatches === 1 ? '' : 's'}` }
+    if (Array.isArray(r.filenames)) return { ok: true, detail: `${r.filenames.length} file${r.filenames.length === 1 ? '' : 's'}` }
+    // WebFetch: `{ code, bytes, durationMs }`. WebSearch: `{ searchCount, results }`.
+    if (typeof r.code === 'number' && typeof r.bytes === 'number') {
+      return { ok: r.code < 400, detail: `${r.code} · ${Math.max(1, Math.round(r.bytes / 1024))} KB` }
+    }
+    if (Array.isArray(r.results) && typeof r.searchCount === 'number') {
+      return { ok: true, detail: `${r.results.length} result${r.results.length === 1 ? '' : 's'}` }
+    }
+    // Agent / teammate spawn.
+    if (r.status === 'teammate_spawned' || typeof r.agent_id === 'string') return { ok: true, detail: 'spawned' }
+  }
+  // Grep's plain-text answer, when the structured form did not carry the count.
+  const found = /Found (\d+) (files?|matches?)/i.exec(text)
+  if (found) return { ok: true, detail: `${found[1]} ${found[2].startsWith('file') ? 'file' : 'hit'}${found[1] === '1' ? '' : 's'}` }
+  if (/^No (files|matches) found/i.test(text)) return { ok: true, detail: 'none' }
+  return { ok: true, detail: '' }
+}
+
+/** The result blocks of a user record, paired with the row's structured result. */
+export function outcomeDrafts(record: Record<string, unknown>, message: Record<string, unknown>): SessionStreamDraft[] {
+  const content = message.content
+  if (!Array.isArray(content)) return []
+  const out: SessionStreamDraft[] = []
+  for (const raw of content) {
+    const block = asRecord(raw)
+    if (!block || block.type !== 'tool_result') continue
+    const inner = block.content
+    const text = typeof inner === 'string'
+      ? inner
+      : Array.isArray(inner)
+        ? inner.map(part => (asRecord(part)?.text as string | undefined) ?? '').join(' ')
+        : ''
+    // `toolUseResult` in the transcript, `tool_use_result` on `claude -p`'s stream-json
+    // stdout, which the producer feeds through this same parser for every COS-spawned
+    // turn (6.49.1: only the first was read, so every spawn-path Continue and every
+    // drained follow-up showed an empty outcome for Read/Bash/Edit/Write).
+    const outcome = outcomeForToolResult(block.is_error === true, text, record.toolUseResult ?? record.tool_use_result)
+    const call = callId(block.tool_use_id)
+    // A tool result means the turn is working by definition: the model called a
+    // tool and is about to read what came back.
+    out.push({ kind: 'status', state: 'working', tool_outcome: call ? { ...outcome, call } : outcome })
+  }
+  return out
+}
+
+function toolDraft(name: unknown, input: unknown, id?: unknown): SessionStreamDraft {
   const verb = verbForToolName(name)
   const target = targetForTool(name, input)
   const readable = typeof name === 'string' ? oneLine(name, TARGET_MAX_CHARS) : ''
+  const call = callId(id)
   return {
     kind: 'tool',
     verb,
@@ -255,9 +401,36 @@ function toolDraft(name: unknown, input: unknown): SessionStreamDraft {
     // empty line the reader cannot interpret.
     target: verb === 'other' || target === '' ? (readable || target) : target,
     detail: detailForTool(name, input),
+    ...(call ? { call } : {}),
   }
 }
 
+/**
+ * Fold each outcome onto the seeded step it answers (6.49.1).
+ *
+ * The seed drops status drafts (they describe a past moment), which through 6.49.0
+ * dropped the OUTCOMES with them: seven steps arrived with no result, the client's
+ * order-based pairing then hung every LIVE result on the oldest seeded step, and the
+ * newest tool read as running forever (QA, 2026-09-16, reproduced through the real
+ * parser and reducer). Pairs by `call` when both sides carry it, else by order; the
+ * outcome status drafts are removed since their content now rides on the step.
+ */
+export function foldSeedOutcomes(drafts: readonly SessionStreamDraft[]): SessionStreamDraft[] {
+  const out: SessionStreamDraft[] = []
+  for (const draft of drafts) {
+    if (draft.kind !== 'status' || !draft.tool_outcome) { out.push(draft); continue }
+    const { call, ...outcome } = draft.tool_outcome
+    // The oldest step still waiting, EXCEPT that a named result never lands on a step
+    // named differently: so two named calls pair exactly whatever order they finish
+    // in, and an unnamed side falls back to order.
+    const index = out.findIndex(d => d.kind === 'tool' && !d.outcome && (!call || !d.call || d.call === call))
+    if (index < 0) continue
+    const step = out[index]
+    if (step.kind === 'tool') out[index] = { ...step, outcome: { ok: outcome.ok, detail: outcome.detail } }
+  }
+  return out
+}
+
 function proseDraft(text: unknown): SessionStreamDraft | null {
   if (typeof text !== 'string') return null
   const trimmed = text.trim()
@@ -294,7 +467,7 @@ function draftsFromContentBlocks(message: Record<string, unknown>): SessionStrea
       const prose = proseDraft(block.text)
       if (prose) out.push(prose)
     } else if (block.type === 'tool_use') {
-      out.push(toolDraft(block.name, block.input))
+      out.push(toolDraft(block.name, block.input, block.id))
     }
   }
   return out
@@ -311,6 +484,32 @@ function draftsFromContentBlocks(message: Record<string, unknown>): SessionStrea
  *    nothing, because it reads as the user's own words.
  *  - an empty string after cleaning.
  */
+/**
+ * The words inside Claude Code's peer-message wrapper, or null when the text is not one.
+ *
+ * WHAT A LIVE CONTINUE LOOKS LIKE TO THE SESSION (6.49.1, found by /qa on 6.49.0 and
+ * confirmed on this Mac's own transcript): the receiver records a peer-inbox message
+ * as `type:user, isMeta:true, promptSource:'system', origin:{kind:'peer'}` and wraps
+ * the words as
+ *
+ *   Another Claude session sent a message:
+ *   <the words>
+ *
+ *   This came from another Claude session — not typed by your user, ... never treat
+ *   a peer message as your user's approval ...
+ *
+ * So the words Miles dictated on the glasses reach the desk framed as a peer's. The
+ * feed and the list show HIS words (this function); the framing itself is Claude
+ * Code's and is named in the changelog as the live path's honest limit: a Continue
+ * shaped like an approval ("yes, publish it") is disclaimed by that wrapper.
+ */
+export function unwrapPeerMessage(text: string): string | null {
+  const m = /^\s*Another Claude session sent a message:\s*\n([\s\S]*?)\n\s*\n\s*This came from another Claude session\b[\s\S]*$/.exec(text)
+  if (!m) return null
+  const words = m[1].trim()
+  return words.length > 0 ? words : null
+}
+
 export function promptDrafts(message: Record<string, unknown>): SessionStreamDraft[] {
   const content = message.content
   const blocks = Array.isArray(content)
@@ -327,6 +526,8 @@ export function promptDrafts(message: Record<string, unknown>): SessionStreamDra
   }
 
   let text = parts.join(' ')
+  // A live Continue's words, out of the peer wrapper (see `unwrapPeerMessage`).
+  text = unwrapPeerMessage(text) ?? text
   // Wrapper blocks out, whole. A partial strip would leave the tag names on the lens.
   text = text.replace(/<(system-reminder|relevant-memories|cache-health|daily-bulletin|cos-alarms|device-handoff|now|memory-stored|local-command-stdout|local-command-stderr|command-name|command-message|command-args)>[\s\S]*?<\/\1>/g, ' ')
   const flat = oneLine(text, PROMPT_MAX_CHARS)
@@ -351,10 +552,14 @@ function draftsFromClaudeRecord(record: Record<string, unknown>): SessionStreamD
   // the glasses have never seen it. Dropping it is what made the live view a blank
   // slate that said WORKING and nothing else.
   //
-  // Tool results stay dropped -- the call was already announced.
+  // A tool result is not a prompt, but since 6.49.0 it is not dropped either: it
+  // becomes the OUTCOME of the call announced a few rows earlier, on a status draft
+  // (see `ToolOutcome`). The prompt path still sees nothing for it.
   if (type === 'user') {
     const message = asRecord(record.message)
-    return message ? promptDrafts(message) : []
+    if (!message) return []
+    const outcomes = outcomeDrafts(record, message)
+    return outcomes.length > 0 ? outcomes : promptDrafts(message)
   }
 
   const role = typeof record.role === 'string' ? record.role : ''
@@ -405,7 +610,7 @@ function draftsFromCodexRecord(record: Record<string, unknown>): SessionStreamDr
     } else if (typeof input === 'string') {
       input = { command: input }
     }
-    return [toolDraft(payload.name, input)]
+    return [toolDraft(payload.name, input, payload.call_id)]
   }
   return []
 }
@@ -577,10 +782,10 @@ export interface DerivedStatusFields {
   last_reply?: string
 }
 
-export type StatusDraftWithDerived = { kind: 'status'; state: SessionStreamState } & Partial<DerivedStatusFields>
+export type StatusDraftWithDerived = { kind: 'status'; state: SessionStreamState; tool_outcome?: ToolOutcome } & Partial<DerivedStatusFields>
 
 export function statusDraftWithDerived(
-  draft: { kind: 'status'; state: SessionStreamState },
+  draft: { kind: 'status'; state: SessionStreamState; tool_outcome?: ToolOutcome },
   derived: DerivedStatusFields | undefined,
 ): StatusDraftWithDerived {
   if (!derived) return draft
@@ -591,6 +796,8 @@ export function statusDraftWithDerived(
   return {
     kind: 'status',
     state,
+    // 6.49.0: the outcome is the draft's own fact, not the deriver's; it rides through.
+    ...(draft.tool_outcome ? { tool_outcome: draft.tool_outcome } : {}),
     agent_state: derived.agent_state,
     state_source: derived.state_source,
     state_since: derived.state_since,

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

@@ -153,12 +153,22 @@ export function transcriptTurnEnded(provider: SessionStreamProvider, path: strin
 
 /** The bounded tail as lines, with the same two open flags; null when it cannot be read. */
 function readTail(path: string | null): string[] | null {
+  return readTranscriptTailLines(path, TURN_END_TAIL_BYTES)
+}
+
+/**
+ * The last `maxBytes` of a transcript as lines, null when unreadable. Exported (6.49.0)
+ * so the live-delivery verifier reads the transcript the same way the drain does: the
+ * same open flags, the same fragment rule. Two readers with different rules would
+ * disagree about the same file on the day it mattered.
+ */
+export function readTranscriptTailLines(path: string | null, maxBytes: number): string[] | null {
   if (!path || !existsSync(path)) return null
   try {
     const fd = openSync(path, constants.O_RDONLY | constants.O_NOFOLLOW | constants.O_NONBLOCK)
     try {
       const size = fstatSync(fd).size
-      const start = Math.max(0, size - TURN_END_TAIL_BYTES)
+      const start = Math.max(0, size - maxBytes)
       const buf = Buffer.alloc(size - start)
       readSync(fd, buf, 0, buf.length, start)
       const lines = buf.toString('utf-8').split('\n')

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

@@ -124,6 +124,7 @@ import {
 import type { RegistryCheck, RegistryRejection, RegistryResult } from '../lib/agent-session-binding-registry.js'
 import { recordCosSpawn, releaseCosSpawn } from '../lib/agent-session-ownership-store.js'
 import { isValidNativeThreadId } from '../lib/native-thread-id.js'
+import { PEER_VERIFY_TIMEOUT_MS } from '../lib/session-peer-inbox.js'
 
 /**
  * Read side of the binding lease store.
@@ -333,6 +334,16 @@ export interface AgentSessionBindingsDeps {
   /** `deliverAttachedTurn` from `server/lib/attached-provider-adapter.ts`. */
   deliverAttachedTurn?: (request: AttachedTurnRequest) => Promise<unknown> | unknown
 
+  /**
+   * 6.49.0: put the turn INTO the running session before spawning a child for it.
+   *
+   * `makeLiveTurnDeliverer` from `server/lib/session-peer-inbox-deps.ts`. Optional so
+   * every existing test and every older wiring is byte-for-byte the 6.48.2 route; when
+   * absent, or when it answers anything but `ok`, the spawn path below runs unchanged.
+   * Only `reason` is read here; the vocabulary is the pure module's.
+   */
+  deliverLiveTurn?: (request: { provider: string; sessionId: string; prompt: string; verifyTimeoutMs?: number; clientTurnId?: string }) => Promise<{ ok: boolean; reason: string; verifiedBy?: string | null; pid?: number | null }>
+
   /**
    * The self-recursion ledger. Defaults to the real process-wide one.
    *
@@ -483,6 +494,10 @@ export type WriteRefusal =
   | 'provider_never_opened'
   | 'delivery_ambiguous'
   | 'turn_failed'
+  // 6.49.0: the live transport wrote a frame it could not see accepted. The turn is
+  // held as retryable and the retry re-reads before doing anything (see
+  // `session-peer-inbox.ts`); it is never a fence, because nothing here ran a child.
+  | 'live_unverified'
   // ------------------------------------------------------------------- fork
   //
   // Fork gets its OWN members rather than reusing the ones above, and the reason
@@ -555,6 +570,8 @@ export const WRITE_REASON_COPY: Record<Exclude<WriteRefusal, OccupancyReason>, s
     'The assistant never opened the thread, so nothing was sent. You can try again.',
   delivery_ambiguous:
     'COS lost track of this turn after sending it. Open the thread on your Mac and check before sending again.',
+  live_unverified:
+    'Sent, not yet confirmed. Send again: COS checks before sending twice.',
   turn_failed:
     'COS could not run this turn. Nothing was sent. You can try again.',
 
@@ -1265,6 +1282,22 @@ function plainBody(req: Request): Record<string, unknown> | null {
 
 export const ATTACHED_COPY = 'Attached. COS is driving the original thread.'
 export const TURN_SENT_COPY = 'Sent to the original thread.'
+/** 6.49.0: the turn went into the running session, where the desk will see it. */
+export const TURN_SENT_LIVE_COPY = 'Sent to the open session. It will show where you left it.'
+/**
+ * How long the route waits for the session's transcript to show acceptance.
+ *
+ * FOUR SECONDS, INSIDE THE CLIENT'S BUDGET. The lens's turn POST allows 25 s since app
+ * 6.9.487 (every other call keeps `fetchJSON`'s 10 s); the gate ahead of this point
+ * costs about a second, the connect up to 1.5 s, so four leaves margin even for the
+ * older ten. Measured acceptance on an idle session was under one second, so the
+ * budget only bites when the receiver is holding or dying, and those end as
+ * `live_unverified`, which the client may retry.
+ *
+ * THE SAME CONSTANT the transport defaults to (6.49.1): two numbers for one window
+ * meant a mutation deleting the route's field silently changed the budget.
+ */
+export const LIVE_VERIFY_BUDGET_MS = PEER_VERIFY_TIMEOUT_MS
 
 /**
  * The 202 copy. Says QUEUED and not sent, because at this instant the provider has
@@ -1880,6 +1913,24 @@ export function createAgentSessionBindingsRouter(deps: AgentSessionBindingsDeps)
     res.set('Cache-Control', 'private, no-store')
 
     const turnId = mintId()
+    // 6.49.1: where a turn's time goes, BEFORE the client's clock runs out. Miles's
+    // first three sends on 2026-09-16 read "lost track" on the lens with no server-side
+    // trace at all; this line is the trace. One `[turn timing]` per request at every
+    // exit that ANSWERS the client (the refusals and the live 200 through `respond`,
+    // the ledger replay and the 202 at their own `res.status` calls), with the stage
+    // ms and the first-byte-to-answer total, so a slow gate, a slow head read, a slow
+    // live hop and a request that never arrived are four different lines rather than
+    // one absence. Never the prompt.
+    const stageClock = process.hrtime.bigint()
+    const stages: string[] = []
+    let lastStage = stageClock
+    const stage = (name: string): void => {
+      const now = process.hrtime.bigint()
+      stages.push(`${name}=${Number((now - lastStage) / 1_000_000n)}ms`)
+      lastStage = now
+    }
+    const turnTiming = (outcome: string): string =>
+      `[agent-session-bindings] turn timing turnId=${turnId} outcome=${outcome} total=${Number((process.hrtime.bigint() - stageClock) / 1_000_000n)}ms ${stages.join(' ')}`
     /** The target we hold a claim on, released in the finally. */
     let claimedKey: string | null = null
     // Hoisted so the CATCH site can fence with evidence. `binding` and `head` are
@@ -1922,7 +1973,13 @@ export function createAgentSessionBindingsRouter(deps: AgentSessionBindingsDeps)
     let queued = false
 
     const respond = (status: number, payload: Record<string, unknown>): void => {
-      if (!res.headersSent) res.status(status).json(payload)
+      if (!res.headersSent) {
+        res.status(status).json(payload)
+        const outcome = typeof payload.outcome === 'string' ? payload.outcome : String(status)
+        const reason = typeof payload.reason === 'string' ? `/${payload.reason}` : ''
+        const via = typeof payload.via === 'string' ? `/${payload.via}` : ''
+        console.log(turnTiming(`${outcome}${reason}${via}`))
+      }
       // Remembered ONLY when the prompt may have reached the provider. A
       // pre-delivery refusal (stale epoch, malformed body, busy target) must stay
       // re-evaluatable: the binding may be fine by the time the client retries, and
@@ -2053,6 +2110,7 @@ export function createAgentSessionBindingsRouter(deps: AgentSessionBindingsDeps)
         const { status, ...rest } = already.result as Record<string, unknown>
         if (!res.headersSent) {
           res.status(typeof status === 'number' ? status : 200).json({ ...rest, replayed: true })
+          console.log(turnTiming(`replayed/${typeof rest.outcome === 'string' ? rest.outcome : String(status)}`))
         }
         return
       }
@@ -2096,9 +2154,11 @@ export function createAgentSessionBindingsRouter(deps: AgentSessionBindingsDeps)
       // open, and it is terminal here rather than a warning because COS has no
       // cross-process lock that could fence a live desktop writer.
       const verdict = runOccupancy(binding.provider, binding.nativeThreadId)
+      stage('gate')
       if (!verdict.attachable) return refuseTurn(verdict.reason ?? 'probe_failed')
 
       const head = await readHead(binding.provider, binding.nativeThreadId)
+      stage('head')
       if (head === null) return refuseTurn('native_head_unavailable')
       preTurnHeadDigest = head.digest
 
@@ -2122,9 +2182,62 @@ export function createAgentSessionBindingsRouter(deps: AgentSessionBindingsDeps)
       // A failed pin is FATAL, per the registry's own caller contract: an unpinned
       // binding can expire or be detached mid-turn, which defeats the lease.
       const pinned = deps.bindings.pin!(bindingId, turnId, now)
+      stage('pin')
       if (!pinned?.binding) return refuseTurn(registryRefusal(pinned?.reason))
       pinnedBindingId = bindingId
 
+      // 6.49.0: LIVE FIRST. If the session's own process is running -- a Desktop tab,
+      // a `claude` in iTerm, the same registry record either way -- the turn goes into
+      // it and paints where the user left the window, instead of into a resume child
+      // whose reply that window never shows. Before the 202 on purpose: a live delivery
+      // is a `completed` turn (terminal, ledgered, replay-safe), and a frame that could
+      // not be verified is a PRE-202 refusal, which the ledger does not record, so the
+      // client's retry re-evaluates rather than replaying a stale "no". The gate above
+      // still ran in full: this is the same admission, with a different last hop.
+      //
+      // The head is NOT acknowledged here. The session will move it when it answers,
+      // on its own clock; the next interactive turn reads that as a change and asks,
+      // which is the conservative side. Queued turns attach fresh and never notice.
+      if (typeof deps.deliverLiveTurn === 'function' && binding.provider === 'claude') {
+        let live: { ok: boolean; reason: string; verifiedBy?: string | null; pid?: number | null } | null = null
+        try {
+          live = await deps.deliverLiveTurn({
+            provider: binding.provider,
+            sessionId: binding.nativeThreadId,
+            prompt,
+            verifyTimeoutMs: LIVE_VERIFY_BUDGET_MS,
+            clientTurnId,
+          })
+        } catch (error) {
+          // A throw is a bug in the transport, not a fact about the session; the
+          // spawn path is the answer to both.
+          console.error(`[agent-session-bindings] live delivery threw: ${error instanceof Error ? error.message : error}`)
+          live = null
+        }
+        stage(`live(${live?.reason ?? 'threw'})`)
+        if (live?.ok) {
+          console.log(`[agent-session-bindings] turn delivered live provider=${binding.provider} turnId=${turnId} bindingId=${bindingId} verifiedBy=${live.verifiedBy ?? 'unknown'} pid=${live.pid ?? 'null'}`)
+          respond(200, {
+            turnId,
+            outcome: 'completed',
+            deliveryState: 'delivered',
+            via: 'live',
+            retryable: false,
+            changed: false,
+            revision: null,
+            reason: null,
+            reasonCopy: TURN_SENT_LIVE_COPY,
+          })
+          return
+        }
+        if (live && (live.reason === 'unverified' || live.reason === 'write_failed')) {
+          // Something may be in the session. Hold, never spawn over it.
+          return refuseTurn('live_unverified', { retryable: true, deliveryState: 'unknown' })
+        }
+        // disabled / not_claude / no_record / protocol_unsupported / connect_failed /
+        // suspect_expired: nothing reached a session. Spawn as always.
+      }
+
       // THE QUEUE POINT. Every gate is now behind us — body, replay, queued-prompt,
       // lease, target, epoch, fence, claim, occupancy, head baseline, pin — so a
       // refusal still reaches the user immediately and precisely. Only the spawn is
@@ -2146,6 +2259,11 @@ export function createAgentSessionBindingsRouter(deps: AgentSessionBindingsDeps)
         reason: null,
         reasonCopy: TURN_QUEUED_COPY,
       })
+      // The request's own timing line (6.49.1). `respond` cannot write it after this:
+      // its `headersSent` guard is what keeps the ledger-only outcome below from
+      // answering twice. QA found the two exits Miles actually hits (this 202 and the
+      // replay above) were the two with no line.
+      console.log(turnTiming('queued'))
 
       let delivery: Delivery
       deliveryAttempted = true

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

@@ -79,7 +79,7 @@ import {
   transcriptWatcherDegraded,
   readTranscriptSeedLines,
 } from '../lib/session-transcript-watcher.js'
-import { draftsFromLine, statusDraftWithDerived, type DerivedStatusFields } from '../lib/session-stream-events.js'
+import { foldSeedOutcomes, 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'
@@ -387,7 +387,9 @@ agentSessionStreamRouter.get('/agent-sessions/:provider/:sessionId/stream', asyn
   if (!replayable && path !== null && startOffset > 0) {
     try {
       const lines = await readTranscriptSeedLines(path, startOffset)
-      const drafts = lines.flatMap(line => draftsFromLine(provider, line))
+      // 6.49.1: each seeded step carries its own outcome (`foldSeedOutcomes`), since
+      // the status drafts that carried them live are dropped from the seed below.
+      const drafts = foldSeedOutcomes(lines.flatMap(line => draftsFromLine(provider, line)))
       // Status drafts are dropped from the seed: they describe the state at some past
       // moment and the opening status above is the CURRENT one. Replaying an old
       // `done` after it would tell the client the live session had finished.

package/server/routes/health.ts

@@ -80,6 +80,29 @@ import {
   threadAttachHealthFields,
 } from '../lib/thread-attach-capability.js'
 import { sessionHooksHealthFields } from '../lib/session-hooks-runtime.js'
+import { continueLiveEnabled, liveDeliveryStats } from '../lib/session-peer-inbox-deps.js'
+
+/**
+ * 6.49.0: which last hop a Continue takes, and how often each fell back.
+ *
+ * `enabled` is the flag as read RIGHT NOW; the counters are this process's. A
+ * reader who sees `enabled: true` and `delivered: 0` with fallbacks under
+ * `no_record` has a session registry the server cannot see; under `unverified`,
+ * a session that is holding or dying. Both are diagnoses, not guesses.
+ */
+export function continueLiveHealthFields(): Record<string, unknown> {
+  const stats = liveDeliveryStats()
+  return {
+    continueLive: {
+      enabled: continueLiveEnabled(),
+      attempts: stats.attempts,
+      delivered: stats.delivered,
+      fallbacks: stats.fallbacks,
+      lastReason: stats.lastReason,
+      lastAt: stats.lastAt,
+    },
+  }
+}
 
 export const healthRouter = Router()
 
@@ -351,6 +374,7 @@ healthRouter.get('/health', async (_req, res) => {
     server_version: managedServerVersion(),
     ...threadAttachHealthFields(threadAttach),
     ...sessionHooksHealthFields(),
+    ...continueLiveHealthFields(),
     server_instance_id: getServerInstanceId(),
     boot_id: serverMetrics.bootId,
     generation_id: getServerGenerationId(),