@gotcos/glasses-server 6.50.3 → 6.51.0

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-stop-followup.ts

@@ -0,0 +1,134 @@
+// A queued turn for a Cursor chat, handed to Cursor by its own Stop hook (6.51.0).
+//
+// ---------------------------------------------------------------------------
+// WHY THE STOP HOOK, AND ONLY THE STOP HOOK
+// ---------------------------------------------------------------------------
+// Cursor has no `queue --thread` and no socket a process outside it can write into. A
+// Cursor IDE composer cannot be resumed from outside either: Gate 0 (2026-08-20) found
+// `--resume` on an IDE transcript to be a clobber / wrong-store landmine, and that stays
+// refused. But Cursor 3.21 runs a `stop` hook when a composer's turn ends, and when the
+// hook answers `{"followup_message": "..."}` Cursor submits that text into THE SAME
+// composer as the next message (`submitChatMaybeAbortCurrent(composerId, text,
+// {isAutoFollowupFromStopHook: true})`, read from the shipped workbench). That is the
+// exact shape of "deliver when the current turn ends", from inside the composer.
+//
+// And the hook is already there: Cursor reads `~/.claude/settings.json` hooks by default
+// (its third-party extensibility setting), so the COS session hook installed on 9/15 has
+// been running for Cursor composers since then -- 478 Cursor events in the ledger by
+// 9/18, stdin = Cursor's own payload (`conversation_id`, `status`, `loop_count`,
+// `cursor_version`), environment `CURSOR_VERSION`. Nothing new is installed for Cursor;
+// the one script gains one Cursor-only branch.
+//
+// ---------------------------------------------------------------------------
+// WHAT THIS CANNOT DO, SAID PLAINLY
+// ---------------------------------------------------------------------------
+// It delivers only at the END OF A TURN. An idle composer fires no Stop, so a turn cannot
+// be put into it from outside; the queue admits a Cursor turn only while the hooks show
+// that composer mid-turn (`native_thread_working`), and a turn that is never claimed
+// expires on the queue's ordinary clock and says so. Cursor also caps consecutive hook
+// follow-ups (its default loop limit, reset by any message typed in Cursor), so a long
+// queue can stop short; the rest waits for the next typed message and its Stop.
+//
+// ---------------------------------------------------------------------------
+// ONE DELIVERER
+// ---------------------------------------------------------------------------
+// The queue drainer never delivers a Cursor turn (see `drainThread`): a turn could
+// otherwise be claimed here and delivered there in the same second. Claiming marks the
+// row `delivered` before the text leaves, and a Stop that is not `completed` (aborted,
+// error) claims nothing -- a queued sentence must not follow a turn the user just
+// stopped.
+
+import { isValidNativeThreadId } from './native-thread-id.js'
+import type { QueuedThreadTurn } from './thread-turn-queue.js'
+
+export interface CursorStopFacts {
+  conversationId: string
+  status: string
+  loopCount: number | null
+  cursorVersion: string
+  /** The envelope's `ts`: when the hook started, epoch ms from the same Mac clock. */
+  hookStartedAtMs: number | null
+}
+
+/** The hook's curl gives up this long after it starts (`--max-time 3`). */
+export const CURSOR_HOOK_WAIT_MS = 3_000
+/**
+ * A claim is made only this soon after the hook started, so its reply is written with at
+ * least a second to spare before the hook stops listening. Past it the turn stays
+ * `waiting` for the next Stop.
+ */
+export const CURSOR_STOP_MAX_AGE_MS = 2_000
+/** A stamp this far in the future is a clock that moved, not a hook; no claim. */
+export const CURSOR_STOP_MAX_SKEW_MS = 5_000
+
+/**
+ * Is the hook that sent this still listening? A socket check cannot answer that (QA,
+ * 6.51.0): when the event loop is blocked past the hook's 3 s, curl gives up and closes,
+ * but Node reads the request bytes before the close, so the handler sees an open socket,
+ * claims the turn, and writes the reply to nobody -- the row reads `delivered` and Cursor
+ * never got it. The hook's own start stamp can answer it: everything from this check to
+ * the reply is synchronous, so a claim made within 2 s of the hook starting is answered
+ * before the hook's 3 s are up.
+ */
+export function cursorStopIsFresh(hookStartedAtMs: number | null, now: number, maxAgeMs = CURSOR_STOP_MAX_AGE_MS): boolean {
+  if (hookStartedAtMs === null || !Number.isFinite(hookStartedAtMs) || !Number.isFinite(now)) return false
+  const age = now - hookStartedAtMs
+  return age <= maxAgeMs && age >= -CURSOR_STOP_MAX_SKEW_MS
+}
+
+/**
+ * The spool envelope the hook posts (`{"ts","ppid","event","payload"}`), read strictly.
+ * Null unless it is a Stop from Cursor naming a valid conversation.
+ */
+export function parseCursorStopEnvelope(body: unknown): CursorStopFacts | null {
+  if (!body || typeof body !== 'object' || Array.isArray(body)) return null
+  const envelope = body as Record<string, unknown>
+  if (envelope.event !== 'Stop') return null
+  const payload = envelope.payload
+  if (!payload || typeof payload !== 'object' || Array.isArray(payload)) return null
+  const p = payload as Record<string, unknown>
+  // Cursor stamps every hook payload with its version. Claude Code never does, so this
+  // is the positive evidence the event came from Cursor and not a Claude Stop.
+  if (typeof p.cursor_version !== 'string' || p.cursor_version.trim().length === 0) return null
+  const raw = typeof p.conversation_id === 'string' ? p.conversation_id : typeof p.session_id === 'string' ? p.session_id : ''
+  const conversationId = raw.trim().toLowerCase()
+  if (!isValidNativeThreadId(conversationId)) return null
+  const status = typeof p.status === 'string' ? p.status : ''
+  const loopCount = typeof p.loop_count === 'number' && Number.isFinite(p.loop_count) ? p.loop_count : null
+  const hookStartedAtMs = typeof envelope.ts === 'number' && Number.isFinite(envelope.ts) ? envelope.ts : null
+  return { conversationId, status, loopCount, cursorVersion: p.cursor_version.trim(), hookStartedAtMs }
+}
+
+/**
+ * The next waiting turn, claimed. Pure: returns the new queue and the claimed turn, or
+ * null when there is nothing to hand over. Queue order, oldest first.
+ */
+export function claimNextCursorTurn(
+  queue: readonly QueuedThreadTurn[],
+  now: number,
+): { queue: QueuedThreadTurn[]; turn: QueuedThreadTurn } | null {
+  const index = queue.findIndex(t => t.status === 'waiting')
+  if (index < 0) return null
+  const turn: QueuedThreadTurn = {
+    ...queue[index]!,
+    status: 'delivered',
+    attempts: queue[index]!.attempts + 1,
+    reason: 'cursor_stop_hook',
+    settledAt: now,
+  }
+  const next = queue.slice()
+  next[index] = turn
+  return { queue: next, turn }
+}
+
+/**
+ * Should this Stop receive a queued turn at all? Only a turn that COMPLETED: Cursor
+ * reports `aborted` when the user stops it and `error` when it failed, and neither is a
+ * moment to add a sentence. A loop count past the queue's own size means something other
+ * than this queue is driving the composer.
+ */
+export function cursorStopAcceptsFollowup(facts: CursorStopFacts, maxLoop: number): boolean {
+  if (facts.status !== 'completed') return false
+  if (facts.loopCount !== null && facts.loopCount >= maxLoop) return false
+  return true
+}

package/server/lib/occupancy-probes.ts

@@ -834,6 +834,58 @@ export function withHookTurnClock(
   }
 }
 
+/**
+ * Add the Codex turn clock (6.51.0) to a probe set, keeping whatever the set already
+ * answers for other providers.
+ *
+ * `codexTurnEndedAtMs` reads the thread's rollout tail and answers a time only when the
+ * newest turn marker CLOSED a turn (`task_complete`/`turn_complete`); a `task_started`
+ * after it, an unreadable file, or a tail with no marker all answer null, which keeps
+ * the 30 s transcript window. Measured on codex-cli 0.155: the app starts a turn queued
+ * in its own queue 10 ms after the `task_complete`, and that `task_started` is what the
+ * next read sees.
+ */
+export function withCodexTurnClock(
+  probes: OccupancyProbes,
+  codexTurnEndedAtMs: (threadId: string) => number | null,
+): OccupancyProbes {
+  const inner = probes.holderTurnEndedAtMs
+  return {
+    ...probes,
+    holderTurnEndedAtMs: (provider, threadId) => {
+      if (provider === 'codex') {
+        if (!NATIVE_THREAD_ID_RE.test(threadId)) return null
+        return codexTurnEndedAtMs(threadId)
+      }
+      return typeof inner === 'function' ? inner(provider, threadId) : null
+    },
+  }
+}
+
+/**
+ * Add the Cursor composer turn signal (6.51.0). `signalFor` is the hook signal store's
+ * reader; Cursor's hook events land there under the composer's conversation id. Open
+ * means: a turn was opened (prompt or tool) and no Stop has closed it, nothing ended the
+ * session, and the newest event is inside the open-turn ceiling -- a composer that died
+ * mid-turn must not read working for ever.
+ */
+export function withCursorComposerTurn(
+  probes: OccupancyProbes,
+  signalFor: (sessionId: string) => { turnOpen: boolean; ended: { at: number; reason: string } | null; lastEventAt: number } | undefined,
+  now: () => number,
+  ceilingMs: number,
+): OccupancyProbes {
+  return {
+    ...probes,
+    cursorComposerTurnOpen: (threadId: string) => {
+      if (!NATIVE_THREAD_ID_RE.test(threadId)) return null
+      const signal = signalFor(threadId)
+      if (!signal) return null
+      return signal.turnOpen === true && signal.ended === null && now() - signal.lastEventAt <= ceilingMs
+    },
+  }
+}
+
 /** The facts the hook turn clock reads off a session signal. */
 export interface HookTurnSignal {
   lastEvent: string

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

@@ -627,7 +627,9 @@ function draftsFromCodexRecord(record: Record<string, unknown>): SessionStreamDr
 function draftsFromCodexEvent(payload: Record<string, unknown>): SessionStreamDraft[] {
   const kind = typeof payload.type === 'string' ? payload.type : ''
   if (kind === 'task_started') return [{ kind: 'status', state: 'working' }]
-  if (kind === 'task_complete' || kind === 'turn_complete') return [{ kind: 'status', state: 'done' }]
+  // 6.51.0: an interrupted turn is over too (`turn_aborted`). Without it a follow-up parked
+  // behind an aborted Codex turn waited out the 30 min open-turn ceiling.
+  if (kind === 'task_complete' || kind === 'turn_complete' || kind === 'turn_aborted') return [{ kind: 'status', state: 'done' }]
   if (kind === 'agent_message') {
     const prose = proseDraft(payload.message ?? payload.text)
     return prose ? [prose] : []

package/server/lib/thread-occupancy.ts

@@ -156,11 +156,18 @@ export interface OccupancyProbes {
    * sub-agent is open, the session has not ended, AND the registry record says `idle`
    * with `statusUpdatedAt` at or after the Stop (Claude flips it only when every Stop
    * hook has returned, 12-38 s after the Stop on the release Mac, which is when a prompt
-   * queued at the desk would dequeue). Null otherwise, and always null for Codex.
+   * queued at the desk would dequeue). Null otherwise.
    * OPTIONAL, and its absence is the default: attached by `withHookTurnClock` at the
    * composition root only when `COS_SESSION_HOOKS` is on, so the pure gate never reads
    * the environment.
    *
+   * 6.51.0, CODEX: `withCodexTurnClock` answers for Codex threads from the rollout's own
+   * turn markers: the newest is `task_complete`/`turn_complete`, so the engine closed the
+   * turn. Safe to read idle at once for Codex in a way it never was for a Claude Stop,
+   * because every write into a held Codex thread goes through the app's own queue
+   * (`codex-live-queue.ts`), which the engine itself serialises behind any turn it starts
+   * next; nothing is ever written beside the holder.
+   *
    * What it buys: a foreign Desktop holder whose turn the engine has closed reads `idle`
    * at once instead of after the 30 s transcript window. The transcript's mtime is not
    * consulted: the bookkeeping rows Claude writes as the hooks finish are exactly what
@@ -177,6 +184,13 @@ export interface OccupancyProbes {
     cwd: string
     hasConversation: boolean
   } | null
+  /**
+   * 6.51.0: is this Cursor IDE composer mid-turn, by its own hook events (Cursor runs the
+   * COS session hook from `~/.claude/settings.json`)? True only on positive evidence: a
+   * prompt or tool event newer than the last Stop, inside the open-turn ceiling. OPTIONAL;
+   * absent, null, or a throw keeps the 6.50 verdict (`unsupported_provider`).
+   */
+  cursorComposerTurnOpen?: (threadId: string) => boolean | null
 }
 
 /**
@@ -287,11 +301,11 @@ function readHolderActivity(
   }
   const activity = holderActivity(mtime, nowMs)
   if (activity !== 'working') return activity
-  // THE B6 CLAUSE. Only a `working` verdict is revisited, only for Claude, only with a
-  // real clock behind it, and only when the hook probe VOUCHES that the engine closed
-  // the turn (null is strict). `unknown` stays unknown: the clause narrows a refusal,
-  // never a doubt.
-  if (provider !== 'claude' || typeof probes.holderTurnEndedAtMs !== 'function' || typeof mtime !== 'number') return activity
+  // THE B6 CLAUSE. Only a `working` verdict is revisited, only for Claude (6.51.0: and
+  // Codex, from its rollout's turn markers), only with a real clock behind it, and only
+  // when the probe VOUCHES that the engine closed the turn (null is strict). `unknown`
+  // stays unknown: the clause narrows a refusal, never a doubt.
+  if ((provider !== 'claude' && provider !== 'codex') || typeof probes.holderTurnEndedAtMs !== 'function' || typeof mtime !== 'number') return activity
   let stopAt: number | null
   try {
     stopAt = probes.holderTurnEndedAtMs(provider, threadId)
@@ -612,7 +626,16 @@ export function threadOccupancy(
       return { attachable: false, owners: [], reason: 'probe_failed' }
     }
     if (!session || session.hasConversation !== true) {
-      return { attachable: false, owners: [], reason: 'unsupported_provider' }
+      // 6.51.0: still never attachable (Gate 0: an IDE composer is not resumed from
+      // outside), but a composer the hooks show MID-TURN is working, not unsupported, so
+      // a turn spoken at it can wait for its Stop hook. The reason is the only change.
+      let open: boolean | null = null
+      try {
+        open = typeof probes.cursorComposerTurnOpen === 'function' ? probes.cursorComposerTurnOpen(threadId) : null
+      } catch {
+        open = null
+      }
+      return { attachable: false, owners: [], reason: open === true ? 'native_thread_working' : 'unsupported_provider' }
     }
     return { attachable: true, owners: [], reason: null }
   }