@gotcos/glasses-server 7.0.7 → 7.0.18

package/server/routes/agent-session-bindings.ts

@@ -2754,8 +2754,9 @@ export function createAgentSessionBindingsRouter(deps: AgentSessionBindingsDeps)
         // 6.99.29 (Codex audit of e4758a6): the record names the SOURCE session, never the fork child
         // that actually receives the words, and the child has no binding yet. Until a destination
         // binding exists, a forked turn is recorded UNVERIFIED for the child: no footer, ever.
-        const forkVerdict = unvouched(deps.provenance.originOf(req), 'fork_destination_unbound')
+        // 6.99.31: a signed web fork is judged too, so its record says why (always fork_destination_unbound).
         const forkTurnId = typeof clientForkId === 'string' ? clientForkId : `fork-${randomBytes(12).toString('hex')}`
+        const forkVerdict = deps.provenance.acceptWebKey(unvouched(deps.provenance.originOf(req), 'fork_destination_unbound'), { provider: providerParam, sessionId: null, turnId: forkTurnId, words: prompt, attachments: [], fork: true })
         forkPrompt = deps.provenance.footed(prompt, forkTurnId, forkVerdict, providerParam)
         deps.provenance.record({ turnId: forkTurnId, prompt, verdict: forkVerdict, provider: providerParam, sessionId: threadIdParam, via: 'fork', fork: true })
       }
@@ -3139,6 +3140,14 @@ export function createAgentSessionBindingsRouter(deps: AgentSessionBindingsDeps)
           return refuseTurn('invalid_request', { retryable: false, error: 'queued_turn_tampered', reasonCopy: QUEUED_TURN_TAMPERED_COPY })
         }
       }
+      // 6.99.31: a web turn carrying an enrolled phone key's envelope is judged once the binding names
+      // the real target (below). Its files are read here (the only await): the envelope's ordered
+      // manifest must equal them. Null: unreadable, so the turn is not vouched.
+      let webKeyFiles: ReadonlyArray<{ id: string; sha256: string }> | null = []
+      if (turnVerdict?.webKeyCandidate && attachIds.ids.length > 0) {
+        const m = await turnAttachmentManifest(attachIds.ids, deps.turnAttachmentStore)
+        webKeyFiles = m.ok ? m.manifest : null
+      }
       /** Ledgered once the text did, or may have, reached a session. Hash of the text WITHOUT the footer. */
       const ledgerTurn = (via: string, provider: string, sessionId: string): void => {
         if (provenance && turnVerdict && clientTurnId !== null) provenance.record({ turnId: clientTurnId, prompt, verdict: turnVerdict, provider, sessionId, via: turnCarried ? `drain-${via}` : via, continues: turnCarried })
@@ -3214,6 +3223,12 @@ export function createAgentSessionBindingsRouter(deps: AgentSessionBindingsDeps)
         console.warn(`[agent-session-bindings] queued turn seal mismatch (target) turnId=${turnId} clientTurnId=${clientTurnId}`)
         return refuseTurn('invalid_request', { retryable: false, error: 'queued_turn_tampered', reasonCopy: QUEUED_TURN_TAMPERED_COPY })
       }
+      // 6.99.31: the envelope against the binding's provider and native thread (the actual receiving
+      // session), the exact words (before the files block) and the files. Synchronous: the nonce is
+      // spent here, in the same tick as the reuse check below. No envelope: the verdict is unchanged.
+      if (provenance && turnVerdict && turnVerdict.webKeyCandidate) {
+        turnVerdict = provenance.acceptWebKey(turnVerdict, { provider: binding.provider, sessionId: binding.nativeThreadId, bindingId, turnId: clientTurnId, words, attachments: webKeyFiles })
+      }
       if (provenance && turnVerdict && provenance.reusesTurnId(clientTurnId, { prompt, verdict: turnVerdict, provider: binding.provider, sessionId: binding.nativeThreadId }, { continues: turnCarried })) {
         return refuseTurn('invalid_request', { retryable: false, error: 'turn_id_in_use', reasonCopy: TURN_ID_IN_USE_COPY })
       }

package/server/routes/agent-session-stream.ts

@@ -59,6 +59,7 @@
 // never be mistaken for a user's explicit opt-out. Off answers 503 and the client
 // polls, which is the same code path as a server too old to have this route at all.
 
+import { streamSignInHolds } from '../lib/api-auth.js'
 import { redactLocalPaths } from '../lib/local-path-redact.js'
 import { Router, type Response } from 'express'
 import { stat } from 'node:fs/promises'
@@ -366,6 +367,12 @@ agentSessionStreamRouter.get('/agent-sessions/:provider/:sessionId/stream', asyn
       teardown()
       return
     }
+    // Final review S1: a stream opened by a browser sign-in ends once that sign-in no longer verifies (signed out
+    // everywhere, expired, past the 30-day cap). A token stream never re-checks.
+    if (!streamSignInHolds(res)) {
+      teardown()
+      return
+    }
     write({ kind: 'heartbeat', at: Date.now() })
   }, HEARTBEAT_INTERVAL_MS)
   if (typeof (heartbeat as any).unref === 'function') (heartbeat as any).unref()

package/server/routes/drops.ts

@@ -18,8 +18,9 @@
  *   POST /drops/:id/move  { dest, target?: { id, label, domain? } }                     DropAnswer
  *   POST /drops/:id/ask   { clientJobId, generation }                                   DropAnswer
  *   POST /drops/:id/sent                                                                DropAnswer
- *   GET  /inbox/summary                                                                 { unread, waiting, lastLine, lastAt, version }
+ *   GET  /inbox/summary                                                                 { unread, waiting, asked, yourMove, lastLine, lastAt, version }
  *   GET  /inbox/feed      ?after&limit                                                  { items, version, more }
+ *   GET  /inbox/archive                                                                 { items, total, waitingExpiryDays, version } (7.0.9)
  *   POST /inbox/read      { through }                                                   { unread, waiting, version }
  *   POST /inbox/action    { itemId, action: 'choose:<id>' | 'undo' }                    DropAnswer
  *   POST /inbox/action    { itemId, action: 'dismiss' }                                 { unread, waiting, version }
@@ -211,9 +212,13 @@ export function createDropsRouter(deps: DropsRouterDependencies): Router {
     try { await service.syncAsks() } catch { /* the chat still reads */ }
     try { return res.json(service.feed({ after, limit })) } catch (e) { return send(res, e) }
   }))
+  // 7.0.9: the older questions (asked WAITING_EXPIRY_DAYS or more ago and still unanswered), newest first.
+  router.get('/inbox/archive', (_req, res) => withService(res, async service => {
+    try { return res.json(service.archive()) } catch (e) { return send(res, e) }
+  }))
   router.post('/inbox/read', (req, res) => withService(res, async service => {
     if (!isRecord(req.body) || typeof req.body.through !== 'string') return bad(res, 'invalid_read')
-    let out: { unread: number; waiting: number; version: number }
+    let out: { unread: number; waiting: number; asked: number; version: number }
     try { out = service.markRead(req.body.through) } catch (e) { return send(res, e) }
     // The same `waiting` the summary gives, Work's Your move included.
     const yourMove = await boundedYourMove(deps.yourMove)

package/server/routes/g2-turns.ts

@@ -42,5 +42,40 @@ export function createG2TurnsRouter(deps: {
       res.status(500).json({ found: false, error: 'lookup_failed' })
     }
   })
+  // 6.99.31 (plan §4.5): POST /api/g2-turns/:turnId/consume {session, provider}. One server-enforced
+  // winner per web-key authorization (keys turn:<turnId> and web:<aud>:<authId>, one write), so two receiving sessions
+  // cannot both act on one signed message. X-Cos-Token only. A token holder can pre-spend: that is
+  // denial of service, not forgery. Not a route while COS_WEB_KEY_AUTHORITY is off.
+  router.post('/g2-turns/:turnId/consume', async (req, res, next) => {
+    const authority = deps.provenance.webKey
+    if (!authority || !authority.enabled()) return next()
+    res.set('Cache-Control', 'private, no-store')
+    let expected = ''
+    try { expected = deps.apiToken ? deps.apiToken() : '' } catch { expected = '' }
+    if (!expected || !timingSafeTokenEqual(req.headers['x-cos-token'], expected)) return void res.status(401).json({ consumed: false, error: 'token_required' })
+    const turnId = String(req.params.turnId ?? '')
+    if (!G2_TURN_ID_RE.test(turnId)) return void res.status(400).json({ consumed: false, error: 'invalid_turn_id' })
+    const b = (req.body && typeof req.body === 'object' ? req.body : {}) as Record<string, unknown>
+    try {
+      const answer = await describeG2Turn(deps.provenance, turnId, now())
+      if (!answer) return void res.status(404).json({ consumed: false, turnId, error: 'not_found' })
+      if (answer.authority !== 'web-key' || answer.verifiedOrigin !== true || typeof answer.authId !== 'string') {
+        return void res.status(409).json({ consumed: false, turnId, error: 'not_web_key_verified', reason: answer.reason ?? null })
+      }
+      const target = answer.target as { provider?: string; sessionId?: string } | undefined
+      if (typeof b.session !== 'string' || typeof b.provider !== 'string' || target?.sessionId !== b.session || target?.provider !== b.provider) {
+        return void res.status(409).json({ consumed: false, turnId, error: 'destination_mismatch' })
+      }
+      // Review B3: one namespace. The turn id and the web authorization are spent in ONE write.
+      const keys = Array.isArray(answer.consumeKeys) ? (answer.consumeKeys as unknown[]).filter((k): k is string => typeof k === 'string') : []
+      if (keys.length !== 2) return void res.status(409).json({ consumed: false, turnId, error: 'not_web_key_verified' })
+      const spent = authority.nonces.spend(keys, b.session, b.provider)
+      if (!spent.ok) return void res.status(spent.reason === 'already_consumed' ? 409 : 503).json({ consumed: false, turnId, error: spent.reason })
+      res.json({ consumed: true, turnId, authId: answer.authId, keys })
+    } catch (error) {
+      console.error(`[g2-turns] consume failed: ${error instanceof Error ? error.message : error}`)
+      res.status(500).json({ consumed: false, error: 'consume_failed' })
+    }
+  })
   return router
 }

package/server/routes/health.ts

@@ -1,3 +1,4 @@
+import { API_AUTH_BY_LOCAL } from '../lib/api-auth.js'
 import { MAX_ATTACHMENTS_PER_PROMPT } from '../../shared/media-attachment.js'
 import { calendarStatus } from '../lib/calendar-source.js'
 import { TURN_FILE_MAX_BYTES } from '../lib/turn-file-store.js'
@@ -10,6 +11,7 @@ import { customInstructionsCapability, learnedStyleCapability, polishOptionsCapa
 import { PAIRING_PROTOCOL_VERSION } from '../lib/glasses-pairing.js'
 import { taskBridgeAvailable } from '../lib/task-bridge.js'
 import { Router } from 'express'
+import { webKeyAuthorityEnabled } from '../lib/web-key-authority.js'
 import { isWorthRecovering } from '../lib/quarantine-auto-recover.js'
 import { claudeSessionsEnabled } from './claude-sessions.js'
 import { statSync } from 'node:fs'
@@ -460,6 +462,9 @@ healthRouter.get('/health', async (_req, res) => {
     // 6.99.27: a session turn also takes ANY file up to this size (lib/turn-file-store.ts), sent to /api/media/file with
     // X-COS-Purpose: session-turn. 0 with attach off; absent on an older server, which takes only what the media store reads.
     threadTurnFileBytes: threadAttach.enabled ? TURN_FILE_MAX_BYTES : 0,
+    // 6.99.31 (Phase 3): the phone key signer exists (COS_WEB_KEY_AUTHORITY on), so Control Web may offer
+    // "Approve on this phone". Absent with the flag off: the composer is exactly 6.99.29's.
+    ...(webKeyAuthorityEnabled() ? { webKeySigner: 1 } : {}),
     ...sessionHooksHealthFields(),
     // 6.52.0: counts, the mode and two timestamps; never an id, a question, a command, or
     // how many are held (that is on the authenticated questions route).
@@ -684,6 +689,11 @@ healthRouter.get('/models', async (req, res) => {
   // mintDisplayTicket refuses an empty key, because a ticket signed with '' can
   // never verify. Omit the field rather than publish a dead capability.
   const apiToken = process.env.COS_API_TOKEN ?? ''
+  // Final review S8 (Q1 and the lead, 2026-11-10 02:20): only a caller the API token let in (the glasses, the phone app,
+  // COS Control) gets a display-stream ticket. A browser signed in by cookie never does: Control Web never uses one, and
+  // a ticket's socket is authorized once at connect, so it would outlive "Sign out every browser". Fails closed: a
+  // request the gate did not mark as the token door gets none.
+  const ticketCaller = res.locals?.[API_AUTH_BY_LOCAL] === 'token'
   res.json({
     ...catalog,
     ...threadAttachHealthFields(threadAttach),
@@ -751,7 +761,7 @@ healthRouter.get('/models', async (req, res) => {
     // 6.8.441 lens fifteen minutes into a meeting. The TTL therefore bounds how
     // long a LEAKED URL can open a new socket, not how long an open socket lives.
     // Changing that is a breaking change that needs a client version gate first.
-    ...(apiToken ? { displayStreamTicket: mintDisplayTicket(apiToken) } : {}),
+    ...(apiToken && ticketCaller ? { displayStreamTicket: mintDisplayTicket(apiToken) } : {}),
     capabilities: {
       meetingAsk: { ...meetingAskCapabilities(), webRetrieval: meetingWebCapability().available },
       // 6.91.0: learnedStyle ("Your style", enabled = the server switch) and polishOptions ("Previous polish").

package/server/routes/live-events.ts

@@ -15,6 +15,7 @@
 // SWITCH: COS_WEB_LIVE_EVENTS. Absent means on. `0` registers no route at all (404), which is also what a client
 // sees from a server older than 7.0.1, so both take the same polling path.
 
+import { streamSignInHolds } from '../lib/api-auth.js'
 import { Router, type Request, type Response } from 'express'
 import { readSwitch } from '../lib/env-switch.js'
 import {
@@ -323,7 +324,11 @@ export function liveEventsHandler(deps: LiveEventsRouterDeps): (req: Request, re
     // or its interval would outlive the stream (review N1).
     if (closed) return
 
-    heartbeat = setInterval(() => write(deps.hub.heartbeatFrame()), heartbeatMs)
+    // Final review S1: each heartbeat first asks whether the browser sign-in that opened the stream still verifies.
+    heartbeat = setInterval(() => {
+      if (!streamSignInHolds(res)) { teardown('signed_out'); return }
+      write(deps.hub.heartbeatFrame())
+    }, heartbeatMs)
     ;(heartbeat as { unref?: () => void }).unref?.()
   }
 }

package/server/routes/permission-broker.ts

@@ -50,6 +50,7 @@
 
 import express, { Router, type NextFunction, type Request, type Response } from 'express'
 import { timingSafeTokenEqual } from '../lib/token-auth.js'
+import { turnEndAskStats } from '../lib/session-hooks-runtime.js'
 import {
   ANSWERING_CLIENTS,
   CLIENT_LIVE_WINDOW_MS,
@@ -162,6 +163,8 @@ export interface SessionQuestionsRouterDeps {
    * rules: `isWebSessionAuthorized` in production). Absent: only the token opens the list, as before.
    */
   webSessionAuthorized?: (req: Request) => boolean
+  /** 7.0.18 (X1): the turn-end ask counters (lib/turn-end-ask.ts), null while COS_TURN_END_ASKS is off. Defaults to the runtime's. */
+  turnEndAskStats?: () => Record<string, number> | null
   /** Where a counted poll is recorded; `noteQuestionsPoll` in production. */
   notePoll?: (at: number, poll: QuestionsPollFacts) => void
   /** 6.99.26: where COS Control Web's presence is recorded; `noteWebPresence` in production. */
@@ -271,6 +274,12 @@ export function requestFromThisMac(
   return own.some(a => normalizeRemoteIp(String(a)).toLowerCase() === ip)
 }
 
+function turnEndAskCounters(deps: SessionQuestionsRouterDeps): { turnEndAsks?: Record<string, number> } {
+  let counters: Record<string, number> | null = null
+  try { counters = (deps.turnEndAskStats ?? turnEndAskStats)() } catch { counters = null }
+  return counters ? { turnEndAsks: counters } : {}
+}
+
 export function createSessionQuestionsRouter(deps: SessionQuestionsRouterDeps): Router {
   const router = Router()
   const notePoll = deps.notePoll ?? noteQuestionsPoll
@@ -325,6 +334,13 @@ export function createSessionQuestionsRouter(deps: SessionQuestionsRouterDeps):
       // forgotten (the server started then, or dropped it while it still waited). Missing from
       // `settled` and settled after it: the session moved past it.
       waitingAtMacForgottenBefore: new Date(deps.broker.waitingAtMacForgottenBeforeMs()).toISOString(),
+      // X1, additive and only while a full-hold switch is on: every question a live session waits on (held, at the
+      // Mac, or just answered), with its words while it waits, and what a web page must send with an answer right now.
+      // With both off the response is 7.0.13's, key for key.
+      ...(deps.broker.extendedQuestionsView() ? { waiting: deps.broker.waitingList(), webAnswer: deps.broker.webAnswerRules() } : {}),
+      // 7.0.18 (X1), additive and only while COS_TURN_END_ASKS is on: how many turn-end asks armed, were shown,
+      // were answered, were overtaken by a new turn, or aged out. Counts only, never words.
+      ...turnEndAskCounters(deps),
     })
   })
   router.post('/session-questions/:id/answer', (req: Request, res: Response) => {
@@ -337,5 +353,15 @@ export function createSessionQuestionsRouter(deps: SessionQuestionsRouterDeps):
     const result = deps.broker.answer(String(req.params.id ?? ''), req.body, by)
     res.status(result.status).json(result.body)
   })
+  // X1: the web door's confirm step for an approval (lib/permission-broker.ts `confirm`). The /api gate let the
+  // request in; the door is labelled exactly as for an answer, and only the web door gets a confirm id.
+  router.post('/session-questions/:id/confirm', (req: Request, res: Response) => {
+    res.set('Cache-Control', 'private, no-store')
+    let expected = ''
+    try { expected = deps.apiToken() } catch { expected = '' }
+    const by = timingSafeTokenEqual(req.headers['x-cos-token'], expected) ? 'app' : 'web'
+    const result = deps.broker.confirm(String(req.params.id ?? ''), req.body, by)
+    res.status(result.status).json(result.body)
+  })
   return router
 }

package/server/routes/query-jobs.ts

@@ -1,3 +1,4 @@
+import { streamSignInHolds } from '../lib/api-auth.js'
 import { Router, type Request, type Response } from 'express'
 import { durableQueryJobsEnabled, messagesSteerEnabled } from '../lib/query-job-feature.js'
 import { ACTIVE_QUERY_JOBS_LIST_MAX, ACTIVE_QUERY_JOBS_PROTOCOL } from '../lib/query-job-active.js'
@@ -429,6 +430,8 @@ export function createQueryJobsRouter(
       if (closed) return
 
       heartbeat = setInterval(() => {
+        // Final review S1: a stream opened by a browser sign-in ends once that sign-in no longer verifies.
+        if (!streamSignInHolds(res)) { finish(); return }
         if (!closed && !res.writableEnded) res.write(': keepalive\n\n')
       }, heartbeatMs)
       heartbeat.unref?.()

package/server/routes/sessions.ts

@@ -1,9 +1,7 @@
 // Session endpoints — recent list, full history, existence check, client-format messages, context breaks, end
 import { Router } from 'express'
-import { readFileSync } from 'fs'
-import { join } from 'path'
 import { getRecentSessions, getHistory, sessionExists, addContextBreak, endSession, getSessionRaw, getActiveSessions, resolveExchangePairModel, ensureArchiveMirrorForDay } from '../lib/conversation.js'
-import { buildSessionLogEntry, writeSessionLog } from '../lib/session-log.js'
+import { buildSessionLogEntry, lookupRangesFromHistory, readSessionLogRanges, writeSessionLogIfChanged } from '../lib/session-log.js'
 import { getArchiveDayMessages, listArchiveDateStrings } from '../lib/archive.js'
 import { recentMessagesLimit, selectRecentMessages } from '../lib/recent-messages.js'
 import { localDay } from '../lib/local-day.js'
@@ -135,7 +133,7 @@ sessionsRouter.get('/sessions/:id/messages', (req, res) => {
 // instead of waiting for the 2hr TTL expiry.
 // POST /api/sessions/lookup — batch resolve timestamps to session IDs
 // Used to retroactively stamp messages that predate the sessionId feature
-sessionsRouter.post('/sessions/lookup', (req, res) => {
+sessionsRouter.post('/sessions/lookup', async (req, res) => {
   const { timestamps } = req.body as { timestamps: number[] }
   if (!timestamps || !Array.isArray(timestamps)) {
     res.status(400).json({ error: 'timestamps[] required' })
@@ -143,7 +141,6 @@ sessionsRouter.post('/sessions/lookup', (req, res) => {
   }
 
   // Build time ranges from BOTH JSONL history AND live server sessions
-  const logPath = join(process.env.COS_SCRIPTS_DIR || '', '.glasses_sessions.jsonl')
   const sessionRanges: Array<{ sid: string; start: number; end: number }> = []
 
   // 1. Live server sessions (always current — no snapshot lag)
@@ -155,25 +152,17 @@ sessionsRouter.post('/sessions/lookup', (req, res) => {
     }
   }
 
-  // 2. JSONL history (ended sessions + snapshots)
+  // 2. JSONL history (ended sessions + snapshots). S1 (2026-11-09): streamed and incremental
+  // (session-log.ts readSessionLogRanges); the old readFileSync().toString() threw on the 1.94 GB
+  // ledger and the catch read that as "no file". The range rule is the old one, unchanged: a
+  // session's end is widened by later lines only when it is NOT in memory (lookupRangesFromHistory).
   try {
-    const lines = readFileSync(logPath, 'utf-8').trim().split('\n')
-    for (const line of lines) {
-      const d = JSON.parse(line)
-      if (d.session_id && d.created_at) {
-        const start = new Date(d.created_at).getTime()
-        const end = d.ended_at ? new Date(d.ended_at).getTime() : start + 7200_000
-        // Live sessions take priority. For JSONL, keep the widest (latest) time range per session.
-        const existing = sessionRanges.find(s => s.sid === d.session_id)
-        if (!existing) {
-          sessionRanges.push({ sid: d.session_id, start, end })
-        } else if (end > existing.end && !getSessionRaw(d.session_id)) {
-          // Widen the JSONL range (but don't overwrite live sessions which extend to NOW)
-          existing.end = end
-        }
-      }
-    }
-  } catch { /* no log file */ }
+    const live = new Set(sessionRanges.map(s => s.sid))
+    const history = await readSessionLogRanges()
+    sessionRanges.push(...lookupRangesFromHistory(history, sid => Boolean(getSessionRaw(sid)), live))
+  } catch (err) {
+    console.warn('[sessions] lookup could not read the session ledger:', err instanceof Error ? err.message : err)
+  }
 
   // Match each timestamp to a session (live sessions checked first, then JSONL)
   const results: Record<number, string | null> = {}
@@ -242,7 +231,9 @@ sessionsRouter.post('/sessions/:id/snapshot', (req, res) => {
     slug: `[LIVE] ${(session.exchanges.find(e => e.role === 'user')?.content ?? '').slice(0, 50)}`,
   })
 
-  const logged = writeSessionLog(entry)
+  // Logged means the ledger holds this content: written now, or already there.
+  const result = writeSessionLogIfChanged(entry, 'snapshot')
+  const logged = result === 'written' || result === 'unchanged'
   res.json({
     ok: true,
     logged,

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

@@ -38,11 +38,11 @@ import { defaultTurnAttachmentStore, keepTurnAttachments, parseTurnAttachmentIds
  * the attachment digest its origin is sealed to. Files whose content cannot be read leave the turn
  * unvouched (it still parks); no files is the empty digest and reads nothing.
  */
-async function sealFiles(ids: readonly string[] | undefined, verdict: OriginVerdict, store: TurnAttachmentStore | undefined): Promise<{ verdict: OriginVerdict; attachments: string }> {
-  if (!Array.isArray(ids) || ids.length === 0) return { verdict, attachments: '' }
+async function sealFiles(ids: readonly string[] | undefined, verdict: OriginVerdict, store: TurnAttachmentStore | undefined): Promise<{ verdict: OriginVerdict; attachments: string; manifest: ReadonlyArray<{ id: string; sha256: string }> | null }> {
+  if (!Array.isArray(ids) || ids.length === 0) return { verdict, attachments: '', manifest: [] }
   const manifest = await turnAttachmentManifest(ids, store)
-  if (!manifest.ok) return { verdict: unvouched(verdict, 'attachments_unsealable'), attachments: '' }
-  return { verdict, attachments: attachmentsDigest(manifest.manifest) }
+  if (!manifest.ok) return { verdict: unvouched(verdict, 'attachments_unsealable'), attachments: '', manifest: null }
+  return { verdict, attachments: attachmentsDigest(manifest.manifest), manifest: manifest.manifest }
 }
 
 export interface ThreadTurnQueueDeps {
@@ -879,7 +879,9 @@ export function createThreadTurnQueueRouter(deps: ThreadTurnQueueDeps): Router {
     // with its content hash), so the drain can carry it (QUEUED_ORIGIN_TTL_MS at most).
     if (deps.provenance && verdict) {
       const sealed = await sealFiles(attach.ids, verdict, deps.turnAttachmentStore)
-      verdict = sealed.verdict
+      // 6.99.31: a signed web turn is judged here, once parking is decided, against this provider and
+      // thread (where it will drain), these exact words and these files. No envelope: unchanged.
+      verdict = deps.provenance.acceptWebKey(sealed.verdict, { provider, sessionId: threadId, turnId: clientTurnId, words: prompt, attachments: sealed.manifest })
       deps.provenance.noteQueued(provider, threadId, clientTurnId, prompt, verdict, sealed.attachments)
     }
 
@@ -990,8 +992,11 @@ export function createThreadTurnQueueRouter(deps: ThreadTurnQueueDeps): Router {
     if (deps.provenance && resendVerdict) {
       // After the write: the read-modify-write above stays one synchronous step. Sealed to the copy's files.
       const sealed = await sealFiles(copy.attachmentIds, resendVerdict, deps.turnAttachmentStore)
-      deps.provenance.noteQueued(provider, threadId, newId, copy.prompt, sealed.verdict, sealed.attachments)
-      deps.provenance.record({ turnId: newId, prompt: copy.prompt, verdict: sealed.verdict, provider, sessionId: threadId, via: 'queue-resend', resendOf: original.clientTurnId })
+      // 6.99.31: Send again from the phone needs a fresh signature over the copy (its new id, the words,
+      // the files); without one the copy stays unvouched ('resend_not_reverified').
+      const copyVerdict = deps.provenance.acceptWebKey(sealed.verdict, { provider, sessionId: threadId, turnId: newId, words: copy.prompt, attachments: sealed.manifest })
+      deps.provenance.noteQueued(provider, threadId, newId, copy.prompt, copyVerdict, sealed.attachments)
+      deps.provenance.record({ turnId: newId, prompt: copy.prompt, verdict: copyVerdict, provider, sessionId: threadId, via: 'queue-resend', resendOf: original.clientTurnId })
     }
     console.log(`[thread-turn-queue] resend provider=${provider} from=${original.clientTurnId} as=${newId} unknown=${original.deliveryState === 'unknown'}`)
     return res.status(200).json(publicRow(copy, queuePosition(admitted.queue, newId)))
@@ -1061,9 +1066,11 @@ export function createThreadTurnQueueRouter(deps: ThreadTurnQueueDeps): Router {
     if (deps.provenance && verdict) {
       // Sealed to the row's files as they are now (an edit changes only the words).
       const sealed = await sealFiles(row.attachmentIds, verdict, deps.turnAttachmentStore)
-      deps.provenance.noteQueued(provider, threadId, id, prompt, sealed.verdict, sealed.attachments)
+      // 6.99.31: an edit needs a fresh signature over the new words (same id, same files), or it is unvouched.
+      const editVerdict = deps.provenance.acceptWebKey(sealed.verdict, { provider, sessionId: threadId, turnId: id, words: prompt, attachments: sealed.manifest })
+      deps.provenance.noteQueued(provider, threadId, id, prompt, editVerdict, sealed.attachments)
       // The queue's own row, re-judged: it continues the record parked under this id.
-      deps.provenance.record({ turnId: id, prompt, verdict: sealed.verdict, provider, sessionId: threadId, via: 'queue-edit', continues: true })
+      deps.provenance.record({ turnId: id, prompt, verdict: editVerdict, provider, sessionId: threadId, via: 'queue-edit', continues: true })
     }
     return res.json({ updated: true })
   })

package/server/routes/today-brief.ts

@@ -25,49 +25,87 @@ import { dataPath } from '../lib/data-dir.js'
 import { runClaudeText } from '../lib/claude-text-runner.js'
 import { logTokenAudit } from '../lib/token-audit.js'
 import type { TaskBoardRow } from '../lib/task-store.js'
-import { agentSessionRoots, findAgentSessionFile } from '../lib/agent-session-store.js'
+import type { TaskDateFields } from '../lib/task-dates.js'
+import { agentSessionRoots, codexSessionRootsOf, findAgentSessionFile, listCodexJsonlFiles, loadClaudeDesktopAliases, loadClaudeTranscriptIndex, type AgentProvider } from '../lib/agent-session-store.js'
 import { readClaudeSubagents, summarize, type SessionSubagents } from '../lib/session-subagents.js'
 import { readCodexSubagentDetails } from '../lib/codex-subagent-activity.js'
+import { readRecentActivity, type RecentActivity } from '../lib/agent-session-recent.js'
 import { acquireMaintenanceWork, maintenanceAdmissionsOpen } from '../lib/maintenance-lifecycle.js'
 import { isRecordingLive } from '../lib/stt-runtime.js'
 import {
   TODAY_BRIEF_BODY_MAX_BYTES, TODAY_BRIEF_EFFORT, TODAY_BRIEF_SETTINGS_FILE, TODAY_BRIEF_STATE_FILE, TODAY_BRIEF_TIMEOUT_MS,
-  TodayBriefInputError, createTodayBrief, normalizeTodayBriefInputs, subagentLookups, todayBriefFingerprint, withSubagents, type BriefWork, type SubagentReading, type TodayBrief,
+  TodayBriefInputError, createTodayBrief, normalizeTodayBriefInputs, sessionContextLookups, todayBriefFingerprint, withCalendar, withRecentActivity, withSubagents, type BriefWork, type CalendarReading, type SubagentReading, type TodayBrief,
 } from '../lib/today-brief.js'
 
 export interface TodayBriefRouterDeps {
   brief: TodayBrief
-  /** The Work board as the server already reads it (a shared, bounded read), or null when it cannot be read. */
-  board: () => Promise<TaskBoardRow[] | null>
-  /** Sub-agents for up to 8 sessions, by "provider|id". Missing keys mean "not read"; the page's counts stay. */
-  subagents?: (keys: string[]) => Promise<Map<string, SubagentReading>>
+  /** The Work board, dated when it can be (2026-11-09: listBoardWithDates, so a card's last move is known), or null
+   *  when it cannot be read. */
+  board: () => Promise<Array<TaskBoardRow & Partial<TaskDateFields>> | null>
+  /** Sub-agents and recent activity for up to 12 sessions, by "provider|id", written into `into` as each session is
+   *  read, so an ask that stops waiting keeps what was read by then. Missing keys mean "not read": the page's counts
+   *  and `line` stay, the line marked "may be old". */
+  context?: (keys: string[], into: SessionContext) => Promise<unknown>
+  /** Today round 2: today's calendar (lib/calendar-source.ts calendarToday). Read with the session reads, inside the
+   *  same wait; a failed, slow or unconnected read means no calendar in the prompt. */
+  calendar?: () => Promise<CalendarReading | null>
   now?: () => number
 }
 
-/** How long the sub-agent reads may hold the ask before it goes on without them. */
+/** How long the session reads may hold the ask before it goes on with what was read by then. */
 export const TODAY_BRIEF_SUBAGENT_WAIT_MS = 2_500
 
+/** What the server read per session: its sub-agents and its recent activity, by "provider|id". */
+export interface SessionContext { agents: Map<string, SubagentReading>; recent: Map<string, RecentActivity> }
+export const emptySessionContext = (): SessionContext => ({ agents: new Map(), recent: new Map() })
+
 /**
- * The server's own sub-agent reads: Claude from the session's transcript tail (lib/session-subagents.ts), Codex from
- * the spawn-edge snapshot (readCodexSubagentDetails, server home only). Cursor has none. Sequential, bounded, read-only.
+ * 2026-11-09: readSubagentsFor became this. For each key, most important first: the sub-agents (Claude from the
+ * transcript tail, Codex from the spawn-edge snapshot) and the recent activity (lib/agent-session-recent.ts). Claude
+ * and Cursor read one after another; Codex reads in parallel with them, because a Codex rollout's first scan is the
+ * slow one (32 GB files) and must not starve the rest. Results land in `into` as they arrive. Read-only.
  */
-export async function readSubagentsFor(keys: string[], now = Date.now()): Promise<Map<string, SubagentReading>> {
-  const out = new Map<string, SubagentReading>()
+export async function readSessionContext(keys: string[], into: SessionContext = emptySessionContext(), now = Date.now()): Promise<SessionContext> {
   const roots = agentSessionRoots()
-  const codex = keys.filter(k => k.startsWith('codex|')).map(k => k.slice(6))
-  for (const key of keys.filter(k => k.startsWith('claude|'))) {
-    const file = await findAgentSessionFile('claude', key.slice(7), roots).catch(() => null)
-    const read: SessionSubagents | null = file ? await readClaudeSubagents(file) : null
-    if (read && read.total) out.set(key, read)
-  }
-  if (codex.length) {
-    const details = await readCodexSubagentDetails(codex, roots.codexSessions, now)
+  const split = (k: string) => { const i = k.indexOf('|'); return { provider: k.slice(0, i) as AgentProvider, id: k.slice(i + 1) } }
+  const codexKeys = keys.filter(k => k.startsWith('codex|'))
+  const localKeys = keys.filter(k => k.startsWith('claude|') || k.startsWith('cursor|'))
+  const local = (async () => {
+    // One index for every Claude id in this ask, not one per call.
+    const claudeFiles = localKeys.some(k => k.startsWith('claude|')) ? await loadClaudeTranscriptIndex(roots).catch(() => undefined) : undefined
+    const aliases = claudeFiles ? await loadClaudeDesktopAliases(roots.claudeCodeSessions).catch(() => undefined) : undefined
+    for (const key of localKeys) {
+      const { provider, id } = split(key)
+      const file = await findAgentSessionFile(provider, id, roots, new Date(now), aliases, claudeFiles ? { claudeFiles } : undefined).catch(() => null)
+      if (!file) continue
+      if (provider === 'claude') {
+        const read: SessionSubagents | null = await readClaudeSubagents(file)
+        if (read && read.total) into.agents.set(key, read)
+      }
+      const recent = await readRecentActivity(provider, file, now)
+      if (recent) into.recent.set(key, recent)
+    }
+  })()
+  const codex = (async () => {
+    if (!codexKeys.length) return
+    const ids = codexKeys.map(k => k.slice(6))
+    const details = await readCodexSubagentDetails(ids, roots.codexSessions, now).catch(() => new Map())
     for (const [id, list] of details) {
-      const rows = list.map(d => ({ name: d.name, task: d.task, status: d.state === 'active' ? 'running' as const : d.state === 'completed' ? 'done' as const : 'unknown' as const, at: d.at }))
-      if (rows.length) out.set('codex|' + id, summarize(rows, false))
+      const rows = (list as Array<{ name: string; task: string; state: string; at: number }>).map(d => ({ name: d.name, task: d.task, status: d.state === 'active' ? 'running' as const : d.state === 'completed' ? 'done' as const : 'unknown' as const, at: d.at }))
+      // Every row, not six: the brief keeps the live and recent ones and counts the rest as history.
+      if (rows.length) into.agents.set('codex|' + id, summarize(rows, false, rows.length))
     }
-  }
-  return out
+    const lists = await Promise.all(codexSessionRootsOf(roots).map(root => listCodexJsonlFiles(root).catch(() => [] as string[])))
+    const codexFiles = lists.flat()
+    for (const key of codexKeys) {
+      const file = await findAgentSessionFile('codex', key.slice(6), roots, new Date(now), undefined, { codexFiles }).catch(() => null)
+      if (!file) continue
+      const recent = await readRecentActivity('codex', file, now)
+      if (recent) into.recent.set(key, recent)
+    }
+  })()
+  await Promise.all([local, codex])
+  return into
 }
 
 /** The server's own brief: the data folder, Sonnet (7.0.1) through the isolated text runner, one audit row per start. */
@@ -90,8 +128,12 @@ export function defaultTodayBrief(): TodayBrief {
 }
 
 const IN_PROGRESS = new Set(['draft', 'built', 'qa'])
-/** Work cards in progress, by title and stage: open, not delegated, drafting to QA, or with an agent on it. */
-export function workInProgress(rows: TaskBoardRow[] | null): BriefWork[] {
+/**
+ * Work cards in progress, by title and stage: open, not delegated, drafting to QA, or with an agent on it. 2026-11-09:
+ * with when each last moved (the dated board read: the line's git change time, else the day it was created; null when
+ * neither is known), running first, then the most recently moved, so the twelve kept are the live ones.
+ */
+export function workInProgress(rows: Array<TaskBoardRow & Partial<TaskDateFields>> | null, now = Date.now()): BriefWork[] {
   if (!rows) return []
   const out: BriefWork[] = []
   for (const row of rows) {
@@ -99,9 +141,11 @@ export function workInProgress(rows: TaskBoardRow[] | null): BriefWork[] {
     const stage = row.workStage ?? (row.stage === 'active' ? 'draft' : row.stage === 'review' ? 'qa' : 'planned')
     const running = row.agentState === 'running'
     if (!IN_PROGRESS.has(stage) && !running) continue
-    out.push({ title: row.title || row.text || '', stage, running })
+    const at = Date.parse(row.lineChangedAt ?? '') || Date.parse(row.createdOn ?? '') || 0
+    out.push({ title: row.title || row.text || '', stage, running, movedMinutes: at > 0 ? Math.max(0, Math.round((now - at) / 60000)) : null })
   }
-  return out.sort((a, b) => Number(b.running) - Number(a.running)).slice(0, 12)
+  const age = (w: BriefWork) => (w.movedMinutes == null ? Number.MAX_SAFE_INTEGER : w.movedMinutes)
+  return out.sort((a, b) => Number(b.running) - Number(a.running) || age(a) - age(b)).slice(0, 12)
 }
 
 /**
@@ -142,15 +186,26 @@ export function createTodayBriefRouter(deps: TodayBriefRouterDeps): Router {
       const pageInputs = normalizeTodayBriefInputs(body)
       const closed = deps.brief.gate({ force, reconnect })
       if (closed) return res.json(deps.brief.askGated(pageInputs, closed))
-      const work = workInProgress(await deps.board().catch(() => null))
-      let inputs = normalizeTodayBriefInputs(body, work)
-      const keys = subagentLookups(inputs)
-      if (keys.length && deps.subagents) {
-        let timer: ReturnType<typeof setTimeout> | undefined
-        const late = new Promise<Map<string, SubagentReading>>(resolve => { timer = setTimeout(() => resolve(new Map()), TODAY_BRIEF_SUBAGENT_WAIT_MS) })
-        const readings = await Promise.race([deps.subagents(keys).catch(() => new Map<string, SubagentReading>()), late]).finally(() => clearTimeout(timer))
-        inputs = withSubagents(inputs, readings, (deps.now ?? Date.now)())
-      }
+      const now = (deps.now ?? Date.now)()
+      // The board and the session reads run together; the reads stop being waited for after 2.5 s and the ask goes on
+      // with whatever they wrote by then (a Codex first scan that runs on still fills its memo for the next ask).
+      const keys = sessionContextLookups(normalizeTodayBriefInputs(body))
+      const context = emptySessionContext()
+      // Today round 2: the calendar reads alongside the sessions, inside the same wait; whatever has not answered by
+      // then is left out (a slow bridge never holds the ask).
+      const cal: { value: CalendarReading | null } = { value: null }
+      const work: Array<Promise<unknown>> = []
+      if (keys.length && deps.context) work.push(Promise.resolve().then(() => deps.context!(keys, context)).catch(() => undefined))
+      if (deps.calendar) work.push(Promise.resolve().then(() => deps.calendar!()).then(c => { cal.value = c }, () => undefined))
+      let timer: ReturnType<typeof setTimeout> | undefined
+      const reads = work.length
+        ? Promise.race([Promise.all(work), new Promise<void>(resolve => { timer = setTimeout(resolve, TODAY_BRIEF_SUBAGENT_WAIT_MS) })]).finally(() => clearTimeout(timer))
+        : Promise.resolve()
+      const [rows] = await Promise.all([deps.board().catch(() => null), reads])
+      // A snapshot: a read still running after the wait cannot change the inputs under the call.
+      const agents = new Map(context.agents), recent = new Map(context.recent), calendar = cal.value
+      let inputs = normalizeTodayBriefInputs(body, workInProgress(rows, now))
+      inputs = withCalendar(withRecentActivity(withSubagents(inputs, agents, now), recent, now), calendar, now)
       res.json(await deps.brief.ask(inputs, todayBriefFingerprint(pageInputs), { force, reconnect }))
     } catch (error) {
       if (error instanceof TodayBriefInputError) return res.status(400).json({ error: { code: error.code, message: 'That is not a Today summary request.' } })