@gotcos/glasses-server 6.61.7 → 6.62.1

package/server/routes/agent-sessions.ts

@@ -44,7 +44,10 @@ import { searchAgentSessions, type AgentSessionSearchHit } from '../lib/agent-se
 import { claudeSessionNamesVisible, claudeSessionsDir, claudeSessionsEnabled, readClaudePeerRecords, registryFacts } from './claude-sessions.js'
 import type { ClaudePeerRecord } from '../lib/claude-session-registry.js'
 import { deriveForRow, signalFor, workObservationFor } from '../lib/session-hooks-runtime.js'
-import { derivedRowFields, type DerivedSessionState } from '../lib/session-state-derive.js'
+import { derivedRowFields, type DerivedSessionState, type RegistryFacts } from '../lib/session-state-derive.js'
+import type { WorkObservation } from '../lib/session-work-observation.js'
+import type { SessionSignal } from '../lib/session-signal-store.js'
+import { HOOK_ACTIVE_CAP_MS, codexRolloutFacts, type CodexRolloutFacts } from '../lib/codex-rollout-state.js'
 import { queuedTurnsFields, allQueuedWaitingLookup } from '../lib/thread-turn-queue-store.js'
 import { isAttachedTurnActive, sessionStreamKey } from '../lib/session-stream-bus.js'
 import { workspaceFromCwd } from '../lib/claude-session-registry.js'
@@ -67,6 +70,8 @@ import {
 import type { OccupancyDirs } from '../lib/thread-occupancy.js'
 import { parseTurnsParam, readRecentSessionTurns, type RecentTurnsRead } from '../lib/agent-session-turns.js'
 import { cosSpawnedPids } from '../lib/agent-session-ownership-store.js'
+import { sessionActFactsFor, sessionActFields } from '../lib/session-act-fields.js'
+import { CONTINUE_NOTE_HEADER, continueNoteAcknowledged } from '../lib/continue-plan.js'
 
 export const agentSessionsRouter = Router()
 
@@ -202,24 +207,129 @@ async function transcriptMtimes(
  * rename here is silent on this side and renders every session as merely open on
  * the lens. Pure: it takes the scan, it does no I/O.
  */
-export function withRunning<T extends { session_id: string }>(entry: T, scan: OccupiedScan) {
+export function withRunning<T extends { session_id: string }>(entry: T, scan: OccupiedScan, hint: RunningHint | null = null) {
   const occ = scan.occupied.get(entry.session_id)
+  // 6.62.0: a Cursor row with hook evidence is decided by it (there is no process occupancy
+  // for Cursor, and its file time says nothing once the hooks have spoken).
+  const decides = hint?.decides === true
   return {
     ...entry,
     // A process HOLDS this thread open, whoever started it. Not "is generating":
     // a Claude record for an open window outlives the work by however long the
     // window stays up, which is why `running_active` exists below.
-    running: occ !== undefined,
+    running: decides ? hint!.running : occ !== undefined || hint?.running === true,
     // Held by something that is not COS, so a Continue would be refused. The
     // badge reads `running`; the Continue affordance reads this.
-    running_foreign: (occ?.foreignOwners ?? 0) > 0,
+    running_foreign: (occ?.foreignOwners ?? 0) > 0 || hint?.foreign === true,
     // The transcript was WRITTEN in the last few seconds: an agent is generating
     // here, not just holding the file. This is the only one of the three that
     // clears on its own when the work stops. Still a display hint, never a gate.
-    running_active: occ?.activeRecently === true,
+    // 6.62.0: or the engine's own hooks (or a Codex rollout) say a turn is open and the
+    // last event is inside HOOK_ACTIVE_CAP_MS (plan 1.1-1.3).
+    running_active: decides ? hint!.active : occ?.activeRecently === true || hint?.active === true,
   }
 }
 
+/**
+ * 6.62.0 (plan 1.1-1.3): what the engine's own evidence says about working, for `withRunning`.
+ *
+ * A DISPLAY HINT, NEVER A GATE: the write gate (`thread-occupancy.ts`) is untouched. An open
+ * turn reads active only while its last event is inside HOOK_ACTIVE_CAP_MS: an Esc with no
+ * Stop, a crash, a Cursor abort leave a turn open, and the half-hour open-turn ceiling would
+ * otherwise show a ghost "working" row for thirty minutes (W5).
+ *
+ *   hook running, last event inside the cap   running, active (every provider)
+ *   hook running, quiet past the cap          Cursor: running, NOT active (OPEN, quiet: a
+ *                                             tool can run longer than the cap with no event,
+ *                                             and an Esc with no Stop looks the same, QA W8);
+ *                                             Claude and Codex: no hint (occupancy answers)
+ *   hook waiting                               running, not active
+ *   Codex rollout turn open inside the cap     running, active (no Codex hooks yet)
+ *   Cursor, any other hook state               not running, not active (`decides`)
+ *
+ * A hook-derived `running` only exists inside the deriver's 30-minute open-turn ceiling, so an
+ * open-quiet Cursor row ends there, or at its Stop or SessionEnd.
+ *
+ * For Claude and Codex the hint only ADDS to occupancy (a held, freshly written thread still
+ * reads as it did). For Cursor, whose list has no occupancy at all, a hook signal decides, and
+ * a running Cursor turn is the user's own (an IDE composer or their terminal; COS's own child
+ * is kept out of the phase), so it is foreign.
+ */
+export interface RunningHint {
+  running: boolean
+  active: boolean
+  foreign: boolean
+  /** Cursor with hook evidence: this hint IS the answer, occupancy and file time are not read. */
+  decides: boolean
+}
+
+export function runningHintFor(provider: AgentProvider, derived: DerivedSessionState | undefined, lastEventAt: number | null, now: number): RunningHint | null {
+  const cursor = provider === 'cursor'
+  const quiet: RunningHint | null = cursor ? { running: false, active: false, foreign: false, decides: true } : null
+  if (!derived) return null
+  const inCap = lastEventAt !== null && now - lastEventAt <= HOOK_ACTIVE_CAP_MS && lastEventAt <= now + 5_000
+  if (derived.state_source === 'hook') {
+    if (derived.agent_state === 'waiting') return { running: true, active: false, foreign: cursor, decides: cursor }
+    if (derived.agent_state === 'running' && inCap) return { running: true, active: true, foreign: cursor, decides: cursor }
+    if (derived.agent_state === 'running' && cursor) return { running: true, active: false, foreign: true, decides: true }
+    return quiet
+  }
+  if (provider === 'codex' && derived.state_source === 'transcript' && derived.agent_state === 'running' && inCap) {
+    return { running: true, active: true, foreign: false, decides: false }
+  }
+  return null
+}
+
+/** The newest thing a signal heard: an event, or (Cursor) a thought. */
+function signalLastAt(signal: SessionSignal | undefined): number | null {
+  if (!signal) return null
+  return Math.max(signal.lastEventAt, signal.lastThought?.at ?? 0)
+}
+
+/** A Codex thread with a writer-lock holder: alive, with no status of its own (W6). */
+const CODEX_HOLDER_FACTS: RegistryFacts = { alive: true, status: null, waitingFor: null, statusUpdatedAt: null, lastActiveAt: null }
+
+/**
+ * 6.62.0 (plan 1.3): one derivation for a Codex row. The hooks when they have spoken; else the
+ * rollout's own turn markers, read for a thread written inside the cap. Registry facts only
+ * when a writer-lock holder exists: passing "dead" facts for every unloaded thread would end
+ * each of them after two scans (session-state-derive.ts).
+ */
+function deriveCodexRow(sessionId: string, held: boolean, facts: CodexRolloutFacts | null, now: number, remember = true): DerivedSessionState | undefined {
+  return deriveForRow({
+    sessionId,
+    registry: held ? CODEX_HOLDER_FACTS : undefined,
+    transcript: facts ? { inFlight: facts.open, lastActivityAt: facts.mtimeMs } : undefined,
+    now,
+    remember,
+    attachedTurn: isAttachedTurnActive(sessionStreamKey('codex', sessionId)),
+  })
+}
+
+/** The evidence clock a row's hint is judged by: the hooks, else (Codex) the rollout write. */
+function hintClock(signal: SessionSignal | undefined, derived: DerivedSessionState | undefined, facts: CodexRolloutFacts | null): number | null {
+  if (derived?.state_source === 'hook') return signalLastAt(signal)
+  return facts?.mtimeMs ?? null
+}
+
+/**
+ * 6.62.0 (plan 1.9): Codex compaction. Codex's PreCompact hook opens it; the rollout's
+ * `ContextCompaction` item, written when it is over, closes it (as does the PostCompact hook).
+ */
+function codexCompactionFields(observation: WorkObservation | undefined, facts: CodexRolloutFacts | null, now: number): ReturnType<typeof workObservationFields> {
+  if (!observation || observation.compactingAt === null) return {}
+  if (facts?.compactedAt != null && facts.compactedAt >= observation.compactingAt) return {}
+  const { compaction } = workObservationFields({ ...observation, agents: [], partial: false }, now)
+  return compaction ? { compaction } : {}
+}
+
+/** 6.62.0 (plan 1.1): a Cursor row's last activity is its last hook event; the transcript has no clock. */
+function cursorActivityFields(provider: AgentProvider, signal: SessionSignal | undefined): { last_activity_at?: string } {
+  if (provider !== 'cursor') return {}
+  const at = signalLastAt(signal)
+  return at ? { last_activity_at: new Date(at).toISOString() } : {}
+}
+
 /**
  * Occupancy plus freshness for ONE thread, for the detail route.
  *
@@ -399,11 +509,30 @@ agentSessionsRouter.get('/agent-sessions', async (req, res) => {
       if (row.provider !== 'cursor' || !signalFor(row.session_id)) continue
       derivedById.set(row.session_id, deriveForRow({ sessionId: row.session_id, now, remember: false }))
     }
+    // 6.62.0 (plan 1.3): Codex rows get the one derivation too, from the hooks or the rollout.
+    const rolloutById = new Map<string, CodexRolloutFacts | null>()
+    for (const row of sessions) {
+      if (row.provider !== 'codex') continue
+      const facts = codexRolloutFacts(row.file, now)
+      rolloutById.set(row.session_id, facts)
+      derivedById.set(row.session_id, deriveCodexRow(row.session_id, running.occupied.has(row.session_id), facts, now))
+    }
     const queuedOf = await allQueuedWaitingLookup(now)
     const subagents = await readCodexSubagents(sessions.filter(row => row.provider === 'codex').map(row => row.session_id), roots.codexSessions, now)
     res.json({
-      sessions: sessions.map((row, index) => ({ ...withRunning(toEntry(row, activity[index], derivedById.get(row.session_id), queuedOf(row.provider, row.session_id)), running),
-        ...(row.provider === 'codex' ? (subagents.has(row.session_id) ? { subagent_activity: subagents.get(row.session_id) } : {}) : workObservationFields(workObservationFor(row.session_id), now)) })),
+      sessions: sessions.map((row, index) => {
+        const derived = derivedById.get(row.session_id)
+        const signal = signalFor(row.session_id)
+        const facts = rolloutById.get(row.session_id) ?? null
+        const hint = runningHintFor(row.provider, derived, hintClock(signal, derived, facts), now)
+        return {
+          ...withRunning(toEntry(row, activity[index], derived, queuedOf(row.provider, row.session_id)), running, hint),
+          ...cursorActivityFields(row.provider, signal),
+          ...(row.provider === 'codex'
+            ? { ...(subagents.has(row.session_id) ? { subagent_activity: subagents.get(row.session_id) } : {}), ...codexCompactionFields(workObservationFor(row.session_id), facts, now) }
+            : workObservationFields(workObservationFor(row.session_id), now)),
+        }
+      }),
       total: sessions.length,
       windowHours: AGENT_SESSION_WINDOW_HOURS,
       sort,
@@ -442,7 +571,9 @@ agentSessionsRouter.get('/agent-sessions/search', async (req, res) => {
       if (!peersByPrefix.has(prefix)) peersByPrefix.set(prefix, peer)
     }
     const derivedFor = (hit: AgentSessionSearchHit): DerivedSessionState | undefined => {
-      if (hit.provider !== 'claude') return undefined
+      // 6.62.0 (plan 1.3): a Codex or Cursor hit the hooks have spoken for gets the same state
+      // as its row, from the signal alone (a hit has no transcript walk).
+      if (hit.provider !== 'claude') return signalFor(hit.session_id) ? deriveForRow({ sessionId: hit.session_id, remember: false, attachedTurn: isAttachedTurnActive(sessionStreamKey(hit.provider, hit.session_id)) }) : undefined
       const peer = peersByPrefix.get(hit.session_id.slice(0, 8).toLowerCase())
       return deriveForRow({
         sessionId: hit.session_id,
@@ -515,7 +646,9 @@ agentSessionsRouter.get('/agent-sessions/:provider/:sessionId', async (req, res)
       const named = names.get(parsed.session_id) || names.get(sessionId)
       if (named) parsed.display_label = named
     }
-    const observed = provider === 'codex' ? {} : workObservationFields(workObservationFor(parsed.session_id))
+    const now = Date.now()
+    const rollout = provider === 'codex' ? codexRolloutFacts(found, now) : null
+    const observed = provider === 'codex' ? codexCompactionFields(workObservationFor(parsed.session_id), rollout, now) : workObservationFields(workObservationFor(parsed.session_id))
     const subagents = provider === 'codex' ? (await readCodexSubagents([sessionId], agentSessionRoots().codexSessions)).get(sessionId.toLowerCase()) : observed.subagent_activity
     const modified = st.mtime.toISOString()
     const activity = await readSessionActivity(provider, found)
@@ -534,9 +667,14 @@ agentSessionsRouter.get('/agent-sessions/:provider/:sessionId', async (req, res)
     } else if (provider === 'cursor' && signalFor(parsed.session_id)) {
       // 6.51.0: the detail agrees with its list row (hook-grounded Cursor state).
       derived = deriveForRow({ sessionId: parsed.session_id, remember: false })
+    } else if (provider === 'codex') {
+      // 6.62.0 (plan 1.3): as its list row: the hooks, else the rollout's turn markers.
+      derived = deriveCodexRow(parsed.session_id, running.occupied.has(parsed.session_id), rollout, now, false)
     }
+    const signal = signalFor(parsed.session_id)
+    const hint = runningHintFor(provider, derived, hintClock(signal, derived, rollout), now)
     res.json({
-      ...withRunning({ session_id: parsed.session_id }, running),
+      ...withRunning({ session_id: parsed.session_id }, running, hint),
       ...derivedRowFields(derived),
       ...queuedTurnsFields((await allQueuedWaitingLookup(Date.now()))(provider, parsed.session_id)),
       // The client must be able to tell "this server stamped nothing" from "this
@@ -587,8 +725,15 @@ agentSessionsRouter.get('/agent-sessions/:provider/:sessionId', async (req, res)
       file_size_bytes: parsed.file_size_bytes,
       omitted_tools: parsed.omitted_tools,
       ...(activity.lastActivityAt ? { last_activity_at: activity.lastActivityAt } : {}),
+      ...cursorActivityFields(provider, signal),
       ...(activity.lastTool ? { last_tool: activity.lastTool } : {}),
       ...(recentTurns ? { recent_turns: recentTurns.turns, recent_turns_more: recentTurns.more } : {}),
+      // 6.62.0 (plans 1.8, 3.12): the lens reads both from the DETAIL (display-pages.ts).
+      // 6.62.0 /qa (W11): detail and the attach verdict only; list rows never wait on model reads.
+      // Q3: the note says Ask unless this client declared it shows the note.
+      ...sessionActFields((await sessionActFactsFor([{ provider, session_id: parsed.session_id, file: found }], {
+        noteAck: continueNoteAcknowledged(req.headers[CONTINUE_NOTE_HEADER]),
+      }))[0]),
     })
   } catch (error) {
     console.error(`[agent-sessions] detail failed: ${error instanceof Error ? error.message : error}`)

package/server/routes/health.ts

@@ -87,7 +87,10 @@ import {
 } from '../lib/thread-attach-capability.js'
 import { cachedHookStatus, sessionHooksEnabled, sessionHooksHealthFields } from '../lib/session-hooks-runtime.js'
 import { sessionCancelFeature } from '../lib/session-cancel.js'
-import { hookHaltReady } from '../lib/claude-hooks-installer.js'
+import { codexDeskHaltReady, providerObserveFields } from '../lib/provider-observe.js'
+import { liveProviderActInput, mergeProviderSections, providerActSections } from '../lib/provider-actions.js'
+import { cursorDeskHaltReady, hookHaltReady } from '../lib/claude-hooks-installer.js'
+import { continueReadHealthFields } from '../lib/continue-read-health.js'
 import { permissionBrokerHealthFields, sessionQuestionsCapability } from '../lib/permission-broker.js'
 import { continueLiveEnabled, liveDeliveryStats } from '../lib/session-peer-inbox-deps.js'
 import { codexLiveStats } from '../lib/codex-live-queue-deps.js'
@@ -305,7 +308,9 @@ healthRouter.get('/health', async (_req, res) => {
     // 6.53.0: cancel a session run. `cosTurn` always; `deskClaude` only once the hooks are
     // applied and the 6.53 hook is installed (Install hooks in COS Control after updating).
     // The status read is the same cached one `sessionHooks` below reports.
-    sessionCancel: sessionCancelFeature(sessionHooksEnabled(), hookHaltReady(cachedHookStatus())),
+    // 6.62.0: `deskCodex` (the Codex hooks installed AND trusted by Codex) and `deskCursor` (it
+    // runs the Claude hooks). `deskClaude` reads exactly as before.
+    sessionCancel: sessionCancelFeature(sessionHooksEnabled(), hookHaltReady(cachedHookStatus()), codexDeskHaltReady(), cursorDeskHaltReady(cachedHookStatus())),
   }
   const voice = {
     available: keyStatus.hasKey || tts_local.ready,
@@ -415,6 +420,18 @@ healthRouter.get('/health', async (_req, res) => {
     // how many are held (that is on the authenticated questions route).
     ...permissionBrokerHealthFields(),
     ...continueLiveHealthFields(),
+    // 6.62.0 /qa (W6): spawn isolation, posture and Cursor model read counters.
+    ...continueReadHealthFields(),
+    // 6.62.0: ONE providers object per engine. `act` (plan 3.11): what each provider can do,
+    // with a reason for every "no". `observe` (plan 1.10): what COS can see of its sessions.
+    providers: mergeProviderSections(
+      providerActSections(liveProviderActInput({
+        attachEnabled: threadAttach.enabled,
+        forkProviders: threadAttach.forkProviders ?? [],
+        sessionCancel: features.sessionCancel,
+      })),
+      providerObserveFields({ state: cachedHookStatus().state, ready: hookHaltReady(cachedHookStatus()) }),
+    ),
     server_instance_id: getServerInstanceId(),
     boot_id: serverMetrics.bootId,
     generation_id: getServerGenerationId(),
@@ -548,6 +565,14 @@ healthRouter.get('/models', async (req, res) => {
   res.json({
     ...catalog,
     ...threadAttachHealthFields(threadAttach),
+    // 6.62.0 (plans 3.5, 3.11): the phone reads THIS surface, so the live-Continue counters
+    // and the per-provider action contract are published here too, same helpers as health.
+    ...continueLiveHealthFields(),
+    providers: mergeProviderSections(providerActSections(liveProviderActInput({
+      attachEnabled: threadAttach.enabled,
+      forkProviders: threadAttach.forkProviders ?? [],
+      sessionCancel: sessionCancelFeature(sessionHooksEnabled(), hookHaltReady(cachedHookStatus()), codexDeskHaltReady(), cursorDeskHaltReady(cachedHookStatus())),
+    })), providerObserveFields({ state: cachedHookStatus().state, ready: hookHaltReady(cachedHookStatus()) })),
     options: [
       ...(catalog.options ?? []),
       ...cursorOptions,

package/server/routes/session-hooks.ts

@@ -1,4 +1,6 @@
 import { installCursorObserver } from '../lib/cursor-observer-installer.js'
+import { codexPresent, installCodexHooks, uninstallCodexHooks, type CodexInstallResult } from '../lib/codex-hooks-installer.js'
+import { refreshAfterInstall } from '../lib/provider-observe.js'
 // Session hooks: status, install, uninstall, and today's runs.
 //
 // `GET /api/session-hooks/status` is what Control's banner keys off. Five outcomes on
@@ -17,8 +19,50 @@ export function isInteractiveEntrypoint(entrypoint: string | null): boolean {
   return entrypoint === 'claude-desktop' || entrypoint === 'cli'
 }
 
-export function createSessionHooksRouter(options: { port: number }): Router {
+/**
+ * 6.62.0: the Codex half of install and uninstall, injectable so a test never touches the
+ * real `~/.codex`. Defaults are the real installer, gated on Codex being present at all.
+ */
+export interface SessionHooksCodexDeps {
+  present: () => boolean
+  install: (options: { dryRun: boolean }) => CodexInstallResult
+  uninstall: (options: { dryRun: boolean }) => CodexInstallResult
+  /** Re-read the provider hook files (and Codex trust, in the background) after a write. */
+  refresh: () => void
+}
+
+const realCodexDeps: SessionHooksCodexDeps = {
+  present: () => codexPresent(),
+  install: options => installCodexHooks(options),
+  uninstall: options => uninstallCodexHooks(options),
+  refresh: () => refreshAfterInstall(),
+}
+
+/**
+ * The Codex half, run AFTER Claude's and the observer's and never able to change their answer
+ * (B2): a missing Codex is `skipped`, a refusal or a throw is reported in `codex` and the route
+ * still answers as Claude's result says.
+ */
+export function codexHookStep(deps: SessionHooksCodexDeps, action: 'install' | 'uninstall', dryRun: boolean): Record<string, unknown> {
+  try {
+    if (!deps.present()) return { ok: true, skipped: 'codex_not_present' }
+    const result = action === 'install' ? deps.install({ dryRun }) : deps.uninstall({ dryRun })
+    return {
+      ok: result.ok,
+      ...(result.reason ? { reason: result.reason } : {}),
+      changed: result.changed,
+      backupPath: result.backupPath,
+      status: { state: result.status.state, installed: result.status.installed, scriptOk: result.status.scriptOk },
+      ...(dryRun && result.merged ? { merged: result.merged } : {}),
+    }
+  } catch (error) {
+    return { ok: false, reason: 'codex_step_threw', detail: error instanceof Error ? error.name : 'error' }
+  }
+}
+
+export function createSessionHooksRouter(options: { port: number; codex?: SessionHooksCodexDeps }): Router {
   const router = Router()
+  const codex = options.codex ?? realCodexDeps
 
   router.get('/session-hooks/status', (_req, res) => {
     res.set('Cache-Control', 'private, no-store')
@@ -34,8 +78,10 @@ export function createSessionHooksRouter(options: { port: number }): Router {
       return
     }
     const cursorObserver = installCursorObserver({ dryRun })
-    if (!cursorObserver.ok) { res.status(409).json({ ok: false, reason: 'cursor_observer_install_failed', cursorObserver, status: result.status }); return }
-    res.json({ ok: true, cursorObserver, changed: result.changed || cursorObserver.changed, scriptCopied: result.scriptCopied, backupPath: result.backupPath, status: result.status, ...(dryRun ? { merged: result.merged } : {}) })
+    const codexStep = codexHookStep(codex, 'install', dryRun)
+    if (!dryRun) { try { codex.refresh() } catch { /* health catches up on its own tick */ } }
+    if (!cursorObserver.ok) { res.status(409).json({ ok: false, reason: 'cursor_observer_install_failed', cursorObserver, codex: codexStep, status: result.status }); return }
+    res.json({ ok: true, cursorObserver, codex: codexStep, changed: result.changed || cursorObserver.changed, scriptCopied: result.scriptCopied, backupPath: result.backupPath, status: result.status, ...(dryRun ? { merged: result.merged } : {}) })
   })
 
   router.post('/session-hooks/uninstall', (req, res) => {
@@ -47,8 +93,10 @@ export function createSessionHooksRouter(options: { port: number }): Router {
       return
     }
     const cursorObserver = installCursorObserver({ dryRun, uninstall: true })
-    if (!cursorObserver.ok) { res.status(409).json({ ok: false, reason: 'cursor_observer_uninstall_failed', cursorObserver, status: result.status }); return }
-    res.json({ ok: true, cursorObserver, changed: result.changed || cursorObserver.changed, backupPath: result.backupPath, status: result.status, ...(dryRun ? { merged: result.merged } : {}) })
+    const codexStep = codexHookStep(codex, 'uninstall', dryRun)
+    if (!dryRun) { try { codex.refresh() } catch { /* health catches up on its own tick */ } }
+    if (!cursorObserver.ok) { res.status(409).json({ ok: false, reason: 'cursor_observer_uninstall_failed', cursorObserver, codex: codexStep, status: result.status }); return }
+    res.json({ ok: true, cursorObserver, codex: codexStep, changed: result.changed || cursorObserver.changed, backupPath: result.backupPath, status: result.status, ...(dryRun ? { merged: result.merged } : {}) })
   })
 
   // Sessions the hooks saw start and end, for Control's scheduled-job ledger. A run
@@ -63,6 +111,9 @@ export function createSessionHooksRouter(options: { port: number }): Router {
     const runs: Array<Record<string, unknown>> = []
     for (const signal of sessionSignalStore.snapshot()) {
       if (signal.observationOnly) continue
+      // 6.62.0: Control's scheduled-job ledger lists `claude -p` jobs. A Codex thread (no
+      // registry entrypoint at all) or a Cursor composer is never one.
+      if (signal.provider !== undefined && signal.provider !== 'claude') continue
       if (signal.firstSeenAt < sinceMs && !(signal.ended && signal.ended.at >= sinceMs)) continue
       if (!all && isInteractiveEntrypoint(signal.entrypoint)) continue
       runs.push({

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

@@ -16,6 +16,7 @@
 // EVERY DEPENDENCY IS INJECTED so the whole path is testable without a live server.
 
 import { Router, type Request, type Response } from 'express'
+import { CONTINUE_NOTE_HEADER, continueNoteAcknowledged } from '../lib/continue-plan.js'
 import { nativeQueueControl, plainQueueText, type NativeQueueControl } from '../lib/codex-queue-control.js'
 import { COS_SESSION_ID_RE, DEFAULT_MAX_PROMPT_CHARS } from './agent-session-bindings.js'
 import {
@@ -49,6 +50,13 @@ export interface ThreadTurnQueueDeps {
     serverRetryable?: boolean
   }>
   nativeQueue?: NativeQueueControl
+  /**
+   * 6.62.0 (W14), optional: is this Cursor id an Agent CLI chat (a `~/.cursor/chats` dir)?
+   * Only those are drained from here, and only when the gate, which now includes the
+   * chat's 30 s busy window, says free. An IDE composer still leaves only through its own
+   * Stop hook. Absent: no Cursor turn is ever drained here, exactly as in 6.61.
+   */
+  cursorCliChat?: (threadId: string) => boolean
   now: () => number
 }
 
@@ -92,6 +100,11 @@ function safeTurnOpen(deps: ThreadTurnQueueDeps, provider: string, threadId: str
   try { return deps.turnOpen!(provider, threadId) } catch { return undefined }
 }
 
+/** A throwing or absent CLI-chat probe means "not a CLI chat": the 6.61 Cursor hold. */
+function safeCursorCliChat(deps: ThreadTurnQueueDeps, threadId: string): boolean {
+  try { return deps.cursorCliChat ? deps.cursorCliChat(threadId) === true : false } catch { return false }
+}
+
 /** A throwing cancel read is no hold: the gate still decides every delivery. */
 function safeCancelHold(deps: ThreadTurnQueueDeps, provider: string, threadId: string): number | null {
   try { return deps.cancelHoldUntil ? deps.cancelHoldUntil(provider, threadId) : null } catch { return null }
@@ -142,18 +155,31 @@ export async function drainThread(
     // composer's own Stop hook (`routes/cursor-stop-followup.ts`), which claims it the
     // moment the turn ends; a second deliverer could hand the same sentence over twice.
     // The pass still runs for it so the TTL retires an unclaimed turn honestly.
-    const gate: ReturnType<ThreadTurnQueueDeps['occupancy']> = provider === 'cursor'
+    //
+    // 6.62.0 (W14): an Agent CLI chat is the exception. A `-p` run fires no Stop hook, so
+    // nothing else would ever send its parked turn; it drains here once the gate (with the
+    // chat's 30 s busy window) reads free, and that quiet window is its turn-ended signal.
+    const cliChat = provider === 'cursor' && safeCursorCliChat(deps, threadId)
+    const gate: ReturnType<ThreadTurnQueueDeps['occupancy']> = provider === 'cursor' && !cliChat
       ? { attachable: false, reason: 'cursor_stop_hook_delivery' }
       : refusedGate ?? deps.occupancy(provider, threadId)
     if (!gate.attachable) refusedGate = gate
-    const seen: DrainObservation = {
-      attachable: gate.attachable,
-      turnEnded: deps.turnEnded(provider, threadId),
-      turnOpen: deps.turnOpen ? safeTurnOpen(deps, provider, threadId) : undefined,
-      activity: deps.activity(provider, threadId),
-      reason: gate.reason,
-      cancelHoldUntil: safeCancelHold(deps, provider, threadId),
-    }
+    const seen: DrainObservation = cliChat
+      ? {
+          attachable: gate.attachable,
+          turnEnded: gate.attachable,
+          activity: gate.attachable ? 'idle' : 'working',
+          reason: gate.reason,
+          cancelHoldUntil: safeCancelHold(deps, provider, threadId),
+        }
+      : {
+          attachable: gate.attachable,
+          turnEnded: deps.turnEnded(provider, threadId),
+          turnOpen: deps.turnOpen ? safeTurnOpen(deps, provider, threadId) : undefined,
+          activity: deps.activity(provider, threadId),
+          reason: gate.reason,
+          cancelHoldUntil: safeCancelHold(deps, provider, threadId),
+        }
     const decision = drainDecision(turn, seen, deps.now())
 
     if (decision === 'hold') { held += 1; continue }
@@ -282,6 +308,8 @@ export function createThreadTurnQueueRouter(deps: ThreadTurnQueueDeps): Router {
     const admitted = admitToQueue(queue, {
       clientTurnId, cosSessionId, provider, threadId, prompt,
       queuedAt: now, status: 'waiting', attempts: 0,
+      // 6.62.0 /qa (Q3): the acknowledgement travels with the row to its drain.
+      ...(continueNoteAcknowledged(req.headers[CONTINUE_NOTE_HEADER]) ? { continueNoteAck: true as const } : {}),
     })
     if (!admitted.ok) return res.status(409).json({ error: admitted.reason })
 

package/server/scripts/hooks-cli.ts

@@ -1,15 +1,21 @@
 #!/usr/bin/env tsx
 import { installCursorObserver } from '../lib/cursor-observer-installer.js'
-// Install, inspect or remove the COS session hook in ~/.claude/settings.json.
+// Install, inspect or remove the COS session hook in ~/.claude/settings.json, and (6.62.0) in
+// ~/.codex/hooks.json when Codex is on this Mac.
 //
-//   npx --yes @gotcos/glasses-server@latest --hooks install [--dry-run] [--port 3141]
+//   npx --yes @gotcos/glasses-server@latest --hooks install [--dry-run] [--port 3141] [--codex]
 //   npx --yes @gotcos/glasses-server@latest --hooks status
-//   npx --yes @gotcos/glasses-server@latest --hooks uninstall [--dry-run]
+//   npx --yes @gotcos/glasses-server@latest --hooks uninstall [--dry-run] [--codex]
+//
+// `--codex` acts on Codex ONLY (the rollback runbook's `--hooks uninstall --codex` leaves the
+// Claude hooks in place). Without it, Codex rides along when present and never changes the
+// exit code: a Codex refusal is reported under `codex` and Claude's answer stands (B2).
 //
 // Prints one JSON document. Exit 0 on success, 2 on a refusal (unparseable or symlinked
 // settings, a missing packaged script), 64 on a bad argument. Never prints the token.
 
 import { hookStatus, hookStatusAdvice, installClaudeHooks, uninstallClaudeHooks } from '../lib/claude-hooks-installer.js'
+import { codexHookAdvice, codexHookStatus, codexPresent, installCodexHooks, refreshCodexHookTrust, uninstallCodexHooks } from '../lib/codex-hooks-installer.js'
 import { sessionHooksEnabled } from '../lib/session-hooks-runtime.js'
 
 const args = process.argv.slice(2)
@@ -20,36 +26,56 @@ const port = portIndex >= 0 ? Number(args[portIndex + 1]) : Number(process.env.P
 const deskIndex = args.indexOf('--desk-idle-s')
 const deskIdleSeconds = deskIndex >= 0 ? Number(args[deskIndex + 1]) : Number(process.env.COS_PERMISSION_BROKER_DESK_IDLE_S ?? 90)
 
+const codexOnly = args.includes('--codex')
+
 function print(value: unknown): void {
   console.log(JSON.stringify(value, null, 2))
 }
 
+/** The Codex half: skipped when Codex is not here; with trust read from Codex itself (K3). */
+async function codexPart(action: 'status' | 'install' | 'uninstall'): Promise<Record<string, unknown> & { ok: boolean }> {
+  if (!codexPresent()) return { ok: true, skipped: 'codex_not_present' }
+  const result = action === 'status' ? { ok: true, status: codexHookStatus() }
+    : action === 'install' ? installCodexHooks({ dryRun }) : uninstallCodexHooks({ dryRun })
+  const trust = result.status.installed && !dryRun ? await refreshCodexHookTrust({ fresh: true }) : null
+  const advice = action === 'uninstall' ? null : codexHookAdvice(result.status, trust?.trust ?? 'unknown')
+  // QA W4: why the trust word is what it is (a failed read's code, `not_listed`), or null.
+  return { ...result, ...(trust ? { trust: trust.trust, trustReason: trust.reason } : {}), ...(advice ? { advice } : {}) }
+}
+
 // `serverApplies` says whether the running server would READ the spool into rows: the
 // hooks can be installed while the feature is off (COS_CLAUDE_SESSIONS_ENABLED unset),
 // and a status that said only "installed" would hide that.
 const serverApplies = sessionHooksEnabled()
 const flagsNote = serverApplies ? undefined : 'Rows change only when the server runs with COS_CLAUDE_SESSIONS_ENABLED=1 (or COS_SESSION_HOOKS=1).'
 
+if ((action === 'install' || action === 'uninstall') && codexOnly) {
+  const codex = await codexPart(action)
+  print({ action, dryRun, codexOnly: true, codex })
+  process.exit(codex.ok ? 0 : 2)
+}
 if (action === 'status') {
   const status = hookStatus()
   // 6.53.3: say in words what the state means and what fixes it (`script_outdated` after an
   // update that changed the script, until Install hooks).
   const advice = hookStatusAdvice(status)
-  print({ action, serverApplies, ...(flagsNote ? { note: flagsNote } : {}), ...(advice ? { advice } : {}), ...status })
+  print({ action, serverApplies, ...(flagsNote ? { note: flagsNote } : {}), ...(advice ? { advice } : {}), ...status, codex: await codexPart('status') })
   process.exit(0)
 }
 if (action === 'install') {
   if (!Number.isFinite(port) || port <= 0) { console.error('Bad --port'); process.exit(64) }
   const result = installClaudeHooks({ port, deskIdleSeconds: Number.isFinite(deskIdleSeconds) ? deskIdleSeconds : 90, dryRun })
   const cursorObserver = result.ok ? installCursorObserver({ dryRun }) : undefined
-  print({ action, dryRun, serverApplies, ...(flagsNote ? { note: flagsNote } : {}), ...result, cursorObserver })
+  const codex = result.ok ? await codexPart('install') : undefined
+  print({ action, dryRun, serverApplies, ...(flagsNote ? { note: flagsNote } : {}), ...result, cursorObserver, codex })
   process.exit(result.ok && cursorObserver?.ok ? 0 : 2)
 }
 if (action === 'uninstall') {
   const result = uninstallClaudeHooks({ dryRun })
   const cursorObserver = result.ok ? installCursorObserver({ dryRun, uninstall: true }) : undefined
-  print({ action, dryRun, ...result, cursorObserver })
+  const codex = result.ok ? await codexPart('uninstall') : undefined
+  print({ action, dryRun, ...result, cursorObserver, codex })
   process.exit(result.ok && cursorObserver?.ok ? 0 : 2)
 }
-console.error('Usage: --hooks install|status|uninstall [--dry-run] [--port N] [--desk-idle-s N]')
+console.error('Usage: --hooks install|status|uninstall [--dry-run] [--port N] [--desk-idle-s N] [--codex]')
 process.exit(64)