@gotcos/glasses-server 6.50.4 → 6.52.0

package/server/lib/agent-session-store.ts

@@ -11,7 +11,7 @@ import { homedir } from 'node:os'
 import { join } from 'node:path'
 import { createInterface } from 'node:readline'
 import { promisify } from 'node:util'
-import { unwrapPeerMessage } from './session-stream-events.js'
+import { codexUserAsk, unwrapPeerMessage } from './session-stream-events.js'
 
 const execFileAsync = promisify(execFile)
 
@@ -484,6 +484,30 @@ export function payloadText(payload: Record<string, unknown>): string | null {
   return joined || null
 }
 
+/**
+ * What the person typed, out of one Codex `response_item/message` user row, or null
+ * (6.52.0).
+ *
+ * `payloadText` joins every block, so the AGENTS.md block Codex writes as a user message
+ * ("# AGENTS.md instructions for /Users/…", the FIRST user row in 469 rollouts on this
+ * Mac) became the session's title, first prompt and opening DISCUSSION line, and typed
+ * words after an `<image>` block were dropped with the wrapper. `codexUserAsk` reads the
+ * row block by block; the stream's `prompt` line uses the same function, so the two
+ * cannot disagree about what was asked.
+ */
+export function codexUserText(payload: Record<string, unknown>): string | null {
+  const content = payload.content
+  if (typeof content === 'string') return codexUserAsk([content])
+  if (!Array.isArray(content)) return null
+  return codexUserAsk(content.map(block => {
+    if (!block || typeof block !== 'object') return null
+    const type = String((block as { type?: unknown }).type ?? '')
+    if (type !== 'text' && type !== 'input_text') return null
+    const text = (block as { text?: unknown }).text
+    return typeof text === 'string' ? text : null
+  }))
+}
+
 export function isoFromMtime(mtimeMs: number): string {
   return new Date(mtimeMs).toISOString()
 }
@@ -912,7 +936,7 @@ export async function peekCodexMeta(path: string): Promise<{ id: string; cwd: st
     if (!title && obj.type === 'response_item' && obj.payload && typeof obj.payload === 'object') {
       const payload = obj.payload as Record<string, unknown>
       if (payload.type === 'message' && payload.role === 'user') {
-        const textBody = payloadText(payload)
+        const textBody = codexUserText(payload)
         if (textBody && !isWrapperPrompt(textBody)) title = firstLineTitle(textBody)
       }
     }
@@ -1624,12 +1648,15 @@ export interface AgentSessionDetail {
 export async function parseAgentSession(
   provider: AgentProvider,
   path: string,
-  opts: { maxBytes?: number; headBytes?: number; tailBytes?: number } = {},
+  opts: { maxBytes?: number; headBytes?: number; tailBytes?: number; codexThreadName?: string } = {},
 ): Promise<AgentSessionDetail> {
   const st = await stat(path)
   const maxBytes = opts.maxBytes ?? AGENT_SESSION_MAX_FILE_BYTES
   const truncated = st.size > maxBytes
-  let title = ''
+  // 6.52.0: a Codex thread's own name (`session_index.jsonl`, what the Codex app shows)
+  // titles the detail the way it already titles the list row. The first ask is still
+  // read below and published as `first_prompt`.
+  let title = provider === 'codex' ? (opts.codexThreadName ?? '').trim() : ''
   let project = ''
   let gitBranch = ''
   let sessionId = path.split('/').pop()?.replace(/\.jsonl$/, '') || ''
@@ -1771,7 +1798,10 @@ export async function parseAgentSession(
         continue
       }
       if (kind !== 'message' || payload.role === 'developer') continue
-      const text = payloadText(payload)
+      // 6.52.0: a user row is read block by block (`codexUserText`), so the AGENTS.md
+      // block Codex writes as a user message is not the title, the first prompt or a
+      // DISCUSSION turn. The assistant path is unchanged.
+      const text = payload.role === 'assistant' ? payloadText(payload) : codexUserText(payload)
       if (!text || isWrapperPrompt(text)) continue
       if (payload.role === 'assistant') {
         assistantCount += 1

package/server/lib/agent-session-turns.ts

@@ -26,6 +26,7 @@
 
 import { open, stat } from 'node:fs/promises'
 import {
+  codexUserText,
   latestAssistantReply,
   isWrapperPrompt,
   parseJsonLine,
@@ -112,7 +113,9 @@ export function sessionTurnFromRecord(provider: AgentProvider, obj: Record<strin
     const payload = obj.payload as Record<string, unknown>
     if (String(payload.type ?? '') !== 'message') return null
     if (payload.role !== 'user' && payload.role !== 'assistant') return null
-    const text = payloadText(payload)
+    // 6.52.0: a user row block by block, so typed words after an `<image>` block are kept
+    // and an attached-file message reads as the request that was typed.
+    const text = payload.role === 'user' ? codexUserText(payload) : payloadText(payload)
     if (!text) return null
     return shaped(payload.role, text, iso(obj.timestamp))
   }

package/server/lib/claude-bridge.ts

@@ -59,6 +59,7 @@ import {
 import { terminalProviderAuthFailure } from './provider-terminal-error.js'
 import { claudePermissionArgs, getClaudeTrustMode } from './claude-permissions.js'
 import { terminateProviderProcess } from './provider-process-lifecycle.js'
+import { teeJobTrail, type JobTrailDraft } from './job-trail.js'
 
 // Inactivity = no stdout data for this long → kill (catches stalls)
 const INACTIVITY_BY_MODEL: Record<ClaudeModelPreference, number> = {
@@ -336,6 +337,9 @@ export interface StreamCallbacks {
   onActivityLine?: (line: ActivityPreviewLine) => void
   onStart?: (model: ModelPreference, sessionId: string, cliSessionId?: string, metadata?: ModelRunMetadata) => void
   onProviderProcess?: (metadata: ProviderProcessMetadata) => boolean | void | Promise<boolean | void>
+  /** 6.52.0: readable steps of a durable Messages job (lib/job-trail.ts). Optional, and
+   * absent on every path that is not a durable job with the trail on. */
+  onTrail?: (draft: JobTrailDraft) => void
 }
 
 /** Claude CLI can emit `subtype: success` with `is_error: true`; the boolean
@@ -964,6 +968,11 @@ export async function callClaudeStreaming(
     }
   })
 
+  // 6.52.0: the Messages trail, a SECOND stdout reader registered after the one above, so
+  // that handler sees every chunk first and nothing it decides can change. Without an
+  // `onTrail` (legacy /api/query, openai-compat, COS_MESSAGES_TRAIL=0) this attaches nothing.
+  teeJobTrail(proc.stdout, 'claude', callbacks.onTrail)
+
   proc.stderr.on('data', (chunk: Buffer) => {
     // stderr activity also counts — Claude CLI logs progress there
     resetInactivity()

package/server/lib/client-liveness.ts

@@ -0,0 +1,50 @@
+// When a client that can ANSWER a session question last asked for them (6.52.0).
+//
+// THE SIGNAL, AND WHY THIS ONE. The permission broker holds a session question or a tool
+// approval only while a lens or phone client could show it and send the answer back. The
+// only proof of that is a client asking for the questions: an authenticated
+// `GET /api/session-questions?client=glasses|phone` (X-Cos-Token, never the hook token)
+// within the last 30 s, checked at admission and again while anything is held.
+//
+// Rejected, and why:
+//   - the client-instance claim (`POST /api/client-instance/claim`): every COS Glasses copy
+//     since 6.9.505 posts it every 15 s, including the ones with no question UI. Counting
+//     it made a 6.9.511 app on the phone read as "someone can answer", so the Mac held
+//     questions and approvals nobody could see for up to 110 s (coordinator review,
+//     2026-09-19). A claim says a copy is alive, not that it can answer.
+//   - the display stream: an open socket is not alive (a half-open connection, a
+//     `probe=1` connect, COS Control and curl all read the same).
+//   - client diagnostics and meeting chunks: lossy, or only while recording.
+//
+// So an app that has never heard of this feature never calls the route, and the broker
+// answers `{}` (the Mac's own dialog) for it, exactly as before. The poll also bounds
+// delivery: a copy whose timers are frozen (a locked phone) cannot poll, and could not
+// show the question either.
+//
+// In memory: a restart forgets it, and the next poll restores it. Until then nothing is
+// held, which is the native dialog, the safe side.
+
+let lastPollAt: number | null = null
+
+/** A stored stamp this far ahead of a new poll means the clock stepped back. */
+const CLOCK_STEP_BACK_MS = 5_000
+
+/**
+ * A counting questions poll answered at `at` (server clock). Never moves backwards for a
+ * slower request answered later, but a clock that stepped back is followed: a stamp left in
+ * the future would read stale to the broker, and ignoring every poll until the clock caught
+ * up would leave no live client for that long.
+ */
+export function noteQuestionsPoll(at: number): void {
+  if (!Number.isFinite(at)) return
+  if (lastPollAt === null || at > lastPollAt || lastPollAt - at > CLOCK_STEP_BACK_MS) lastPollAt = at
+}
+
+/** When the newest authenticated questions poll arrived, or null when none has since boot. */
+export function lastQuestionsPollAt(): number | null {
+  return lastPollAt
+}
+
+export function __resetClientLivenessForTests(): void {
+  lastPollAt = null
+}

package/server/lib/codex-bridge.ts

@@ -84,6 +84,7 @@ import {
 } from '../../shared/media-attachment.js'
 import { terminalProviderAuthFailure } from './provider-terminal-error.js'
 import { terminateProviderProcess } from './provider-process-lifecycle.js'
+import { teeJobTrail } from './job-trail.js'
 
 const INACTIVITY_MS = 180_000
 const WALL_MAX_MS = 900_000
@@ -833,6 +834,11 @@ export async function callCodexStreaming(
     }
   })
 
+  // 6.52.0: the Messages trail, a SECOND stdout reader registered after the one above, so
+  // that handler sees every chunk first and nothing it decides can change. Without an
+  // `onTrail` (legacy /api/query, openai-compat, COS_MESSAGES_TRAIL=0) this attaches nothing.
+  teeJobTrail(proc.stdout, 'codex', callbacks.onTrail)
+
   proc.stderr.on('data', (chunk: Buffer) => {
     resetInactivity()
     stderr += chunk.toString()

package/server/lib/codex-live-queue-deps.ts

@@ -0,0 +1,135 @@
+// The real world behind `codex-live-queue.ts`: the binary, the process, the counters.
+//
+// Kept apart from the pure module so the verdict rules there never touch a process.
+// Nothing here writes a file; the only write is the one `codex queue` makes itself.
+
+import { spawn } from 'node:child_process'
+import { resolveProviderBinary } from './provider-binary.js'
+import {
+  codexLiveQueueEnabled,
+  deliverOverCodexQueue,
+  type CodexLiveResult,
+  type CodexQueueRun,
+} from './codex-live-queue.js'
+
+/** Output past this is not a confirmation line; keep memory bounded if the CLI misbehaves. */
+const MAX_CAPTURE_BYTES = 64 * 1024
+
+/**
+ * Run the CLI with no shell, a closed stdin and a hard timeout. Always resolves.
+ *
+ * The environment is the server's own, so `CODEX_HOME` (if an operator set one) is the
+ * same one occupancy read the writer lock from: the queue row lands in the database the
+ * holder is watching.
+ */
+export function runCodexQueueCli(binary: string, args: readonly string[], timeoutMs: number): Promise<CodexQueueRun> {
+  return new Promise(resolve => {
+    let stdout = ''
+    let stderr = ''
+    let timedOut = false
+    let settled = false
+    const finish = (run: CodexQueueRun) => {
+      if (settled) return
+      settled = true
+      resolve(run)
+    }
+    let child: ReturnType<typeof spawn>
+    try {
+      // Its own process group, so the ceiling can kill anything it started too: a
+      // grandchild holding stdout open would otherwise keep 'close' from ever firing
+      // (found by the hang test, which waited out the whole `sleep`).
+      child = spawn(binary, [...args], { stdio: ['ignore', 'pipe', 'pipe'], shell: false, detached: true })
+    } catch (error) {
+      finish({ code: null, stdout: '', stderr: '', timedOut: false, spawnError: error instanceof Error ? error.message : 'spawn threw' })
+      return
+    }
+    const timer = setTimeout(() => {
+      timedOut = true
+      try { if (typeof child.pid === 'number') process.kill(-child.pid, 'SIGKILL') } catch { /* group already gone */ }
+      try { child.kill('SIGKILL') } catch { /* already gone */ }
+      // Answer at the ceiling, not whenever the pipes finally close.
+      finish({ code: null, stdout, stderr, timedOut: true, spawnError: null })
+    }, Math.max(100, timeoutMs))
+    timer.unref?.()
+    child.stdout?.on('data', (chunk: Buffer) => { if (stdout.length < MAX_CAPTURE_BYTES) stdout += chunk.toString('utf-8') })
+    child.stderr?.on('data', (chunk: Buffer) => { if (stderr.length < MAX_CAPTURE_BYTES) stderr += chunk.toString('utf-8') })
+    child.on('error', error => {
+      clearTimeout(timer)
+      // ENOENT/EACCES arrive here before any byte ran: nothing was queued.
+      finish({ code: null, stdout, stderr, timedOut: false, spawnError: error.message })
+    })
+    child.on('close', code => {
+      clearTimeout(timer)
+      finish({ code: timedOut ? null : code, stdout, stderr, timedOut, spawnError: null })
+    })
+  })
+}
+
+export interface CodexLiveStats {
+  attempts: number
+  delivered: number
+  /** By reason, so the health row says WHY a Codex Continue did not go live. */
+  fallbacks: Record<string, number>
+  lastReason: string | null
+  lastAt: number | null
+}
+
+const stats: CodexLiveStats = { attempts: 0, delivered: 0, fallbacks: {}, lastReason: null, lastAt: null }
+
+/** For `/api/health`. A copy, never the live object. */
+export function codexLiveStats(): CodexLiveStats {
+  return { ...stats, fallbacks: { ...stats.fallbacks } }
+}
+
+/** Tests only. */
+export function __resetCodexLiveStatsForTests(): void {
+  stats.attempts = 0
+  stats.delivered = 0
+  stats.fallbacks = {}
+  stats.lastReason = null
+  stats.lastAt = null
+}
+
+/**
+ * The route's Codex dep. `disabled` and `no_holder` are not counted as attempts: the
+ * first is the operator's choice and the second is the ordinary spawn path, so neither
+ * should make the health row look busy.
+ */
+export function makeCodexLiveDeliverer(deps?: {
+  run?: typeof runCodexQueueCli
+  resolveBinary?: () => string | null
+  enabled?: () => boolean
+}) {
+  return async (request: { provider: string; sessionId: string; prompt: string; foreignHolder?: boolean }): Promise<CodexLiveResult> => {
+    const result = await deliverOverCodexQueue(
+      {
+        provider: request.provider,
+        sessionId: request.sessionId,
+        prompt: request.prompt,
+        enabled: (deps?.enabled ?? codexLiveQueueEnabled)(),
+        foreignHolder: request.foreignHolder === true,
+      },
+      {
+        resolveBinary: deps?.resolveBinary ?? (() => {
+          const resolved = resolveProviderBinary('codex')
+          return resolved.ok ? resolved.path : null
+        }),
+        run: deps?.run ?? runCodexQueueCli,
+        now: () => Date.now(),
+        log: (level, event, detail) => {
+          const line = `[${event}] ${JSON.stringify(detail)}`
+          if (level === 'warn') console.warn(line)
+          else console.log(line)
+        },
+      },
+    )
+    if (result.reason !== 'disabled' && result.reason !== 'no_holder') {
+      stats.attempts += 1
+      if (result.ok) stats.delivered += 1
+      else stats.fallbacks[result.reason] = (stats.fallbacks[result.reason] ?? 0) + 1
+      stats.lastReason = result.reason
+      stats.lastAt = Date.now()
+    }
+    return result
+  }
+}

package/server/lib/codex-live-queue.ts

@@ -0,0 +1,232 @@
+// Continue into a Codex thread the Codex app already has open, through Codex's own queue.
+//
+// ---------------------------------------------------------------------------
+// WHY THIS EXISTS (6.51.0)
+// ---------------------------------------------------------------------------
+// The attached path spawns `codex exec resume <id> -`. When ChatGPT.app (Codex Desktop)
+// has the thread open, its app-server holds the thread's writer lock for as long as the
+// thread is LOADED, idle included, and the child dies in about 0.2 s with "thread
+// <id> already has an active writer" -- AFTER the adapter has written the prompt to its
+// stdin, so the turn lands as `ambiguous` and fences the thread until an operator
+// releases it. Production has two such fences on record (August, provider_exit_nonzero,
+// exit 1, ~0.7 s). So for a thread the Codex app holds, today's Continue cannot work.
+//
+// Codex ships the fix itself. `codex queue --thread <id> --message <text>` inserts a row
+// into `$CODEX_HOME/queue_1.sqlite`, and every app-server watches that database for writes
+// from OTHER processes (`PRAGMA data_version` plus the `queued_thread_revisions` table).
+// Canary, 2026-09-19, scratch CODEX_HOME, codex-cli 0.155.0-alpha.9.2, holder =
+// `codex app-server` over stdio exactly as ChatGPT.app runs it:
+//
+//   holder mid-turn     queued in 0.05 s; the holder started it 10 ms after the running
+//                       turn's `task_complete`, as an ordinary user turn
+//   holder idle         the holder picked it up and started it 7.35 s later
+//   no holder           the row waits in the queue until something opens the thread;
+//                       no daemon is started
+//   writer lock         held by the holder the whole time the thread is loaded, idle too
+//   exec resume, held   exits 1 in 0.2 s: "already has an active writer"
+//   --message=-h        queued the literal text "-h" (the `=` form is flag-safe)
+//   --message -         queued a literal "-": the CLI does NOT read stdin
+//   unknown thread      exit 1, "failed to queue session message: ... no rollout found",
+//                       and nothing queued
+//
+// So this is the Codex counterpart of the Claude peer inbox (`session-peer-inbox.ts`),
+// and a better one: the message is a real user turn in the app's own queue, visible and
+// editable there, and delivered by the engine at exactly the end of the running turn.
+//
+// ---------------------------------------------------------------------------
+// THE ONE CONCESSION: THE PROMPT RIDES IN ARGV
+// ---------------------------------------------------------------------------
+// The attached adapter keeps prompts off argv. `codex queue` has no stdin form (measured
+// above), and the alternative -- a second `codex app-server` on the user's CODEX_HOME to
+// send `thread/queue/add` over JSON-RPC -- starts a whole engine that can run automations
+// and memory jobs on its own. The CLI lives about 50 ms, is spawned without a shell, and
+// macOS shows a process's arguments only to its own user. The prompt never reaches a log
+// line here: only lengths, reasons and the queued id do.
+//
+// ---------------------------------------------------------------------------
+// WHAT COUNTS AS DELIVERED
+// ---------------------------------------------------------------------------
+// Exit 0 AND the CLI's confirmation line naming OUR thread id. That line is printed from
+// the insert's own RETURNING row, so it is positive evidence the row exists. Anything
+// else that might have inserted -- exit 0 without the line, a timeout, a kill, a nonzero
+// exit we cannot place -- is `unverified`, and the route fences the thread as an
+// ambiguous delivery rather than retrying, because a retried queue write puts the same
+// sentence into the thread twice. A clap usage error (exit 2) queued nothing.
+
+import { isValidNativeThreadId } from './native-thread-id.js'
+
+export type CodexLiveReason =
+  /** The row is in the holder's queue. */
+  | 'delivered'
+  /** `COS_CODEX_LIVE_QUEUE=0`. Nothing sent. */
+  | 'disabled'
+  /** Not a Codex turn, or not a thread the app holds. Nothing sent; the spawn path is right. */
+  | 'no_holder'
+  | 'invalid_request'
+  /** No usable `codex` binary. Nothing sent. */
+  | 'binary_not_found'
+  /** The CLI never started. Nothing sent. */
+  | 'spawn_failed'
+  /** The CLI said it queued nothing ("failed to queue session message"). */
+  | 'refused'
+  /** Something may be queued. Hold; never retry, never spawn over it. */
+  | 'unverified'
+
+export interface CodexLiveResult {
+  ok: boolean
+  reason: CodexLiveReason
+  verifiedBy: 'codex-queue' | null
+  /** Codex's own id for the queued submission, when delivered. */
+  queuedId: string | null
+  elapsedMs: number
+  /** Always null: the holder is the app-server, not a process this module talks to. */
+  pid: null
+}
+
+export interface CodexQueueRun {
+  /** Null when the process was killed or never started. */
+  code: number | null
+  stdout: string
+  stderr: string
+  timedOut: boolean
+  /** Set when the process could not be started at all. */
+  spawnError: string | null
+}
+
+export interface CodexLiveDeps {
+  /** An absolute, verified `codex` path, or null. */
+  resolveBinary: () => string | null
+  /** Run the CLI without a shell. MUST resolve, never reject. */
+  run: (binary: string, args: readonly string[], timeoutMs: number) => Promise<CodexQueueRun>
+  now: () => number
+  log?: (level: 'info' | 'warn', event: string, detail: Record<string, unknown>) => void
+}
+
+export interface CodexLiveRequest {
+  provider: string
+  sessionId: string
+  prompt: string
+  /** The flag read at the call site, so this module never reads the environment. */
+  enabled: boolean
+  /**
+   * The route's own occupancy verdict: a live process that is not ours holds this
+   * thread's writer lock. Without a holder the queue row would wait until somebody opens
+   * the thread, which is not a Continue; the spawn path is the right answer there.
+   */
+  foreignHolder: boolean
+  timeoutMs?: number
+}
+
+/** Measured 50-70 ms. The ceiling sits inside the phone's 10 s turn budget with room for the gate. */
+export const CODEX_QUEUE_TIMEOUT_MS = 5_000
+
+/** Codex 0.155's confirmation line, printed from the insert's RETURNING row. */
+const CONFIRMATION = /^Queued message (\S+) for thread (\S+)\.\s*$/m
+
+/** The CLI's own "nothing was queued" prefix (the add failed before or at the insert). */
+const NOTHING_QUEUED = /failed to queue session message/i
+
+/**
+ * clap's argument errors (exit 2): a `codex` without the `queue` subcommand, or one that
+ * renamed a flag. The parser refuses before any command runs, so nothing was queued.
+ */
+const USAGE_ERROR = /^error: (unrecognized subcommand|unexpected argument|invalid value|the following required arguments)/m
+
+/**
+ * The argv, in the `--flag=value` form on purpose: clap reads `--message -h` as a flag
+ * and `--message=-h` as text (measured). The thread id is validated by the caller, and
+ * this refuses anything that is not a native thread id anyway, because it is about to
+ * become a process argument.
+ */
+export function buildCodexQueueArgs(threadId: string, prompt: string): string[] {
+  if (!isValidNativeThreadId(threadId)) throw new Error('buildCodexQueueArgs: invalid thread id')
+  if (typeof prompt !== 'string' || prompt.trim().length === 0 || prompt.includes('\0')) {
+    throw new Error('buildCodexQueueArgs: unusable prompt')
+  }
+  return ['queue', `--thread=${threadId}`, `--message=${prompt}`]
+}
+
+/** Codex's queued-submission id when the line names OUR thread, else null. */
+export function parseCodexQueueConfirmation(stdout: string, threadId: string): string | null {
+  const match = CONFIRMATION.exec(typeof stdout === 'string' ? stdout : '')
+  if (!match) return null
+  return match[2]!.toLowerCase() === threadId.toLowerCase() ? match[1]! : null
+}
+
+/**
+ * One CLI run to a verdict. Pure, and total: every shape lands on a reason, and every
+ * shape that could have inserted a row without saying so lands on `unverified`.
+ */
+export function classifyCodexQueueRun(run: CodexQueueRun, threadId: string): { reason: CodexLiveReason; queuedId: string | null } {
+  if (run.spawnError !== null) return { reason: 'spawn_failed', queuedId: null }
+  if (run.timedOut || run.code === null) return { reason: 'unverified', queuedId: null }
+  if (run.code === 0) {
+    const queuedId = parseCodexQueueConfirmation(run.stdout, threadId)
+    return queuedId ? { reason: 'delivered', queuedId } : { reason: 'unverified', queuedId: null }
+  }
+  if (NOTHING_QUEUED.test(run.stderr)) return { reason: 'refused', queuedId: null }
+  if (run.code === 2 && USAGE_ERROR.test(run.stderr)) return { reason: 'refused', queuedId: null }
+  return { reason: 'unverified', queuedId: null }
+}
+
+/** Put the turn into the Codex app's own queue for this thread, and say honestly what happened. */
+export async function deliverOverCodexQueue(request: CodexLiveRequest, deps: CodexLiveDeps): Promise<CodexLiveResult> {
+  const started = deps.now()
+  const done = (reason: CodexLiveReason, queuedId: string | null = null): CodexLiveResult => ({
+    ok: reason === 'delivered',
+    reason,
+    verifiedBy: reason === 'delivered' ? 'codex-queue' : null,
+    queuedId,
+    elapsedMs: Math.max(0, deps.now() - started),
+    pid: null,
+  })
+  if (!request.enabled) return done('disabled')
+  if (request.provider !== 'codex' || request.foreignHolder !== true) return done('no_holder')
+  let args: string[]
+  try {
+    args = buildCodexQueueArgs(request.sessionId, request.prompt)
+  } catch {
+    return done('invalid_request')
+  }
+  let binary: string | null
+  try {
+    binary = deps.resolveBinary()
+  } catch {
+    binary = null
+  }
+  if (!binary) return done('binary_not_found')
+
+  let run: CodexQueueRun
+  try {
+    run = await deps.run(binary, args, request.timeoutMs ?? CODEX_QUEUE_TIMEOUT_MS)
+  } catch (error) {
+    // `run` must not reject; if it does we cannot say whether the CLI got as far as the
+    // insert, so this is the ambiguous answer, never the "nothing sent" one.
+    deps.log?.('warn', 'codex-live-queue', { outcome: 'run_threw', detail: error instanceof Error ? error.message.slice(0, 120) : 'unknown' })
+    return done('unverified')
+  }
+  const verdict = classifyCodexQueueRun(run, request.sessionId)
+  deps.log?.(verdict.reason === 'delivered' ? 'info' : 'warn', 'codex-live-queue', {
+    outcome: verdict.reason,
+    code: run.code,
+    timedOut: run.timedOut,
+    promptChars: request.prompt.length,
+    queuedId: verdict.queuedId,
+    // The CLI's own first stderr line names the failure; it cannot carry the prompt,
+    // which only ever travels in argv. Bounded anyway.
+    stderr: verdict.reason === 'delivered' ? undefined : run.stderr.split('\n').find(l => l.trim().length > 0)?.slice(0, 160),
+  })
+  return done(verdict.reason, verdict.queuedId)
+}
+
+/**
+ * `COS_CODEX_LIVE_QUEUE`. ON unless set to `0`.
+ *
+ * Default-on, unlike `COS_CONTINUE_LIVE`, because the path it replaces cannot work: for a
+ * thread the Codex app holds, the spawn fails every time and leaves a fence. Only a
+ * thread with a foreign writer ever reaches this module, so a thread nobody holds keeps
+ * the 6.50 path exactly.
+ */
+export function codexLiveQueueEnabled(env: NodeJS.ProcessEnv = process.env): boolean {
+  return env.COS_CODEX_LIVE_QUEUE !== '0'
+}

package/server/lib/codex-turn-clock.ts

@@ -0,0 +1,36 @@
+// When did the Codex engine close this thread's turn? (6.51.0)
+//
+// Read from the rollout itself, never from its mtime: the engine writes `task_complete`
+// (or `turn_complete`) as the turn's last record and `task_started` as the next turn's
+// first, so the NEWEST of those markers in the tail is the answer. The tail rule is the
+// drain's own (`transcriptTurnVerdict`), so the gate and the drain cannot disagree about
+// the same file.
+
+import { statSync } from 'node:fs'
+import { transcriptPathFor, type NativeHeadDeps } from './native-head.js'
+import { transcriptTurnVerdict } from './thread-turn-queue-store.js'
+
+/**
+ * The rollout's mtime when its newest turn marker closed a turn; null on any doubt (no
+ * rollout, an unreadable tail, a tail with no marker, or a turn that is open).
+ */
+export function readCodexTurnEndedAtMs(
+  threadId: string,
+  nativeHeadDeps: NativeHeadDeps,
+  deps: {
+    pathFor?: typeof transcriptPathFor
+    verdict?: typeof transcriptTurnVerdict
+    mtimeMs?: (path: string) => number | null
+  } = {},
+): number | null {
+  try {
+    const path = (deps.pathFor ?? transcriptPathFor)('codex', threadId, nativeHeadDeps)
+    if (!path) return null
+    const verdict = (deps.verdict ?? transcriptTurnVerdict)('codex', path)
+    if (!verdict || verdict.ended !== true || verdict.reason !== 'codex_complete') return null
+    const mtime = (deps.mtimeMs ?? ((p: string) => statSync(p).mtimeMs))(path)
+    return typeof mtime === 'number' && Number.isFinite(mtime) ? mtime : null
+  } catch {
+    return null
+  }
+}

package/server/lib/cursor-bridge.ts

@@ -63,6 +63,7 @@ import {
   type MediaAttachmentRef,
 } from '../../shared/media-attachment.js'
 import { terminalProviderAuthFailure } from './provider-terminal-error.js'
+import { teeJobTrail } from './job-trail.js'
 
 const INACTIVITY_MS = 180_000
 const WALL_MAX_MS = 900_000
@@ -666,6 +667,11 @@ export async function callCursorStreaming(
     }
   })
 
+  // 6.52.0: the Messages trail, a SECOND stdout reader registered after the one above, so
+  // that handler sees every chunk first and nothing it decides can change. Without an
+  // `onTrail` (legacy /api/query, openai-compat, COS_MESSAGES_TRAIL=0) this attaches nothing.
+  teeJobTrail(proc.stdout, 'cursor', callbacks.onTrail)
+
   proc.stderr.on('data', (chunk: Buffer) => {
     resetInactivity()
     stderr += chunk.toString()