@gotcos/glasses-server 6.61.7 → 6.63.0

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

@@ -79,12 +79,12 @@ import {
   transcriptWatcherDegraded,
   readTranscriptSeedLines,
 } from '../lib/session-transcript-watcher.js'
-import { foldSeedOutcomes, draftsFromLine, statusDraftWithDerived, type DerivedStatusFields } from '../lib/session-stream-events.js'
+import { cursorThoughtStatus, foldSeedOutcomes, draftsFromLine, statusDraftWithDerived, type DerivedStatusFields } from '../lib/session-stream-events.js'
 import type { SessionStreamState } from '../lib/session-stream-events.js'
 import { RING_EPOCH, replaySessionStream, ringBounds } from '../lib/session-stream-bus.js'
 import { claudeSessionsDir, readClaudePeerRecords, registryFacts } from './claude-sessions.js'
 import type { RegistryFacts } from '../lib/session-state-derive.js'
-import { deriveForRow, sessionHooksEnabled, sessionSignalStore } from '../lib/session-hooks-runtime.js'
+import { deriveForRow, sessionHooksEnabled, sessionSignalStore, signalFor } from '../lib/session-hooks-runtime.js'
 import { derivedStatusFields } from '../lib/session-state-derive.js'
 
 export const agentSessionStreamRouter = Router()
@@ -121,9 +121,12 @@ export const REGISTRY_REFRESH_MS = 5_000
 type RegistryReader = () => Promise<RegistryFacts | undefined>
 
 function derivedForStream(provider: AgentProvider, sessionId: string, key: string, registry: RegistryFacts | undefined): DerivedStatusFields | undefined {
-  if (provider !== 'claude' || !sessionHookSseEnabled()) return undefined
+  if (!sessionHookSseEnabled()) return undefined
+  // 6.62.0 (plan 1.3): Codex and Cursor too, once their hooks have spoken for the session. A
+  // session they have not stays exactly as before: the transcript's own status lines narrate it.
+  if (provider !== 'claude' && !signalFor(sessionId)) return undefined
   try {
-    const derived = deriveForRow({ sessionId, registry, remember: false, attachedTurn: isAttachedTurnActive(key) })
+    const derived = deriveForRow({ sessionId, registry: provider === 'claude' ? registry : undefined, remember: false, attachedTurn: isAttachedTurnActive(key) })
     return derived ? derivedStatusFields(derived) : undefined
   } catch {
     return undefined
@@ -278,7 +281,8 @@ agentSessionStreamRouter.get('/agent-sessions/:provider/:sessionId/stream', asyn
   // opening state (nothing awaits once the headers are out, so a close can never slip
   // between a write and the `close` listener), refreshed at most every REGISTRY_REFRESH_MS.
   const readRegistry = registryReaderFor(sessionId)
-  let registry: RegistryFacts | undefined = await readRegistry()
+  // Only a Claude session has a `~/.claude/sessions` record (6.62.0: the feed now derives for all three).
+  let registry: RegistryFacts | undefined = provider === 'claude' ? await readRegistry() : undefined
 
   res.writeHead(200, {
     'Content-Type': 'text/event-stream',
@@ -300,6 +304,7 @@ agentSessionStreamRouter.get('/agent-sessions/:provider/:sessionId/stream', asyn
   let closed = false
 
   let releaseSignals: (() => void) | null = null
+  let releaseThoughts: (() => void) | null = null
 
   const teardown = (): void => {
     if (closed) return
@@ -308,6 +313,7 @@ agentSessionStreamRouter.get('/agent-sessions/:provider/:sessionId/stream', asyn
     unsubscribe()
     releaseWatcher?.()
     releaseSignals?.()
+    releaseThoughts?.()
     try { res.end() } catch { /* already gone */ }
   }
 
@@ -437,7 +443,8 @@ agentSessionStreamRouter.get('/agent-sessions/:provider/:sessionId/stream', asyn
   // client's state line moves on the engine's own events (prompt, permission prompt,
   // Stop, end) rather than on the transcript clock. Filtered to this session (the
   // client may have addressed it by the registry's 8-character form).
-  if (provider === 'claude' && sessionHookSseEnabled() && !closed) {
+  // 6.62.0 (plan 1.3): Codex and Cursor sessions as well, now that their hooks reach the store.
+  if (sessionHookSseEnabled() && !closed) {
     const wanted = sessionId.toLowerCase()
     // `lastStamp` is whatever the OPENING status actually wrote (set inside `write`), so a
     // change during the seed read is emitted as the first live line, not lost.
@@ -446,7 +453,7 @@ agentSessionStreamRouter.get('/agent-sessions/:provider/:sessionId/stream', asyn
       if (signal.sessionId !== wanted && !signal.sessionId.startsWith(wanted)) return
       // The registry may have moved with the hooks (an Esc flips it idle); refresh it
       // off the hot path and let the next event read the new facts.
-      void readRegistry().then(facts => { registry = facts })
+      if (provider === 'claude') void readRegistry().then(facts => { registry = facts })
       const derived = derivedForStream(provider, sessionId, key, registry)
       if (!derived) return
       // Only a CHANGE of state is a line; tool events inside a running turn are narrated
@@ -454,6 +461,16 @@ agentSessionStreamRouter.get('/agent-sessions/:provider/:sessionId/stream', asyn
       if (stampOf(derived) === lastStamp) return
       write({ kind: 'status', state: 'working', at: Date.now() })
     })
+    // 6.62.0 (plan 1.7): a Cursor session's newest agent thought is its reasoning line, the
+    // way Codex's reasoning headline is. Memory and this feed only; never the ledger.
+    if (provider === 'cursor') {
+      releaseThoughts = sessionSignalStore.subscribeThoughts((signal, thought) => {
+        if (closed) return
+        if (signal.sessionId !== wanted && !signal.sessionId.startsWith(wanted)) return
+        const draft = cursorThoughtStatus(thought.text)
+        if (draft) write({ ...draft, at: Date.now() })
+      })
+    }
   }
 
   releaseWatcher = path === null
@@ -466,6 +483,8 @@ agentSessionStreamRouter.get('/agent-sessions/:provider/:sessionId/stream', asyn
     releaseWatcher = null
     releaseSignals?.()
     releaseSignals = null
+    releaseThoughts?.()
+    releaseThoughts = null
     return
   }
 

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 })