@gotcos/glasses-server 6.61.7 → 6.63.0

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

@@ -25,8 +25,8 @@ import { observeWork, type WorkObservation } from './session-work-observation.js
 //  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'
@@ -51,6 +51,21 @@ 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
@@ -107,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,
@@ -136,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
@@ -181,10 +216,12 @@ 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 (p.display_only === true) return { ...base, ...(prev?.observationOnly !== false ? { lastEventAt: Math.max(base.lastEventAt, env.ts) } : {}), observationOnly: prev?.observationOnly ?? !prev, workObservation: observeWork(base.workObservation, env) }
+  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,
@@ -212,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),
@@ -280,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,
@@ -303,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
@@ -312,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) {
@@ -319,9 +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 (env.payload.display_only === true) return next // no drain, permission or halt listeners
+    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) {
@@ -392,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
@@ -426,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.

package/server/lib/thread-attach-capability.ts

@@ -44,7 +44,8 @@
 // registered."
 //
 // `providers` is sourced from BINDABLE_PROVIDERS for the same reason. Cursor is
-// Continue-capable once bindable; Fork stays on FORKABLE_PROVIDERS (claude/codex).
+// Continue-capable once bindable; Fork reads FORKABLE_PROVIDERS (6.62.0: Cursor too, as a new
+// read-only session with context).
 // The way to guarantee the published list matches the attach route is to read
 // the list that `isBindableProvider` is built from, rather than restating names
 // here and hoping.
@@ -64,8 +65,10 @@
 
 import {
   BINDABLE_PROVIDERS,
+  FORKABLE_PROVIDERS,
   isBindableProvider,
   type BindableProvider,
+  type ForkableProvider,
 } from './agent-session-binding-store.js'
 import { threadAttachEnabled } from '../routes/agent-session-bindings.js'
 
@@ -98,6 +101,13 @@ export interface ThreadAttachCapability {
    * incoherent default: every refusal recommends Fork while the route 404s.
    */
   forkSupported: boolean
+  /**
+   * 6.62.0 (plan 3.7, W10): WHICH providers the fork route serves. `forkSupported` stays a
+   * boolean for every reader that already checks it with `=== true`; this list is new.
+   * Sourced from FORKABLE_PROVIDERS, the list `isForkableProvider` is built from. Cursor's
+   * entry is "New session with this context" (a new read-only chat), not a native fork.
+   */
+  forkProviders?: ForkableProvider[]
 }
 
 /**
@@ -129,6 +139,7 @@ export function threadAttachCapability(
     // byte-identical, so the flag protecting an existing conversation does not
     // apply. Gating it made every refusal recommend a route that 404s.
     forkSupported: THREAD_ATTACH_SUPPORTED,
+    forkProviders: THREAD_ATTACH_SUPPORTED ? [...FORKABLE_PROVIDERS] : [],
   }
 }
 
@@ -139,6 +150,8 @@ export interface ThreadAttachHealthFields {
   /** Fork is available whenever the build supports it, gate or no gate. */
   threadForkSupported: boolean
   threadAttachProviders: BindableProvider[]
+  /** 6.62.0: the providers the fork route serves (`threadForkSupported` stays the boolean). */
+  threadForkProviders: ForkableProvider[]
 }
 
 /** Flatten the capability onto the health payload's key names. */
@@ -150,6 +163,7 @@ export function threadAttachHealthFields(
     threadAttachEnabled: capability.enabled,
     threadAttachProviders: capability.providers,
     threadForkSupported: capability.forkSupported,
+    threadForkProviders: capability.forkSupported ? [...(capability.forkProviders ?? [])] : [],
   }
 }
 

package/server/lib/thread-drain-kick.ts

@@ -70,11 +70,13 @@ export type KickPlan = { kind: 'kick' } | { kind: 'kick_when_registry_idle'; sto
  *  - a SubagentStop never kicks: a background sub-agent finishing after the Stop is
  *    answered by the model in a turn of its own, whose Stop kicks, and neither the hook
  *    short-circuit nor the B6 clause vouches for a session whose newest event is a
- *    SubagentStop, so a kick there could only fall through to the 30 s backstop.
+ *    SubagentStop, so a kick there could only fall through to the 30 s backstop;
+ *  - 6.62.0: a Codex `Interrupt` ends a turn the way a Stop does (Esc in Codex fires no
+ *    Stop), so it follows the same rule; no Claude or Cursor hook emits it.
  */
 export function kickPlanFor(signal: KickSignalFacts, event: string, eventTs: number, child: boolean): KickPlan {
   if (child) return event === 'SessionEnd' ? { kind: 'kick' } : null
-  if (event !== 'Stop') return null
+  if (event !== 'Stop' && event !== 'Interrupt') return null
   if (signal.turnOpen || signal.subagentsOpen > 0 || signal.ended) return null
   return { kind: 'kick_when_registry_idle', stopAt: typeof signal.stopAt === 'number' ? signal.stopAt : eventTs }
 }

package/server/lib/thread-occupancy.ts

@@ -93,6 +93,14 @@ export interface Occupancy {
    * Absent (not false) on every other verdict, so `=== true` is the only test.
    */
   idleHolder?: true
+  /**
+   * 6.62.0 (plan 3.6, W8): attachable DESPITE a foreign owner that is WORKING, because the
+   * owner is the Codex app and the turn goes into that app's own queue (`codex queue`),
+   * which runs it at the end of the running turn. Never set by `threadOccupancy`: only the
+   * bindings route declares it, and only when the hop is wired, on, and COS holds no turn
+   * of its own for the thread. Same `=== true` contract as `idleHolder`.
+   */
+  busyHolder?: true
 }
 
 /**
@@ -191,8 +199,25 @@ export interface OccupancyProbes {
    * absent, null, or a throw keeps the 6.50 verdict (`unsupported_provider`).
    */
   cursorComposerTurnOpen?: (threadId: string) => boolean | null
+  /**
+   * 6.62.0 (W14): the newest write to a Cursor CLI chat (`store.db`, its WAL, or the agent
+   * transcript), epoch ms, or null. A `-p` run fires no turn hooks (canary C7), so file
+   * times are the only busy signal a CLI chat has, and a Run Everything Continue must not
+   * run at the same moment as the person's own terminal run. OPTIONAL; absent or null
+   * keeps the 6.61 verdict.
+   */
+  cursorChatLastWriteMs?: (chatDir: string, threadId: string) => number | null
+  /**
+   * 6.62.0 /qa (W7): does a process that is NOT COS hold this CLI chat's `store.db` open?
+   * True is positive evidence of a run (a terminal `agent`, a desk run quiet past 30 s).
+   * Null or a throw: cannot tell, and the 30 s write window alone decides.
+   */
+  cursorChatForeignHolder?: (chatDir: string) => boolean | null
 }
 
+/** 6.62.0 (W14): a CLI chat written this recently is working; a turn for it queues. */
+export const CURSOR_CHAT_BUSY_WINDOW_MS = 30_000
+
 /**
  * How recently the transcript must have been written for a held thread to read
  * as WORKING rather than merely OPEN.
@@ -637,6 +662,25 @@ export function threadOccupancy(
       }
       return { attachable: false, owners: [], reason: open === true ? 'native_thread_working' : 'unsupported_provider' }
     }
+    // 6.62.0 (W14): a CLI chat written in the last 30 s is mid-run, at the desk or by a
+    // COS child that just finished; a turn spoken at it waits rather than running
+    // alongside. A probe that throws or cannot tell keeps the 6.61 verdict.
+    let lastWrite: number | null = null
+    try {
+      lastWrite = typeof probes.cursorChatLastWriteMs === 'function' ? probes.cursorChatLastWriteMs(session.dir, threadId) : null
+    } catch {
+      lastWrite = null
+    }
+    if (typeof lastWrite === 'number' && Number.isFinite(lastWrite) && Date.now() - lastWrite < CURSOR_CHAT_BUSY_WINDOW_MS) {
+      return { attachable: false, owners: [], reason: 'native_thread_working' }
+    }
+    let held: boolean | null = null
+    try {
+      held = typeof probes.cursorChatForeignHolder === 'function' ? probes.cursorChatForeignHolder(session.dir) : null
+    } catch {
+      held = null
+    }
+    if (held === true) return { attachable: false, owners: [], reason: 'native_thread_working' }
     return { attachable: true, owners: [], reason: null }
   }
   if (provider !== 'claude' && provider !== 'codex') {

package/server/lib/thread-turn-queue-deliver.ts

@@ -34,7 +34,7 @@ const DELIVER_TIMEOUT_MS = 15_000
 
 interface LoopbackReply { status: number; body: Record<string, unknown> }
 
-function post(port: number, token: string, path: string, payload: unknown): Promise<LoopbackReply> {
+function post(port: number, token: string, path: string, payload: unknown, extraHeaders: Record<string, string> = {}): Promise<LoopbackReply> {
   return new Promise((resolve, reject) => {
     const data = JSON.stringify(payload)
     const req = request({
@@ -47,6 +47,7 @@ function post(port: number, token: string, path: string, payload: unknown): Prom
         'content-length': Buffer.byteLength(data),
         // The header the rest of COS authenticates with. NOT `Authorization: Bearer`.
         'X-Cos-Token': token,
+        ...extraHeaders,
       },
       timeout: DELIVER_TIMEOUT_MS,
     }, res => {
@@ -77,11 +78,14 @@ export async function deliverQueuedTurnOverLoopback(
   port: number,
   token: string,
 ): Promise<{ ok: boolean; reason?: string; serverRetryable?: boolean }> {
+  // 6.62.0 /qa (Q3): repeat the parking client's acknowledgement, and only that.
+  const noteHeaders: Record<string, string> = turn.continueNoteAck === true ? { 'X-COS-Continue-Note': '1' } : {}
   try {
     const attach = await post(
       port, token,
       `/api/agent-sessions/${encodeURIComponent(turn.provider)}/${encodeURIComponent(turn.threadId)}/attach`,
       { cosSessionId: turn.cosSessionId },
+      noteHeaders,
     )
     if (attach.status !== 200 && attach.status !== 201) {
       // THE KEY IS `reason`, NOT `error`. `refuseAttach` emits
@@ -117,6 +121,7 @@ export async function deliverQueuedTurnOverLoopback(
         targetKey: targetKey(turn.provider, turn.threadId),
         ...(boundTo ? { boundTo } : {}),
       },
+      noteHeaders,
     )
     if (sent.status === 202 || sent.status === 200) return { ok: true }
     // Same defect on the turn leg: `refuseTurn` emits `reason`/`reasonCopy`/`retryable`

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

@@ -87,6 +87,12 @@ export interface QueuedThreadTurn {
   /** The SERVER's reason for a terminal outcome. Never the client's wording. */
   reason?: string
   settledAt?: number
+  /**
+   * 6.62.0 /qa (Q3): the client that parked this turn sent `X-COS-Continue-Note: 1` (it shows
+   * `continue_note`). The drain repeats the header, so a Cursor CLI chat runs Run Everything
+   * only for a client that said it would show it. Absent: the 6.61 Ask posture.
+   */
+  continueNoteAck?: true
 }
 
 /**