@gotcos/glasses-server 6.61.6 → 6.61.7

package/CHANGELOG.md

@@ -1,3 +1,10 @@
+## 6.61.7 — 2026-10-04 — Agent activity and compaction visibility
+
+- Add display-only child activity to native Sessions list/detail. Codex uses read-only spawn relationships plus each child's lifecycle, with bounded reads, freshness, deduplication and explicit incomplete/unknown counts.
+- Observe Claude subagent identities and compaction hooks. Refresh hooks after upgrading. Native Cursor observers cover subagent start/stop, context compaction and resumed output; installation preserves other hooks. Observers retain no prompts and never trigger queue drains or permission decisions.
+- Stream past oversized top-level Codex context replacement records in bounded chunks instead of declaring completion and disconnecting. Other oversized records keep their existing fallback.
+- Paired with glasses 6.10.590. No model routing or Cursor model-catalog changes. Automated fixture canaries pass; physical device and live-provider acceptance are recorded separately.
+
 ## 6.61.6 — 2026-10-03
 
 - Keep Codex-owned waiting messages visible in Sessions queue counts and queue reads after the COS handoff. Unavailable native reads report unknown, not empty.

package/bin/hooks/cos-cursor-observer.cjs

@@ -0,0 +1,29 @@
+#!/usr/bin/env node
+// Read-only native Cursor lifecycle observer. No network, credentials, commands or prompts.
+const fs=require('node:fs'),path=require('node:path'),crypto=require('node:crypto');
+const event=process.argv[2],spool=process.argv[3];
+const names={subagentStart:'SubagentStart',subagentStop:'SubagentStop',preCompact:'PreCompact',postToolUse:'PostToolUse',afterAgentResponse:'PostCompact',stop:'PostCompact',sessionEnd:'PostCompact'};
+let input='',oversize=false;
+process.stdin.setEncoding('utf8');
+process.stdin.on('data',chunk=>{if(input.length+chunk.length>1048576){oversize=true;input=''}else if(!oversize)input+=chunk});
+process.stdin.on('error',()=>{});
+process.stdin.on('end',()=>{
+ try {
+  if(!oversize && names[event] && spool){
+   const p=JSON.parse(input),id=p.parent_conversation_id||p.conversation_id||p.session_id;
+   if(typeof id==='string'&&/^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i.test(id)){
+    fs.mkdirSync(spool,{recursive:true,mode:0o700});
+    if(fs.readdirSync(spool).length<2000){
+     const ts=Date.now(),payload={session_id:id.toLowerCase(),display_only:true};
+     const agent=p.subagent_id||p.agent_id;
+     if(typeof agent==='string'&&/^[a-zA-Z0-9_-]{1,160}$/.test(agent))payload.agent_id=agent;
+     const name=ts+'-'+process.pid+'-'+crypto.randomBytes(6).toString('hex')+'-'+names[event]+'.json';
+     const temp=path.join(spool,'.'+name);
+     fs.writeFileSync(temp,JSON.stringify({ts,ppid:null,event:names[event],payload}),{mode:0o600,flag:'wx'});
+     fs.renameSync(temp,path.join(spool,name));
+    }
+   }
+  }
+ } catch {} // An observational failure never blocks a user action.
+ process.stdout.write(event==='subagentStart'?'{"permission":"allow"}\n':'{}\n');
+});

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@gotcos/glasses-server",
-  "version": "6.61.6",
+  "version": "6.61.7",
   "description": "COS Glasses: self-hosted AI heads-up-display server for Even G2 smart glasses, powered by Claude Code, Codex, Cursor Agent CLI, or local Ollama",
   "type": "module",
   "bin": {
@@ -73,7 +73,8 @@
     "docs/work-handoff-requests.md",
     "work-task-runtime",
     "docs/work-task-runtime.md",
-    "!server/scripts/build-work-task-runtime.py"
+    "!server/scripts/build-work-task-runtime.py",
+    "bin/hooks/cos-cursor-observer.cjs"
   ],
   "author": "COS Contributors",
   "license": "MIT",

package/server/lib/claude-hooks-installer.ts

@@ -90,6 +90,7 @@ export const HOOK_SUBSCRIPTIONS: readonly HookSubscription[] = [
   { event: 'Notification', matcher: 'permission_prompt|idle_prompt|elicitation_dialog|agent_needs_input', async: true, timeout: 10 },
   { event: 'SubagentStart', async: true, timeout: 10 },
   { event: 'SubagentStop', async: true, timeout: 10 },
+  { event: 'PreCompact', async: true, timeout: 10 },
   { event: 'PostCompact', async: true, timeout: 10 },
   { event: 'PostModelSwitch', async: true, timeout: 10 },
 ]
@@ -307,6 +308,7 @@ export interface HookStatus {
    * has not run Install hooks since. Questions are then held at most 120 s, as before.
    */
   priorWaitOnly: boolean
+  observerOnlyDrift?: boolean
   /** 6.60.0: our PermissionRequest hook's `timeout` in the settings file, or null (`permissionHookTimeoutS`). */
   permissionHookTimeoutS: number | null
   tokenPresent: boolean
@@ -362,7 +364,8 @@ export function hookStatus(paths: { settingsPath?: string; scriptPath?: string;
   else state = 'installed'
   const priorWaitOnly = state === 'drift' && events.missing.length === 0 && events.drifted.length > 0
     && events.drifted.every(event => events.priorWait.includes(event))
-  return { state, installed: state === 'installed', settingsPath, scriptPath, scriptSha, packageScriptSha, ...events, priorWaitOnly, permissionHookTimeoutS: permissionWaitS, tokenPresent }
+  const observerOnlyDrift = state === 'drift' && events.missing.length > 0 && events.missing.every(event => event === 'PreCompact') && events.drifted.every(event => events.priorWait.includes(event))
+  return { observerOnlyDrift, state, installed: state === 'installed', settingsPath, scriptPath, scriptSha, packageScriptSha, ...events, priorWaitOnly, permissionHookTimeoutS: permissionWaitS, tokenPresent }
 }
 
 /**
@@ -397,11 +400,11 @@ export const HALT_CAPABLE_PRIOR_SCRIPT_SHAS: readonly string[] = [
  * check, so updating the server never turns cancel from the lens off. Any other drift
  * still is not halt-ready.
  */
-export function hookHaltReady(status: Pick<HookStatus, 'installed' | 'state' | 'scriptSha'> & Partial<Pick<HookStatus, 'priorWaitOnly' | 'packageScriptSha'>>): boolean {
+export function hookHaltReady(status: Pick<HookStatus, 'installed' | 'state' | 'scriptSha'> & Partial<Pick<HookStatus, 'priorWaitOnly' | 'observerOnlyDrift' | 'packageScriptSha'>>): boolean {
   if (status.installed === true) return true
   const priorScript = typeof status.scriptSha === 'string' && HALT_CAPABLE_PRIOR_SCRIPT_SHAS.includes(status.scriptSha)
   if (status.state === 'script_outdated') return priorScript
-  if (status.state === 'drift' && status.priorWaitOnly === true) {
+  if (status.state === 'drift' && (status.priorWaitOnly === true || status.observerOnlyDrift === true)) {
     return priorScript || (typeof status.scriptSha === 'string' && status.scriptSha === status.packageScriptSha)
   }
   return false

package/server/lib/codex-subagent-activity.ts

@@ -0,0 +1,119 @@
+// Read-only display evidence. Never imported by attachment, queue or write gates.
+// Open spawn edges describe relationships, not work: completed children remain open.
+import { execFile } from 'node:child_process'
+import { promisify } from 'node:util'
+import { open, realpath, readdir, stat } from 'node:fs/promises'
+import { dirname, join, relative } from 'node:path'
+
+const exec = promisify(execFile)
+const UUID = /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i
+export const SUBAGENT_FRESH_MS = 5 * 60_000
+const MAX_ROWS = 512
+const MAX_TAIL = 4 * 1024 * 1024
+const MAX_SNAPSHOT_BYTES = 16 * 1024 * 1024
+export interface SubagentActivity {
+  active: number
+  completed: number
+  unknown: number
+  total: number
+  checked_at: number
+  partial: boolean
+}
+export type ChildState = 'active' | 'completed' | 'unknown'
+
+/** Latest explicit turn lifecycle wins; ordinary output alone never starts a turn. */
+interface ChildEvidence { lifecycle: 'open' | 'completed' | 'unknown'; latest: number }
+function parseChildEvidence(text: string, now: number, startsMidFile = false): ChildEvidence {
+  const lines = text.split('\n')
+  if (startsMidFile) lines.shift()
+  let latest = 0
+  for (let i = lines.length - 1; i >= 0; i--) {
+    let row: any
+    try { row = JSON.parse(lines[i]) } catch { continue }
+    const at = Date.parse(row?.timestamp)
+    if (Number.isFinite(at) && at <= now + 5000 && at > 0) latest = Math.max(latest, at)
+    if (row?.type !== 'event_msg') continue
+    const kind = row.payload?.type
+    if (['task_complete', 'task_failed', 'turn_aborted', 'turn_cancelled'].includes(kind)) return { lifecycle: Number.isFinite(at) && at > 0 && at <= now + 5000 ? 'completed' : 'unknown', latest }
+    if (kind === 'task_started') {
+      // A crashed/interrupted writer with no terminal event must age into uncertainty.
+      return { lifecycle: Number.isFinite(at) && at > 0 && at <= now + 5000 ? 'open' : 'unknown', latest }
+    }
+  }
+  return { lifecycle: 'unknown', latest }
+}
+function stateOf(evidence: ChildEvidence, now: number): ChildState {
+  if (evidence.lifecycle === 'completed') return 'completed'
+  return evidence.lifecycle === 'open' && evidence.latest <= now + 5000 && now - evidence.latest <= SUBAGENT_FRESH_MS ? 'active' : 'unknown'
+}
+export function childStateFromTail(text: string, now: number, startsMidFile = false): ChildState {
+  return stateOf(parseChildEvidence(text, now, startsMidFile), now)
+}
+
+const fileMemo = new Map<string, { mtime: number; size: number; evidence: ChildEvidence }>()
+async function childState(file: string, root: string, now: number, budget: { bytes: number }): Promise<ChildState> {
+  try {
+    const canonical = await realpath(file)
+    const rel = relative(await realpath(root), canonical)
+    if (!rel || rel.startsWith('..') || rel.startsWith('/') || !canonical.endsWith('.jsonl')) return 'unknown'
+    const st = await stat(canonical)
+    if (!st.isFile()) return 'unknown'
+    const hit = fileMemo.get(canonical)
+    if (hit && hit.mtime === st.mtimeMs && hit.size === st.size) return stateOf(hit.evidence, now)
+    const handle = await open(canonical, 'r')
+    let evidence: ChildEvidence = { lifecycle: 'unknown', latest: 0 }
+    try {
+      for (let limit = 256 * 1024; ; limit *= 4) {
+        if (budget.bytes <= 0) return 'unknown'
+        const length = Math.min(st.size, limit, budget.bytes), start = st.size - length
+        budget.bytes -= length
+        const buffer = Buffer.alloc(length)
+        const read = await handle.read(buffer, 0, length, start)
+        evidence = parseChildEvidence(buffer.subarray(0, read.bytesRead).toString('utf8'), now, start > 0)
+        if (evidence.lifecycle !== 'unknown' || start === 0 || limit >= MAX_TAIL) break
+      }
+    } finally { await handle.close() }
+    // Cache only lifecycle metadata, never transcript text. Freshness is recomputed.
+    if (fileMemo.size >= MAX_ROWS) fileMemo.delete(fileMemo.keys().next().value!)
+    fileMemo.set(canonical, { mtime: st.mtimeMs, size: st.size, evidence })
+    return stateOf(evidence, now)
+  } catch { return 'unknown' }
+}
+
+/** One bounded read-only SQLite snapshot per list/detail read. */
+export async function readCodexSubagents(
+  parents: readonly string[], sessionsRoot: string, now = Date.now(),
+): Promise<Map<string, SubagentActivity>> {
+  const ids = [...new Set(parents.filter(id => UUID.test(id)).map(id => id.toLowerCase()))].slice(0, 80)
+  const out = new Map<string, SubagentActivity>()
+  if (!ids.length) return out
+  try {
+    const home = dirname(sessionsRoot)
+    const files = (await readdir(home)).filter(n => /^state_\d+\.sqlite$/.test(n)).sort((a,b) => Number(b.match(/\d+/)![0])-Number(a.match(/\d+/)![0]))
+    if (!files.length) return out // older installations do not advertise this capability
+    // UUID validation above is the SQL parameter boundary; no prompt/path reaches SQL.
+    const values = ids.map(id => `'${id}'`).join(',')
+    const query = `WITH RECURSIVE children(root,id,depth,trail) AS (
+      SELECT parent_thread_id,child_thread_id,1,','||parent_thread_id||','||child_thread_id||',' FROM thread_spawn_edges WHERE status='open' AND parent_thread_id IN (${values})
+      UNION ALL SELECT c.root,e.child_thread_id,c.depth+1,c.trail||e.child_thread_id||',' FROM children c JOIN thread_spawn_edges e ON e.parent_thread_id=c.id WHERE e.status='open' AND c.depth<16 AND instr(c.trail,','||e.child_thread_id||',')=0
+    ) SELECT DISTINCT c.root,c.id,t.rollout_path,t.archived,c.depth FROM children c LEFT JOIN threads t ON t.id=c.id LIMIT ${MAX_ROWS+1}`
+    const { stdout } = await exec('/usr/bin/sqlite3', ['-readonly', '-json', join(home,files[0]), query], { timeout: 2000, maxBuffer: 2*1024*1024 })
+    const rows = JSON.parse(stdout || '[]') as Array<{root:string;id:string;rollout_path?:string;archived?:number;depth:number}>
+    for (const id of ids) out.set(id, {active:0,completed:0,unknown:0,total:0,checked_at:now,partial:rows.length>MAX_ROWS})
+    const seen = new Set<string>()
+    const budget = { bytes: MAX_SNAPSHOT_BYTES }
+    // Sequential bounded reads avoid descriptor storms; most children are memo hits.
+    for (const row of rows.slice(0, MAX_ROWS)) {
+      const key = row.root+':'+row.id, summary = out.get(row.root)
+      if (!summary || seen.has(key)) continue
+      seen.add(key); summary.total++
+      if (row.depth >= 16) summary.partial = true
+      const state = row.archived === 1 ? 'completed' : typeof row.rollout_path === 'string' ? await childState(row.rollout_path, sessionsRoot, now, budget) : 'unknown'
+      summary[state === 'active' ? 'active' : state === 'completed' ? 'completed' : 'unknown']++
+    }
+  } catch {
+    // Do not convert a schema/read failure into a fabricated zero-agent count.
+    for (const id of ids) out.set(id, {active:0,completed:0,unknown:0,total:0,checked_at:now,partial:true})
+  }
+  return out
+}

package/server/lib/cursor-observer-installer.ts

@@ -0,0 +1,38 @@
+import { readFileSync, existsSync, lstatSync, mkdirSync, copyFileSync, chmodSync } from 'node:fs'
+import { dirname, join, resolve } from 'node:path'
+import { homedir } from 'node:os'
+import { fileURLToPath } from 'node:url'
+import { atomicWriteFileSync } from './atomic-fs.js'
+import { cosGlassesHome, hookSpoolDir } from './claude-hooks-installer.js'
+export const CURSOR_OBSERVER_EVENTS=['subagentStart','subagentStop','preCompact','postToolUse','afterAgentResponse','stop','sessionEnd'] as const
+const quote=(s:string)=>"'"+s.replace(/'/g,"'\\''")+"'"
+export function installCursorObserver(options:{settingsPath?:string;scriptPath?:string;spool?:string;dryRun?:boolean;uninstall?:boolean}={}) {
+ const settings=options.settingsPath??join(process.env.CURSOR_CONFIG_DIR??join(homedir(),'.cursor'),'hooks.json')
+ const script=options.scriptPath??join(cosGlassesHome(),'bin','cos-cursor-observer.cjs')
+ const spool=options.spool??hookSpoolDir()
+ try {
+  if(existsSync(settings)&&lstatSync(settings).isSymbolicLink())throw new Error('symlinked Cursor settings')
+  const old=existsSync(settings)?readFileSync(settings,'utf8'):'{}', config=JSON.parse(old)
+  if(!config||typeof config!=='object'||Array.isArray(config)||(config.version!==undefined&&config.version!==1))throw new Error('unsupported Cursor config')
+  if(config.hooks!==undefined&&(!config.hooks||typeof config.hooks!=='object'||Array.isArray(config.hooks)))throw new Error('invalid Cursor hooks')
+  const hooks={...config.hooks}
+  for(const event of CURSOR_OBSERVER_EVENTS){
+   if(hooks[event]!==undefined&&!Array.isArray(hooks[event]))throw new Error('invalid Cursor hook list')
+   const ours=(h:any)=>typeof h?.command==='string'&&h.command.startsWith(quote(process.execPath)+' '+quote(script)+' ')
+   hooks[event]=(hooks[event]??[]).filter((h:any)=>!ours(h))
+   if(!options.uninstall)hooks[event].push({command:[process.execPath,script,event,spool].map(quote).join(' '),timeout:5})
+   if(!hooks[event].length)delete hooks[event]
+  }
+  const next=JSON.stringify({...config,version:1,hooks},null,2)+'\n'
+  if(!options.dryRun){
+   if(!options.uninstall){
+    mkdirSync(dirname(script),{recursive:true,mode:0o700})
+    const source=resolve(dirname(fileURLToPath(import.meta.url)),'../../bin/hooks/cos-cursor-observer.cjs')
+    atomicWriteFileSync(script,readFileSync(source),{mode:0o755});chmodSync(script,0o755)
+   }
+   mkdirSync(dirname(settings),{recursive:true})
+   if(next!==old){if(existsSync(settings))copyFileSync(settings,settings+'.cos-observer-backup');atomicWriteFileSync(settings,next,{mode:0o600})}
+  }
+  return {ok:true,changed:next!==old,events:[...CURSOR_OBSERVER_EVENTS],dryRun:!!options.dryRun}
+ }catch(error){return {ok:false,changed:false,reason:error instanceof Error?error.message:String(error)}}
+}

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

@@ -30,6 +30,7 @@ export const HOOK_EVENT_NAMES = [
   'Notification',
   'SubagentStart',
   'SubagentStop',
+  'PreCompact',
   'PostCompact',
   'PostModelSwitch',
 ] as const
@@ -154,6 +155,7 @@ 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') } : {}),
@@ -199,6 +201,7 @@ 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':
       return base
   }

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

@@ -404,7 +404,14 @@ 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
+}
+
+/** 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-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.
 //
@@ -48,6 +49,8 @@ export interface FailureSignal {
 }
 
 export interface SessionSignal {
+  workObservation?: WorkObservation
+  observationOnly?: boolean
   sessionId: string
   firstSeenAt: number
   lastEventAt: number
@@ -179,7 +182,10 @@ 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)
   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) }
   const common = {
+    observationOnly: false,
+    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,
@@ -285,6 +291,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':
@@ -313,6 +321,7 @@ export class SessionSignalStore {
   apply(env: HookEnvelope, child?: boolean): SessionSignal {
     const next = applyHookEvent(this.signals.get(env.sessionId), env, this.ctx, child)
     this.signals.set(env.sessionId, next)
+    if (env.payload.display_only === true) return next // no drain, permission or halt listeners
     const isChild = child ?? this.ctx.isCosSpawnedPid(env.ppid)
     for (const listener of this.listeners) {
       try { listener(next, env, isChild) } catch (error) {

package/server/lib/session-transcript-watcher.ts

@@ -243,6 +243,7 @@ export function createTranscriptTailer(options: TranscriptTailerOptions): Transc
   let state: 'working' | 'idle' | 'done' | null = null
   let lastActivity = now()
   let degraded = false
+  let skippingCompaction = false
 
   const emit = (draft: SessionStreamDraft) => {
     try {
@@ -275,17 +276,40 @@ export function createTranscriptTailer(options: TranscriptTailerOptions): Transc
           // this design exists to avoid, so we rejoin at the new end and let the poll
           // fallback carry whatever the rotation took with it.
           cursor = { offset: size }
+          skippingCompaction = false
           return
         }
 
         if (size > cursor.offset) {
           const pending = size - cursor.offset
           const length = Math.min(pending, maxRead)
-          const chunk = await readRangeAt(options.path, cursor.offset, length)
+          let chunk = await readRangeAt(options.path, cursor.offset, length)
           if (chunk !== null && chunk.length > 0) {
+            if (skippingCompaction) {
+              const end = chunk.indexOf(10)
+              if (end < 0) { cursor.offset += chunk.length; lastActivity = now(); return }
+              cursor.offset += end + 1
+              chunk = chunk.subarray(end + 1)
+              skippingCompaction = false
+              lastActivity = now()
+              if (!suppressed(options.key)) emit({ kind: 'status', state: 'working' })
+              if (!chunk.length) return
+            }
             const result = consumeTranscriptChunk(cursor, chunk, chunk.length >= maxRead)
             cursor = result.cursor
             if (result.tooLarge) {
+              // A Codex context replacement is internal bookkeeping, not a reply. Its
+              // replacement_history can exceed 4 MiB. Discard just this recognized
+              // top-level record incrementally, retaining heartbeats and later output.
+              const head = chunk.subarray(0, 512).toString('utf8')
+              if (options.provider === 'codex' && /^\s*\{\s*(?:"timestamp"\s*:\s*"[^"\r\n]*"\s*,\s*)?"type"\s*:\s*"compacted"\s*[,}]/.test(head)) {
+                skippingCompaction = true
+                cursor.offset += chunk.length
+                lastActivity = now()
+                state = 'working'
+                if (!suppressed(options.key)) emit({ kind: 'status', state: 'working', reasoning: 'Updating context' } as SessionStreamDraft)
+                return
+              }
               // HAND OFF, do not skip. `done` is the same terminal status a finished turn
               // sends, so the client already knows to close the stream and resume its
               // 5s/15s/60s poll -- no new client vocabulary, no frozen screen.

package/server/lib/session-work-observation.ts

@@ -0,0 +1,46 @@
+// Display-only evidence. Never decides whether a thread can be written or dequeued.
+import type { HookEnvelope } from './session-hook-events.js'
+import type { SubagentActivity } from './codex-subagent-activity.js'
+export interface WorkObservation {
+  agents: Array<{id:string;at:number;state:'active'|'completed'}>
+  partial: boolean
+  compactingAt: number | null
+  phaseAt?: number
+}
+export function observeWork(previous: WorkObservation | undefined, env: HookEnvelope): WorkObservation {
+  const prev=previous ?? {agents:[],partial:false,compactingAt:null}
+  if (!Number.isFinite(env.ts) || env.ts <= 0 || env.ts > Date.now()+5000) return prev
+  const p=env.payload, id=typeof p.agent_id==='string' && /^[a-zA-Z0-9_-]{1,160}$/.test(p.agent_id) ? p.agent_id : null
+  if(env.event==='SubagentStart'||env.event==='SubagentStop') {
+    if(!id)return {...prev,partial:true}
+    const existing=prev.agents.find(a=>a.id===id)
+    if(existing && (existing.at>env.ts || (existing.at===env.ts && (existing.state==='completed' || env.event==='SubagentStart'))))return prev
+    if(!existing && prev.agents.length>=512)return {...prev,partial:true}
+    const row={id,at:env.ts,state:env.event==='SubagentStart'?'active' as const:'completed' as const}
+    return {...prev,agents:[...prev.agents.filter(a=>a.id!==id),row]}
+  }
+  if(id && ['PreToolUse','PostToolUse','PostToolUseFailure'].includes(env.event)) {
+    const existing=prev.agents.find(a=>a.id===id)
+    // Tool output may arrive after Stop; it must never reopen a completed child.
+    if(existing?.state==='active' && env.ts>existing.at)return {...prev,agents:prev.agents.map(a=>a.id===id?{...a,at:env.ts}:a)}
+    return prev
+  }
+  if(id)return prev // Child compaction must not label the parent as compacting.
+  if(env.ts<(prev.phaseAt??0))return prev
+  if(env.event==='PreCompact')return {...prev,compactingAt:env.ts,phaseAt:env.ts}
+  const resumes=['PostCompact','UserPromptSubmit','Stop','StopFailure','SessionEnd','PostToolUse','PostToolUseFailure'].includes(env.event)
+    || (env.event==='SessionStart' && p.source==='compact')
+  if(resumes)return {...prev,compactingAt:null,phaseAt:env.ts}
+  return prev
+}
+export function workObservationFields(observation: WorkObservation | undefined, now=Date.now()): {subagent_activity?:SubagentActivity;compaction?:{state:'compacting'|'unknown';started_at:number;checked_at:number}} {
+  if(!observation)return {}
+  const fields:ReturnType<typeof workObservationFields>={}
+  if(observation.agents.length||observation.partial){
+    const summary:SubagentActivity={active:0,completed:0,unknown:0,total:observation.agents.length,checked_at:now,partial:observation.partial}
+    for(const a of observation.agents)summary[a.state==='completed'?'completed':now-a.at<=300_000&&a.at<=now+5000?'active':'unknown']++
+    fields.subagent_activity=summary
+  }
+  if(observation.compactingAt!==null)fields.compaction={state:now-observation.compactingAt<=600_000?'compacting':'unknown',started_at:observation.compactingAt,checked_at:now}
+  return fields
+}

package/server/routes/agent-sessions.ts

@@ -1,3 +1,5 @@
+import { workObservationFields } from '../lib/session-work-observation.js'
+import { readCodexSubagents } from '../lib/codex-subagent-activity.js'
 // GET /api/agent-sessions
 // GET /api/agent-sessions/search?q=
 // GET /api/agent-sessions/:provider/:sessionId
@@ -41,7 +43,7 @@ import {
 import { searchAgentSessions, type AgentSessionSearchHit } from '../lib/agent-session-search.js'
 import { claudeSessionNamesVisible, claudeSessionsDir, claudeSessionsEnabled, readClaudePeerRecords, registryFacts } from './claude-sessions.js'
 import type { ClaudePeerRecord } from '../lib/claude-session-registry.js'
-import { deriveForRow, signalFor } from '../lib/session-hooks-runtime.js'
+import { deriveForRow, signalFor, workObservationFor } from '../lib/session-hooks-runtime.js'
 import { derivedRowFields, type DerivedSessionState } from '../lib/session-state-derive.js'
 import { queuedTurnsFields, allQueuedWaitingLookup } from '../lib/thread-turn-queue-store.js'
 import { isAttachedTurnActive, sessionStreamKey } from '../lib/session-stream-bus.js'
@@ -398,8 +400,10 @@ agentSessionsRouter.get('/agent-sessions', async (req, res) => {
       derivedById.set(row.session_id, deriveForRow({ sessionId: row.session_id, now, remember: false }))
     }
     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)),
+      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)) })),
       total: sessions.length,
       windowHours: AGENT_SESSION_WINDOW_HOURS,
       sort,
@@ -511,6 +515,8 @@ 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 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)
     const running = runningForThread(provider, parsed.session_id, activityClockMs(st.mtimeMs, activity))
@@ -573,7 +579,9 @@ agentSessionsRouter.get('/agent-sessions/:provider/:sessionId', async (req, res)
       tools_used: {},
       files_touched: [],
       git_branch: parsed.git_branch || 'unknown',
-      has_subagents: false,
+      has_subagents: (subagents?.total ?? 0) > 0,
+      ...observed,
+      ...(subagents ? { subagent_activity: subagents } : {}),
       total_input_tokens: 0,
       total_output_tokens: 0,
       file_size_bytes: parsed.file_size_bytes,

package/server/routes/session-hooks.ts

@@ -1,3 +1,4 @@
+import { installCursorObserver } from '../lib/cursor-observer-installer.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
@@ -32,7 +33,9 @@ export function createSessionHooksRouter(options: { port: number }): Router {
       res.status(409).json({ ok: false, reason: result.reason ?? 'install_failed', status: result.status })
       return
     }
-    res.json({ ok: true, changed: result.changed, scriptCopied: result.scriptCopied, backupPath: result.backupPath, status: result.status, ...(dryRun ? { merged: result.merged } : {}) })
+    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 } : {}) })
   })
 
   router.post('/session-hooks/uninstall', (req, res) => {
@@ -43,7 +46,9 @@ export function createSessionHooksRouter(options: { port: number }): Router {
       res.status(409).json({ ok: false, reason: result.reason ?? 'uninstall_failed', status: result.status })
       return
     }
-    res.json({ ok: true, changed: result.changed, backupPath: result.backupPath, status: result.status, ...(dryRun ? { merged: result.merged } : {}) })
+    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 } : {}) })
   })
 
   // Sessions the hooks saw start and end, for Control's scheduled-job ledger. A run
@@ -57,6 +62,7 @@ export function createSessionHooksRouter(options: { port: number }): Router {
     const all = req.query.all === '1'
     const runs: Array<Record<string, unknown>> = []
     for (const signal of sessionSignalStore.snapshot()) {
+      if (signal.observationOnly) continue
       if (signal.firstSeenAt < sinceMs && !(signal.ended && signal.ended.at >= sinceMs)) continue
       if (!all && isInteractiveEntrypoint(signal.entrypoint)) continue
       runs.push({

package/server/scripts/hooks-cli.ts

@@ -1,4 +1,5 @@
 #!/usr/bin/env tsx
+import { installCursorObserver } from '../lib/cursor-observer-installer.js'
 // Install, inspect or remove the COS session hook in ~/.claude/settings.json.
 //
 //   npx --yes @gotcos/glasses-server@latest --hooks install [--dry-run] [--port 3141]
@@ -40,13 +41,15 @@ if (action === 'status') {
 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 })
-  print({ action, dryRun, serverApplies, ...(flagsNote ? { note: flagsNote } : {}), ...result })
-  process.exit(result.ok ? 0 : 2)
+  const cursorObserver = result.ok ? installCursorObserver({ dryRun }) : undefined
+  print({ action, dryRun, serverApplies, ...(flagsNote ? { note: flagsNote } : {}), ...result, cursorObserver })
+  process.exit(result.ok && cursorObserver?.ok ? 0 : 2)
 }
 if (action === 'uninstall') {
   const result = uninstallClaudeHooks({ dryRun })
-  print({ action, dryRun, ...result })
-  process.exit(result.ok ? 0 : 2)
+  const cursorObserver = result.ok ? installCursorObserver({ dryRun, uninstall: true }) : undefined
+  print({ action, dryRun, ...result, cursorObserver })
+  process.exit(result.ok && cursorObserver?.ok ? 0 : 2)
 }
 console.error('Usage: --hooks install|status|uninstall [--dry-run] [--port N] [--desk-idle-s N]')
 process.exit(64)