@gotcos/glasses-server 6.99.25 → 6.99.29

package/server/lib/media-store.ts

@@ -166,7 +166,15 @@ export interface MediaRecord {
   textPath?: string
   derivativePaths?: string[]
   bytes: number
+  /** SHA-256 of the bytes stored NOW. The x265 pass replaces it with the compressed file's hash. */
   sha256: string
+  /**
+   * QA 6.99.29: SHA-256 of the bytes as ingested. Set once at publication and never changed by
+   * compression, so a queued turn sealed to (id, original hash) still matches after the x265 pass
+   * replaced the bytes under the same id. Absent only on a legacy record that was already compressed
+   * before this field existed (its compressed hash is then its stable identity: compression never reruns).
+   */
+  originalSha256?: string
   lifecycle: MediaLifecycle
   /** Set once the background x265 pass replaced the stored original with a
    *  smaller file. Kept so the size drop is explainable and never retried. */
@@ -281,6 +289,8 @@ function sanitizeVideoCompression(raw: unknown): VideoCompressionRecord | null {
   return { label: r.label.slice(0, 64), originalBytes: r.originalBytes, bytes: r.bytes, atMs: r.atMs }
 }
 
+const SHA256_HEX_RE = /^[0-9a-f]{64}$/
+
 function sanitizeRecord(raw: unknown): MediaRecord | null {
   if (!raw || typeof raw !== 'object') return null
   const r = raw as Record<string, unknown>
@@ -309,6 +319,12 @@ function sanitizeRecord(raw: unknown): MediaRecord | null {
     ? r.derivativePaths.filter(isOwnedPath).slice(0, VIDEO_SUMMARY_FRAMES_MAX)
     : undefined
   const videoCompression = sanitizeVideoCompression(r.videoCompression)
+  const sha256 = typeof r.sha256 === 'string' ? r.sha256 : ''
+  // A record never compressed still holds its ingested bytes, so its current hash IS the original (backfills
+  // records written before originalSha256 existed). A compressed legacy record has no original to recover.
+  const originalSha256 = typeof r.originalSha256 === 'string' && SHA256_HEX_RE.test(r.originalSha256)
+    ? r.originalSha256
+    : !videoCompression && SHA256_HEX_RE.test(sha256) ? sha256 : undefined
   return {
     ref,
     storagePath: r.storagePath,
@@ -316,7 +332,8 @@ function sanitizeRecord(raw: unknown): MediaRecord | null {
     ...(textPath ? { textPath } : {}),
     ...(derivativePaths?.length ? { derivativePaths } : {}),
     bytes: typeof r.bytes === 'number' && r.bytes >= 0 ? r.bytes : 0,
-    sha256: typeof r.sha256 === 'string' ? r.sha256 : '',
+    sha256,
+    ...(originalSha256 ? { originalSha256 } : {}),
     lifecycle,
     ...(videoCompression ? { videoCompression } : {}),
     contentRemoved: r.contentRemoved === true,
@@ -690,6 +707,7 @@ export class MediaStore {
       ...(derivativePaths.length ? { derivativePaths } : {}),
       bytes: prepared.originalBytes,
       sha256,
+      originalSha256: sha256,
       lifecycle: 'staged',
       ...(input.sessionId ? { sessionId: input.sessionId } : {}),
       ...(input.videoUploadId ? { videoUploadId: input.videoUploadId } : {}),
@@ -857,12 +875,14 @@ export class MediaStore {
       throw err
     }
 
+    const normalizedSha256 = createHash('sha256').update(normalized.normalized).digest('hex')
     const record: MediaRecord = {
       ref,
       storagePath: join('assets', id, 'original-normalized.jpg'),
       thumbPath: join('assets', id, 'thumb.jpg'),
       bytes: normalized.normalized.length,
-      sha256: createHash('sha256').update(normalized.normalized).digest('hex'),
+      sha256: normalizedSha256,
+      originalSha256: normalizedSha256,
       lifecycle: 'staged',
       ...(input.sessionId ? { sessionId: input.sessionId } : {}),
       createdAtMs: now,
@@ -1109,6 +1129,25 @@ export class MediaStore {
     return { record: rec, path: content.path }
   }
 
+  /**
+   * QA 6.99.29: the content identity a queued turn's files are sealed to: the hash of the bytes as
+   * ingested (`originalSha256`), stable across the x265 pass that rewrites a video under the same id.
+   * The stored bytes are still hashed, and must be what the index says is stored (the compressed or
+   * the original file): anything else returns the hash of what is really there, so a file swapped
+   * under the id no longer matches its seal. Throws as resolveUsable does.
+   */
+  async contentIdentitySha256(id: string, clientQueueItemId?: string): Promise<string> {
+    const { path } = this.resolveUsable(id, clientQueueItemId)
+    const actual = await sha256OfFile(path)
+    // Read the record AFTER hashing: a compression that swapped the bytes meanwhile has updated it.
+    const rec = this.getRecord(id)
+    if (!rec) throw new MediaStoreError('media_not_found', `attachment ${id} not found`)
+    const original = rec.originalSha256 && SHA256_HEX_RE.test(rec.originalSha256) ? rec.originalSha256 : null
+    const current = SHA256_HEX_RE.test(rec.sha256) ? rec.sha256 : null
+    if (actual === current || actual === original) return original ?? current ?? actual
+    return actual
+  }
+
   /** Resolve private model derivatives after lifecycle/ownership validation. */
   resolveModelDerivatives(
     id: string,

package/server/lib/permission-broker.ts

@@ -91,6 +91,24 @@
 // while Miles is at the desk is still `{}` at once (`desk_active`); every path still ends.
 // Every request answered `{}` is logged with why, the presence age and the window.
 //
+// COS Control Web joins the away hold, never the liveness (6.99.26, Miles 11/07: "Away rule, like
+// phone"; he answers from wherever he is, sometimes the Mac itself through Screens from the phone).
+// A browser poll `?client=web&hold=1&presenceAgeMs=<int>`, the ms since a touch or a key while the
+// page was in front, is its own presence (`webPresenceAgeMs`, lib/client-liveness), read here in
+// exactly two places: it can make a request away (so held up to the away hold while the desk is idle,
+// and answerable from the web), and it keeps an away-held request through the re-check while it is
+// recent. It never makes a client live: not the 6.59.0 liveness, not a `hold=1` client, not a
+// connected client for a stamped question. So with the away hold off, a hook that waits no longer than
+// 120 s, a stale touch (past the same recent window), or a desk in use, the web holds nothing and the
+// Mac's own pop-up shows at once, as Miles chose for an open tab in 6.99.13.
+// QA round 1 (6.99.26): the web touch admits only what nothing else would (`webOnly`), and changes
+// nothing about a request a glasses or phone client admits: same deadline, flag and hand-back as 6.99.25,
+// and it never keeps one through the re-check. A web-only STAMPED question needs the desk idle at admit
+// (only Claude Desktop is proven to keep its own prompt up while the hook waits, D1) and goes back to the
+// Mac the moment the desk is used, like any away-held request. A touch from the Mac itself never counts
+// (routes/permission-broker.ts requestFromThisMac), and `COS_WEB_AWAY_HOLD=0` turns the web part off
+// alone (`webAwayHoldEnabled`).
+//
 // NEVER past the hook's own wait. The hold is clamped to `holdCeilingS`: the PermissionRequest
 // `timeout` in the Claude settings file (read, not assumed) and the wait the hook stamped on
 // THIS request (`hookWaitS`, 6.60.0 script), whichever is less, minus 10 s; settings that
@@ -129,6 +147,16 @@ import { ASK_USER_QUESTION_TOOL, type SessionSignalStore } from './session-signa
 
 export type BrokerMode = 'off' | 'questions' | 'all'
 
+/**
+ * 6.99.26 (QA round 1): `COS_WEB_AWAY_HOLD`: `0`/`false`/`off` turns off COS Control Web's part of the
+ * away hold alone, so it can be rolled back without touching the glasses and phone. Default on; read per
+ * request.
+ */
+export function webAwayHoldEnabled(env: NodeJS.ProcessEnv): boolean {
+  const raw = (env.COS_WEB_AWAY_HOLD ?? '').trim().toLowerCase()
+  return !(raw === '0' || raw === 'false' || raw === 'off')
+}
+
 /**
  * `COS_PERMISSION_BROKER`: `0`/`false`/`off` answers `{}` to everything (the kill switch,
  * no reinstall needed); `questions` brokers AskUserQuestion only; unset or anything else
@@ -716,6 +744,9 @@ export function approvalCard(toolName: string, toolInput: Record<string, unknown
 // ---------------------------------------------------------------------------
 
 export type BrokerItemKind = 'question' | 'approval'
+/** 6.99.27: the door an answer came through: the Even app with the API token, or COS Control Web's browser session. */
+export type AnswerSurface = 'app' | 'web'
+
 export type BrokerResolution = 'answered' | 'handed_to_desk' | 'expired' | 'hook_gone' | 'retracted' | 'drained' | 'no_client'
 export type BrokerFastPath =
   | 'broker_off' | 'draining' | 'malformed' | 'cursor' | 'approvals_off' | 'unsupported_tool'
@@ -771,6 +802,14 @@ export interface PermissionBrokerDeps {
    * lib/client-liveness). Absent: null.
    */
   presenceAgeMs?(): number | null
+  /**
+   * 6.99.26: how long ago COS Control Web's newest touch or key was (`webPresenceAgeMs`,
+   * lib/client-liveness), or null when none since boot. Read for the away hold only, never as a live
+   * client. Absent: null (the web holds nothing).
+   */
+  webPresenceAgeMs?(): number | null
+  /** 6.99.26 (QA round 1): the web part's own switch (`webAwayHoldEnabled`). Absent: on. */
+  webAwayHold?(): boolean
   /**
    * 6.60.0: how recent that presence must be for the away hold, in ms
    * (`permissionBrokerAwayRecentClientMs`), never below the 30 s live window. Absent: 30 s.
@@ -810,6 +849,10 @@ export interface HoldFacts {
   recentWindowS: number
   /** 6.60.0: why this request is not away-held, or null when it is. */
   notAwayReason: NotAwayReason | null
+  /** 6.99.26: held for COS Control Web's touch alone; absent for every other request. */
+  webOnly?: true
+  /** 6.99.26: the age of that touch, present only with `webOnly`. */
+  webPresenceAgeMs?: number
 }
 
 /**
@@ -841,6 +884,8 @@ export interface ParkRequest {
   awayHold?: boolean
   askHold?: boolean
   lensVisible?: boolean
+  /** 6.99.26: admitted for COS Control Web's recent touch alone (see THE AWAY HOLD). */
+  webOnly?: boolean
   hold?: HoldFacts
 }
 
@@ -874,6 +919,8 @@ interface BrokerItem {
   awayHold: boolean
   askHold: boolean
   lensVisible: boolean
+  /** 6.99.26: admitted for the web touch alone: kept only while a touch is recent, and the desk hands it back. */
+  webOnly: boolean
   toolUseId: string | null
   questionFingerprint: string
   /**
@@ -1024,6 +1071,13 @@ function sessionMovedPast(item: Pick<BrokerItem, 'kind' | 'fingerprint' | 'toolN
   return false
 }
 
+/** A presence age from a dep: a finite number of ms at or above 0, else null (absent, throwing or nonsense). */
+function readAgeMs(read: () => number | null): number | null {
+  let ageMs: number | null = null
+  try { ageMs = read() } catch { ageMs = null }
+  return typeof ageMs === 'number' && Number.isFinite(ageMs) && ageMs >= 0 ? ageMs : null
+}
+
 export class PermissionBroker {
   private readonly deps: PermissionBrokerDeps
   private readonly items = new Map<string, BrokerItem>()
@@ -1058,7 +1112,7 @@ export class PermissionBroker {
   }
 
   /** A request answered `{}` without being parked, counted by why. */
-  noteFastPath(reason: BrokerFastPath, context: { notAway?: NotAwayReason; presence?: { ageMs: number | null; windowMs: number }; clientLive?: boolean } = {}): { ok: false; reason: BrokerFastPath } {
+  noteFastPath(reason: BrokerFastPath, context: { notAway?: NotAwayReason; presence?: { ageMs: number | null; windowMs: number; webAgeMs?: number | null }; clientLive?: boolean } = {}): { ok: false; reason: BrokerFastPath } {
     const key = camelKey(reason)
     this.fastPaths[key] = (this.fastPaths[key] ?? 0) + 1
     this.lastFastPath = reason
@@ -1068,7 +1122,9 @@ export class PermissionBroker {
     let presence = context.presence
     if (!presence) { try { presence = this.presence(this.deps.now()) } catch { presence = undefined } }
     const age = presence?.ageMs === null || presence?.ageMs === undefined ? 'null' : String(Math.round(presence.ageMs))
-    this.log(`fast path ${reason}${context.notAway ? ` not_away=${context.notAway}` : ''} presenceAgeMs=${age} windowMs=${presence?.windowMs ?? 'null'}${context.clientLive === undefined ? '' : ` clientLive=${context.clientLive}`}`)
+    // 6.99.26: the web's touch age only once the web has reported one, so every older line reads as before.
+    const web = typeof presence?.webAgeMs === 'number' ? ` webPresenceAgeMs=${Math.round(presence.webAgeMs)}` : ''
+    this.log(`fast path ${reason}${context.notAway ? ` not_away=${context.notAway}` : ''} presenceAgeMs=${age} windowMs=${presence?.windowMs ?? 'null'}${web}${context.clientLive === undefined ? '' : ` clientLive=${context.clientLive}`}`)
     return { ok: false, reason }
   }
 
@@ -1110,16 +1166,19 @@ export class PermissionBroker {
    *   - `holdLive`: a `hold=1` client polled within the live window AND its presence is
    *     recent, so it counts as a live client the way an older client's poll does. A
    *     connected lens nobody touches never counts (QA round 1, Skeptic W1).
+   *   - 6.99.26: `webAgeMs` and `webRecent`, COS Control Web's touch on its own: for the away
+   *     hold only, so it is never part of `recent` or `holdLive`.
    */
-  private presence(now: number): { ageMs: number | null; recent: boolean; holdLive: boolean; windowMs: number } {
-    let ageMs: number | null = null
-    try { ageMs = this.deps.presenceAgeMs?.() ?? null } catch { ageMs = null }
-    if (typeof ageMs !== 'number' || !Number.isFinite(ageMs) || ageMs < 0) ageMs = null
+  private presence(now: number): { ageMs: number | null; recent: boolean; holdLive: boolean; windowMs: number; webAgeMs: number | null; webRecent: boolean } {
+    const ageMs = readAgeMs(() => this.deps.presenceAgeMs?.() ?? null)
+    let webOn = true
+    try { webOn = this.deps.webAwayHold?.() !== false } catch { webOn = false }
+    const webAgeMs = webOn ? readAgeMs(() => this.deps.webPresenceAgeMs?.() ?? null) : null
     const windowMs = this.recentWindowMs()
     const recent = ageMs !== null && ageMs <= windowMs
     let holdPollAt: number | null = null
     try { holdPollAt = this.deps.lastHoldPollAt?.() ?? null } catch { holdPollAt = null }
-    return { ageMs, recent, holdLive: recent && this.polledWithin(holdPollAt, now), windowMs }
+    return { ageMs, recent, holdLive: recent && this.polledWithin(holdPollAt, now), windowMs, webAgeMs, webRecent: webAgeMs !== null && webAgeMs <= windowMs }
   }
 
   /** 6.60.0: the installed hook timeout, or null when absent or unreadable. */
@@ -1207,13 +1266,19 @@ export class PermissionBroker {
     // window (Miles, 19:54; QA round 1).
     const switchOn = this.awayHoldMs() > 0
     const ceilingAllowsAway = this.holdMs(facts.hookWaitS, false).ceilingAllowsAway
-    const away = switchOn && ceilingAllowsAway && (askHold || presence.recent)
+    // 6.60.0 to 6.99.25, unchanged: what a live client and a wearer's presence allow.
+    const deviceAway = switchOn && ceilingAllowsAway && (askHold || presence.recent)
+    const deviceAdmits = askHold ? clientLive || presence.recent : clientLive || deviceAway
+    // 6.99.26 (QA round 1): a recent touch on COS Control Web admits only what nothing else would, for the away
+    // hold alone. A request a glasses or phone client admits keeps its 6.99.25 deadline, flag and hand-back.
+    const webOnly = !deviceAdmits && switchOn && ceilingAllowsAway && presence.webRecent
+    const away = deviceAway || webOnly
     const notAwayReason: NotAwayReason | null = away ? null
       : !switchOn ? 'hold_off'
       : !ceilingAllowsAway ? 'ceiling_at_base'
       : presence.ageMs === null ? 'no_hold_client'
       : 'stale_presence'
-    if (askHold && !clientLive && !presence.recent) return this.noteFastPath('no_client', { presence, clientLive })
+    if (askHold && !deviceAdmits && !webOnly) return this.noteFastPath('no_client', { presence, clientLive })
     const hold = this.holdMs(facts.hookWaitS, away)
     // With it, a request is held whether or not a client is polling right now, so a lens or
     // phone that comes back can still answer it. Without it, no client is `{}`, as in 6.59.0.
@@ -1228,6 +1293,10 @@ export class PermissionBroker {
     try { idle = await this.deps.readDeskIdleSeconds() } catch { idle = null }
     if (!askHold && idle === null) return this.noteFastPath('desk_unknown')
     if (!askHold && idle! < this.deskIdleThreshold()) return this.noteFastPath('desk_active', { notAway: 'desk_active', presence, clientLive })
+    // 6.99.26 (QA round 1): a stamped question the web touch alone admits needs the desk idle now. Only Claude
+    // Desktop is proven to keep its own prompt up while the hook waits (D1); at the desk, the Mac answers.
+    if (webOnly && idle === null) return this.noteFastPath('desk_unknown')
+    if (webOnly && idle! < this.deskIdleThreshold()) return this.noteFastPath('desk_active', { notAway: 'desk_active', presence, clientLive })
     const mode = this.deps.mode()
     if (mode === 'off') return this.noteFastPath('broker_off')
     if (!this.deps.admissionsOpen()) return this.noteFastPath('draining')
@@ -1258,8 +1327,9 @@ export class PermissionBroker {
       presenceAgeMs: presence.ageMs === null ? null : Math.round(presence.ageMs),
       recentWindowS: Math.round(presence.windowMs / 1000),
       notAwayReason,
+      ...(webOnly ? { webOnly: true as const, webPresenceAgeMs: Math.round(presence.webAgeMs ?? 0) } : {}),
     }
-    return { ok: true, request: { facts: { ...facts, fingerprint }, kind, questions, approval, deadlineAt, awayHold, askHold, lensVisible: !askHold || (idle !== null && idle >= this.deskIdleThreshold()), hold: holdFacts } }
+    return { ok: true, request: { facts: { ...facts, fingerprint }, kind, questions, approval, deadlineAt, awayHold, askHold, lensVisible: !askHold || (idle !== null && idle >= this.deskIdleThreshold()), ...(webOnly ? { webOnly: true } : {}), hold: holdFacts } }
   }
 
   /** Hold the hook's response until exactly one resolution. Returns the item id. */
@@ -1289,6 +1359,7 @@ export class PermissionBroker {
       channel,
       timer: null,
       awayHold: request.awayHold === true,
+      webOnly: request.webOnly === true,
       askHold: request.askHold === true,
       lensVisible: request.lensVisible !== false,
       toolUseId: facts.toolUseId ?? null,
@@ -1438,7 +1509,7 @@ export class PermissionBroker {
    * clientAnswerId) replays its 200. `handBack` wins over any answer fields in the same body:
    * it is the safe direction, since it only shows the dialog that would have shown anyway.
    */
-  answer(id: string, body: unknown): AnswerResult {
+  answer(id: string, body: unknown, by: AnswerSurface = 'app'): AnswerResult {
     const item = BROKER_ID_RE.test(id) ? this.items.get(id) : undefined
     if (!item) return { status: 404, body: { error: 'not_found' } }
     const input = isRecord(body) ? body : {}
@@ -1490,7 +1561,9 @@ export class PermissionBroker {
     item.timer = null
     this.counters.answered++
     try { this.deps.signals?.decided(item.sessionId, item.id, item.fingerprint) } catch { /* rows are advisory */ }
-    if (item.kind === 'question') this.log(`glasses_won ${item.id}`)
+    // 6.99.27: who answered, by the door it came through: the Even app (lens or phone, the API token) or COS Control
+    // Web (the browser session). A web answer once logged as glasses_won.
+    if (item.kind === 'question') this.log(`${by === 'web' ? 'web_won' : 'glasses_won'} ${item.id}`)
     this.log(`answered ${item.id} kind=${item.kind} pending=${this.pendingCount()}`)
     this.prune()
     return { status: 200, body: { ok: true, id: item.id, kind: item.kind, ...chosen } }
@@ -1631,11 +1704,14 @@ export class PermissionBroker {
       // 6.60.0: an item held by the away hold outlives the client going quiet, but only while
       // the wearer's latest presence is still within the window (QA round 1, Skeptic W2: a
       // single glance must not hold a question 10 more minutes). The desk below still hands
-      // it back.
-      this.settleAll('no_client', item => !item.askHold && (!item.awayHold || !presence.recent))
+      // it back. 6.99.26 (QA round 1): a recent web touch keeps only what it admitted; a glasses or
+      // phone hold reads exactly as in 6.99.25.
+      this.settleAll('no_client', item => item.webOnly
+        ? !(presence.recent || presence.webRecent)
+        : !item.askHold && (!item.awayHold || !presence.recent))
       if (this.pendingCount() === 0) return
     }
-    if (![...this.items.values()].some(item => item.state === 'pending' && (!item.askHold || !item.lensVisible))) return
+    if (![...this.items.values()].some(item => item.state === 'pending' && (!item.askHold || !item.lensVisible || item.webOnly))) return
     if (this.pollInFlight) return
     this.pollInFlight = true
     let idle: number | null = null
@@ -1643,7 +1719,7 @@ export class PermissionBroker {
     if (idle === null) {
       this.counters.deskUnreadable++
       this.deskUnreadableStreak++
-      if (this.deskUnreadableStreak >= 2) this.settleAll('handed_to_desk', item => !item.askHold)
+      if (this.deskUnreadableStreak >= 2) this.settleAll('handed_to_desk', item => !item.askHold || item.webOnly)
       return
     }
     this.deskUnreadableStreak = 0
@@ -1656,7 +1732,8 @@ export class PermissionBroker {
       }
       return
     }
-    this.settleAll('handed_to_desk', item => !item.askHold)
+    // 6.99.26 (QA round 1): a web-only stamped question goes back to the Mac as any away-held request does.
+    this.settleAll('handed_to_desk', item => !item.askHold || item.webOnly)
   }
 
   private settleAll(resolution: 'handed_to_desk' | 'drained' | 'no_client', only: (item: BrokerItem) => boolean = () => true): void {

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

@@ -17,6 +17,7 @@
 
 import { cancelVoidsOpenTurn, type ThreadCancel } from './session-cancel.js'
 import { unwrapPeerMessage } from './session-stream-events.js'
+import { stripG2TurnFooter, withoutTurnFooter } from './turn-footer.js'
 import type { TurnAttemptLookup } from './agent-session-binding-registry.js'
 import type { QueuedThreadTurn } from './thread-turn-queue.js'
 
@@ -215,13 +216,29 @@ function textOf(content: unknown): string | null {
   return parts.length > 0 ? parts.join('\n') : null
 }
 
-/** The words, as typed or out of Claude Code's peer wrapper, equal the prompt exactly. */
+/**
+ * The words, as typed or out of Claude Code's peer wrapper, equal the prompt exactly.
+ * 6.99.29: a glasses, phone or web turn reaches the session with one trailing verify footer line
+ * (lib/g2-turn-provenance.ts) that the queue row and the turns route never held, so that one
+ * line is taken off the transcript's text before the exact comparison. Nothing else is.
+ */
 function sameWords(text: string | null, want: string): boolean {
   if (text === null) return false
   if (text.trim() === want) return true
+  if (footedWords(text, want)) return true
   return unwrapPeerMessage(text) === want
 }
 
+/** A row that carries a verify footer, as typed or inside the peer wrapper, whose words are `want`. */
+function footedWords(text: string, want: string): boolean {
+  for (const candidate of [text, unwrapPeerMessage(text)]) {
+    if (typeof candidate !== 'string') continue
+    const stripped = stripG2TurnFooter(candidate)
+    if (stripped.turnId !== null && stripped.text.trim() === want) return true
+  }
+  return false
+}
+
 /**
  * Does this transcript tail show the session took exactly these words, at or after
  * `sinceMs`? WRAPPER-AWARE AND EXACT: the whole prompt, trimmed, either as typed or inside
@@ -286,7 +303,7 @@ export function makeDeliveryEvidence(deps: DeliveryEvidenceDeps): (turn: QueuedT
       let codexQueueMatch = false
       if (!transcriptMatch && turn.provider === 'codex' && typeof deps.codexQueueTexts === 'function') {
         const texts = await deps.codexQueueTexts(turn.threadId)
-        codexQueueMatch = texts.some(text => typeof text === 'string' && text.trim() === turn.prompt.trim())
+        codexQueueMatch = texts.some(text => typeof text === 'string' && withoutTurnFooter(text).trim() === turn.prompt.trim())
       }
       return reconcileVerdict({ row: turn, ledgerOutcome, transcriptMatch, codexQueueMatch, attempt })
     } catch {

package/server/lib/session-halt.ts

@@ -39,6 +39,7 @@ import { atomicWriteFileSync } from './atomic-fs.js'
 import { dataPath } from './data-dir.js'
 import { isValidNativeThreadId } from './native-thread-id.js'
 import { unwrapPeerMessage } from './session-stream-events.js'
+import { stripG2TurnFooter, withoutTurnFooter } from './turn-footer.js'
 
 /**
  * How long a marker may outlive its cancel. An hour, not the plan's first 15 minutes: the
@@ -263,14 +264,27 @@ export function normalizePromptWords(text: unknown): string {
 export function isDeliveredPrompt(prompt: unknown, delivered: string, options: { verbatim?: boolean } = {}): boolean {
   if (options.verbatim === true) {
     // 6.62.0: Codex's queued turn arrives as its own text. No wrapper to take off.
+    // 6.99.29: a glasses, phone or web turn arrives with one trailing verify footer line the
+    // route's own `prompt` never held; that line, and only that line, comes off first.
     const want = typeof delivered === 'string' ? delivered.trim() : ''
-    return want.length > 0 && typeof prompt === 'string' && prompt.trim() === want
+    return want.length > 0 && typeof prompt === 'string' && withoutTurnFooter(prompt).trim() === want
   }
   const want = normalizePromptWords(delivered)
   if (want.length === 0 || typeof prompt !== 'string') return false
+  if (footedPromptIs(prompt, want)) return true
   return normalizePromptWords(unwrapPeerMessage(prompt) ?? prompt) === want
 }
 
+/** 6.99.29: a prompt that carries a verify footer, as typed or inside the peer wrapper, whose words are `want`. */
+function footedPromptIs(prompt: string, want: string): boolean {
+  for (const candidate of [prompt, unwrapPeerMessage(prompt)]) {
+    if (typeof candidate !== 'string') continue
+    const stripped = stripG2TurnFooter(candidate)
+    if (stripped.turnId !== null && normalizePromptWords(stripped.text) === want) return true
+  }
+  return false
+}
+
 /**
  * A UserPromptSubmit from the session itself (never a COS child): the hook has just deleted
  * the session's marker. The FIRST such prompt after the send spends the pending re-arm: when

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

@@ -17,6 +17,8 @@
 // carrying its real name in `target`, so a provider adding a tool tomorrow degrades to
 // a readable line instead of an unrenderable one.
 
+import { withoutTurnFooter } from './turn-footer.js'
+
 /** Closed set. A provider tool name that is not in the table maps to `other`. */
 export type SessionStreamVerb = 'read' | 'edit' | 'write' | 'bash' | 'search' | 'task' | 'other'
 
@@ -557,6 +559,8 @@ export function promptDrafts(message: Record<string, unknown>): SessionStreamDra
   let text = parts.join(' ')
   // A live Continue's words, out of the peer wrapper (see `unwrapPeerMessage`).
   text = unwrapPeerMessage(text) ?? text
+  // 6.99.29: the one trailing verify footer line of a glasses, phone or web turn is for the agent.
+  text = withoutTurnFooter(text)
   // Wrapper blocks out, whole. A partial strip would leave the tag names on the lens.
   text = text.replace(/<(system-reminder|relevant-memories|cache-health|daily-bulletin|cos-alarms|device-handoff|now|memory-stored|local-command-stdout|local-command-stderr|command-name|command-message|command-args)>[\s\S]*?<\/\1>/g, ' ')
   const flat = oneLine(text, PROMPT_MAX_CHARS)

package/server/lib/session-subagents.ts

@@ -0,0 +1,155 @@
+/**
+ * 6.99.26 candidate: who a session has working for it, for the Today summary (lib/today-brief.ts). Read-only display
+ * evidence: never imported by an attach, queue or write gate.
+ *
+ * Claude Code: nothing on the server read sub-agent NAMES before this (the hooks give counts only:
+ * session-work-observation.ts). This reads the session's own transcript TAIL (the last 768 KB) and follows each Agent
+ * or Task tool call:
+ * - the call gives the name (`name`, else `subagent_type`) and the one-line task (`description`);
+ * - its tool result says how it started: `async_launched` and `teammate_spawned` are running, any other result is a
+ *   finished foreground agent, an error result is failed;
+ * - a `<task-notification>` naming the call's tool-use id ends a background agent (completed, failed or killed);
+ * - a `<teammate-message teammate_id="name">` moves a teammate: an `idle_notification` makes it idle, a shutdown
+ *   approval makes it done, anything else is it reporting; a SendMessage to it from the session makes it running again.
+ * Agents spawned before the tail are not seen; `partial` says the read started mid-file.
+ *
+ * Codex: codex-subagent-activity.ts readCodexSubagentDetails (the same spawn-edge table and child lifecycle reader the
+ * list already uses for its counts).
+ *
+ * Opens are non-blocking and refuse symlinks (O_NONBLOCK | O_NOFOLLOW, then a regular-file check); a read is memoized
+ * on mtime and size like readSessionActivity, and the memo holds only names, tasks, states and times.
+ */
+import { constants } from 'node:fs'
+import { open } from 'node:fs/promises'
+
+export type SubagentStatus = 'running' | 'idle' | 'done' | 'failed' | 'unknown'
+export interface SubagentRow { name: string; task: string; status: SubagentStatus; at: number }
+export interface SessionSubagents { rows: SubagentRow[]; running: number; idle: number; done: number; failed: number; total: number; partial: boolean }
+
+export const SUBAGENTS_PER_SESSION = 6
+export const CLAUDE_SUBAGENT_TAIL_BYTES = 768 * 1024
+const MAX_TRACKED = 256
+const MEMO_MAX = 64
+const NAME_MAX = 60
+const TASK_MAX = 160
+
+const clip = (v: unknown, max: number) => (typeof v === 'string' ? v.replace(/\s+/g, ' ').trim().slice(0, max) : '')
+const AGENT_TOOLS = new Set(['Agent', 'Task'])
+
+interface Tracked extends SubagentRow { team: boolean }
+
+/** The plain text of a user line or a queued message: a string, or its text blocks joined. */
+function textOf(content: unknown): string {
+  if (typeof content === 'string') return content
+  if (!Array.isArray(content)) return ''
+  return content.map(b => (b && typeof b === 'object' && (b as any).type === 'text' && typeof (b as any).text === 'string' ? (b as any).text : '')).join('\n')
+}
+
+const NOTIFICATION = /<task-notification>[\s\S]*?<tool-use-id>([^<\s]{1,120})<\/tool-use-id>[\s\S]*?<status>([a-z_]{1,24})<\/status>/g
+const TEAMMATE = /<teammate-message\s+teammate_id="([^"]{1,80})"[^>]*>([\s\S]{0,600})/g
+
+/**
+ * Sub-agents from a transcript's tail, most recently moved first, at most `limit` rows, with counts over every one
+ * the tail shows. `startsMidFile` drops the first (partial) line.
+ */
+export function parseClaudeSubagents(text: string, startsMidFile = false, limit = SUBAGENTS_PER_SESSION): SessionSubagents {
+  // A read that starts mid-file has a cut first line; it fails to parse and is skipped like any bad line. It is not
+  // dropped blindly: a tail that starts exactly on a line boundary would lose a whole event. `partial` says so either way.
+  const lines = text.split('\n')
+  const byTool = new Map<string, Tracked>()
+  const byName = new Map<string, Tracked>()
+  const move = (t: Tracked, status: SubagentStatus | null, at: number) => {
+    if (at < t.at) return
+    t.at = at
+    if (status) t.status = status
+  }
+  for (const line of lines) {
+    if (!line || line.length > 4_000_000) continue
+    let row: any
+    try { row = JSON.parse(line) } catch { continue }
+    const at = Date.parse(row?.timestamp) || 0
+    if (row?.type === 'assistant' && Array.isArray(row.message?.content)) {
+      for (const b of row.message.content) {
+        if (b?.type !== 'tool_use' || typeof b.id !== 'string') continue
+        const input = b.input && typeof b.input === 'object' ? b.input : {}
+        if (AGENT_TOOLS.has(b.name)) {
+          if (byTool.size >= MAX_TRACKED) continue
+          const name = clip(input.name, NAME_MAX) || clip(input.subagent_type, NAME_MAX) || 'agent'
+          const t: Tracked = { name, task: clip(input.description, TASK_MAX), status: 'running', at, team: typeof input.name === 'string' && !!input.name.trim() }
+          byTool.set(b.id, t)
+          if (t.team) byName.set(name, t)
+        } else if (b.name === 'SendMessage' && typeof input.to === 'string') {
+          const t = byName.get(input.to.trim())
+          if (t && t.status !== 'done' && t.status !== 'failed') move(t, 'running', at)
+        }
+      }
+      continue
+    }
+    if (row?.type === 'user' && Array.isArray(row.message?.content)) {
+      for (const b of row.message.content) {
+        if (b?.type !== 'tool_result' || typeof b.tool_use_id !== 'string') continue
+        const t = byTool.get(b.tool_use_id)
+        if (!t) continue
+        const result = row.toolUseResult && typeof row.toolUseResult === 'object' ? row.toolUseResult : {}
+        if (b.is_error === true) move(t, 'failed', at)
+        else if (result.status === 'async_launched' || result.status === 'teammate_spawned') move(t, 'running', at)
+        else move(t, 'done', at)
+        if (result.status === 'teammate_spawned' && typeof result.name === 'string' && result.name.trim()) {
+          t.team = true
+          byName.set(clip(result.name, NAME_MAX), t)
+        }
+      }
+    }
+    // Notifications arrive as a user line, and as a queued message before it is delivered.
+    const text = row?.type === 'user' ? textOf(row.message?.content) : row?.type === 'queue-operation' ? textOf(row.content) : ''
+    if (!text || (text.indexOf('<task-notification>') < 0 && text.indexOf('<teammate-message') < 0)) continue
+    for (const m of text.matchAll(NOTIFICATION)) {
+      const t = byTool.get(m[1]!)
+      if (t) move(t, m[2] === 'failed' ? 'failed' : 'done', at)
+    }
+    for (const m of text.matchAll(TEAMMATE)) {
+      const t = byName.get(m[1]!)
+      if (!t) continue
+      const body = m[2] || ''
+      if (/"type"\s*:\s*"shutdown_(?:approved|response)"[\s\S]*?"approve"\s*:\s*true|"type"\s*:\s*"shutdown_approved"/.test(body)) move(t, 'done', at)
+      else if (/"type"\s*:\s*"idle_notification"/.test(body)) move(t, 'idle', at)
+      else move(t, null, at)
+    }
+  }
+  return summarize([...byTool.values()], startsMidFile, limit)
+}
+
+export function summarize(all: SubagentRow[], partial: boolean, limit = SUBAGENTS_PER_SESSION): SessionSubagents {
+  const out: SessionSubagents = { rows: [], running: 0, idle: 0, done: 0, failed: 0, total: all.length, partial }
+  for (const a of all) if (a.status !== 'unknown') out[a.status]++
+  // Live ones first, then by when each last moved.
+  const rank = (s: SubagentStatus) => (s === 'running' ? 0 : s === 'idle' ? 1 : 2)
+  out.rows = [...all].sort((a, b) => rank(a.status) - rank(b.status) || b.at - a.at).slice(0, limit)
+    .map(a => ({ name: a.name, task: a.task, status: a.status, at: a.at }))
+  return out
+}
+
+const memo = new Map<string, { mtimeMs: number; size: number; value: SessionSubagents }>()
+
+/** One Claude transcript's sub-agents, or null when it cannot be read. Never throws. */
+export async function readClaudeSubagents(file: string, tailBytes = CLAUDE_SUBAGENT_TAIL_BYTES): Promise<SessionSubagents | null> {
+  let handle: Awaited<ReturnType<typeof open>> | null = null
+  try {
+    handle = await open(file, constants.O_RDONLY | (constants.O_NONBLOCK ?? 0) | (constants.O_NOFOLLOW ?? 0))
+    const st = await handle.stat()
+    if (!st.isFile()) return null
+    const hit = memo.get(file)
+    if (hit && hit.mtimeMs === st.mtimeMs && hit.size === st.size) return hit.value
+    const length = Math.min(st.size, tailBytes), start = st.size - length
+    const buffer = Buffer.alloc(length)
+    const read = await handle.read(buffer, 0, length, start)
+    const value = parseClaudeSubagents(buffer.subarray(0, read.bytesRead).toString('utf8'), start > 0)
+    if (memo.size >= MEMO_MAX) memo.delete(memo.keys().next().value!)
+    memo.set(file, { mtimeMs: st.mtimeMs, size: st.size, value })
+    return value
+  } catch {
+    return null
+  } finally {
+    await handle?.close().catch(() => {})
+  }
+}