@gotcos/glasses-server 7.0.7 → 7.0.27

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/agent-sessions.ts

@@ -91,6 +91,35 @@ import { resetPreviewLogThrottle, warnPreviewThrottled } from '../lib/preview-lo
 import { sessionFilesSetting, withoutPreviews } from '../lib/session-files-setting.js'
 import { withoutLinkMarkers } from '../lib/session-links.js'
 import { createSessionPreviewRouter } from './session-preview.js'
+import { organizerKey, sessionOrganizer, type OrganizerRowFields } from '../lib/session-organizer.js'
+import { listOlderSessions, shortRowFor, OLDER_DEFAULT_DAYS, OLDER_DEFAULT_LIMIT, OLDER_MAX_DAYS, OLDER_MAX_LIMIT, OLDER_MIN_DAYS } from '../lib/agent-session-older.js'
+import { cachedListModel, warmListModels } from '../lib/list-model-memo.js'
+import { cosStartedSessionIds } from '../lib/cos-started-sessions.js'
+
+/** Step 2a: the organizer, or null when it is unavailable or empty (the list is then exactly today's). */
+function organizerForList(): ReturnType<typeof sessionOrganizer> | null {
+  try {
+    const o = sessionOrganizer()
+    return o.isAvailable() && !o.isEmpty() ? o : null
+  } catch {
+    return null
+  }
+}
+/** Claude Desktop ids per CLI id, from the request's alias table (an entry written under a Desktop id still matches). */
+function desktopIdsByCli(aliases: ClaudeAliasMap | undefined): Map<string, string[]> {
+  const out = new Map<string, string[]>()
+  for (const [desktopId, head] of aliases ?? new Map()) {
+    const cli = head?.cliSessionId
+    if (!cli || cli.startsWith('!')) continue
+    out.set(cli, [...(out.get(cli) ?? []), desktopId])
+  }
+  return out
+}
+function organizerFieldsOf(o: ReturnType<typeof sessionOrganizer> | null, provider: string, sessionId: string, desktopIds?: Map<string, string[]>): OrganizerRowFields {
+  if (!o) return {}
+  const id = sessionId.toLowerCase()
+  return o.fieldsForAny([organizerKey(provider, id)], provider === 'claude' ? desktopIds?.get(id) ?? [] : [])
+}
 
 export const agentSessionsRouter = Router()
 // Preview engine phase 1: GET /api/preview/agent-sessions/... and /api/preview-folders/settings (routes/session-preview.ts).
@@ -511,7 +540,17 @@ agentSessionsRouter.get('/agent-sessions', async (req, res) => {
     const peers = await liveClaudePeerRecords()
     const live = liveClaudeRows(peers)
     const dropped = emptySessionListDropped()
-    const sessions = await listAgentSessions(roots, new Date(), live, limit, sort, dropped, aliases)
+    // Step 2a: COS pins and folder members are listed at any age, outside the cap and `limit`.
+    const organizer = organizerForList()
+    const desktopIds = organizer ? desktopIdsByCli(aliases) : undefined
+    // 7.0.25 (lead 2026-11-11 10:29): kept rows only for a client that ASKS (`kept=1`, Control Web). The public lens
+    // (6.11.681) and Control Mac (0.5.389) do not clamp to their own limit, so a server-only update would have added
+    // up to KEPT_LIST_MAX rows to their lists unasked. Without the parameter the walk gets no keep set at all: exactly
+    // the 7.0.18 selection (same rows, same limit). The organizer fields on rows stay (additive, ignored by them).
+    const wantsKept = req.query.kept === '1'
+    // Miles, 2026-11-10: sessions a COS job started in the last 7 days stay listed (memoized journal read).
+    const started = wantsKept ? await cosStartedSessionIds() : {}
+    const sessions = await listAgentSessions(roots, new Date(), live, limit, sort, dropped, aliases, wantsKept && organizer ? organizer.keptIds() : {}, started)
     // 6.45.5: each row's last real activity, read from its transcript records. Memoized on
     // mtime and size, so a steady poll re-reads nothing; bounded so a cold list of 80 rows
     // never holds 80 descriptors at once.
@@ -583,8 +622,12 @@ agentSessionsRouter.get('/agent-sessions', async (req, res) => {
         const signal = signalFor(row.session_id)
         const facts = rolloutById.get(row.session_id) ?? null
         const hint = runningHintFor(row.provider, derived, hintClock(signal, derived, facts), now, clocks.get(row.session_id) ?? null)
+        // Step 2a: the model only from the memo (never a read on the list path, 6.62.0 W11).
+        const model = cachedListModel(row.provider, row.file, Number.isFinite(Date.parse(row.modified)) ? Date.parse(row.modified) : null)
         return {
           ...withRunning(toEntry(row, activity[index], derived, queuedOf(row.provider, row.session_id)), running, hint),
+          ...organizerFieldsOf(organizer, row.provider, row.session_id, desktopIds),
+          ...(model ? { reported_model: model } : {}),
           ...cursorActivityFields(row.provider, signal),
           ...(row.provider === 'codex'
             ? { ...(subagents.has(row.session_id) ? { subagent_activity: subagents.get(row.session_id) } : {}), ...codexCompactionFields(workObservationFor(row.session_id), facts, now) }
@@ -602,13 +645,57 @@ agentSessionsRouter.get('/agent-sessions', async (req, res) => {
       // client ignores this key. Zero means the walk found nothing to hide, not
       // that the caps are off.
       dropped,
+      ...(organizer ? { organizer: { rev: organizer.rev() } } : {}),
     }))
+    // Step 2a: read the models this answer lacked, in the background, for a later poll. Never awaited.
+    warmListModels(sessions)
   } catch (error) {
     console.error(`[agent-sessions] list failed: ${error instanceof Error ? error.message : error}`)
     res.status(500).json({ error: 'Failed to read agent sessions', reason: 'agent_sessions_read_failed' })
   }
 })
 
+// Step 2a (S1_CONTRACT_step2a.md B2): the last `days` days in a short form, paged, for the compact groups. Not on the
+// list poll: fetched when the list opens and as a group unfolds. Live rows, COS-kept rows and each agent's own pins are
+// left out (the main list has them in full); a row may still also be in the main list, and the client keeps that one.
+agentSessionsRouter.get('/agent-sessions/older', async (req, res) => {
+  res.set('Cache-Control', 'private, no-store')
+  try {
+    const days = boundedInteger(req.query.days, OLDER_DEFAULT_DAYS, OLDER_MIN_DAYS, OLDER_MAX_DAYS)
+    const limit = boundedInteger(req.query.limit, OLDER_DEFAULT_LIMIT, 1, OLDER_MAX_LIMIT)
+    const beforeRaw = typeof req.query.before === 'string' ? Date.parse(req.query.before) : NaN
+    if (typeof req.query.before === 'string' && !Number.isFinite(beforeRaw)) {
+      res.status(400).json({ error: 'before must be an ISO time', reason: 'invalid_before' })
+      return
+    }
+    const roots = agentSessionRoots()
+    const aliases = await loadClaudeDesktopAliases(roots.claudeCodeSessions)
+    const organizer = organizerForList()
+    const kept = organizer ? organizer.keptIds() : { claude: new Set<string>(), codex: new Set<string>(), cursor: new Set<string>() }
+    const started = await cosStartedSessionIds()
+    for (const provider of ['claude', 'codex', 'cursor'] as const) for (const id of started[provider]) kept[provider].add(id)
+    // Kept Claude ids may be Desktop ids; the walk names transcripts by CLI id.
+    for (const id of [...kept.claude]) { const cli = aliases.get(id)?.cliSessionId; if (cli && !cli.startsWith('!')) kept.claude.add(cli) }
+    const liveIds = new Set(liveClaudeRows(await liveClaudePeerRecords()).map(row => row.session_id.toLowerCase()))
+    const result = await listOlderSessions(roots, new Date(), {
+      days, limit, aliases,
+      ...(Number.isFinite(beforeRaw) ? { before: beforeRaw } : {}),
+      // Kept rows come back here at any age: the main list holds at most KEPT_LIST_MAX of them (Q1 FIX 1).
+      exclude: { claude: liveIds },
+      keep: kept,
+    })
+    res.json(redactLocalPathsDeep({
+      sessions: result.rows.map(row => ({ ...row, ...organizerFieldsOf(organizer, row.provider, row.session_id, desktopIdsByCli(aliases)) })),
+      windowDays: days,
+      next_before: result.nextBefore,
+      ...(Number.isFinite(beforeRaw) ? {} : { older_than_window: result.olderThanWindow }),
+    }))
+  } catch (error) {
+    console.error(`[agent-sessions] older list failed: ${error instanceof Error ? error.message : error}`)
+    res.status(500).json({ error: 'Failed to read older agent sessions', reason: 'agent_sessions_read_failed' })
+  }
+})
+
 agentSessionsRouter.get('/agent-sessions/search', async (req, res) => {
   res.set('Cache-Control', 'private, no-store')
   const query = typeof req.query.q === 'string' ? req.query.q.trim() : ''
@@ -619,6 +706,23 @@ agentSessionsRouter.get('/agent-sessions/search', async (req, res) => {
   try {
     const limit = boundedInteger(req.query.limit, 20, 1, 50)
     const result = await searchAgentSessions({ query, limit })
+    // Step 2a: a session renamed in COS is found by its new title too (the agent's own title still matches as before).
+    const organizer = organizerForList()
+    if (organizer) {
+      const seen = new Set(result.hits.map(hit => organizerKey(hit.provider, hit.session_id)))
+      const roots = agentSessionRoots()
+      const extra: AgentSessionSearchHit[] = []
+      for (const match of organizer.titleMatches(query)) {
+        if (seen.has(organizerKey(match.provider, match.session_id)) || extra.length + result.hits.length >= limit) continue
+        const file = await findAgentSessionFile(match.provider, match.session_id, roots).catch(() => null)
+        const short = file ? await shortRowFor(match.provider, file, undefined, roots) : null
+        if (!short) continue
+        extra.push({ session_id: short.session_id, provider: short.provider, display_label: short.display_label, project: short.project,
+          modified: short.modified, created: short.created, alive: false, state: 'recent', pinned: false,
+          snippet: '', keywordScore: 1, semanticScore: 0, match: 'keyword' })
+      }
+      result.hits = [...extra, ...result.hits]
+    }
     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.
@@ -644,7 +748,7 @@ agentSessionsRouter.get('/agent-sessions/search', async (req, res) => {
     // 7.0.4 S1: search hits carry snippets of the same words.
     res.json(redactLocalPathsDeep({
       ...result,
-      hits: result.hits.map(hit => toSearchHit(hit, queuedOf(hit.provider, hit.session_id), derivedFor(hit))),
+      hits: result.hits.map(hit => ({ ...toSearchHit(hit, queuedOf(hit.provider, hit.session_id), derivedFor(hit)), ...organizerFieldsOf(organizer, hit.provider, hit.session_id) })),
     }))
   } catch (error) {
     console.error(`[agent-sessions] search failed: ${error instanceof Error ? error.message : error}`)

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'
@@ -9,7 +10,9 @@ import { DICTATION_CLEAN_MODELS } from '../lib/dictation-clean-models.js'
 import { customInstructionsCapability, learnedStyleCapability, polishOptionsCapability } from './dictation-polish-settings.js'
 import { PAIRING_PROTOCOL_VERSION } from '../lib/glasses-pairing.js'
 import { taskBridgeAvailable } from '../lib/task-bridge.js'
+import { modelEfforts } from '../lib/model-efforts.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 +463,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 +690,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),
@@ -702,6 +713,8 @@ healthRouter.get('/models', async (req, res) => {
       ...cursorOptions,
       ...ollamaOptions,
     ],
+    // Step 2a (Sessions chat-style layout): each agent's efforts, the values POST /api/query-jobs accepts. Additive.
+    efforts: modelEfforts(),
     cursor: cursorCatalog,
     cursorReady: isCursorProviderReady(),
     ollama: {
@@ -751,7 +764,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/session-organizer.ts

@@ -0,0 +1,149 @@
+/**
+ * Session organizer routes (Sessions chat-style layout, step 2a; S1_CONTRACT_step2a.md, A1).
+ *
+ *   GET    /api/session-folders
+ *   POST   /api/session-folders                              { name }
+ *   PATCH  /api/session-folders/:id                          { name }
+ *   DELETE /api/session-folders/:id                          (its sessions leave it; no session is deleted)
+ *   PATCH  /api/agent-sessions/:provider/:sessionId/organizer { folder_id?, cos_pinned?, title? }
+ *
+ * Behind index.ts's /api gate (API token, or a browser cookie with `x-cos-web: 1` and a same-origin Origin).
+ * The session route canonicalizes the id from the transcript it finds, so a Claude Desktop id and its CLI id are
+ * one key, and a session the server cannot find is refused (404) instead of stored.
+ * Logs carry reason codes only: never a folder name or a title.
+ */
+import { Router, type Request, type Response } from 'express'
+import {
+  agentSessionRoots,
+  findAgentSessionFile,
+  idFromCodexFilename,
+  isSafeSessionId,
+  loadClaudeDesktopAliases,
+  normalizeClaudeSessionId,
+  type AgentProvider,
+  type AgentSessionRoots,
+} from '../lib/agent-session-store.js'
+import { OrganizerError, organizerKey, sessionOrganizer, type SessionOrganizer } from '../lib/session-organizer.js'
+
+const PROVIDERS: ReadonlySet<string> = new Set(['claude', 'codex', 'cursor'])
+
+export interface SessionOrganizerRouteDeps {
+  organizer: () => SessionOrganizer
+  roots: () => AgentSessionRoots
+  /** The canonical id of a session the server can find on disk, or null. */
+  canonicalId: (provider: AgentProvider, sessionId: string, roots: AgentSessionRoots) => Promise<SessionIdentity | null>
+}
+
+/** Where a session's organizer entry lives: its canonical id, and for Claude the Desktop id it was named by when one is
+ *  known. `null`: the server cannot find the session. Throws 409 alias_conflict while Claude Desktop's records disagree
+ *  about the session's CLI id (Q1 FIX 2): an entry written then could be orphaned when they settle. */
+export interface SessionIdentity { id: string; desktopId?: string }
+
+/** The id a found transcript names: Claude's CLI uuid (a Desktop id resolves to it), Codex's rollout id, Cursor's composer. */
+export async function canonicalSessionId(provider: AgentProvider, sessionId: string, roots: AgentSessionRoots): Promise<SessionIdentity | null> {
+  if (!isSafeSessionId(sessionId)) return null
+  if (provider === 'claude') {
+    // A Desktop id may arrive as `local_<uuid>`; the alias table and transcripts use the bare uuid.
+    sessionId = normalizeClaudeSessionId(sessionId)
+    const aliases = await loadClaudeDesktopAliases(roots.claudeCodeSessions)
+    if (aliases.has(sessionId) && aliases.get(sessionId) === null) throw new OrganizerError(409, 'alias_conflict')
+    const head = aliases.get(sessionId)
+    const file = await findAgentSessionFile('claude', sessionId, roots, new Date(), aliases)
+    if (file) {
+      const id = (file.split('/').pop() || '').replace(/\.jsonl$/, '').toLowerCase()
+      if (!id) return null
+      // The Desktop id: the one asked for when it is an alias, else the single Desktop record that names this CLI id.
+      let desktopId: string | undefined = head ? sessionId : undefined
+      if (!desktopId) {
+        const named = [...aliases].filter(([, h]) => h?.cliSessionId === id).map(([d]) => d)
+        if (named.length === 1) desktopId = named[0]
+      }
+      return { id, ...(desktopId && desktopId !== id ? { desktopId } : {}) }
+    }
+    // A Desktop-only session (no CLI transcript yet): keyed by its Desktop id, which the list also shows.
+    if (head) return { id: sessionId, desktopId: sessionId }
+    return null
+  }
+  const file = await findAgentSessionFile(provider, sessionId, roots)
+  if (!file) return null
+  const parts = file.split('/')
+  const id = provider === 'codex'
+    ? idFromCodexFilename(parts[parts.length - 1] || '')
+    : (parts[parts.length - 2] || '').toLowerCase() || null
+  return id ? { id } : null
+}
+
+function fail(res: Response, error: unknown): void {
+  if (error instanceof OrganizerError) {
+    res.status(error.status).json({ error: error.reason, reason: error.reason })
+    return
+  }
+  console.error(`[session-organizer] write failed (reason=${(error as NodeJS.ErrnoException)?.code ?? 'error'})`)
+  res.status(500).json({ error: 'organizer_write_failed', reason: 'organizer_write_failed' })
+}
+
+export function createSessionOrganizerRouter(deps: SessionOrganizerRouteDeps = {
+  organizer: sessionOrganizer,
+  roots: () => agentSessionRoots(),
+  canonicalId: canonicalSessionId,
+}): Router {
+  const router = Router()
+  const noStore = (res: Response) => res.set('Cache-Control', 'private, no-store')
+
+  router.get('/session-folders', (_req: Request, res: Response) => {
+    noStore(res)
+    const o = deps.organizer()
+    if (!o.isAvailable()) return void res.status(503).json({ error: 'organizer_unavailable', reason: 'organizer_unavailable' })
+    res.json({ rev: o.rev(), folders: o.listFolders() })
+  })
+
+  router.post('/session-folders', (req: Request, res: Response) => {
+    noStore(res)
+    try {
+      const o = deps.organizer()
+      const folder = o.createFolder((req.body as { name?: unknown } | undefined)?.name)
+      res.status(201).json({ rev: o.rev(), folder })
+    } catch (error) { fail(res, error) }
+  })
+
+  router.patch('/session-folders/:id', (req: Request, res: Response) => {
+    noStore(res)
+    try {
+      const o = deps.organizer()
+      const folder = o.renameFolder(String(req.params.id), (req.body as { name?: unknown } | undefined)?.name)
+      res.json({ rev: o.rev(), folder })
+    } catch (error) { fail(res, error) }
+  })
+
+  router.delete('/session-folders/:id', (req: Request, res: Response) => {
+    noStore(res)
+    try {
+      const o = deps.organizer()
+      const released = o.deleteFolder(String(req.params.id))
+      res.json({ rev: o.rev(), released })
+    } catch (error) { fail(res, error) }
+  })
+
+  router.patch('/agent-sessions/:provider/:sessionId/organizer', async (req: Request, res: Response) => {
+    noStore(res)
+    const provider = String(req.params.provider)
+    if (!PROVIDERS.has(provider)) return void res.status(400).json({ error: 'invalid_provider', reason: 'invalid_provider' })
+    // A Claude Desktop id arrives as `local_<uuid>`; the bare uuid is the id everywhere else.
+    const sessionId = provider === 'claude' ? normalizeClaudeSessionId(String(req.params.sessionId)) : String(req.params.sessionId)
+    if (!isSafeSessionId(sessionId)) return void res.status(400).json({ error: 'invalid_session_id', reason: 'invalid_session_id' })
+    const body = req.body && typeof req.body === 'object' && !Array.isArray(req.body) ? req.body as Record<string, unknown> : {}
+    const change: { folder_id?: unknown; cos_pinned?: unknown; title?: unknown } = {}
+    for (const key of ['folder_id', 'cos_pinned', 'title'] as const) if (Object.prototype.hasOwnProperty.call(body, key)) change[key] = body[key]
+    try {
+      const o = deps.organizer()
+      if (!o.isAvailable()) throw new OrganizerError(503, 'organizer_unavailable')
+      if (Object.keys(change).length === 0) throw new OrganizerError(400, 'empty_change')
+      const identity = await deps.canonicalId(provider as AgentProvider, sessionId, deps.roots())
+      if (!identity) throw new OrganizerError(404, 'session_not_found')
+      const fields = o.updateSession(organizerKey(provider, identity.id), change, { desktopId: identity.desktopId })
+      res.json({ rev: o.rev(), session: { provider, session_id: identity.id, ...fields } })
+    } catch (error) { fail(res, error) }
+  })
+
+  return router
+}