@gotcos/glasses-server 6.61.6 → 6.62.1

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

@@ -30,12 +30,53 @@ export const HOOK_EVENT_NAMES = [
   'Notification',
   'SubagentStart',
   'SubagentStop',
+  '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 {
@@ -56,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
 }
 
 /**
@@ -110,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 } : {}),
     },
   }
 }
@@ -154,10 +204,14 @@ export function projectHookPayload(event: HookEventName, payload: Record<string,
   const str = (k: string) => (typeof payload[k] === 'string' ? payload[k] as string : undefined)
   const base: Record<string, unknown> = {
     session_id: str('session_id'),
+    ...(payload.display_only === true ? { display_only: true } : {}),
     ...(str('transcript_path') ? { transcript_path: str('transcript_path') } : {}),
     ...(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':
@@ -199,7 +253,13 @@ export function projectHookPayload(event: HookEventName, payload: Record<string,
       return { ...base, agent_id: str('agent_id'), agent_type: str('agent_type') }
     case 'PostModelSwitch':
       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(),
     },
   }
 }
@@ -404,7 +420,28 @@ export function sessionHooksHealthFields(): { sessionHooks: SessionHooksHealth }
 /** Signal for a row id that may be the registry's eight-character form. */
 export function signalFor(sessionId: string): SessionSignal | undefined {
   if (!sessionHooksEnabled()) return undefined
-  return sessionId.length >= 36 ? sessionSignalStore.get(sessionId) : sessionSignalStore.getByPrefix(sessionId)
+  const signal = sessionId.length >= 36 ? sessionSignalStore.get(sessionId) : sessionSignalStore.getByPrefix(sessionId)
+  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
+  return (sessionId.length >= 36 ? sessionSignalStore.get(sessionId) : sessionSignalStore.getByPrefix(sessionId))?.workObservation
 }
 
 /** 6.60.0: told when a row derives `ended`, so the broker stops saying the Mac is waiting on it. */

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
 

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

@@ -1,3 +1,4 @@
+import { observeWork, type WorkObservation } from './session-work-observation.js'
 // The signal store: what the hooks have said about each Claude session, reduced to
 // one record per full session id.
 //
@@ -24,8 +25,8 @@
 //  3. `ended` is recorded here but RANKED in the deriver, which also sees the registry:
 //     an ended signal with an alive registry record is a child that ended, not the tab.
 
-import type { HookEnvelope, HookEventName } from './session-hook-events.js'
-import { clipText, toolFingerprint, toolTarget } from './session-hook-events.js'
+import type { HookEnvelope, HookEventName, HookProvider } from './session-hook-events.js'
+import { AGENT_THOUGHT_MAX, clipText, toolFingerprint, toolTarget } from './session-hook-events.js'
 import { isKeepWarmSessionTitle } from './agent-session-store.js'
 
 export type WaitingKind = 'permission' | 'question' | 'plan' | 'mcp_input'
@@ -48,6 +49,23 @@ export interface FailureSignal {
 }
 
 export interface SessionSignal {
+  workObservation?: WorkObservation
+  observationOnly?: boolean
+  /**
+   * 6.62.0: the engine whose hooks these are (`inferHookProvider`). Absent on a record built
+   * from envelopes that never carried one (an older ledger row), which is read as Claude.
+   */
+  provider?: HookProvider
+  /**
+   * 6.62.0: the newest agent thought the Cursor observer reported, capped at
+   * AGENT_THOUGHT_MAX. MEMORY ONLY: the ledger keeps no thought text, so a restart forgets it.
+   */
+  lastThought?: { text: string; at: number }
+  /**
+   * 6.62.0 (QA W2): the newest phase event (never an observer one) whose envelope the hook
+   * script stamped with its provider: proof a 6.62 script is running this session's hooks.
+   */
+  stampedAt?: number
   sessionId: string
   firstSeenAt: number
   lastEventAt: number
@@ -104,6 +122,7 @@ function toolFacts(p: Record<string, unknown>): { name: string; target: string;
 
 function fresh(env: HookEnvelope): SessionSignal {
   return {
+    ...(env.provider ? { provider: env.provider } : {}),
     sessionId: env.sessionId,
     firstSeenAt: env.ts,
     lastEventAt: env.ts,
@@ -133,6 +152,25 @@ function fresh(env: HookEnvelope): SessionSignal {
 
 const str = (v: unknown): string | null => (typeof v === 'string' && v.length > 0 ? v : null)
 
+/**
+ * Observer evidence: never a phase, never a listener. 6.62.0: an AgentThought is display only
+ * whatever its payload says, so a thought can never open, close or reopen a turn.
+ */
+export function isDisplayOnly(env: HookEnvelope): boolean {
+  return env.payload.display_only === true || env.event === 'AgentThought'
+}
+
+/**
+ * 6.62.0: an AgentThought with text becomes the record's `lastThought`, unless an older one
+ * arrived late. A replayed row carries no text (the ledger drops it) and changes nothing.
+ */
+function thoughtOf(base: SessionSignal, env: HookEnvelope): Pick<SessionSignal, 'lastThought'> {
+  if (env.event !== 'AgentThought') return {}
+  const text = clipText(env.payload.text, AGENT_THOUGHT_MAX)
+  if (!text || (base.lastThought && base.lastThought.at > env.ts)) return {}
+  return { lastThought: { text, at: env.ts } }
+}
+
 /**
  * 6.48.1. A tool runs only inside a turn, so a MAIN-THREAD tool event (no `agent_id`) is
  * evidence the turn is open even when its UserPromptSubmit was never seen: a tab adopted
@@ -178,8 +216,13 @@ function resolvesWaiting(waiting: WaitingSignal, event: HookEventName, toolName:
  */
 export function applyHookEvent(prev: SessionSignal | undefined, env: HookEnvelope, ctx: ReducerContext, child?: boolean): SessionSignal {
   const base = prev ? { ...prev } : fresh(env)
+  if (env.provider) base.provider = env.provider
   const p = env.payload
+  if (isDisplayOnly(env)) return { ...base, ...(prev?.observationOnly !== false ? { lastEventAt: Math.max(base.lastEventAt, env.ts) } : {}), observationOnly: prev?.observationOnly ?? !prev, workObservation: observeWork(base.workObservation, env), ...thoughtOf(base, env) }
   const common = {
+    observationOnly: false,
+    ...(env.stamped ? { stampedAt: Math.max(base.stampedAt ?? 0, env.ts) } : {}),
+    workObservation: observeWork(base.workObservation, env),
     cwd: str(p.cwd) ?? base.cwd,
     transcriptPath: str(p.transcript_path) ?? base.transcriptPath,
     permissionMode: str(p.permission_mode) ?? base.permissionMode,
@@ -206,6 +249,11 @@ export function applyHookEvent(prev: SessionSignal | undefined, env: HookEnvelop
       const prompt = clipText(p.prompt)
       return {
         ...next,
+        // 6.62.0: Codex and Cursor have no registry to say a session lives on after its
+        // SessionEnd (a composer the hooks saw end and then reopened; a Codex thread resumed
+        // in the app without a SessionStart). A prompt after the end is a new life. Claude's
+        // own resume fires SessionStart, so its rows keep the 6.61 rule.
+        ...(next.provider === 'codex' || next.provider === 'cursor' ? { ended: null } : {}),
         turnOpen: true,
         turnStartedAt: env.ts,
         promptId: str(p.prompt_id),
@@ -274,6 +322,11 @@ export function applyHookEvent(prev: SessionSignal | undefined, env: HookEnvelop
         waiting: null,
         lastReply: clipText(p.last_assistant_message) || next.lastReply,
       }
+    // 6.62.0: Codex's Interrupt (Esc) ends the turn with no Stop and no reply.
+    case 'Interrupt':
+      return { ...next, turnOpen: false, stopAt: env.ts, waiting: null }
+    case 'AgentThought': // display only (`isDisplayOnly`); never reaches here
+      return next
     case 'StopFailure':
       return {
         ...next,
@@ -285,6 +338,8 @@ export function applyHookEvent(prev: SessionSignal | undefined, env: HookEnvelop
       return { ...next, subagentsOpen: next.subagentsOpen + 1 }
     case 'SubagentStop':
       return { ...next, subagentsOpen: Math.max(0, next.subagentsOpen - 1) }
+    case 'PreCompact':
+      return next
     case 'PostCompact':
       return { ...next, compactions: next.compactions + 1 }
     case 'PostModelSwitch':
@@ -295,6 +350,8 @@ export function applyHookEvent(prev: SessionSignal | undefined, env: HookEnvelop
 }
 
 export type SignalListener = (signal: SessionSignal, env: HookEnvelope, child: boolean) => void
+/** 6.62.0: told of each new agent thought (display only; the drain, permission and halt listeners never are). */
+export type ThoughtListener = (signal: SessionSignal, thought: { text: string; at: number }) => void
 
 /** Records older than this after a SessionEnd are dropped; Control keeps its own ledger. */
 export const SIGNAL_PRUNE_AFTER_END_MS = 6 * 60 * 60_000
@@ -304,6 +361,7 @@ export const SIGNAL_PRUNE_SILENT_MS = 24 * 60 * 60_000
 export class SessionSignalStore {
   private readonly signals = new Map<string, SessionSignal>()
   private readonly listeners = new Set<SignalListener>()
+  private readonly thoughtListeners = new Set<ThoughtListener>()
   private readonly ctx: ReducerContext
 
   constructor(ctx: ReducerContext) {
@@ -311,8 +369,21 @@ export class SessionSignalStore {
   }
 
   apply(env: HookEnvelope, child?: boolean): SessionSignal {
-    const next = applyHookEvent(this.signals.get(env.sessionId), env, this.ctx, child)
+    const prev = this.signals.get(env.sessionId)
+    const next = applyHookEvent(prev, env, this.ctx, child)
     this.signals.set(env.sessionId, next)
+    if (isDisplayOnly(env)) {
+      // No drain, permission or halt listeners. A NEW thought reaches the live feed only.
+      const thought = next.lastThought
+      if (env.event === 'AgentThought' && thought && thought !== prev?.lastThought) {
+        for (const listener of this.thoughtListeners) {
+          try { listener(next, thought) } catch (error) {
+            console.error(`[session-signals] thought listener failed: ${error instanceof Error ? error.message : error}`)
+          }
+        }
+      }
+      return next
+    }
     const isChild = child ?? this.ctx.isCosSpawnedPid(env.ppid)
     for (const listener of this.listeners) {
       try { listener(next, env, isChild) } catch (error) {
@@ -383,6 +454,12 @@ export class SessionSignalStore {
     return () => { this.listeners.delete(listener) }
   }
 
+  /** 6.62.0: new agent thoughts, for the live feed. Display only. */
+  subscribeThoughts(listener: ThoughtListener): () => void {
+    this.thoughtListeners.add(listener)
+    return () => { this.thoughtListeners.delete(listener) }
+  }
+
   /** Drop records that ended long ago, and records silent for a day (a tab that died with no SessionEnd). */
   prune(nowMs = Date.now()): number {
     let dropped = 0
@@ -417,5 +494,6 @@ export class SessionSignalStore {
   __resetForTests(): void {
     this.signals.clear()
     this.listeners.clear()
+    this.thoughtListeners.clear()
   }
 }

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

@@ -565,6 +565,37 @@ export function promptDrafts(message: Record<string, unknown>): SessionStreamDra
   return [{ kind: 'prompt', text: flat }]
 }
 
+/**
+ * Cursor (6.62.0, plan 1.5): the user's words are the inside of `<user_query>`; the rest of a
+ * Cursor user row is scaffolding (attached files, rules). Until 6.62.0 the whole row was
+ * dropped, so a Cursor feed never showed what it was working on. Everything else is the
+ * Claude-shaped content the two share.
+ */
+function draftsFromCursorRecord(record: Record<string, unknown>): SessionStreamDraft[] {
+  if (record.role === 'user' && record.type === undefined) {
+    const message = asRecord(record.message)
+    if (!message) return []
+    const blocks = Array.isArray(message.content) ? message.content : typeof message.content === 'string' ? [{ type: 'text', text: message.content }] : []
+    if (blocks.some(b => asRecord(b)?.type === 'tool_result')) return []
+    const text = blocks.map(b => asRecord(b)).filter(b => b && (b.type === 'text' || b.type === undefined) && typeof b.text === 'string').map(b => b!.text as string).join(' ')
+    const start = text.indexOf('<user_query>')
+    const end = text.indexOf('</user_query>')
+    const query = start >= 0 && end > start ? text.slice(start + '<user_query>'.length, end) : text
+    return promptDrafts({ content: [{ type: 'text', text: query }] })
+  }
+  return draftsFromClaudeRecord(record)
+}
+
+/**
+ * Cursor (6.62.0, plan 1.7): the observer's newest agent thought, as the reasoning line. The
+ * same shape Codex's reasoning headline rides (`CodexReasoningStatus`): an extra field on a
+ * `status: working` draft, one line, as long as a target.
+ */
+export function cursorThoughtStatus(text: unknown): CodexReasoningStatus | null {
+  const reasoning = typeof text === 'string' ? oneLine(text, TARGET_MAX_CHARS) : ''
+  return reasoning ? { kind: 'status', state: 'working', reasoning } : null
+}
+
 function draftsFromClaudeRecord(record: Record<string, unknown>): SessionStreamDraft[] {
   const type = typeof record.type === 'string' ? record.type : ''
 
@@ -1262,7 +1293,7 @@ export function draftsFromRecord(
   const obj = asRecord(record)
   if (!obj) return []
   try {
-    const drafts = provider === 'codex' ? draftsFromCodexRecord(obj) : draftsFromClaudeRecord(obj)
+    const drafts = provider === 'codex' ? draftsFromCodexRecord(obj) : provider === 'cursor' ? draftsFromCursorRecord(obj) : draftsFromClaudeRecord(obj)
     return stampPromptTurnStart(drafts, obj)
   } catch {
     // A malformed record costs one line of the trail. It must never cost the stream.