@gotcos/glasses-server 6.99.33 → 7.0.18

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

@@ -24,6 +24,7 @@ import { homedir } from 'node:os'
 import { dirname, join, resolve } from 'node:path'
 import { fileURLToPath } from 'node:url'
 import { atomicWriteFileSync } from './atomic-fs.js'
+import { FULL_HOLD_HOOK_WAIT_S, NON_QUESTION_MATCHER, QUESTION_MATCHER, fullHoldSwitches } from './full-hold.js'
 
 const __dirname = dirname(fileURLToPath(import.meta.url))
 
@@ -187,6 +188,93 @@ function priorWaitBlock(scriptPath: string, sub: HookSubscription, paths: HookPa
   return canonicalBlock(scriptPath, { event: sub.event, async: sub.async, timeout: LEGACY_PERMISSION_HOOK_TIMEOUT_S }, paths)
 }
 
+/**
+ * X1 (2026-11-09): how the PermissionRequest hook is written. With `COS_QUESTION_FULL_HOLD` and
+ * `COS_APPROVAL_FULL_HOLD` both off (the default) it is the ONE block every release since 6.60.0
+ * writes, byte for byte (`split: false`). With either on it is TWO blocks of ours, split by matcher
+ * (canary C9, both engines): `AskUserQuestion` waits `questionWaitS`, everything else `otherWaitS`;
+ * a kind whose switch is on waits FULL_HOLD_HOOK_WAIT_S, the other keeps 630. Each block passes its
+ * own wait to the script, so the stamp a request carries is its own block's. Reinstall hooks is what
+ * writes it: until then the file reads `drift` (`priorWaitOnly`, still halt-ready).
+ */
+export interface PermissionHookPlan { split: boolean; questionWaitS: number; otherWaitS: number }
+
+export function permissionHookPlan(env: NodeJS.ProcessEnv = process.env): PermissionHookPlan {
+  const on = fullHoldSwitches(env)
+  if (!on.questions && !on.approvals) return { split: false, questionWaitS: PERMISSION_HOOK_TIMEOUT_S, otherWaitS: PERMISSION_HOOK_TIMEOUT_S }
+  return {
+    split: true,
+    questionWaitS: on.questions ? FULL_HOLD_HOOK_WAIT_S : PERMISSION_HOOK_TIMEOUT_S,
+    otherWaitS: on.approvals ? FULL_HOLD_HOOK_WAIT_S : PERMISSION_HOOK_TIMEOUT_S,
+  }
+}
+
+const UNSPLIT_PLAN: PermissionHookPlan = { split: false, questionWaitS: PERMISSION_HOOK_TIMEOUT_S, otherWaitS: PERMISSION_HOOK_TIMEOUT_S }
+
+/** The two blocks of a split PermissionRequest, question block first. */
+function splitPermissionBlocks(scriptPath: string, sub: HookSubscription, paths: HookPaths, questionWaitS: number, otherWaitS: number): Record<string, unknown>[] {
+  return [
+    canonicalBlock(scriptPath, { ...sub, matcher: QUESTION_MATCHER, timeout: questionWaitS }, paths),
+    canonicalBlock(scriptPath, { ...sub, matcher: NON_QUESTION_MATCHER, timeout: otherWaitS }, paths),
+  ]
+}
+
+/** Our blocks for one event under a plan. Every event but a split PermissionRequest: exactly `[canonicalBlock]`. */
+export function canonicalBlocks(scriptPath: string, sub: HookSubscription, paths: HookPaths, plan: PermissionHookPlan = UNSPLIT_PLAN): Record<string, unknown>[] {
+  if (sub.event === 'PermissionRequest' && plan.split) return splitPermissionBlocks(scriptPath, sub, paths, plan.questionWaitS, plan.otherWaitS)
+  return [canonicalBlock(scriptPath, sub, paths)]
+}
+
+/**
+ * Earlier shapes of our PermissionRequest blocks that differ from the plan only by the wait: the
+ * pre-6.60.0 block (`priorWaitBlock`); with a split plan, the one unsplit block; with an unsplit
+ * plan, every split pair this file can write (a flag turned off after Reinstall hooks).
+ */
+function priorWaitVariants(scriptPath: string, sub: HookSubscription, paths: HookPaths, plan: PermissionHookPlan): Record<string, unknown>[][] {
+  const prior = priorWaitBlock(scriptPath, sub, paths)
+  if (!prior) return []
+  const out: Record<string, unknown>[][] = [[prior]]
+  if (plan.split) out.push([canonicalBlock(scriptPath, sub, paths)])
+  const waits = [PERMISSION_HOOK_TIMEOUT_S, FULL_HOLD_HOOK_WAIT_S]
+  for (const q of waits) for (const o of waits) {
+    if (plan.split && q === plan.questionWaitS && o === plan.otherWaitS) continue
+    if (q === PERMISSION_HOOK_TIMEOUT_S && o === PERMISSION_HOOK_TIMEOUT_S) continue
+    out.push(splitPermissionBlocks(scriptPath, sub, paths, q, o))
+  }
+  return out
+}
+
+/** Whether a hook block's `matcher` selects this tool, as Claude Code reads it: no matcher, `*` or an empty one is every tool, else a regex. */
+function matcherSelects(matcher: unknown, toolName: string): boolean {
+  if (matcher === undefined || matcher === null || matcher === '' || matcher === '*') return true
+  if (typeof matcher !== 'string') return false
+  if (matcher === toolName) return true
+  try { return new RegExp(`^(?:${matcher})$`).test(toolName) } catch { return false }
+}
+
+/**
+ * X1: how long Claude Code waits on our PermissionRequest hook FOR THIS TOOL: the smallest timeout
+ * among our blocks whose matcher selects it. With the one unsplit block, the same number as
+ * `permissionHookTimeoutS`. Null when none of ours selects it or one has no usable number.
+ */
+export function permissionHookTimeoutForToolS(settings: unknown, toolName: string): number | null {
+  const hooks = settings && typeof settings === 'object' ? (settings as Record<string, unknown>).hooks : null
+  const blocks = hooks && typeof hooks === 'object' ? (hooks as Record<string, unknown>).PermissionRequest : null
+  if (!Array.isArray(blocks)) return null
+  let least: number | null = null
+  for (const block of blocks) {
+    if (!blockIsOurs(block)) continue
+    if (!matcherSelects((block as HookBlock).matcher, toolName)) continue
+    for (const h of (block as HookBlock).hooks as unknown[]) {
+      if (!hookIsOurs(h)) continue
+      const timeout = (h as { timeout?: unknown }).timeout
+      if (typeof timeout !== 'number' || !Number.isFinite(timeout) || timeout <= 0) return null
+      least = least === null ? timeout : Math.min(least, timeout)
+    }
+  }
+  return least
+}
+
 /**
  * 6.60.0: how long Claude Code waits on OUR PermissionRequest hook, read from a settings
  * object: the smallest `timeout` among our entries (Claude runs each, so the first to give up
@@ -220,7 +308,7 @@ export type MergeResult =
  * `hooks` key that is not an object, or an event whose value is not an array, is refused
  * rather than replaced: "preserving every existing hook block" is the contract.
  */
-export function mergeHookSettings(current: unknown, scriptPath: string, paths: HookPaths = currentHookPaths()): MergeResult {
+export function mergeHookSettings(current: unknown, scriptPath: string, paths: HookPaths = currentHookPaths(), plan: PermissionHookPlan = permissionHookPlan()): MergeResult {
   const settings: Record<string, unknown> = current && typeof current === 'object' && !Array.isArray(current) ? { ...(current as Record<string, unknown>) } : {}
   const before = JSON.stringify(settings)
   if (settings.hooks !== undefined && (!settings.hooks || typeof settings.hooks !== 'object' || Array.isArray(settings.hooks))) return { ok: false, reason: 'settings_hooks_invalid' }
@@ -231,7 +319,7 @@ export function mergeHookSettings(current: unknown, scriptPath: string, paths: H
     if (value !== undefined && !Array.isArray(value)) return { ok: false, reason: 'settings_hooks_invalid' }
     const existing = Array.isArray(value) ? value : []
     const foreign = existing.filter(b => !blockIsOurs(b))
-    hooks[sub.event] = [...foreign, canonicalBlock(scriptPath, sub, paths)]
+    hooks[sub.event] = [...foreign, ...canonicalBlocks(scriptPath, sub, paths, plan)]
   }
   settings.hooks = hooks
   return { ok: true, settings, changed: JSON.stringify(settings) !== before }
@@ -258,7 +346,7 @@ export function stripHookSettings(current: unknown): MergeResult {
  * (6.60.0) names the drifted events whose one block of ours is exactly the block an earlier
  * release wrote, differing only by the wait (`priorWaitBlock`).
  */
-export function subscribedEvents(current: unknown, scriptPath: string, paths: HookPaths = currentHookPaths()): { subscribed: string[]; missing: string[]; drifted: string[]; priorWait: string[] } {
+export function subscribedEvents(current: unknown, scriptPath: string, paths: HookPaths = currentHookPaths(), plan: PermissionHookPlan = permissionHookPlan()): { subscribed: string[]; missing: string[]; drifted: string[]; priorWait: string[] } {
   const hooks = current && typeof current === 'object' && (current as Record<string, unknown>).hooks
   const table = hooks && typeof hooks === 'object' ? hooks as Record<string, unknown> : {}
   const subscribed: string[] = []
@@ -269,11 +357,10 @@ export function subscribedEvents(current: unknown, scriptPath: string, paths: Ho
     const blocks = Array.isArray(table[sub.event]) ? table[sub.event] as unknown[] : []
     const ours = blocks.filter(blockIsOurs)
     if (ours.length === 0) { missing.push(sub.event); continue }
-    const canonical = JSON.stringify(canonicalBlock(scriptPath, sub, paths))
-    if (ours.length === 1 && JSON.stringify(ours[0]) === canonical) { subscribed.push(sub.event); continue }
+    const canonical = JSON.stringify(canonicalBlocks(scriptPath, sub, paths, plan))
+    if (JSON.stringify(ours) === canonical) { subscribed.push(sub.event); continue }
     drifted.push(sub.event)
-    const prior = priorWaitBlock(scriptPath, sub, paths)
-    if (prior && ours.length === 1 && JSON.stringify(ours[0]) === JSON.stringify(prior)) priorWait.push(sub.event)
+    if (priorWaitVariants(scriptPath, sub, paths, plan).some(variant => JSON.stringify(variant) === JSON.stringify(ours))) priorWait.push(sub.event)
   }
   return { subscribed, missing, drifted, priorWait }
 }
@@ -312,6 +399,11 @@ export interface HookStatus {
   observerOnlyDrift?: boolean
   /** 6.60.0: our PermissionRequest hook's `timeout` in the settings file, or null (`permissionHookTimeoutS`). */
   permissionHookTimeoutS: number | null
+  /**
+   * X1: the same, per kind (`permissionHookTimeoutForToolS` for AskUserQuestion and for any other
+   * tool). Equal to `permissionHookTimeoutS` while the block is not split.
+   */
+  permissionHookTimeouts?: { question: number | null; approval: number | null }
   tokenPresent: boolean
 }
 
@@ -343,7 +435,7 @@ function hooksDisabled(settings: unknown): boolean {
   return !!settings && typeof settings === 'object' && (settings as { disableAllHooks?: unknown }).disableAllHooks === true
 }
 
-export function hookStatus(paths: { settingsPath?: string; scriptPath?: string; packageScriptPath?: string; hookPaths?: HookPaths } = {}): HookStatus {
+export function hookStatus(paths: { settingsPath?: string; scriptPath?: string; packageScriptPath?: string; hookPaths?: HookPaths; plan?: PermissionHookPlan } = {}): HookStatus {
   const settingsPath = paths.settingsPath ?? claudeSettingsPath()
   const scriptPath = paths.scriptPath ?? stableHookScriptPath()
   const packageScriptPath = paths.packageScriptPath ?? packagedHookScriptPath()
@@ -355,8 +447,12 @@ export function hookStatus(paths: { settingsPath?: string; scriptPath?: string;
   if (!read.ok) {
     return { state: read.reason, installed: false, settingsPath, scriptPath, scriptSha, packageScriptSha, subscribed: [], missing: HOOK_SUBSCRIPTIONS.map(s => s.event), drifted: [], priorWait: [], priorWaitOnly: false, permissionHookTimeoutS: null, tokenPresent }
   }
-  const events = subscribedEvents(read.settings, scriptPath, hookPaths)
+  const events = subscribedEvents(read.settings, scriptPath, hookPaths, paths.plan ?? permissionHookPlan())
   const permissionWaitS = permissionHookTimeoutS(read.settings)
+  const permissionHookTimeouts = {
+    question: permissionHookTimeoutForToolS(read.settings, 'AskUserQuestion'),
+    approval: permissionHookTimeoutForToolS(read.settings, 'Bash'),
+  }
   let state: HookInstallState
   if (hooksDisabled(read.settings)) state = 'disabled_by_settings'
   else if (events.subscribed.length === 0 && events.drifted.length === 0) state = 'missing'
@@ -366,7 +462,7 @@ export function hookStatus(paths: { settingsPath?: string; scriptPath?: string;
   const priorWaitOnly = state === 'drift' && events.missing.length === 0 && events.drifted.length > 0
     && events.drifted.every(event => events.priorWait.includes(event))
   const observerOnlyDrift = state === 'drift' && events.missing.length > 0 && events.missing.every(event => event === 'PreCompact') && events.drifted.every(event => events.priorWait.includes(event))
-  return { observerOnlyDrift, state, installed: state === 'installed', settingsPath, scriptPath, scriptSha, packageScriptSha, ...events, priorWaitOnly, permissionHookTimeoutS: permissionWaitS, tokenPresent }
+  return { observerOnlyDrift, state, installed: state === 'installed', settingsPath, scriptPath, scriptSha, packageScriptSha, ...events, priorWaitOnly, permissionHookTimeoutS: permissionWaitS, ...(paths.plan?.split || permissionHookPlan().split || permissionHookTimeouts.question !== permissionHookTimeouts.approval ? { permissionHookTimeouts } : {}), tokenPresent }
 }
 
 /**
@@ -476,6 +572,8 @@ export interface InstallOptions {
   port?: number
   deskIdleSeconds?: number
   dryRun?: boolean
+  /** X1: how the PermissionRequest hook is written. Default: from the two full-hold switches (`permissionHookPlan`). */
+  plan?: PermissionHookPlan
 }
 
 export interface InstallResult {
@@ -548,10 +646,11 @@ export function installClaudeHooks(options: InstallOptions = {}): InstallResult
   const packageScriptPath = options.packageScriptPath ?? packagedHookScriptPath()
   const hookPaths = options.hookPaths ?? currentHookPaths()
   const read = readSettings(settingsPath)
-  const statusNow = () => hookStatus({ settingsPath, scriptPath, packageScriptPath, hookPaths })
+  const plan = options.plan ?? permissionHookPlan()
+  const statusNow = () => hookStatus({ settingsPath, scriptPath, packageScriptPath, hookPaths, plan })
   const refuse = (reason: string, scriptCopied = false): InstallResult => ({ ok: false, reason, changed: false, scriptCopied, backupPath: null, status: statusNow() })
   if (!read.ok) return refuse(read.reason)
-  const merged = mergeHookSettings(read.settings, scriptPath, hookPaths)
+  const merged = mergeHookSettings(read.settings, scriptPath, hookPaths, plan)
   if (!merged.ok) return refuse(merged.reason)
   if (options.dryRun) {
     return { ok: true, changed: merged.changed, scriptCopied: false, backupPath: null, status: statusNow(), merged: merged.settings }

package/server/lib/codex-bridge.ts

@@ -60,6 +60,8 @@ import {
 } from './claude-tool-access.js'
 import {
   classifyCodexError,
+  codexTerminalUsageLimitError,
+  safeCodexUsageLimitMessage,
   extractCodexThreadId,
   finishCodexRun,
   getCodexExecutionCwd,
@@ -382,6 +384,7 @@ export function runCodexKeyProfileTurn(
 
 function safeCodexUserError(message: string): string {
   const code = classifyCodexError(message)
+  if (code === 'provider_limit') return safeCodexUsageLimitMessage(message)
   if (code === 'codex.cli_unavailable') return 'Codex CLI unavailable. Check server Settings.'
   if (code === 'codex.auth_error') return 'Codex auth failed. Run codex login on the Mac.'
   if (code === 'codex.timeout') return 'Codex timed out. Retry or start a new chat.'
@@ -1021,7 +1024,7 @@ export async function callCodexStreaming(
         rawProviderError,
         structuredProviderError,
       )
-      finalizeError(authenticationError ?? `codex-bridge: ${rawProviderError}`)
+      finalizeError(authenticationError ?? codexTerminalUsageLimitError(event) ?? `codex-bridge: ${rawProviderError}`)
     }
   }
 

package/server/lib/codex-run-ledger.ts

@@ -215,8 +215,37 @@ export function redactForCodexLedger(value: string, maxChars = ERROR_PREVIEW_CHA
     .slice(0, maxChars)
 }
 
+/** Only a validated provider retry date may cross the terminal error boundary. */
+export function safeCodexUsageLimitMessage(message: string): string {
+  const fallback = 'Codex usage limit reached. Try again later or choose another model.'
+  // Bound work on untrusted terminal text; do not preserve links, identifiers or prose.
+  const retry = /(?:try again|resets?) at (Jan(?:uary)?|Feb(?:ruary)?|Mar(?:ch)?|Apr(?:il)?|May|Jun(?:e)?|Jul(?:y)?|Aug(?:ust)?|Sep(?:tember)?|Oct(?:ober)?|Nov(?:ember)?|Dec(?:ember)?)\s+(\d{1,2})(?:st|nd|rd|th)?,?\s+(20\d{2})\s+(\d{1,2}):(\d{2})\s*(AM|PM)\b/i.exec(message.slice(0, 8_000))
+  if (!retry) return fallback
+  const months = ['Jan', 'Feb', 'Mar', 'Apr', 'May', 'Jun', 'Jul', 'Aug', 'Sep', 'Oct', 'Nov', 'Dec']
+  const month = months.findIndex(value => value.toLowerCase() === retry[1].slice(0, 3).toLowerCase())
+  const day = Number(retry[2]), year = Number(retry[3]), hour = Number(retry[4]), minute = Number(retry[5])
+  const date = new Date(Date.UTC(year, month, day))
+  if (date.getUTCMonth() !== month || date.getUTCDate() !== day || hour < 1 || hour > 12 || minute > 59) return fallback
+  return `Codex usage limit reached. Try again at ${months[month]} ${day}, ${year} ${hour}:${retry[5]} ${retry[6].toUpperCase()} (provider time), or choose another model.`
+}
+
+/** Codex JSON terminal errors carry the quota code separately from their message. */
+export function codexTerminalUsageLimitError(event: unknown): string | undefined {
+  if (!event || typeof event !== 'object') return undefined
+  const value = event as Record<string, unknown>
+  if (value.type !== 'error' && value.type !== 'turn.failed') return undefined
+  const error = value.error && typeof value.error === 'object' ? value.error as Record<string, unknown> : undefined
+  const code = error?.codex_error_info ?? value.codex_error_info
+  if (code !== 'usage_limit_exceeded') return undefined
+  const message = typeof error?.message === 'string' ? error.message
+    : typeof value.message === 'string' ? value.message
+      : typeof value.error === 'string' ? value.error : ''
+  return safeCodexUsageLimitMessage(message)
+}
+
 export function classifyCodexError(message: string): string {
   const text = message.toLowerCase()
+  if (/\busage_limit_exceeded\b|^codex usage limit reached\./.test(text)) return 'provider_limit'
   if (/command not found|enoent|not found/.test(text)) return 'codex.cli_unavailable'
   if (/permission|denied|sandbox|read-only|operation not permitted/.test(text)) return 'codex.permission_denied'
   if (/auth|login|sign in|unauthorized|forbidden|token/.test(text)) return 'codex.auth_error'

package/server/lib/context-builder.ts

@@ -2,6 +2,7 @@
 // Caches context for 60s to avoid hammering Python scripts every query
 
 import { callPython, COS_MODE } from './python-bridge.js'
+import { readCalendar } from './calendar-source.js'
 import { getOwnerName } from './profile.js'
 
 interface ContextCache {
@@ -76,7 +77,7 @@ async function fetchLiveContext(): Promise<string> {
 
   // Fetch calendar and tasks in parallel
   const [calResult, taskResult] = await Promise.allSettled([
-    callPython(['calendar']),
+    readCalendar().then(r => r.data),
     callPython(['tasks']),
   ])
 

package/server/lib/conversation.ts

@@ -9,7 +9,7 @@ import { fileURLToPath } from 'node:url'
 import { notifySessionStart, notifySessionEnd } from './telegram-notify.js'
 import { appendToArchive, type SessionToArchive } from './archive.js'
 import { updateGlassesSessionCache, scheduleCacheUpdate, setSessionProvider } from './session-cache-writer.js'
-import { logSessionEnd, buildSessionLogEntry, writeSessionLog } from './session-log.js'
+import { logSessionEnd, buildSessionLogEntry, writeSessionLogIfChanged, flushSessionLogState } from './session-log.js'
 import { atomicWriteFileSync, durableAtomicWriteFileSync, loadJsonOrQuarantine } from './atomic-fs.js'
 import { localDay } from './local-day.js'
 import { normalizeModelPreference, type ModelPreference } from '../../shared/model-preference.js'
@@ -966,11 +966,14 @@ export async function endSession(sessionId: string): Promise<{ logged: boolean;
   return { logged: exchangeCount > 0, exchangeCount, durationMin }
 }
 
-/** Log all active sessions on server shutdown — prevents data loss on restart */
-export function logActiveSessionsOnShutdown(): void {
+/** Log active sessions on server shutdown — prevents data loss on restart.
+ * S1 (2026-11-09): a session whose content was already written (by a snapshot or an
+ * earlier shutdown, in this boot or a previous one) is not appended again. */
+export function logActiveSessionsOnShutdown(): { written: number; unchanged: number; unconfigured: number; failed: number } {
+  const counts = { written: 0, unchanged: 0, unconfigured: 0, failed: 0 }
   for (const session of sessions.values()) {
     if (session.exchanges.length === 0) continue
-    logSessionEnd({
+    const entry = buildSessionLogEntry({
       id: session.id,
       exchanges: session.exchanges,
       createdAt: session.createdAt,
@@ -978,40 +981,65 @@ export function logActiveSessionsOnShutdown(): void {
       modelPreference: session.modelPreference,
       endReason: 'server_shutdown',
     })
+    counts[writeSessionLogIfChanged(entry, 'shutdown')]++
+  }
+  flushSessionLogState()
+  // No ledger configured (the new-install default): nothing to report.
+  if (counts.written || counts.unchanged || counts.failed) {
+    console.log(`[session-log] shutdown: ${counts.written} written, ${counts.unchanged} unchanged, ${counts.failed} failed`)
   }
+  return counts
 }
 
-// ── Auto-snapshot: periodically write active sessions to .glasses_sessions.jsonl ──
-// Runs every 5 minutes. No LLM calls, no network — just JSON serialize + file append.
-// Cost: ~0 CPU, ~0 RAM, ~50KB disk per snapshot.
+// ── Auto-snapshot: periodically write changed active sessions to .glasses_sessions.jsonl ──
+// Runs every 5 minutes. No LLM calls, no network. A session is appended only when its
+// content changed since the last write for it, and that memory survives restarts
+// (session-log.ts). Before 2026-11-09 the memory was this module's own map, empty after
+// every boot, so the first tick after a restart re-appended every session (about 300 entries,
+// roughly 5 MB, per boot on Miles's Mac; not the "~50KB per snapshot" once written here).
 let snapshotTimer: ReturnType<typeof setInterval> | null = null
-let lastSnapshotCounts: Record<string, number> = {} // track exchange counts to skip unchanged sessions
+let lastSnapshotCounts: Record<string, number> = {} // cheap in-process pre-check before hashing
+
+/** One auto-snapshot pass. Exported for tests. */
+export function runAutoSnapshotOnce(): { written: number; unchanged: number; unconfigured: number; failed: number } {
+  const counts = { written: 0, unchanged: 0, unconfigured: 0, failed: 0 }
+  for (const session of sessions.values()) {
+    if (session.exchanges.length === 0) continue
+    // Skip if exchange count hasn't changed since this process last looked
+    const prevCount = lastSnapshotCounts[session.id]
+    if (prevCount !== undefined && session.exchanges.length === prevCount) continue
+
+    const entry = buildSessionLogEntry({
+      id: session.id,
+      exchanges: session.exchanges,
+      createdAt: session.createdAt,
+      lastActivity: Date.now(), // Use NOW, not lastActivity — ensures lookup covers up to this moment
+      modelPreference: session.modelPreference,
+      endReason: 'explicit_end',
+      slug: `[LIVE] ${(session.exchanges.find(e => e.role === 'user')?.content ?? '').slice(0, 50)}`,
+    })
+    counts[writeSessionLogIfChanged(entry, 'snapshot')]++
+    // Recorded whatever the result, as before S1: a failed or unconfigured write is not retried
+    // every 5 minutes (Q1 review M2), only after the session changes again.
+    lastSnapshotCounts[session.id] = session.exchanges.length
+  }
+  if (counts.written) flushSessionLogState()
+  return counts
+}
 
 export function startAutoSnapshot(intervalMs = 5 * 60_000): void {
   if (snapshotTimer) return
-  snapshotTimer = setInterval(() => {
-    for (const session of sessions.values()) {
-      if (session.exchanges.length === 0) continue
-      // Skip if exchange count hasn't changed since last snapshot
-      const prevCount = lastSnapshotCounts[session.id] ?? 0
-      if (session.exchanges.length === prevCount) continue
-
-      const entry = buildSessionLogEntry({
-        id: session.id,
-        exchanges: session.exchanges,
-        createdAt: session.createdAt,
-        lastActivity: Date.now(), // Use NOW, not lastActivity — ensures lookup covers up to this moment
-        modelPreference: session.modelPreference,
-        endReason: 'explicit_end',
-        slug: `[LIVE] ${(session.exchanges.find(e => e.role === 'user')?.content ?? '').slice(0, 50)}`,
-      })
-      writeSessionLog(entry)
-      lastSnapshotCounts[session.id] = session.exchanges.length
-    }
-  }, intervalMs)
+  snapshotTimer = setInterval(() => { runAutoSnapshotOnce() }, intervalMs)
   console.log(`[conversation] Auto-snapshot started (every ${intervalMs / 1000}s)`)
 }
 
+/** Tests only. */
+export function __resetAutoSnapshotForTests(): void {
+  if (snapshotTimer) clearInterval(snapshotTimer)
+  snapshotTimer = null
+  lastSnapshotCounts = {}
+}
+
 /** Return all active sessions with exchanges, shaped for archiving */
 export function getActiveSessions(): SessionToArchive[] {
   const result: SessionToArchive[] = []

package/server/lib/cors-reject-log.ts

@@ -0,0 +1,51 @@
+/**
+ * Log a rejected CORS origin (S1, 2026-11-09).
+ *
+ * The scan of 10/26 to 11/09 found 22 "Error: CORS blocked" lines with nothing else, so no one
+ * could tell a COS client bug from a probe. This logs the ORIGIN only (an Origin header is a
+ * scheme, host and port; never a header dump, cookie or token), once per origin per hour, with a
+ * running count, and caps how many distinct origins it remembers so a scanner cannot grow it.
+ */
+const ONE_HOUR_MS = 60 * 60_000
+export const CORS_REJECT_ORIGIN_CAP = 200
+const seen = new Map<string, { count: number; lastLoggedAt: number }>()
+let overflow = 0
+
+/** An origin made safe for one log line: printable ASCII, no spaces, at most 200 characters. */
+export function sanitizeOrigin(origin: string): string {
+  const clean = origin.replace(/[^\x21-\x7e]/g, '?')
+  return clean.length > 200 ? `${clean.slice(0, 200)}…(${clean.length} chars)` : clean
+}
+
+export type CorsRejectReason = 'not_allowed' | 'check_failed'
+
+export function noteCorsRejection(
+  origin: string,
+  reason: CorsRejectReason,
+  now = Date.now(),
+  log: (line: string) => void = line => console.warn(line),
+): boolean {
+  const key = sanitizeOrigin(origin)
+  let entry = seen.get(key)
+  if (!entry) {
+    if (seen.size >= CORS_REJECT_ORIGIN_CAP) {
+      overflow++
+      if (overflow === 1 || overflow % 100 === 0) {
+        log(`[cors] blocked ${overflow} request(s) from origins beyond the first ${CORS_REJECT_ORIGIN_CAP} distinct ones (not listed)`)
+      }
+      return false
+    }
+    entry = { count: 0, lastLoggedAt: 0 }
+    seen.set(key, entry)
+  }
+  entry.count++
+  if (entry.lastLoggedAt && now - entry.lastLoggedAt < ONE_HOUR_MS) return false
+  entry.lastLoggedAt = now
+  log(`[cors] blocked origin=${key} reason=${reason} (${entry.count} from this origin since boot)`)
+  return true
+}
+
+export function __resetCorsRejectLogForTests(): void {
+  seen.clear()
+  overflow = 0
+}