@gotcos/glasses-server 6.61.7 → 6.63.0

package/server/lib/session-halt.ts

@@ -100,6 +100,44 @@ export function clearHaltMarker(sessionId: string, dir = haltDir()): boolean {
   }
 }
 
+/**
+ * 6.62.0 /qa (Q4): COS is about to start its OWN child on this thread (a Continue, a queue
+ * drain, or a fork). A marker left by an earlier desk cancel must not deny it: Cursor `-p`
+ * fires neither UserPromptSubmit nor SessionEnd, so until this a cancelled Cursor CLI chat
+ * refused every Continue for the marker's hour. The callers only reach here once the
+ * occupancy gate (Continue, drain) or an explicit probe (fork) says no desk run is working,
+ * so no live desk cancel is undone. True when a marker was removed.
+ */
+export function clearHaltForCosChild(sessionId: string, why: 'continue' | 'fork', dir = haltDir()): boolean {
+  const cleared = clearHaltMarker(sessionId, dir)
+  if (cleared) console.log(`[session-halt] marker cleared: COS starts its own ${why} child session=${String(sessionId).slice(0, 8)}`)
+  return cleared
+}
+
+/**
+ * The same deps with `spawn` clearing the thread's marker first, at the moment the child is
+ * created (after every gate and ban check), and only when `mayClear` says no desk run is
+ * working. A throwing `mayClear` clears nothing.
+ */
+export function clearingHaltOnSpawn<T extends { spawn: (request: never) => unknown }>(
+  deps: T,
+  sessionId: string,
+  why: 'continue' | 'fork',
+  mayClear: () => boolean = () => true,
+  dir = haltDir(),
+): T {
+  const spawn = deps.spawn as (request: unknown) => unknown
+  return {
+    ...deps,
+    spawn: ((request: unknown) => {
+      let clear = false
+      try { clear = mayClear() === true } catch { clear = false }
+      if (clear) clearHaltForCosChild(sessionId, why, dir)
+      return spawn(request)
+    }) as T['spawn'],
+  }
+}
+
 /**
  * Clear the marker because the SESSION ended, but only a marker written at or before the
  * event. A SessionEnd drained late from the spool must not remove a cancel written after
@@ -149,6 +187,11 @@ export function clearHaltMarkerOnSessionEnd(sessionId: string, endedAt: number,
 //     a halted desk run is the worse error, and the lens already said "at its next step".
 //   - LIMIT, stated: a desk prompt with exactly the delivered words, typed after the send and
 //     taken first, is indistinguishable from the delivered turn and re-arms.
+//
+// 6.62.0 (plan 3.6, W8): a Codex turn queued into the Codex app (`codex queue`, from the busy
+// fast path or the idle hop) is re-armed too. Codex hands the queued text to its own
+// UserPromptSubmit unchanged, with no peer wrapper, so that comparison is VERBATIM (only the
+// ends trimmed): no wrapper is taken off and no inner whitespace is collapsed.
 
 interface PendingRearm {
   marker: HaltMarker
@@ -157,6 +200,10 @@ interface PendingRearm {
   /** Prompts submitted before this are someone else's. */
   after: number
   until: number
+  /** 6.62.0: a Codex queued turn, compared verbatim (no peer unwrap). */
+  verbatim: boolean
+  /** The delivered text as sent, for the verbatim comparison. */
+  text: string
 }
 
 const pendingRearms = new Map<string, PendingRearm>()
@@ -171,12 +218,21 @@ const MAX_PENDING_REARMS = 64
 export function haltDeliveredTurn(
   sessionId: string,
   marker: HaltMarker,
-  turn: { prompt: string; after: number; rearm: boolean; now?: number; windowMs?: number },
+  turn: { prompt: string; after: number; rearm: boolean; now?: number; windowMs?: number; verbatim?: boolean; deferMarker?: boolean },
   dir = haltDir(),
 ): boolean {
-  if (!writeHaltMarker(sessionId, marker, dir)) return false
-  const id = sessionId.toLowerCase()
+  const id = typeof sessionId === 'string' ? sessionId.toLowerCase() : ''
   const words = normalizePromptWords(turn.prompt)
+  // 6.62.0 /qa (W3): `deferMarker` (a busy hop) writes NOTHING now: the session is still on
+  // the person's own turn, and a marker would stop it. Only the re-arm is registered, and it
+  // writes the marker when the delivered turn's own prompt arrives. A delivered turn that has
+  // already started (`rearm` false) is ours, so it is written at once as before.
+  const deferred = turn.deferMarker === true && turn.rearm && words.length > 0
+  if (deferred) {
+    if (haltMarkerPath(id, dir) === null) return false
+  } else if (!writeHaltMarker(sessionId, marker, dir)) {
+    return false
+  }
   if (!turn.rearm || words.length === 0) {
     pendingRearms.delete(id)
     return true
@@ -186,7 +242,7 @@ export function haltDeliveredTurn(
     ? Math.min(turn.windowMs, HALT_MARKER_TTL_MS)
     : HALT_MARKER_TTL_MS
   pendingRearms.delete(id)
-  pendingRearms.set(id, { marker, words, after: turn.after, until: now + windowMs })
+  pendingRearms.set(id, { marker, words, after: turn.after, until: now + windowMs, verbatim: turn.verbatim === true, text: turn.prompt })
   while (pendingRearms.size > MAX_PENDING_REARMS) {
     const oldest = pendingRearms.keys().next()
     if (oldest.done) break
@@ -204,7 +260,12 @@ export function normalizePromptWords(text: unknown): string {
  * Is `prompt` (a UserPromptSubmit's `prompt`) the delivered prompt? Equal words, compared
  * whole, after taking off Claude Code's peer wrapper when the prompt arrived in one.
  */
-export function isDeliveredPrompt(prompt: unknown, delivered: string): boolean {
+export function isDeliveredPrompt(prompt: unknown, delivered: string, options: { verbatim?: boolean } = {}): boolean {
+  if (options.verbatim === true) {
+    // 6.62.0: Codex's queued turn arrives as its own text. No wrapper to take off.
+    const want = typeof delivered === 'string' ? delivered.trim() : ''
+    return want.length > 0 && typeof prompt === 'string' && prompt.trim() === want
+  }
   const want = normalizePromptWords(delivered)
   if (want.length === 0 || typeof prompt !== 'string') return false
   return normalizePromptWords(unwrapPeerMessage(prompt) ?? prompt) === want
@@ -226,7 +287,7 @@ export function rearmHaltOnPrompt(sessionId: string, promptAt: number, prompt: u
   }
   if (!Number.isFinite(promptAt) || promptAt < pending.after) return false
   pendingRearms.delete(id)
-  if (!isDeliveredPrompt(prompt, pending.words)) {
+  if (!(pending.verbatim ? isDeliveredPrompt(prompt, pending.text, { verbatim: true }) : isDeliveredPrompt(prompt, pending.words))) {
     console.warn(`[session-halt] re-arm dropped: the first prompt after the hand-off was not the delivered turn session=${id.slice(0, 8)} clientCancelId=${pending.marker.clientCancelId}`)
     return false
   }

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

@@ -33,10 +33,50 @@ export const HOOK_EVENT_NAMES = [
   'PreCompact',
   'PostCompact',
   'PostModelSwitch',
+  // 6.62.0: Codex fires this when a turn is interrupted (Esc). It closes the turn, as a Stop
+  // does. Never in Claude's subscription list: Claude Code has no such hook.
+  'Interrupt',
+  // 6.62.0: the Cursor observer's `afterAgentThought`. Display only, like every observer
+  // event: its text lives in memory and on the live feed, never in the ledger.
+  'AgentThought',
 ] as const
 
 export type HookEventName = typeof HOOK_EVENT_NAMES[number]
 
+/**
+ * 6.62.0: events the reducer understands that no Claude Code hook fires. They stay OUT of
+ * Claude's `HOOK_SUBSCRIPTIONS` (a new Claude block would turn every install into `drift`):
+ * `Interrupt` is Codex's, and `AgentThought` is the Cursor observer's.
+ */
+export const NON_CLAUDE_HOOK_EVENTS: readonly HookEventName[] = ['Interrupt', 'AgentThought']
+
+/**
+ * 6.62.0: which engine ran the hook. The Codex command carries `COS_HOOK_PROVIDER=codex`,
+ * which the script writes into the envelope; Claude Code and Cursor share the
+ * `~/.claude/settings.json` command and are told apart by the payload (`inferHookProvider`).
+ */
+export type HookProvider = 'claude' | 'codex' | 'cursor'
+
+export function isHookProvider(value: unknown): value is HookProvider {
+  return value === 'claude' || value === 'codex' || value === 'cursor'
+}
+
+/**
+ * The provider of one envelope, in this order (plan 2.1): the envelope's own stamp (the Codex
+ * command and the Cursor observer write one); else Cursor's `cursor_version`, which every
+ * Cursor payload carries and no other engine's does; else a transcript under
+ * `/.codex/sessions/` (a COS Claude block Codex imported runs without the stamp); else Claude.
+ */
+export function inferHookProvider(stamped: unknown, payload: Record<string, unknown>): HookProvider {
+  if (isHookProvider(stamped)) return stamped
+  if ('cursor_version' in payload) return 'cursor'
+  if (typeof payload.transcript_path === 'string' && payload.transcript_path.includes('/.codex/sessions/')) return 'codex'
+  return 'claude'
+}
+
+/** 6.62.0: the cap on an agent thought kept in memory and sent on the live feed. */
+export const AGENT_THOUGHT_MAX = 280
+
 const EVENT_SET: ReadonlySet<string> = new Set(HOOK_EVENT_NAMES)
 
 export function isHookEventName(value: unknown): value is HookEventName {
@@ -57,6 +97,13 @@ export interface HookEnvelope {
   event: HookEventName
   sessionId: string
   payload: Record<string, unknown>
+  /** 6.62.0: set by `parseHookEnvelope` and a 6.62 ledger row; absent on older rows and hand-built envelopes. */
+  provider?: HookProvider
+  /**
+   * 6.62.0 (QA W2): the envelope itself named the provider: a 6.62 hook script (from the Codex
+   * command, or from a Codex payload) or the Cursor observer wrote it. Inferred is not stamped.
+   */
+  stamped?: true
 }
 
 /**
@@ -111,6 +158,8 @@ export function parseHookEnvelope(text: string): ParsedHookEnvelope {
       event: r.event,
       sessionId,
       payload: p,
+      provider: inferHookProvider(r.provider, p),
+      ...(isHookProvider(r.provider) ? { stamped: true as const } : {}),
     },
   }
 }
@@ -160,6 +209,9 @@ export function projectHookPayload(event: HookEventName, payload: Record<string,
     ...(str('cwd') ? { cwd: str('cwd') } : {}),
     ...(str('permission_mode') ? { permission_mode: str('permission_mode') } : {}),
     ...(str('prompt_id') ? { prompt_id: str('prompt_id') } : {}),
+    // 6.62.0: Codex stamps every turn-scoped event with its turn id and model.
+    ...(str('turn_id') ? { turn_id: str('turn_id') } : {}),
+    ...(event !== 'SessionStart' && str('model') ? { model: clipText(payload.model, 100) } : {}),
   }
   switch (event) {
     case 'SessionStart':
@@ -203,6 +255,11 @@ export function projectHookPayload(event: HookEventName, payload: Record<string,
       return { ...base, from_model: str('from_model'), to_model: str('to_model') }
     case 'PreCompact':
     case 'PostCompact':
+    case 'Interrupt':
+      return base
+    // The thought's TEXT is never kept: the ledger is a 10 MB ring replayed at boot, and a
+    // thought can quote anything the agent read. A replayed AgentThought carries nothing.
+    case 'AgentThought':
       return base
   }
 }

package/server/lib/session-hook-ledger.ts

@@ -7,8 +7,8 @@
 // applying the same event twice.
 
 import { appendFileSync, existsSync, readFileSync, renameSync, statSync } from 'node:fs'
-import type { HookEnvelope, HookEventName } from './session-hook-events.js'
-import { projectHookPayload, isHookEventName, SESSION_ID_RE } from './session-hook-events.js'
+import type { HookEnvelope, HookEventName, HookProvider } from './session-hook-events.js'
+import { projectHookPayload, isHookEventName, isHookProvider, SESSION_ID_RE } from './session-hook-events.js'
 
 export const LEDGER_ROTATE_BYTES = 10 * 1024 * 1024
 
@@ -22,6 +22,14 @@ export interface LedgerRow {
   child?: boolean
   /** The registry's `entrypoint` for the session, once read (6.48.1); a replay restores it. */
   entrypoint?: string
+  /**
+   * 6.62.0: the engine, decided at ingest from the full payload (`inferHookProvider`). The
+   * projection drops `cursor_version`, so a replay could not tell a Cursor row again without
+   * it. A row from an older server has none and replays exactly as it did.
+   */
+  provider?: HookProvider
+  /** 6.62.0 (QA W2): the envelope carried the provider stamp; a replay keeps the evidence. */
+  stamped?: true
   payload: Record<string, unknown>
 }
 
@@ -67,6 +75,8 @@ export class SessionHookLedger {
         session_id: env.sessionId,
         ...(child ? { child: true } : {}),
         ...(entrypoint ? { entrypoint } : {}),
+        ...(env.provider ? { provider: env.provider } : {}),
+        ...(env.stamped ? { stamped: true as const } : {}),
         payload: projectHookPayload(env.event, env.payload),
       }
     } catch (error) {
@@ -119,7 +129,15 @@ export class SessionHookLedger {
       if (r.ts < sinceMs) continue
       const payload = r.payload && typeof r.payload === 'object' ? r.payload as Record<string, unknown> : {}
       const entrypoint = typeof r.entrypoint === 'string' && r.entrypoint ? r.entrypoint : null
-      apply({ ts: r.ts, ppid: typeof r.ppid === 'number' ? r.ppid : null, event: r.event, sessionId: r.session_id.toLowerCase(), payload: { session_id: r.session_id, ...payload } }, r.key, r.child === true, entrypoint)
+      apply({
+        ts: r.ts,
+        ppid: typeof r.ppid === 'number' ? r.ppid : null,
+        event: r.event,
+        sessionId: r.session_id.toLowerCase(),
+        payload: { session_id: r.session_id, ...payload },
+        ...(isHookProvider(r.provider) ? { provider: r.provider } : {}),
+        ...(r.stamped === true && isHookProvider(r.provider) ? { stamped: true as const } : {}),
+      }, r.key, r.child === true, entrypoint)
       applied++
     }
     return { rows, applied, keys }

package/server/lib/session-hook-spool.ts

@@ -27,7 +27,13 @@ export const REJECTED_KEEP = 1_000
 export const REJECTED_MAX_AGE_MS = 7 * 24 * 60 * 60_000
 export const LAST_DRAIN_STAMP = '.last-drain'
 
-const SPOOL_FILE_RE = /^(\d{10,16})-(\d+)-([A-Za-z]+)\.json$/
+/**
+ * `<ms>-<pid>-<Event>.json` from the hook script; 6.62.0: also `<ms>-<pid>-<12 hex>-<Event>.json`,
+ * the Cursor observer's name since it shipped (6.61.7). The nonce keeps two observer runs in one
+ * millisecond apart; until 6.62.0 every one of its files was moved aside as unrecognized.
+ * Ordering reads groups 1 and 2 only.
+ */
+export const SPOOL_FILE_RE = /^(\d{10,16})-(\d+)(?:-[0-9a-f]{12})?-([A-Za-z]+)\.json$/
 
 /** A code, never a message: raw fs messages carry the home path and health is public. */
 export function errorCode(error: unknown): string {
@@ -38,6 +44,17 @@ export function errorCode(error: unknown): string {
 
 /** A hook killed mid-write leaves `.tmp.*`; reap those older than this. */
 export const TMP_MAX_AGE_MS = 10 * 60_000
+/** 6.62.0: the observer's `.<name>` temp file, left by a run killed between write and rename. */
+export const DOT_TEMP_MAX_AGE_MS = 60 * 60_000
+/**
+ * 6.62.0: observer files 6.61.x moved aside as `.unrecognized` are put back ONCE, and only those
+ * from the last hour: older ones describe sub-agents and compactions long over (and canary
+ * throwaways), and age out with the rest of `rejected/` as before.
+ */
+export const REINGEST_MAX_AGE_MS = 60 * 60_000
+export const REINGEST_MARKER = '.reingested-6.62.0'
+/** The window `rejected24h` counts over. */
+export const REJECTED_WINDOW_MS = 24 * 60 * 60_000
 /** The startup drain never loops more times than a full spool needs. */
 export const STARTUP_MAX_PASSES = Math.ceil(2_000 / SPOOL_BATCH) + 1
 
@@ -63,7 +80,12 @@ export interface SpoolIngesterOptions {
 
 export interface SpoolStats {
   ingested: number
+  /** Since the process started (cumulative). */
   rejected: number
+  /** 6.62.0: in the last 24 hours, so a fixed cause reads as fixed without a restart. */
+  rejected24h: number
+  /** 6.62.0: rejected observer files put back into the spool at boot (once per Mac). */
+  reingested: number
   salvaged: number
   duplicates: number
   /** Files a sweep visited and could not remove (ledger refused, unreadable). */
@@ -90,7 +112,13 @@ export function startSpoolIngester(options: SpoolIngesterOptions): SpoolIngester
   const batch = options.batch ?? SPOOL_BATCH
   const seen = options.seenKeys ?? new Set<string>()
   const rejectedDir = join(dir, 'rejected')
-  const stats: SpoolStats = { ingested: 0, rejected: 0, salvaged: 0, duplicates: 0, stuck: 0, foreign: 0, applyErrors: 0, backlog: 0, lastSweepAt: null, lastEventAt: null, lastError: null }
+  const stats: SpoolStats = { ingested: 0, rejected: 0, rejected24h: 0, reingested: 0, salvaged: 0, duplicates: 0, stuck: 0, foreign: 0, applyErrors: 0, backlog: 0, lastSweepAt: null, lastEventAt: null, lastError: null }
+  const rejectedAt: number[] = []
+  const countRejected = () => {
+    stats.rejected++
+    rejectedAt.push(now())
+    if (rejectedAt.length > 10_000) rejectedAt.splice(0, rejectedAt.length - 10_000)
+  }
   let ticking = false
   let stopped = false
   let watcher: FSWatcher | null = null
@@ -134,16 +162,22 @@ export function startSpoolIngester(options: SpoolIngesterOptions): SpoolIngester
         try { if (now() - statSync(join(dir, n)).mtimeMs > TMP_MAX_AGE_MS) unlinkSync(join(dir, n)) } catch { /* fine */ }
         continue
       }
+      // 6.62.0: the observer writes `.<spool name>` and renames it; one killed in between left
+      // it here for good. Only that exact shape, and only once it is an hour old.
+      if (n.startsWith('.') && SPOOL_FILE_RE.test(n.slice(1))) {
+        try { if (now() - statSync(join(dir, n)).mtimeMs > DOT_TEMP_MAX_AGE_MS) unlinkSync(join(dir, n)) } catch { /* fine */ }
+        continue
+      }
       if (n.startsWith('.')) continue
       if (!n.endsWith('.json')) { foreign++; continue }
-      try { renameSync(join(dir, n), join(rejectedDir, `${n}.unrecognized`)) ; stats.rejected++ } catch { /* fine */ }
+      try { renameSync(join(dir, n), join(rejectedDir, `${n}.unrecognized`)) ; countRejected() } catch { /* fine */ }
     }
     stats.foreign = foreign
     return names.filter(n => SPOOL_FILE_RE.test(n)).sort(spoolOrder)
   }
 
   const reject = (name: string, reason: string) => {
-    stats.rejected++
+    countRejected()
     try { renameSync(join(dir, name), join(rejectedDir, `${name}.${reason}`)) } catch {
       try { unlinkSync(join(dir, name)) } catch { /* gone already */ }
     }
@@ -203,7 +237,8 @@ export function startSpoolIngester(options: SpoolIngesterOptions): SpoolIngester
 
   const pruneRejected = () => {
     let names: string[]
-    try { names = readdirSync(rejectedDir).sort() } catch { return }
+    // The re-ingest marker is not a rejected file: it is never pruned, so the re-ingest stays once.
+    try { names = readdirSync(rejectedDir).filter(n => n !== REINGEST_MARKER).sort() } catch { return }
     const cutoff = now() - REJECTED_MAX_AGE_MS
     const excess = Math.max(0, names.length - REJECTED_KEEP)
     names.forEach((n, index) => {
@@ -242,6 +277,29 @@ export function startSpoolIngester(options: SpoolIngesterOptions): SpoolIngester
     return removed
   }
 
+  // 6.62.0: put back the observer files 6.61.x could not read (see REINGEST_MAX_AGE_MS), once.
+  // Moved, never copied: the normal drain below ingests and deletes them like any other file.
+  const reingest = () => {
+    const marker = join(rejectedDir, REINGEST_MARKER)
+    if (existsSync(marker)) return
+    let names: string[] = []
+    try { names = readdirSync(rejectedDir) } catch { return }
+    const suffix = '.unrecognized'
+    for (const n of names) {
+      if (!n.endsWith(suffix)) continue
+      const original = n.slice(0, -suffix.length)
+      if (!SPOOL_FILE_RE.test(original)) continue
+      try {
+        if (now() - statSync(join(rejectedDir, n)).mtimeMs > REINGEST_MAX_AGE_MS) continue
+        if (existsSync(join(dir, original))) continue
+        renameSync(join(rejectedDir, n), join(dir, original))
+        stats.reingested++
+      } catch { /* left where it is; it ages out */ }
+    }
+    try { writeFileSync(marker, `${new Date(now()).toISOString()} ${stats.reingested}\n`, { mode: 0o600 }) } catch { /* the next boot tries once more */ }
+  }
+  reingest()
+
   // Startup drain: the backlog, in bounded passes, before anyone asks. Bounded twice: a pass
   // that removed nothing ends it (a refusing ledger must never spin the boot), and no
   // backlog needs more passes than a full spool.
@@ -267,6 +325,10 @@ export function startSpoolIngester(options: SpoolIngesterOptions): SpoolIngester
       clearInterval(timer)
       try { watcher?.close() } catch { /* fine */ }
     },
-    stats: () => ({ ...stats }),
+    stats: () => {
+      const since = now() - REJECTED_WINDOW_MS
+      while (rejectedAt.length > 0 && rejectedAt[0]! < since) rejectedAt.shift()
+      return { ...stats, rejected24h: rejectedAt.length }
+    },
   }
 }

package/server/lib/session-hooks-runtime.ts

@@ -20,6 +20,7 @@ import { OPEN_TURN_CEILING_MS, deriveSessionState, type DerivedSessionState, typ
 import { HALT_MARKER_TTL_MS, HALT_REARM_UNVERIFIED_MS, clearHaltMarkerOnSessionEnd, dropHaltRearm, haltDeliveredTurn, rearmHaltOnPrompt, sweepHaltMarkers, type HaltMarker } from './session-halt.js'
 import { cancelVoidsOpenTurn, threadCancel } from './session-cancel.js'
 import { ensureHookRuntimeFiles, ensureStableHookScript, hookSpoolDir, hookStatus, type HookStatus } from './claude-hooks-installer.js'
+import { codexHooksHealthField, cursorObserverHealthField, type CodexHooksHealth, type CursorObserverHealth } from './provider-observe.js'
 
 export function sessionHooksEnabled(): boolean {
   const raw = process.env.COS_SESSION_HOOKS
@@ -235,7 +236,7 @@ export function claudeDeskRunning(sessionId: string, now = Date.now(), dir = cla
  * hooks do not yet show the turn started (its UserPromptSubmit at or after `sentAt`), it is
  * re-armed once when that prompt's own UserPromptSubmit deletes it (`haltDeliveredTurn`).
  */
-export function haltHandedOffTurn(sessionId: string, marker: HaltMarker, turn: { prompt: string; sentAt: number; unverified?: boolean }, now = Date.now()): boolean {
+export function haltHandedOffTurn(sessionId: string, marker: HaltMarker, turn: { prompt: string; sentAt: number; unverified?: boolean; verbatim?: boolean; deferMarker?: boolean }, now = Date.now()): boolean {
   const signal = signalFor(sessionId)
   const started = !!signal && typeof signal.turnStartedAt === 'number' && signal.turnStartedAt >= turn.sentAt
   return haltDeliveredTurn(sessionId, marker, {
@@ -245,6 +246,10 @@ export function haltHandedOffTurn(sessionId: string, marker: HaltMarker, turn: {
     now,
     // 6.53.3 /qa: an unverified hand-off (`maybe`) holds its re-arm two minutes, not an hour.
     windowMs: turn.unverified === true ? HALT_REARM_UNVERIFIED_MS : HALT_MARKER_TTL_MS,
+    // 6.62.0 (plan 3.6): a Codex turn queued into the app is matched verbatim.
+    verbatim: turn.verbatim === true,
+    // 6.62.0 /qa (W3): a busy hop's marker waits for the delivered turn's own prompt.
+    deferMarker: turn.deferMarker === true,
   })
 }
 
@@ -277,7 +282,8 @@ export function startSessionHooksRuntime(options: { port: number }): SessionHook
     ledger,
     seenKeys: replay.keys,
     isChild: env => isCosSpawnedPid(env.ppid),
-    entrypointOf: enabled ? (env, child) => entrypointFor(env.sessionId, child) : undefined,
+    // 6.62.0: only a Claude session has a `~/.claude/sessions` record to read.
+    entrypointOf: enabled ? (env, child) => (env.provider === undefined || env.provider === 'claude' ? entrypointFor(env.sessionId, child) : null) : undefined,
     apply: enabled ? (env, child, entrypoint) => {
       sessionSignalStore.apply(env, child)
       if (entrypoint) sessionSignalStore.setEntrypoint(env.sessionId, entrypoint)
@@ -354,6 +360,14 @@ export interface SessionHooksHealth {
   signals: number
   replayed: { rows: number; applied: number } | null
   spool: SpoolStats | null
+  /**
+   * 6.62.0: the Codex hooks, APART from the Claude fields above (B2): `state`, `installed` and
+   * `hookHaltReady` stay Claude's alone, because Control 0.5.254 keys its banner and its
+   * Install check off them. No Codex banner this release.
+   */
+  codex: CodexHooksHealth
+  /** 6.62.0: the native Cursor observer (`~/.cursor/hooks.json`). */
+  cursorObserver: CursorObserverHealth
 }
 
 // Health is polled by three clients every few seconds; the status read (settings parse,
@@ -397,6 +411,8 @@ export function sessionHooksHealthFields(): { sessionHooks: SessionHooksHealth }
       signals: sessionSignalStore.size(),
       replayed,
       spool,
+      codex: codexHooksHealthField(),
+      cursorObserver: cursorObserverHealthField(),
     },
   }
 }
@@ -408,6 +424,20 @@ export function signalFor(sessionId: string): SessionSignal | undefined {
   return signal?.observationOnly ? undefined : signal
 }
 
+/**
+ * 6.62.0 (QA W2): has a hook event of this engine reached COS for this thread? The positive
+ * evidence a desk cancel needs before it may be offered for Codex or Cursor. Never an observer
+ * event (those prove the observer runs, not the halt check):
+ *   codex   an event the Codex command's script STAMPED (a 6.62 script, whose halt reply Codex
+ *           honours; an inferred-only Codex event came from an older script that fails open)
+ *   cursor  an event from the Claude-compatible hook Cursor runs (its own `cursor_version`)
+ */
+export function providerHookSeen(provider: 'codex' | 'cursor', threadId: string): boolean {
+  const signal = signalFor(threadId)
+  if (!signal || signal.provider !== provider) return false
+  return provider === 'codex' ? typeof signal.stampedAt === 'number' : true
+}
+
 /** Display observers do not create hook occupancy or permission evidence. */
 export function workObservationFor(sessionId: string) {
   if (!sessionHooksEnabled()) return undefined

package/server/lib/session-peer-inbox-deps.ts

@@ -19,12 +19,13 @@ import {
 } from './session-peer-inbox.js'
 
 /**
- * `COS_CONTINUE_LIVE`. OFF by default in 6.49.0.
+ * `COS_CONTINUE_LIVE`. ON unless exactly '0' (6.62.0, D3).
  *
- * The transport rides a protocol Claude Code documents in a help string, not a
- * contract, and the first days are for reading the health row on one Mac. A literal
- * '1' turns it on; anything else, including absence, keeps every Continue on the
- * 6.48.2 path.
+ * 6.49.0 shipped it off: the transport rides a protocol Claude Code documents in a help
+ * string, not a contract, and the first days were for reading the health row on one Mac.
+ * Those days are behind it (Miles's Mac has run it on since 6.49; measured on Claude Code
+ * 2.1.289), and a Continue that lands in the open session is the desk behaviour. '0' keeps
+ * every Continue on the 6.48.2 spawn path; every refusal still falls back there anyway.
  *
  * WHERE TO SET IT. `~/.cos-glasses/.env` (read at boot by `env.ts`, the plist wins
  * when both carry it). Control's `providerEnvironmentKeys` allowlist does NOT carry
@@ -32,7 +33,7 @@ import {
  * by the next Install/Repair/Update Server; Control 0.5.234 is to add it.
  */
 export function continueLiveEnabled(env: NodeJS.ProcessEnv = process.env): boolean {
-  return env.COS_CONTINUE_LIVE === '1'
+  return env.COS_CONTINUE_LIVE !== '0'
 }
 
 /** Registry files are small; anything larger is not one. */

package/server/lib/session-recommendation.ts

@@ -27,8 +27,9 @@ const EXACT = "Which one of the user's agent sessions is already doing this exac
   + 'A session on the same project doing different work does not count. Choose none if no session is doing this task.'
 
 /** Providers a Work handoff can fork natively (Control 0.5.243 applies a Fork suggestion as a same-platform fork).
- *  One list with the fork route (agent-session-binding-store FORKABLE_PROVIDERS). */
-export const FORKABLE = new Set<string>(FORKABLE_PROVIDERS)
+ *  6.62.0 (W9): the fork route also serves Cursor ("New session with this context"), but Control 0.5.254 has no
+ *  Cursor fork plan, so the recommender keeps to Claude and Codex until the Control release. */
+export const FORKABLE = new Set<string>(FORKABLE_PROVIDERS.filter(provider => provider !== 'cursor'))
 const clip = (text: string | undefined, max: number) => (text ?? '').replace(/\s+/g, ' ').trim().slice(0, max)
 const round = (n: number) => Math.round(n * 100) / 100