@gotcos/glasses-server 6.61.5 → 6.61.7

package/CHANGELOG.md

@@ -1,3 +1,17 @@
+## 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.
+- Edit existing COS and Codex queue slots in place. Return full text for authenticated queue reads; never cancel and resend as an edit. Native messages with attachments or structured spans remain manageable in Codex.
+- Preserve concurrent enqueue, cancel and edit changes while the drainer awaits delivery. Native management uses local Codex queue protocol calls with automation and memory jobs disabled; no model turn is started.
+
+
 ## 6.61.5
 
 Local dictation-choice candidate, based on the 6.61.4 hardening candidate.
@@ -7,6 +21,7 @@ Local dictation-choice candidate, based on the 6.61.4 hardening candidate.
 - Run cleanup in a temporary workspace with no MCP. Claude tools/hooks are disabled; Cursor ask mode retains its read tools and uses an isolated subscription profile. Abort/timeout terminates the process tree; failures preserve the glossary-corrected transcript. Model circuit breakers are independent.
 - Local verification: model routing, legacy/default behavior, failure recovery, isolated configuration, cancellation, and real signed-in CLI smoke calls. Hardware acceptance and stable promotion remain outstanding.
 
+
 ## 6.61.4
 
 Local hardening candidate; stable promotion remains gated on native UI and G2 acceptance.

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.5",
+  "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-queue-control.ts

@@ -0,0 +1,100 @@
+// Queue management only. Never loads/starts a thread or starts a model turn.
+// Protocol verified from the installed Codex generate-ts schema (2026-10-03).
+import { spawn, execFile } from 'node:child_process'
+import { promisify } from 'node:util'
+import { existsSync } from 'node:fs'
+import { homedir } from 'node:os'
+import { join } from 'node:path'
+import { resolveProviderBinary } from './provider-binary.js'
+
+export interface NativeQueuedSubmission { id: string; input: Array<{ type: string; text?: string; text_elements?: unknown[] }>; clientUserMessageId: string }
+export interface NativeQueueControl {
+  list(threadId: string): Promise<NativeQueuedSubmission[]>
+  update(threadId: string, id: string, prompt: string): Promise<void>
+  cancel(threadId: string, id: string): Promise<boolean>
+}
+const METHODS = new Set(['thread/queue/list', 'thread/queue/update', 'thread/queue/delete'])
+export function codexQueueRpc(method: string, params: Record<string, unknown>, binary?: string): Promise<any> {
+  if (!METHODS.has(method)) return Promise.reject(new Error('queue_method_not_allowed'))
+  const resolved = binary ? { ok: true as const, path: binary } : resolveProviderBinary('codex')
+  if (!resolved.ok) return Promise.reject(new Error('codex_queue_unavailable'))
+  return new Promise((resolve, reject) => {
+    // A separate, short-lived protocol client: automations and memories explicitly
+    // disabled. No thread/start, turn/start or queue/start call is allowed here.
+    const child = spawn(resolved.path, ['app-server', '--disable', 'in_app_local_automation', '--disable', 'memories'], { stdio: ['pipe', 'pipe', 'ignore'], shell: false })
+    let buffer = '', done = false, initialized = false
+    const finish = (error: Error | null, value?: unknown) => {
+      if (done) return
+      done = true; clearTimeout(timer); child.kill(); error ? reject(error) : resolve(value)
+    }
+    const timer = setTimeout(() => finish(new Error('codex_queue_timeout')), 8000)
+    const send = (payload: unknown) => child.stdin.write(JSON.stringify(payload) + '\n')
+    child.on('error', () => finish(new Error('codex_queue_unavailable')))
+    child.stdin.on('error', () => finish(new Error('codex_queue_unavailable')))
+    child.on('exit', () => finish(new Error('codex_queue_closed')))
+    child.stdout.on('data', data => {
+      buffer += data.toString()
+      if (buffer.length > 4 * 1024 * 1024) { finish(new Error('codex_queue_response_too_large')); return }
+      let end: number
+      while ((end = buffer.indexOf('\n')) >= 0) {
+        const line = buffer.slice(0, end); buffer = buffer.slice(end + 1)
+        let row: any
+        try { row = JSON.parse(line) } catch { continue }
+        if (row.id !== 1 && row.id !== 2) continue
+        if (row.error) { finish(new Error('codex_queue_request_refused')); return }
+        if (row.id === 1 && !initialized) {
+          initialized = true
+          send({ method: 'initialized' })
+          send({ id: 2, method, params })
+        } else if (row.id === 2) { finish(null, row.result); return }
+      }
+    })
+    send({ id: 1, method: 'initialize', params: { clientInfo: { name: 'cos-queue-control', version: '1' }, capabilities: { experimentalApi: true, explicitGatewayOauth: true } } })
+  })
+}
+
+export function plainQueueText(row: NativeQueuedSubmission): string | null {
+  // Never turn a message containing files, mentions or structured text into plain text.
+  return Array.isArray(row.input) && row.input.length === 1 && row.input[0]?.type === 'text'
+    && typeof row.input[0].text === 'string' && !row.input[0].text_elements?.length ? row.input[0].text : null
+}
+export const nativeQueueControl: NativeQueueControl = {
+  async list(threadId) {
+    const rows: NativeQueuedSubmission[] = []
+    let cursor: string | null = null
+    const seen = new Set<string>()
+    do {
+      const result = await codexQueueRpc('thread/queue/list', { threadId, cursor, limit: 100 })
+      if (!Array.isArray(result?.data) || result.data.some((r: any) => typeof r?.id !== 'string' || !Array.isArray(r.input))) throw new Error('codex_queue_bad_response')
+      rows.push(...result.data)
+      cursor = result.nextCursor ?? null
+      if (cursor && (seen.has(cursor) || rows.length >= 1000)) throw new Error('codex_queue_incomplete')
+      if (cursor) seen.add(cursor)
+    } while (cursor)
+    return rows
+  },
+  async update(threadId, id, prompt) {
+    const current = (await this.list(threadId)).find(r => r.id === id)
+    if (!current || plainQueueText(current) === null) throw new Error('queue_not_editable')
+    const result = await codexQueueRpc('thread/queue/update', { threadId, queuedSubmissionId: id, input: [{ type: 'text', text: prompt, text_elements: [] }] })
+    if (result?.queuedSubmission?.id !== id) throw new Error('codex_queue_bad_response')
+  },
+  async cancel(threadId, id) {
+    const result = await codexQueueRpc('thread/queue/delete', { threadId, queuedSubmissionId: id })
+    if (typeof result?.deleted !== 'boolean') throw new Error('codex_queue_bad_response')
+    return result.deleted
+  },
+}
+
+// One read-only aggregate per session-list request, not 80 protocol processes.
+// No queue file is ever edited via SQL; mutations use Codex's own protocol above.
+export async function nativeQueuedCounts(): Promise<Map<string, number> | null> {
+  const db = join(process.env.CODEX_HOME || join(homedir(), '.codex'), 'queue_1.sqlite')
+  if (!existsSync(db)) return new Map()
+  try {
+    const { stdout } = await promisify(execFile)('/usr/bin/sqlite3', ['-readonly', '-json', db, 'SELECT thread_id, count(*) AS n FROM queued_items GROUP BY thread_id'], { timeout: 2000, maxBuffer: 1024 * 1024 })
+    const rows = JSON.parse(stdout || '[]')
+    if (!Array.isArray(rows) || rows.some(r => typeof r.thread_id !== 'string' || !Number.isInteger(r.n))) return null
+    return new Map(rows.map(r => [r.thread_id, r.n]))
+  } catch { return null }
+}

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/lib/thread-turn-queue-store.ts

@@ -1,3 +1,4 @@
+import { nativeQueuedCounts } from './codex-queue-control.js'
 // Durable storage for queued thread turns, and the terminal-record probe.
 //
 // SEPARATE FROM THE DECISIONS. `thread-turn-queue.ts` is pure and holds every rule;
@@ -104,8 +105,8 @@ export function queuedWaitingLookup(now: number): (provider: string, sessionId:
   return (provider, sessionId) => queuedWaitingForSession(queues, provider, sessionId)
 }
 
-export function queuedTurnsFields(count: number): { queued_turns?: number } {
-  return count > 0 ? { queued_turns: count } : {}
+export function queuedTurnsFields(count: number | null): { queued_turns?: number; queue_unknown?: boolean } {
+  return count === null ? { queue_unknown: true } : count > 0 ? { queued_turns: count } : {}
 }
 
 /** Every thread with a queue file, for the drain sweep. */
@@ -182,3 +183,11 @@ export function readTranscriptTailLines(path: string | null, maxBytes: number):
     return null
   }
 }
+
+/** Native queued submissions remain waiting after COS has handed them over. */
+export async function allQueuedWaitingLookup(now: number): Promise<(provider: string, id: string) => number | null> {
+  const cos = queuedWaitingLookup(now)
+  const native = await nativeQueuedCounts()
+  return (provider, id) => provider !== 'codex' ? cos(provider, id)
+    : native === null ? null : cos(provider, id) + (native.get(id) ?? 0)
+}

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,9 +43,9 @@ 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, queuedWaitingLookup } from '../lib/thread-turn-queue-store.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'
 import {
@@ -83,7 +85,7 @@ function asSort(value: unknown): AgentSessionSort {
   return String(value ?? '').toLowerCase() === 'opened' ? 'opened' : 'updated'
 }
 
-function toSearchHit(row: AgentSessionSearchHit, queuedTurns = 0, derived?: DerivedSessionState) {
+function toSearchHit(row: AgentSessionSearchHit, queuedTurns: number | null = 0, derived?: DerivedSessionState) {
   return {
     ...toEntry(row, undefined, derived, queuedTurns),
     snippet: row.snippet,
@@ -269,7 +271,7 @@ function runningForThread(provider: AgentProvider, threadId: string, mtimeMs: nu
   }
 }
 
-function toEntry(row: AgentSessionRow, activity?: SessionActivity | null, derived?: DerivedSessionState, queuedTurns = 0) {
+function toEntry(row: AgentSessionRow, activity?: SessionActivity | null, derived?: DerivedSessionState, queuedTurns: number | null = 0) {
   return {
     session_id: row.session_id,
     provider: row.provider,
@@ -397,9 +399,11 @@ 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 }))
     }
-    const queuedOf = queuedWaitingLookup(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)),
+      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,
@@ -428,7 +432,7 @@ agentSessionsRouter.get('/agent-sessions/search', async (req, res) => {
   try {
     const limit = boundedInteger(req.query.limit, 20, 1, 50)
     const result = await searchAgentSessions({ query, limit })
-    const queuedOf = queuedWaitingLookup(Date.now())
+    const queuedOf = await allQueuedWaitingLookup(Date.now())
     // 6.48.1: search hits carry the same derived state as list rows (no list/search shape
     // drift), from the registry and the hook signal; a hit has no transcript walk.
     const peers = await liveClaudePeerRecords()
@@ -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))
@@ -532,7 +538,7 @@ agentSessionsRouter.get('/agent-sessions/:provider/:sessionId', async (req, res)
     res.json({
       ...withRunning({ session_id: parsed.session_id }, running),
       ...derivedRowFields(derived),
-      ...queuedTurnsFields(queuedWaitingLookup(Date.now())(provider, parsed.session_id)),
+      ...queuedTurnsFields((await allQueuedWaitingLookup(Date.now()))(provider, parsed.session_id)),
       // The client must be able to tell "this server stamped nothing" from "this
       // server stamped false", because the two demand opposite behaviour: an old
       // server's silence means keep using the hint borrowed from the list row, and
@@ -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/routes/thread-turn-queue.ts

@@ -16,7 +16,8 @@
 // EVERY DEPENDENCY IS INJECTED so the whole path is testable without a live server.
 
 import { Router, type Request, type Response } from 'express'
-import { COS_SESSION_ID_RE } from './agent-session-bindings.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 {
   admitToQueue, drainDecision, queueableRefusal, queuePosition,
   MAX_DELIVERY_ATTEMPTS, type DrainObservation, type QueuedThreadTurn,
@@ -47,6 +48,7 @@ export interface ThreadTurnQueueDeps {
     /** The turn route's OWN `retryable` judgement, when it sent one. Authoritative. */
     serverRetryable?: boolean
   }>
+  nativeQueue?: NativeQueueControl
   now: () => number
 }
 
@@ -58,6 +60,9 @@ function publicRow(turn: QueuedThreadTurn, position: number): Record<string, unk
     queuedAt: turn.queuedAt,
     attempts: turn.attempts,
     position: turn.status === 'waiting' ? position : -1,
+    prompt: turn.prompt,
+    editable: turn.status === 'waiting',
+    owner: 'cos',
     preview: turn.prompt.length > 80 ? `${turn.prompt.slice(0, 79)}…` : turn.prompt,
     ...(turn.reason ? { reason: turn.reason } : {}),
     ...(turn.settledAt ? { settledAt: turn.settledAt } : {}),
@@ -116,10 +121,16 @@ export async function drainThread(
   if (queue.length === 0) return { delivered: 0, held: 0, retired: 0 }
 
   let delivered = 0, held = 0, retired = 0
-  let dirty = false
+  const persist = (turn: QueuedThreadTurn) => {
+    const latest = readQueue(provider, threadId, deps.now())
+    const index = latest.findIndex(t => t.clientTurnId === turn.clientTurnId)
+    if (index >= 0) { latest[index] = turn; writeQueue(provider, threadId, latest) }
+  }
   let refusedGate: ReturnType<ThreadTurnQueueDeps['occupancy']> | null = null
 
-  for (const turn of queue) {
+  for (const snapshot of queue) {
+    const turn = readQueue(provider, threadId, deps.now()).find(t => t.clientTurnId === snapshot.clientTurnId)
+    if (!turn) continue
     if (turn.status !== 'waiting') continue
 
     // Reuse only refusal within this synchronous pass. Rechecking a busy thread
@@ -150,7 +161,7 @@ export async function drainThread(
       turn.status = decision === 'expire' ? 'expired' : 'refused'
       turn.reason = decision === 'expire' ? 'queued_turn_expired' : 'delivery_attempts_exhausted'
       turn.settledAt = deps.now()
-      retired += 1; dirty = true
+      retired += 1; persist(turn)
       continue
     }
 
@@ -159,8 +170,7 @@ export async function drainThread(
     // forever; the ceiling only bounds anything if it survives the crash it is bounding.
     turn.attempts += 1
     turn.status = 'delivering'
-    writeQueue(provider, threadId, queue)
-    dirty = true
+    persist(turn)
 
     let outcome: { ok: boolean; reason?: string; serverRetryable?: boolean }
     refusedGate = null
@@ -209,9 +219,8 @@ export async function drainThread(
       turn.reason = outcome.reason
       held += 1
     }
+    persist(turn)
   }
-
-  if (dirty) writeQueue(provider, threadId, queue)
   return { delivered, held, retired }
 }
 
@@ -286,20 +295,59 @@ export function createThreadTurnQueueRouter(deps: ThreadTurnQueueDeps): Router {
   })
 
   // GET — what is waiting, for the pending row on the lens.
-  router.get('/agent-sessions/:provider/:threadId/queued-turns', (req: Request, res: Response) => {
+  router.get('/agent-sessions/:provider/:threadId/queued-turns', async (req: Request, res: Response) => {
     res.set('Cache-Control', 'private, no-store')
     const provider = String(req.params.provider ?? '')
     const threadId = String(req.params.threadId ?? '')
     const queue = readQueue(provider, threadId, deps.now())
-    return res.json({ turns: queue.map(t => publicRow(t, queuePosition(queue, t.clientTurnId))) })
+    let native: Record<string, unknown>[] = []
+    if (provider === 'codex') {
+      try {
+        native = (await (deps.nativeQueue ?? nativeQueueControl).list(threadId)).map((row, position) => {
+          const text = plainQueueText(row)
+          return { clientTurnId: `codex-native:${row.id}`, status: 'waiting', position, queuedAt: 0,
+            attempts: 0, preview: text?.slice(0, 80) ?? 'Message with attachments · manage in Codex',
+            ...(text !== null ? { prompt: text } : {}), editable: text !== null, owner: 'codex' }
+        })
+      } catch { return res.status(503).json({ error: 'native_queue_unavailable' }) }
+    }
+    // Re-read after the native await: delivery may have changed COS ownership.
+    const current = readQueue(provider, threadId, deps.now())
+    return res.json({ turns: [...native, ...current.map(t => publicRow(t, queuePosition(current, t.clientTurnId) + native.length))] })
+  })
+
+  // Atomic replacement: no cancel-and-requeue window, and the slot is retained.
+  router.patch('/agent-sessions/:provider/:threadId/queued-turns/:clientTurnId', async (req: Request, res: Response) => {
+    res.set('Cache-Control', 'private, no-store')
+    const provider = String(req.params.provider), threadId = String(req.params.threadId), id = String(req.params.clientTurnId)
+    const prompt = req.body?.prompt
+    if (typeof prompt !== 'string' || !prompt.trim() || prompt.length > DEFAULT_MAX_PROMPT_CHARS) return res.status(400).json({ error: 'invalid_prompt' })
+    if (provider === 'codex' && id.startsWith('codex-native:')) {
+      try {
+        await (deps.nativeQueue ?? nativeQueueControl).update(threadId, id.slice(13), prompt)
+        return res.json({ updated: true })
+      } catch { return res.status(409).json({ error: 'queue_edit_unconfirmed' }) }
+    }
+    const queue = readQueue(provider, threadId, deps.now())
+    const row = queue.find(t => t.clientTurnId === id)
+    if (!row || row.status !== 'waiting') return res.status(409).json({ error: 'already_delivering' })
+    row.prompt = prompt
+    writeQueue(provider, threadId, queue)
+    return res.json({ updated: true })
   })
 
   // DELETE — the cancel control, the same affordance the desktop queue offers.
-  router.delete('/agent-sessions/:provider/:threadId/queued-turns/:clientTurnId', (req: Request, res: Response) => {
+  router.delete('/agent-sessions/:provider/:threadId/queued-turns/:clientTurnId', async (req: Request, res: Response) => {
     res.set('Cache-Control', 'private, no-store')
     const provider = String(req.params.provider ?? '')
     const threadId = String(req.params.threadId ?? '')
     const clientTurnId = String(req.params.clientTurnId ?? '')
+    if (provider === 'codex' && clientTurnId.startsWith('codex-native:')) {
+      try {
+        const cancelled = await (deps.nativeQueue ?? nativeQueueControl).cancel(threadId, clientTurnId.slice(13))
+        return res.status(cancelled ? 200 : 409).json(cancelled ? { cancelled: true, clientTurnId, status: 'cancelled' } : { error: 'already_delivering' })
+      } catch { return res.status(503).json({ error: 'native_queue_unavailable' }) }
+    }
     const now = deps.now()
     const queue = readQueue(provider, threadId, now)
     const row = queue.find(t => t.clientTurnId === clientTurnId)

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)