@gotcos/glasses-server 6.75.0 → 6.77.0

package/server/scripts/live-cues-v2-notes-mutation-gate.mjs

@@ -0,0 +1,170 @@
+#!/usr/bin/env node
+// Live cues v2 6.76.2 mutation gate: the runtime switch, the notes fallback and the decision provider. Mutations run only
+// in a disposable copy of the checkout; the live checkout is never rewritten.
+//
+// What it proves, in order:
+//   0. The target suites are GREEN unmutated. A gate over a red suite reads every mutant as killed and proves nothing.
+//   1. Each target string appears EXACTLY ONCE in its file, so the mutation is unambiguous.
+//   2. The mutated file differs from the original, so the edit landed.
+//   3. A NAMED test fails ("FAIL  server/x.test.ts > name"); a build error or a harness failure is not a kill.
+//   4. The file is restored byte for byte (compared) before the next mutant.
+// Also the Live COS Ask's memory bridge fallback (searchAskHistory) and the helpers it shares with cues (cos-bridge-notes.ts).
+// Usage: node server/scripts/live-cues-v2-notes-mutation-gate.mjs [--list] [name…]
+import { mkdtempSync, cpSync, readFileSync, writeFileSync, symlinkSync, rmSync } from 'node:fs'
+import { tmpdir } from 'node:os'
+import { resolve, join, dirname, basename } from 'node:path'
+import { fileURLToPath } from 'node:url'
+import { spawnSync } from 'node:child_process'
+
+const root = resolve(dirname(fileURLToPath(import.meta.url)), '../..')
+const CUES = ['server/lib/live-cues-v2.test.ts', 'server/lib/live-cues-v2-notes.test.ts', 'server/lib/live-cues-v2-notes-bridge.test.ts',
+  'server/lib/live-cues-v2-settings.test.ts', 'server/routes/live-cues-v2-settings-route.test.ts', 'server/routes/live-cues-v2-route.test.ts']
+const HEALTH = [...CUES, 'server/routes/health.test.ts']
+const ASK = ['server/lib/live-cos-ask-memory-fallback.test.ts', 'server/lib/live-cos-ask-queen-runtime.test.ts', 'server/lib/meeting-ask-cos-search.test.ts',
+  'server/lib/live-cos-ask.test.ts', 'server/lib/meeting-ask-owner.test.ts']
+const BOTH = [...CUES, ...ASK]
+const ALL = [...HEALTH, ...ASK]
+const ENGINE = 'server/lib/live-cues-v2.ts', NOTES = 'server/lib/live-cues-v2-notes.ts', SETTINGS = 'server/lib/live-cues-v2-settings.ts'
+const ROUTE = 'server/routes/live-cues.ts', DECISION = 'server/lib/decision-provider.ts'
+const SHARED = 'server/lib/cos-bridge-notes.ts', ASKLIB = 'server/lib/live-cos-ask.ts'
+const m = (name, file, edits, tests = CUES) => ({ name, file, edits: typeof edits[0] === 'string' ? [edits] : edits, tests })
+
+const mutations = [
+  // ── Runtime switch ──
+  m('env-forces-only-exact-1', SETTINGS, ["return env.COS_LIVE_CUES_V2 === '1'", 'return !!env.COS_LIVE_CUES_V2']),
+  m('env-forced-wins-over-setting', SETTINGS, ["if (liveCuesV2EnvForced(env)) return { enabled: true, source: 'env' }", 'if (false) return { enabled: true, source: \'env\' }']),
+  m('saved-setting-read', SETTINGS, ["if (stored !== null) return { enabled: stored, source: 'setting' }", "if (stored === true) return { enabled: stored, source: 'setting' }"]),
+  m('malformed-setting-is-none', SETTINGS, ["typeof (raw as { enabled?: unknown }).enabled === 'boolean'", '(raw as { enabled?: unknown }).enabled !== undefined']),
+  m('cache-follows-write', SETTINGS, ['    this.cache = { value: enabled }\n', '']),
+  m('failed-write-keeps-memory', SETTINGS, [
+    ['    mkdirSync(dirname(this.file), { recursive: true, mode: 0o700 })\n', '    this.cache = { value: enabled }\n    mkdirSync(dirname(this.file), { recursive: true, mode: 0o700 })\n'],
+    ["{ mode: 0o600 })\n    this.cache = { value: enabled }\n", '{ mode: 0o600 })\n']]),
+  m('settings-file-private', SETTINGS, ["+ '\\n', { mode: 0o600 })", "+ '\\n', { mode: 0o644 })"]),
+  m('engine-reads-setting', ENGINE, ['private enabled(): boolean { return liveCuesV2Enabled(this.deps.env, this.deps.settings) }', 'private enabled(): boolean { return liveCuesV2Enabled(this.deps.env, null) }']),
+  m('feed-stops-while-off', ENGINE, ['    if (!this.enabled()) return\n    if (this.deps.store.isEnded(sessionId)) return', '    if (this.deps.store.isEnded(sessionId)) return']),
+  m('last-check-before-emit', ENGINE, ['|| this.deps.store.isPaused(s.sessionId) || !this.enabled()) {', '|| this.deps.store.isPaused(s.sessionId)) {']),
+  m('suspend-aborts-in-flight', ENGINE, ['if (s.inFlight) { s.inFlight.abort(V2_OFF); aborted += 1 }', 'if (s.inFlight) { aborted += 1 }']),
+  m('cancel-reason-traced', ENGINE, ["      if (trace.outcome === 'cancelled' && abort.signal.reason === V2_OFF) trace.cancelReason = V2_OFF\n", '']),
+  m('env-forced-off-refused', ENGINE, ["if (!enabled && liveCuesV2EnvForced(env)) return { ok: false, error: 'env_forced' }", "if (false) return { ok: false, error: 'env_forced' }"]),
+  m('turning-off-suspends', ENGINE, ['const aborted = engine?.suspend() ?? 0', 'const aborted = 0']),
+  m('suspend-only-on-transition', ENGINE, ['if (wasOn && !liveCuesV2Enabled(env)) {', 'if (!liveCuesV2Enabled(env)) {']),
+  m('saved-meeting-ends-known-session', ENGINE, ['(liveCuesV2Enabled() || engine?.knows(sid))', 'liveCuesV2Enabled()']),
+  m('knows-armed-sessions', ENGINE, ['knows(sessionId: string): boolean { return this.sessions.has(sessionId) }', 'knows(sessionId: string): boolean { return false }']),
+  m('route-v2-owns-known-meeting', ROUTE, ['return liveCuesV2Enabled() || (peekLiveCuesV2()?.knows(sessionId) ?? false)', 'return liveCuesV2Enabled()']),
+  m('route-boolean-enabled-only', ROUTE, ["typeof body.enabled !== 'boolean'", 'body.enabled === undefined']),
+  m('route-409-body', ROUTE, ['if (!result.ok) return res.status(409).json({ error: result.error })', 'if (!result.ok) return res.status(200).json(liveCuesV2SettingsView())']),
+  m('advertised-follows-setting', ENGINE, ['return liveCuesV2Enabled(env) ? liveCuesV2Capability() : undefined', "return env.COS_LIVE_CUES_V2 === '1' ? liveCuesV2Capability() : undefined"], HEALTH),
+  // ── Notes fallback (engine) ──
+  m('fallback-runs-on-failure', ENGINE, ['if (cueMemoryFailed(mem) && !abort.signal.aborted) {', 'if (false) {']),
+  m('cue-memory-preferred', ENGINE, ['if (cueMemoryFailed(mem) && !abort.signal.aborted) {', 'if (!abort.signal.aborted) {']),
+  m('failure-codes-only', ENGINE, ['return !!mem.denseError && CUE_MEMORY_FAILURES.has(mem.denseError)', 'return !!mem.denseError']),
+  m('timeout-is-a-failure', ENGINE, ["'no_cue_memory_script', 'memory_timeout', 'spawn_failed'", "'no_cue_memory_script', 'spawn_failed'"]),
+  m('notes-candidates-to-judge', ENGINE, ['        mem = { notes: found.notes }\n', '        mem = { notes: [] }\n']),
+  m('notes-get-session-and-bound', ENGINE, ['this.deps.notes(window, before, abort.signal, s.sessionId)', "this.deps.notes(window, before, abort.signal, '')"]),
+  m('source-none-when-empty', ENGINE, ["cueMemorySource: mem.notes.length ? source : 'none'", 'cueMemorySource: source']),
+  m('capability-memory-source', ENGINE, [": notesAvailable() ? 'notes' : 'none'", ": 'none'"]),
+  // ── Notes fallback (search) ──
+  m('notes-date-bound', NOTES, ['!!c && !(c.date && c.date >= before)', '!!c']),
+  m('notes-local-day', SHARED, ["return Number.isFinite(ms) ? new Date(ms).toLocaleDateString('en-CA') : ''", "return Number.isFinite(ms) ? v.slice(0, 10) : ''"], BOTH),
+  m('notes-drop-live-meeting', NOTES, ['hits.filter(h => !(opts.sessionId && h.sessionId === opts.sessionId))', 'hits']),
+  m('notes-budget-race', NOTES, ['new Promise<boolean>(r => { timer = setTimeout(() => r(true), budgetMs) })', 'new Promise<boolean>(() => {})']),
+  m('notes-bridge-timeout', NOTES, ['searchers.bridge(local.signal, budgetMs)', 'searchers.bridge(local.signal, 30_000)']),
+  m('notes-abort-at-budget', NOTES, ['  clearTimeout(timer)\n  local.abort()\n', '  clearTimeout(timer)\n']),
+  m('notes-aborted-gets-nothing', NOTES, ['  if (signal.aborted) return { notes: [] }\n', '']),
+  m('notes-no-terms-no-search', NOTES, ["  if (!terms.length) return { notes: [], error: 'notes_no_terms' }\n", '']),
+  m('notes-queries-short', NOTES, ['terms.slice(0, 4).join', 'terms.join']),
+  m('notes-stopwords', NOTES, ['if (term.length < 3 || STOP.has(term) ||', 'if (term.length < 3 ||']),
+  m('shared-rank-fusion', SHARED, ['score: (prev?.score ?? 0) + 1 / (RRF_K + rank)', 'score: 1 / (RRF_K + rank)'], BOTH),
+  m('shared-fusion-keeps-order-on-ties', SHARED, ['b.score - a.score || a.order - b.order', 'b.score - a.score || b.order - a.order'], BOTH),
+  m('notes-top-four', NOTES, ['fused.ranked(top)', 'fused.ranked()']),
+  m('shared-bridge-scored', SHARED, ['    .filter(x => x.score > 0).sort(', '    .sort('], BOTH),
+  m('shared-bridge-needs-content', SHARED, ['if (!id || !content.trim()) continue', 'if (!id) continue'], BOTH),
+  m('shared-bridge-lists-memory', SHARED, ["callPython(['memory', '--days'", "callPython(['memory-overview', '--days'"], BOTH),
+  m('notes-bridge-searched', NOTES, ['    for (const q of queries) add(rankBridgeMemories(rows, q).map(bridgeCandidate))\n', '']),
+  m('notes-real-memories-keyword-only', NOTES, ['(await searchMemories({ query, limit: 10, semantic: false, signal })).hits', '[]']),
+  m('notes-real-meetings-keyword-only', NOTES, ['(await searchMeetingLibrary({ query, limit: 10, semantic: false, signal })).hits', '[]']),
+  // ── Decision provider ──
+  m('cue-override-read', ENGINE, ['  if (raw !== undefined) {\n', '  if (false) {\n']),
+  m('cue-override-validated', ENGINE, ["    if (v !== 'jev' && v !== 'subq') throw new DecisionProviderError('decision_invalid_provider')\n", '']),
+  m('only-key-subq', ENGINE, ["  if (!keys.jev() && keys.subq()) return { provider: 'subq', source: 'only_key' }\n", '']),
+  m('only-key-needs-no-jev', ENGINE, ['if (!keys.jev() && keys.subq()) return', 'if (keys.subq()) return']),
+  m('global-env-ignored', ENGINE, ['  const raw = env.COS_DECISION_PROVIDER_CUES\n', "  const raw = env.COS_DECISION_PROVIDER_CUES ?? env.COS_DECISION_PROVIDER\n"]),
+  m('global-setting-ignored', ENGINE, [
+    ["import type { DecisionProvider } from './decision-settings.js'", "import { readDecisionSettings, type DecisionProvider } from './decision-settings.js'"],
+    ['  const raw = env.COS_DECISION_PROVIDER_CUES\n', '  const raw = env.COS_DECISION_PROVIDER_CUES ?? readDecisionSettings().provider\n']]),
+  m('judge-uses-evaluation-provider', ENGINE, ['abort.signal, provider)\n        Object.assign(trace, { judgeMs', 'abort.signal, this.deps.decisionProvider())\n        Object.assign(trace, { judgeMs']),
+  m('gate-uses-provider', ENGINE, ['await this.deps.gate(s.title, window, abort.signal, provider)', "await this.deps.gate(s.title, window, abort.signal, 'jev')"]),
+  m('real-deps-route-subq', ENGINE, ["cueDecisionCalls(provider === 'subq' ? subq : jev)", 'cueDecisionCalls(jev)']),
+  m('capability-key-check', ENGINE, ["      if (!st.configured) return off(provider === 'jev' && this.deps.decisionState('subq').configured ? 'jev_not_configured' : 'decision_not_configured')\n", '']),
+  m('jev-alias-only-with-subq-key', ENGINE, ["provider === 'jev' && this.deps.decisionState('subq').configured ? 'jev_not_configured'", "provider === 'jev' ? 'jev_not_configured'"]),
+  m('decision-not-configured-reason', ENGINE, ["this.deps.decisionState('subq').configured ? 'jev_not_configured' : 'decision_not_configured'", "this.deps.decisionState('subq').configured ? 'jev_not_configured' : 'jev_not_configured'"]),
+  m('capability-selected-provider-state', ENGINE, ['      const st = this.deps.decisionState(provider)\n', "      const st = this.deps.decisionState('jev')\n"]),
+  m('subq-cap-reason', ENGINE, ["off(provider === 'jev' ? 'jev_cap_reached' : 'decision_cap_reached')", "off('jev_cap_reached')"]),
+  m('subq-breaker-reason', ENGINE, ["off(provider === 'jev' ? 'jev_breaker_open' : 'decision_breaker_open')", "off('jev_breaker_open')"]),
+  m('capability-names-provider', ENGINE, ['...(provider ? { decisionProvider: provider } : {})', '...({})']),
+  m('quiet-decision-stops', ENGINE, ["'decision_cap_reached', 'decision_breaker_open', 'decision_not_configured', 'decision_invalid_provider'])", "'decision_breaker_open', 'decision_not_configured', 'decision_invalid_provider'])"]),
+  m('quiet-sees-decision-errors', ENGINE, ['if ((error instanceof JevError || error instanceof DecisionProviderError) && QUIET_DECISION_STOPS.has(error.code)) {', 'if (error instanceof JevError && QUIET_DECISION_STOPS.has(error.code)) {']),
+  m('decision-error-code-traced', ENGINE, ["trace.error = error instanceof JevError || error instanceof DecisionProviderError ? error.code :", "trace.error = error instanceof JevError ? error.code :"]),
+  m('subq-cue-cap-env', ENGINE, ['Number(process.env.COS_LIVE_CUES_SUBQ_DAILY_TOKENS)', 'Number(process.env.COS_SUBQ_DAILY_TOKENS)']),
+  m('subq-cue-ledger', ENGINE, ["dataPath('subq-cues-usage.json')", "dataPath('subq-usage.json')"]),
+  m('subq-configured-honest', ENGINE, ['return { configured: st.configured, breakerOpen: st.breakerOpenUntil !== null', 'return { configured: true, breakerOpen: st.breakerOpenUntil !== null']),
+  m('subq-status-unreadable-is-spent', DECISION, ['    let usedToday = dailyCap\n', '    let usedToday = 0\n']),
+  m('subq-tracked-for-new-key', DECISION, ['{ configuredSubqClients.add(client); return client }', '{ return client }']),
+  // ── Live COS Ask: memory bridge fallback ──
+  m('ask-listing-only-when-memory-did-not-answer', ASKLIB, ['  const memoryDidNotAnswer = memoryRaw.length === 0 ||', '  const memoryDidNotAnswer = true ||'], ASK),
+  m('ask-listing-when-memory-empty', ASKLIB, ['  const memoryDidNotAnswer = memoryRaw.length === 0 ||', '  const memoryDidNotAnswer = false ||'], ASK),
+  m('ask-listing-when-meaning-failed', ASKLIB, ["|| (memory.status === 'fulfilled' && semantic && !memory.value.semanticAvailable)\n", '\n'], ASK),
+  m('ask-listing-meaning-only', ASKLIB, ["(memory.status === 'fulfilled' && semantic && !memory.value.semanticAvailable)", "(memory.status === 'fulfilled' && !memory.value.semanticAvailable)"], ASK),
+  m('ask-listing-threshold', ASKLIB, ['x.score >= ASK_HIT_MIN && (!domain', 'x.score > 0 && (!domain'], ASK),
+  m('ask-listing-domain', ASKLIB, ['x.score >= ASK_HIT_MIN && (!domain || x.row.domain === domain)', 'x.score >= ASK_HIT_MIN'], ASK),
+  m('ask-memory-cap-three', ASKLIB, ['const memorySources = fused.ranked(3)', 'const memorySources = fused.ranked()'], ASK),
+  m('ask-listing-notice', ASKLIB, ["  if (memorySources.some(s => s.listed)) notices.push('COS also searched the notes in its memory list by keyword.')\n", ''], ASK),
+  m('ask-abort-skips-listing', ASKLIB, ['if (memoryDidNotAnswer && !signal?.aborted) {', 'if (memoryDidNotAnswer) {'], ASK),
+  m('ask-listing-failure-tolerated', ASKLIB, ['try { listed = await bridge(signal) } catch { /* no listing: the notices above stand */ }', 'listed = await bridge(signal)'], ASK),
+  m('ask-source-id-first', ASKLIB, ["({ id: `H${sources.length + 1}`, ...s })", "({ ...s, id: `H${sources.length + 1}` })"], ASK),
+  m('ask-listing-cites-content', ASKLIB, ['text: redactSecrets(row.content).slice(0, 1500), memoryId: row.id', "text: '', memoryId: row.id"], ASK),
+  m('ask-default-listing-is-the-bridge', ASKLIB, ['bridge: AskBridgeList = s => listBridgeMemories(s)', 'bridge: AskBridgeList = async () => []'], ASK),
+]
+
+const args = process.argv.slice(2)
+if (args.includes('--list')) { for (const { name } of mutations) console.log(name); process.exit(0) }
+const selected = args.length ? mutations.filter(({ name }) => args.includes(name)) : mutations
+if (args.length && selected.length !== args.length) throw new Error('Unknown mutation name in: ' + args.join(' '))
+if (new Set(mutations.map(x => x.name)).size !== mutations.length) throw new Error('Duplicate mutation name')
+
+const scratch = mkdtempSync(join(tmpdir(), 'cues-notes-mutations-'))
+try {
+  const skip = new Set(['data', 'models', 'certs', 'node_modules'])
+  cpSync(join(root, 'server'), join(scratch, 'server'), { recursive: true, filter: src => !(skip.has(basename(src)) && dirname(src) === join(root, 'server')) })
+  for (const dir of ['shared', 'work-task-runtime', 'bin', 'docs', 'memory-runtime']) cpSync(join(root, dir), join(scratch, dir), { recursive: true })
+  for (const file of ['vitest.config.ts', 'package.json', 'managed-runtime-contract.json']) cpSync(join(root, file), join(scratch, file))
+  symlinkSync(join(root, 'node_modules'), join(scratch, 'node_modules'), 'dir')
+  const run = tests => spawnSync(process.execPath, [join(root, 'node_modules/vitest/vitest.mjs'), 'run', '--maxWorkers=1', ...tests], {
+    cwd: scratch, env: { PATH: process.env.PATH, HOME: scratch, TMPDIR: process.env.TMPDIR, COS_DATA_DIR: join(scratch, 'data'), COS_PROFILE_PATH: join(scratch, 'data', 'profile.json') },
+    encoding: 'utf8', timeout: 300000,
+  })
+  const baseline = run(ALL)
+  if (baseline.status !== 0) throw new Error('Baseline failed; a gate over a red suite proves nothing:\n' + baseline.stdout + '\n' + baseline.stderr)
+  const totals = /Tests\s+(\d+) passed/.exec(baseline.stdout)
+  console.log(`baseline PASS (${totals ? totals[1] : '?'} tests in ${ALL.length} files)`)
+  let killed = 0
+  for (const { name, file, edits, tests } of selected) {
+    const target = join(scratch, file), original = readFileSync(target, 'utf8')
+    let mutated = original
+    for (const [find, replacement] of edits) {
+      if (mutated.split(find).length !== 2) throw new Error(`Mutation ${name} does not match exactly once in ${file}: ${find.slice(0, 80)}`)
+      mutated = mutated.replace(find, () => replacement)
+    }
+    if (mutated === original) throw new Error(`Mutation ${name} did not change ${file}`)
+    writeFileSync(target, mutated)
+    let result
+    try { result = run(tests) } finally { writeFileSync(target, original) }
+    if (readFileSync(target, 'utf8') !== original) throw new Error(`Restore failed for ${file} after ${name}`)
+    const output = result.stdout + '\n' + result.stderr
+    const killers = [...new Set([...output.matchAll(/FAIL\s+(server\/\S+\.test\.ts > [^\n]+)/g)].map(x => x[1].trim()))]
+    if (result.status === 0 || result.error || !killers.length) { console.log(`${name} SURVIVED or harness failed\n${output.slice(-3000)}`); process.exitCode = 1; continue }
+    killed += 1
+    console.log(`${name} KILLED by ${killers.slice(0, 2).join(' | ')}${killers.length > 2 ? ` (+${killers.length - 2} more)` : ''}`)
+  }
+  console.log(`${killed} of ${selected.length} live cues and Ask 6.76.2 mutations killed`)
+} finally { rmSync(scratch, { recursive: true, force: true }) }

package/server/scripts/transcript-cleanup-mutation-gate.mjs

@@ -0,0 +1,219 @@
+#!/usr/bin/env node
+// Transcript cleanup 6.77.0 mutation gate: span selection, the deterministic fixes, the edit guards, the ledger, the stop
+// conditions, the screen-context store and route, the dictionary suggestions and the save wiring. Mutations run only in a
+// disposable copy of the checkout; the live checkout is never rewritten.
+//
+// What it proves, in order:
+//   0. The target suites are GREEN unmutated. A gate over a red suite reads every mutant as killed and proves nothing.
+//   1. Each target string appears EXACTLY ONCE in its file, so the mutation is unambiguous.
+//   2. The mutated file differs from the original, so the edit landed.
+//   3. A NAMED test fails ("FAIL  server/x.test.ts > name"); a build error or a harness failure is not a kill.
+//   4. The file is restored byte for byte (compared) before the next mutant.
+// Usage: node server/scripts/transcript-cleanup-mutation-gate.mjs [--list | --check] [name…]
+import { mkdtempSync, cpSync, readFileSync, writeFileSync, symlinkSync, rmSync } from 'node:fs'
+import { tmpdir } from 'node:os'
+import { resolve, join, dirname, basename } from 'node:path'
+import { fileURLToPath } from 'node:url'
+import { spawnSync } from 'node:child_process'
+
+const root = resolve(dirname(fileURLToPath(import.meta.url)), '../..')
+const LIB = ['server/lib/transcript-cleanup.test.ts', 'server/lib/transcript-cleanup-spans.test.ts']
+const ROUTE = ['server/routes/transcript-cleanup.test.ts']
+const MEETING = ['server/routes/meeting.test.ts']
+const WIRE = ['server/routes/health.test.ts', 'server/routes/transcribe.test.ts', 'server/lib/transcript-cleanup-provider.test.ts']
+const ALL = [...LIB, ...ROUTE, ...MEETING, ...WIRE]
+const RUN = 'server/lib/transcript-cleanup.ts', SPANS = 'server/lib/transcript-cleanup-spans.ts', TEXT = 'server/lib/transcript-cleanup-text.ts'
+const MODEL = 'server/lib/transcript-cleanup-model.ts', LEDGER = 'server/lib/transcript-cleanup-ledger.ts', STATE = 'server/lib/transcript-cleanup-state.ts'
+const SCREEN = 'server/lib/transcript-cleanup-screen.ts', SUG = 'server/lib/transcript-cleanup-suggestions.ts', CTX = 'server/lib/transcript-cleanup-context.ts'
+const R = 'server/routes/transcript-cleanup.ts', MEET = 'server/routes/meeting.ts'
+const m = (name, file, edits, tests = LIB) => ({ name, file, edits: typeof edits[0] === 'string' ? [edits] : edits, tests })
+
+const mutations = [
+  // ── Switch, model, stops ──
+  m('switch-checked-first', RUN, ['if (!resolveCleanupSwitch(deps.env, deps.settings).enabled) return', 'if (false) return']),
+  m('env-0-forces-off', STATE, ["  if (env.COS_TRANSCRIPT_CLEANUP === '0') return { enabled: false, source: 'env' }\n", '']),
+  m('env-1-forces-on', STATE, ["  if (env.COS_TRANSCRIPT_CLEANUP === '1') return { enabled: true, source: 'env' }\n", '']),
+  m('default-off', STATE, ["  return { enabled: false, source: 'default' }", "  return { enabled: true, source: 'default' }"], [...LIB, ...ROUTE]),
+  m('default-model-haiku', STATE, ["return { choice: 'haiku', id: CLEANUP_MODEL_IDS.haiku, source: 'default' }", "return { choice: 'sonnet', id: CLEANUP_MODEL_IDS.sonnet, source: 'default' }"], [...LIB, ...ROUTE]),
+  m('setting-model-read', STATE, ["  if (stored) return { choice: stored, id: CLEANUP_MODEL_IDS[stored], source: 'setting' }\n", '']),
+  m('env-model-wins', STATE, ["  if (raw === 'haiku' || raw === 'sonnet') return { choice: raw, id: CLEANUP_MODEL_IDS[raw], source: 'env' }\n", '']),
+  m('charge-before-call', RUN, ["else if (!deps.budget.charge(limits)) modelSkipped = 'daily_calls'", "else if (false) modelSkipped = 'daily_calls'"]),
+  m('gate-breaker', STATE, ["    if (s.breakerOpenUntil !== null && this.now().getTime() < s.breakerOpenUntil) return 'breaker_open'\n", '']),
+  m('gate-daily-calls', STATE, ["    if (s.calls >= limits.dailyCalls) return 'daily_calls'\n", '']),
+  m('gate-daily-tokens', STATE, ["    if (s.tokens >= limits.dailyTokens) return 'daily_tokens'\n", '']),
+  m('usage-recorded', RUN, ['          deps.budget.recordUsage(trace.inputTokens + trace.outputTokens)\n', '']),
+  m('provider-limit-opens-breaker', STATE, ['const open = providerLimit || failures >= limits.breakerFailures', 'const open = failures >= limits.breakerFailures']),
+  m('breaker-after-three', STATE, ['    breakerFailures: 3,', '    breakerFailures: 4,']),
+  m('success-closes-breaker', STATE, ['    this.write({ ...s, consecutiveFailures: 0, breakerOpenUntil: null })', '    return']),
+  m('unreadable-state-is-spent', STATE, ['    } catch {\n      return spent\n', '    } catch {\n      return { day, calls: 0, tokens: 0, consecutiveFailures: 0, breakerOpenUntil: null }\n']),
+  m('future-day-is-spent', STATE, ['      if (raw.day > day) return { ...spent, ...breaker }\n', '']),
+  m('negative-count-is-spent', STATE, ['      if (!(calls >= 0) || !(tokens >= 0)) return { ...spent, ...breaker }\n', '']),
+  m('failure-recorded', RUN, ['          deps.budget.recordFailure(limits, limit)\n', '']),
+  m('api-key-guard', RUN, ["else if (deps.env.ANTHROPIC_API_KEY && deps.env.COS_ALLOW_API_FALLBACK !== '1') modelSkipped = 'api_key_in_env'", "else if (false) modelSkipped = 'api_key_in_env'"]),
+  m('claude-cli-guard', RUN, ["else if (!deps.claudeAvailable()) modelSkipped = 'claude_not_found'", "else if (false) modelSkipped = 'claude_not_found'"]),
+  m('live-session-skipped', RUN, ["    if (live) return finish({ status: 'skipped', reason: 'session_live', applied: 0 })", "    if (false) return finish({ status: 'skipped', reason: 'session_live', applied: 0 })"]),
+  m('span-cap-per-meeting', RUN, ['{ maxSpans: limits.maxSpans, fixed:', '{ maxSpans: 80, fixed:']),
+  m('idempotent-rerun', RUN, ["    if (alreadyCleaned(input.sessionId, inputSha)) return finish({ status: 'skipped', reason: 'already_done', applied: 0 })", "    if (false) return finish({ status: 'skipped', reason: 'already_done', applied: 0 })"]),
+  m('ledger-intent-first', RUN, ["    if (!appendLedger(input.sessionId, [{ kind: 'run', runId, phase: 'intent', at: at(), inputSha }])) {", "    if (!appendLedger(input.sessionId, [{ kind: 'run', runId, phase: 'intent', at: at(), inputSha }]) && false) {"]),
+  m('prompt-size-cap', MODEL, ['    if (prompt.length + block.length + 1 > MODEL_LIMITS.promptChars) break\n', '']),
+  m('screen-lines-in-prompt', MODEL, ['const screen = screenLinesFor(pack.screen, span.atMs, span.near, { max: MODEL_LIMITS.screenLinesPerSpan })', 'const screen: typeof pack.screen = []']),
+  m('owner-in-prompt', MODEL, ['  if (pack.owner) {\n    head.push', '  if (false) {\n    head.push']),
+  m('parse-scans-past-first-object', MODEL, ["    i = text.indexOf('{', i + 1)", '    i = -1']),
+  m('parse-string-aware', MODEL, ["        else if (c === '\"') inString = false", '']),
+
+  m('notes-exclude-this-meeting', RUN, ['if (!hit.recordId || hit.sessionId === sessionId) continue', 'if (!hit.recordId) continue']),
+  m('notes-bridge-when-memory-empty', RUN, ['      if (!memoryHits && !signal.aborted) {', '      if (!signal.aborted) {']),
+  m('notes-in-prompt', MODEL, ['  for (const n of pack.notes) head.push', '  for (const n of [] as typeof pack.notes) head.push']),
+  m('notes-snippet-bounded', CTX, [
+    ["snippet: redactSecrets(n.snippet).replace(/\\s+/g, ' ').slice(0, CONTEXT_LIMITS.noteChars) }\n    pack.notes.push(note)", "snippet: n.snippet }\n    pack.notes.push(note)"]]),
+  m('notes-snippet-clipped-in-prompt', MODEL, ['${quote(n.title)}: ${clip(n.snippet, 280)}`)', '${quote(n.title)}: ${n.snippet}`)']),
+
+  // ── Span selection ──
+  m('parakeet-floor', SPANS, ["  if (engine.startsWith('parakeet')) return LOW_CONFIDENCE.parakeet\n", '']),
+  m('fillers-never-doubtful', SPANS, [' && !FILLERS.has(t.key)) flag(t.i, ', ') flag(t.i, ']),
+  m('near-name-needs-unsure', SPANS, ['const unsure = input.probability === undefined || input.probability < NEAR_NAME_UNSURE', 'const unsure = true']),
+  m('near-name-inflection-skip', SPANS, ['    if (inflectionOf(key, t.key)) continue\n', '']),
+  m('exact-join-is-a-hit', SPANS, ['    if (d === 0 && !input.join) return null', '    if (d === 0) return null']),
+  m('join-no-function-words', SPANS, ['group.some(g => g.key.length > 5 || FUNCTION_WORDS.has(g.key))', 'group.some(g => g.key.length > 5)']),
+  m('join-pieces-short', SPANS, ['group.some(g => g.key.length > 5 || FUNCTION_WORDS.has(g.key))', 'group.some(g => FUNCTION_WORDS.has(g.key))']),
+  m('sounds-alike-onset', TEXT, ['  if (vowelOnset(fa) !== vowelOnset(fb)) return false\n', '']),
+  m('sounds-alike-two-consonants', TEXT, ['  if (sa.length < 2 || sa !== sb) return false', '  if (sa !== sb) return false']),
+  m('oov-not-at-sentence-start', SPANS, ['if (fixed.has(t.i) || t.sentenceStart || !/^\\p{Lu}/u.test(t.core)', 'if (fixed.has(t.i) || !/^\\p{Lu}/u.test(t.core)']),
+  m('repeat-needs-three', SPANS, ['if (reps >= (unit === 1 ? 4 : 3)) found', 'if (reps >= 2) found']),
+  m('merge-stops-at-clause', SPANS, ['      if (tokens.slice(to - 1, next).some(t => /[,.;:!?]["\')\\]]*$/.test(t.raw))) break\n', '']),
+  m('merge-stays-in-line', SPANS, ['      if (tokens[next].line !== tokens[from].line || next - to > 1', '      if (next - to > 1']),
+  m('span-word-cap', SPANS, ['  maxSpanWords: 6,', '  maxSpanWords: 8,']),
+  m('names-ranked-first', SPANS, ["(d.reasons.has('near_name') ? 4 : 0)", "(d.reasons.has('near_name') ? 0 : 0)"]),
+  m('align-by-folded-word', TEXT, ['if (words[k].word === token.raw || fold(words[k].word) === token.key)', 'if (words[k].word === token.raw)']),
+  m('word-time-on-meeting-clock', TEXT, ['Math.round(startTime + startElapsed + s * 1000)', 'Math.round(startTime + s * 1000)']),
+
+  // ── Deterministic fixes ──
+  m('fix-capitalised-only', SPANS, ['if (!/^\\p{Lu}/u.test(base) || allLower.has(base.toLowerCase()) || known.has(fold(base))) continue', 'if (allLower.has(base.toLowerCase()) || known.has(fold(base))) continue']),
+  m('fix-never-a-known-spelling', SPANS, ['if (!/^\\p{Lu}/u.test(base) || allLower.has(base.toLowerCase()) || known.has(fold(base))) continue', 'if (!/^\\p{Lu}/u.test(base) || allLower.has(base.toLowerCase())) continue']),
+  m('fix-strong-only-when-unsure', SPANS, ['let replacement = unsure ? fuzzyReplacementFor(base, strong, allLower) : null', 'let replacement = fuzzyReplacementFor(base, strong, allLower)']),
+  m('fix-sentence-opener-only-unsure', SPANS, ['    if (token.sentenceStart && !unsure) continue\n', '']),
+  m('fix-no-inflection', SPANS, ['if (replacement === null || replacement === base || inflectionOf(base, replacement)) continue', 'if (replacement === null || replacement === base) continue']),
+  m('fix-no-attendee-targets', RUN, ['const strongTargets = [...pack.vocabulary, ...pack.corrections.map(c => c.written), ...(pack.owner ? [pack.owner.name] : [])]', 'const strongTargets = [...pack.vocabulary, ...pack.corrections.map(c => c.written), ...pack.speakers, ...(pack.owner ? [pack.owner.name] : [])]']),
+
+  // ── Edit guards ──
+  m('only-sent-ids', MODEL, ['const byId = new Map(spans.filter(s => sentIds.includes(s.id)).map(s => [s.id, s]))', 'const byId = new Map(spans.map(s => [s.id, s]))']),
+  m('duplicate-rejected', MODEL, ["    if (seen.has(id)) { reject('duplicate'); continue }\n", '']),
+  m('bracket-is-unsafe', MODEL, ["/[\\u0000-\\u001f\\u007f\\[\\]]/.test(edit!.text", "/[\\u0000-\\u001f\\u007f]/.test(edit!.text"]),
+  m('no-op-rejected', MODEL, ["    if (text === span.text) { reject('no_op'); continue }\n", '']),
+  m('word-count-cap', MODEL, ['newWords.length > spanWords.length + 1 ||', 'newWords.length > spanWords.length + 9 ||']),
+  m('char-length-cap', MODEL, [' || text.length > span.text.length * 2 + 8) {', ') {']),
+  m('repeat-shrinks-to-own-run', MODEL, ["      if (!isRun) { reject('longer_than_span'); continue }\n", '']),
+  m('outside-span-before', MODEL, ['(beforeLast && firstNew === beforeLast && !spanKeys.has(beforeLast)) || ', '']),
+  m('outside-span-after', MODEL, [' || (afterFirst && lastNew === afterFirst && !spanKeys.has(afterFirst))', '']),
+  m('numbers-unchanged', MODEL, ["    if (numbers(text) !== numbers(span.text)) { reject('number_unit'); continue }\n", '']),
+  m('negations-unchanged', MODEL, ["    if (negationCount(text) !== negationCount(span.text)) { reject('negation'); continue }\n", '']),
+  m('added-content-rejected', MODEL, ["    if (unsupported.length) { reject('added_content'); continue }\n", '']),
+  m('context-terms-admit', MODEL, ['const knownTerm = (w: string) => pack.terms.has(fold(w))', 'const knownTerm = (_w: string) => false']),
+
+  // ── Ledger and writes ──
+  m('overlap-dropped', LEDGER, ['      if (e.start < cursor || e.end > source.length || e.start >= e.end) continue', '      if (e.end > source.length || e.start >= e.end) continue']),
+  m('commit-refuses-changed-files', LEDGER, ["  if (markdownNow !== options.markdown || sidecarNow !== options.sidecarText) throw new CleanupWriteError('changed_during_cleanup')\n", '']),
+  m('failed-markdown-restores-sidecar', LEDGER, ['    try { write(options.sidecarPath, options.sidecarText) } catch { /* the two files now disagree; say so */ }\n', '']),
+  m('batch-transcript-kept-canonical', LEDGER, ["sidecar.batchTranscript.replace(/\\n+$/, '') === oldSection) sidecar.batchTranscript = options.transcript", "sidecar.batchTranscript.replace(/\\n+$/, '') === oldSection) sidecar.batchTranscript = sidecar.batchTranscript"]),
+  m('lifecycle-revision-bumped', LEDGER, ['  sidecar.lifecycleRevision = Number(sidecar.lifecycleRevision ?? 0) + 1\n', '']),
+  m('undo-refuses-stale', LEDGER, ["    if (at < 0) return { ok: false, status: 409, error: 'stale' }\n", '']),
+  m('undo-exact-offsets', LEDGER, ['    if (untouched.get(line.index) && line.text.slice(edit.offset, edit.offset + edit.replacement.length) === edit.replacement) at = edit.offset', '    if (false) at = edit.offset']),
+  m('undo-records-revert', LEDGER, ["  appendLedger(options.sessionId, targets.map(t => ({ kind: 'revert' as const, editId: t.id, at: now })))\n", '']),
+
+  // ── Screen context ──
+  m('screen-secrets-held', SCREEN, ['    if (imageTextHasSecrets(o.text) || imageTextHasSecrets(text)) { result.held++; continue }\n', ''], [...LIB, ...ROUTE]),
+  m('screen-line-truncated', SCREEN, ['    if (text.length > SCREEN_LIMITS.charsPerLine) { text = text.slice(0, SCREEN_LIMITS.charsPerLine); result.truncated++ }\n', '']),
+  m('screen-duplicates', SCREEN, ["    if (recent.some(r => norm(r.text) === key && Math.abs(r.at - at) <= SCREEN_LIMITS.duplicateWindowMs)) { result.duplicates++; continue }\n", '']),
+  m('screen-clock-bounds', SCREEN, ['at === null || at < earliest || at > latest ||', 'at === null ||']),
+  m('screen-meeting-line-cap', SCREEN, ['if (result.stored >= SCREEN_LIMITS.linesPerMeeting || storedBytes', 'if (storedBytes']),
+  m('screen-request-line-cap', SCREEN, ["  if (lines.length > SCREEN_LIMITS.linesPerRequest) throw new ScreenContextError('too_many_lines', 413)\n", ''], [...LIB, ...ROUTE]),
+  m('screen-request-byte-cap', SCREEN, ["  if (requestBytes > SCREEN_LIMITS.bytesPerRequest) throw new ScreenContextError('request_too_large', 413)\n", ''], [...LIB, ...ROUTE]),
+  m('screen-path-confined', SCREEN, [
+    ['  if (!SESSION_ID.test(sessionId)) return null\n', ''],
+    ["  return resolve(path).startsWith(resolve(dir) + '/') ? path : null", '  return path']]),
+  m('route-unknown-session-404', R, ["    if (!meeting) return { ok: false, status: 404, error: 'unknown_session' }\n", ''], ROUTE),
+  m('route-cleanup-done-409', R, ["    return done ? { ok: false, status: 409, error: 'cleanup_done' } : { ok: true }", '    return { ok: true }'], ROUTE),
+  m('route-env-forced-409', R, ["    if (hasEnabled && (env.COS_TRANSCRIPT_CLEANUP === '1' || env.COS_TRANSCRIPT_CLEANUP === '0') && body.enabled !== (env.COS_TRANSCRIPT_CLEANUP === '1')) {", '    if (false) {'], ROUTE),
+  m('sweep-keeps-known', SCREEN, ['        try { gone = !opts.known(sessionId) } catch { gone = false }', '        gone = true'], ROUTE),
+  m('sweep-screen-retention', SCREEN, ["      const expired = kind === 'screen' && age > retentionMs", '      const expired = false'], ROUTE),
+
+  // ── Dictionary suggestions ──
+  m('suggestion-needs-evidence', SUG, ['if (!written || written.length > 100 || !input.evidence.length) return null', 'if (!written || written.length > 100) return null'], [...LIB, ...ROUTE]),
+  m('suggestion-not-for-dictionary-words', SUG, ['    if (input.inDictionary(written)) return null\n', ''], ROUTE),
+  m('suggestion-dismissed-stays-out', SUG, ["    if (existing && existing.status !== 'pending') return null\n", ''], ROUTE),
+  m('suggestion-dedupe-case', SUG, ['const existing = list.find(s => same(s.written, written))', 'const existing = list.find(s => s.written === written)'], ROUTE),
+  m('orchestrator-skips-dictionary-terms', RUN, [
+    ['      if (!term || inDictionary(term) || heardKeys.has(term.key)) continue', '      if (!term || heardKeys.has(term.key)) continue'],
+    ["        if (deps.suggestions.record({ written: term.display, heard: edit.original, evidence, sessionId, at, inDictionary: w => dictionary.has(w.trim().toLowerCase()) })) recorded++", "        if (deps.suggestions.record({ written: term.display, heard: edit.original, evidence, sessionId, at, inDictionary: () => false })) recorded++"]]),
+  m('orchestrator-longest-term', RUN, ['      if (parts.every(p => covered.has(p))) continue\n', '']),
+  m('evidence-maps-screen', CTX, ["['screen', 'screen'], ", '']),
+  m('accept-uses-vocabulary-writer', R, ['        : await addVocabulary(suggestion.written)', "        : { status: 200, body: { unchanged: false, glossary: null } }"], ROUTE),
+  m('accept-correction-path', R, ["const outcome = body.correction === true && heard", 'const outcome = false && heard'], ROUTE),
+  m('accept-refuses-dismissed', R, ["    if (suggestion.status === 'dismissed') return res.status(409).json({ error: 'suggestion_dismissed' })\n", ''], ROUTE),
+
+  // ── Save wiring and capability ──
+  m('cleanup-stage-in-finalization', MEET, ['    await runCleanupStage(runtime.transcriptCleanup, { sessionId: current.sessionId, meetingPath: current.meetingPath, sidecarPath: current.sidecarPath }, runtime.sessions)\n', ''], MEETING),
+  m('cleanup-stage-never-fails-save', MEET, ['  try {\n    await run(input)\n  } catch (error) {', '  {\n    await run(input)\n  } if (false) { const error = null as unknown;'], MEETING),
+  m('health-says-off', R, ['  return { protocol: TRANSCRIPT_CLEANUP_PROTOCOL, enabled }', '  return { protocol: TRANSCRIPT_CLEANUP_PROTOCOL, enabled: true }'], [...ROUTE, ...WIRE]),
+  m('capabilities-advertised', 'server/routes/transcribe.ts', ['    transcriptCleanup: { protocol: 1, suggestions: 1, screenContext: 1 },\n', ''], WIRE),
+  m('provider-source-tag', RUN, ["source: 'transcript-cleanup', maxOutputTokens: opts.maxOutputTokens", "source: 'lens_gist', maxOutputTokens: opts.maxOutputTokens"], WIRE),
+]
+
+const args = process.argv.slice(2)
+if (args.includes('--list')) { for (const { name } of mutations) console.log(name); process.exit(0) }
+const selected = args.length && !args.includes('--check') ? mutations.filter(({ name }) => args.includes(name)) : mutations
+if (args.length && !args.includes('--check') && selected.length !== args.length) throw new Error('Unknown mutation name in: ' + args.join(' '))
+if (new Set(mutations.map(x => x.name)).size !== mutations.length) throw new Error('Duplicate mutation name')
+// --check: every target matches exactly once and changes its file. Runs no tests.
+if (args.includes('--check')) {
+  let bad = 0
+  for (const { name, file, edits } of mutations) {
+    let text = readFileSync(join(root, file), 'utf8')
+    const original = text
+    for (const [find, replacement] of edits) {
+      const n = text.split(find).length - 1
+      if (n !== 1) { console.log(`${name}: matches ${n} times in ${file}: ${find.slice(0, 90)}`); bad++ }
+      else text = text.replace(find, () => replacement)
+    }
+    if (text === original) { console.log(`${name}: no change`); bad++ }
+  }
+  console.log(`${mutations.length - bad} of ${mutations.length} targets match exactly once`)
+  process.exit(bad ? 1 : 0)
+}
+
+const scratch = mkdtempSync(join(tmpdir(), 'transcript-cleanup-mutations-'))
+try {
+  const skip = new Set(['data', 'models', 'certs', 'node_modules'])
+  cpSync(join(root, 'server'), join(scratch, 'server'), { recursive: true, filter: src => !(skip.has(basename(src)) && dirname(src) === join(root, 'server')) })
+  for (const dir of ['shared', 'work-task-runtime', 'bin', 'docs']) cpSync(join(root, dir), join(scratch, dir), { recursive: true })
+  for (const file of ['vitest.config.ts', 'package.json', 'managed-runtime-contract.json']) cpSync(join(root, file), join(scratch, file))
+  symlinkSync(join(root, 'node_modules'), join(scratch, 'node_modules'), 'dir')
+  const run = tests => spawnSync(process.execPath, [join(root, 'node_modules/vitest/vitest.mjs'), 'run', '--maxWorkers=1', ...tests], {
+    cwd: scratch, env: { PATH: process.env.PATH, HOME: scratch, TMPDIR: process.env.TMPDIR, COS_DATA_DIR: join(scratch, 'data'), COS_PROFILE_PATH: join(scratch, 'data', 'profile.json') },
+    encoding: 'utf8', timeout: 300000,
+  })
+  const baseline = run(ALL)
+  if (baseline.status !== 0) throw new Error('Baseline failed; a gate over a red suite proves nothing:\n' + baseline.stdout + '\n' + baseline.stderr)
+  const totals = /Tests\s+(\d+) passed/.exec(baseline.stdout)
+  console.log(`baseline PASS (${totals ? totals[1] : '?'} tests in ${ALL.length} files)`)
+  let killed = 0
+  for (const { name, file, edits, tests } of selected) {
+    const target = join(scratch, file), original = readFileSync(target, 'utf8')
+    let mutated = original
+    for (const [find, replacement] of edits) {
+      if (mutated.split(find).length !== 2) throw new Error(`Mutation ${name} does not match exactly once in ${file}: ${find.slice(0, 80)}`)
+      mutated = mutated.replace(find, () => replacement)
+    }
+    if (mutated === original) throw new Error(`Mutation ${name} did not change ${file}`)
+    writeFileSync(target, mutated)
+    let result
+    try { result = run(tests) } finally { writeFileSync(target, original) }
+    if (readFileSync(target, 'utf8') !== original) throw new Error(`Restore failed for ${file} after ${name}`)
+    const output = result.stdout + '\n' + result.stderr
+    const killers = [...new Set([...output.matchAll(/FAIL\s+(server\/\S+\.test\.ts > [^\n]+)/g)].map(x => x[1].trim()))]
+    if (result.status === 0 || result.error || !killers.length) { console.log(`${name} SURVIVED or harness failed\n${output.slice(-3000)}`); process.exitCode = 1; continue }
+    killed += 1
+    console.log(`${name} KILLED by ${killers.slice(0, 2).join(' | ')}${killers.length > 2 ? ` (+${killers.length - 2} more)` : ''}`)
+  }
+  console.log(`${killed} of ${selected.length} transcript cleanup 6.77.0 mutations killed`)
+} finally { rmSync(scratch, { recursive: true, force: true }) }

package/shared/live-cues-v2.ts

@@ -1,5 +1,5 @@
 /**
- * Live cues v2 wire contract (server 6.75 candidate, companion 6.10.641 candidate).
+ * Live cues v2 wire contract (server 6.75 candidate, companion 6.10.641 candidate; optional capability fields since 6.76.2).
  * Additive to v1: old clients keep receiving `coaching_nudge` and ignore the new named event.
  * The companion keeps a byte-identical copy at src/lib/live-cues-v2-contract.ts.
  */
@@ -33,13 +33,18 @@ export interface LiveCueV2 {
 /** v1 `coaching_nudge` as the v2 engine emits it for old clients (headline only). */
 export interface LiveCueV1Compat { nudge: string; type: CueKind; priority: 2; cueId: string; sessionId: string; protocol: 2 }
 
-/** `reason` when unavailable: master_flag_off, api_key_in_env, jev_not_configured, claude_not_found, budget_exhausted,
- *  jev_cap_reached, jev_breaker_open. */
-export interface LiveCuesV2Capability { available: boolean; reason?: string; protocol: 2; model: string }
+/** `reason` when unavailable: master_flag_off, api_key_in_env, decision_invalid_provider, decision_not_configured (no key
+ *  for the selected decision provider; jev_not_configured when Jev was chosen and only a SubQ key exists), claude_not_found,
+ *  budget_exhausted, jev_cap_reached, jev_breaker_open, decision_cap_reached, decision_breaker_open (the last two for SubQ).
+ *  Server 6.76.2 adds two optional fields; older servers omit them. `memory`: where past notes come from (cue_memory.py,
+ *  the owner's own COS notes and meetings, or nothing). `decisionProvider`: which classifier runs the gate and the judge. */
+export type LiveCuesV2MemorySource = 'cue_memory' | 'notes' | 'none'
+export interface LiveCuesV2Capability { available: boolean; reason?: string; protocol: 2; model: string; memory?: LiveCuesV2MemorySource; decisionProvider?: 'jev' | 'subq' }
 
 /** Why cues are not coming for this meeting. `active` means evaluations are running normally (silence is a choice). */
 export type LiveCuesV2SessionState = 'active' | 'paused' | 'ended' | 'stopped'
 export type LiveCuesV2StopReason = 'breaker_open' | 'meeting_cap' | 'budget_exhausted' | 'jev_cap_reached' | 'jev_breaker_open' | 'jev_not_configured'
+  | 'decision_cap_reached' | 'decision_breaker_open' | 'decision_not_configured' | 'decision_invalid_provider'
 
 export interface LiveCuesV2SessionStatus {
   sessionId: string

package/shared/meeting-ask.ts

@@ -40,7 +40,8 @@ export interface MeetingAskSource {
   /** Server-owned accepted post-stop quotation; no live turn target or precise word clock. */
   finalizedTranscript?: boolean
     id: string;
-    kind: 'transcript' | 'memory' | 'meeting' | 'file' | 'web';
+    /** 'profile' (server 6.76.0): the COS owner card from the profile; cited with an H id like other COS history. */
+    kind: 'transcript' | 'memory' | 'meeting' | 'file' | 'web' | 'profile';
     title: string;
     text: string;
     turnId?: number;
@@ -115,6 +116,8 @@ export function meetingAskFromLine(sections: readonly MeetingAskSection[] | unde
         } }));
         parts.push(hosts.length ? `the web, ${hosts.slice(0, 2).join(', ')}` : 'the web');
     }
+    if (used.some(s => s.kind === 'profile'))
+        parts.push('COS profile');
     if (used.some(s => s.kind === 'memory'))
         parts.push('COS memory');
     const meetings = unique(used.filter(s => s.kind === 'meeting').map(s => {
@@ -170,6 +173,8 @@ export interface MeetingAskExchange {
     files: MeetingAskFile[];
     error?: string;
     retryOf?: string;
+    /** Server 6.76.0: how long the answer took on the server and in which phase. Not the meeting position; that is throughMs. */
+    timings?: MeetingAskTimings;
     /** Server 6.71.13 (capabilities.factCheckScope): what a completed Fact check covered. Named-claim checks and follow-ups carry none. */
     factCheckRange?: MeetingAskFactCheckRange;
 }
@@ -178,6 +183,23 @@ export interface MeetingAskExchange {
  * check covers the whole meeting (full); each later one covers only what is new since the last completed
  * check's throughMs. A check that found nothing new still completes with claims 0, so the next one moves on.
  */
+/**
+ * One phase of one answer, in wall-clock ms on the server (6.76.0). plan is a model call that asked for a lookup,
+ * answer the one that wrote the draft, review the grounding check, public_topic the fact-check topic selection,
+ * fact_check the whole fact-check route. forced marks the COS lookup a person question always gets.
+ */
+export interface MeetingAskPhaseTiming {
+    phase: 'plan' | 'answer' | 'review' | 'cos_search' | 'web_search' | 'public_topic' | 'fact_check';
+    ms: number;
+    forced?: true;
+    failed?: true;
+    results?: number;
+}
+export interface MeetingAskTimings {
+    /** From the server starting the request to its final state. */
+    totalMs: number;
+    phases: MeetingAskPhaseTiming[];
+}
 export interface MeetingAskFactCheckRange {
     fromMs: number;
     throughMs: number;