@gotcos/glasses-server 6.95.0 → 6.98.0

package/server/lib/live-cues-v2.ts

@@ -15,6 +15,19 @@
 // own daily cap and breaker; resolveCuesDecisionProvider), and
 // when cue_memory.py is unavailable, fails or times out the memory arm searches the owner's own COS notes and meetings
 // instead (live-cues-v2-notes.ts; local keyword search, no model call). Each evaluation traces `cueMemorySource`.
+//
+// Live cues v3: `grounding: grounded` (a setting, default classic; COS_LIVE_CUES_GROUNDING=classic forces the old path) swaps
+// the memory and judge steps for grounded retrieval: cue_memory.py and the owner's notes in parallel, plus a best-matching
+// passage of the files attached to the meeting, minus this conversation's own copies and other domains' personal notes, judged
+// by one yes/no question per candidate (live-cues-v2-grounded.ts, live-cues-v2-judge-b.ts). With classic nothing in an
+// evaluation changes: the same Jev requests, writer prompt, trace row and cue, pinned by live-cues-v2-classic-pin.test.ts.
+//
+// Live cues v3, general cues: with cueMode `general` or `all` a server-wide runner (live-cues-general.ts) now and then looks up one
+// public fact for a Mac meeting and hands it to emitInsight() below. This engine only HOSTS it: it lists the extended meetings,
+// emits the insight, and passes end, pause, suspend and a mode change on as aborts. An insight is kept apart from the focused
+// state: its own list (`insights`), no v1 twin, and it never touches the focused counters, cooldown, lastCueAt, inFlight,
+// failures or breaker. `general` mode turns the FOCUSED cues off for Mac meetings (a G2 meeting keeps them: it cannot carry an
+// insight); `all` runs both.
 
 import { spawn, type ChildProcess } from 'node:child_process'
 import { appendFileSync, existsSync, mkdirSync, readFileSync } from 'node:fs'
@@ -27,26 +40,41 @@ import { DecisionProviderError, SubqDecisionClient, trackSubqDecisionClient, typ
 import type { DecisionProvider } from './decision-settings.js'
 import { resolveSubqKey } from './subq-key.js'
 import {
-  LIVE_CUES_V2_LIMIT_BOUNDS, LIVE_CUES_V2_LIMIT_NAMES, liveCuesV2EnvForced, liveCuesV2Settings, resolveLiveCuesV2,
-  type LiveCuesV2LimitName, type LiveCuesV2SettingReader, type LiveCuesV2SettingSource, type LiveCuesV2StoredLimits,
+  LIVE_CUES_GENERAL_LIMIT_BOUNDS, LIVE_CUES_GENERAL_LIMIT_NAMES, LIVE_CUES_V2_LIMIT_BOUNDS, LIVE_CUES_V2_LIMIT_NAMES, liveCuesV2EnvForced, liveCuesV2Settings,
+  resolveLiveCuesCueMode, resolveLiveCuesGrounding, resolveLiveCuesV2,
+  type LiveCuesCueMode, type LiveCuesGeneralLimitName, type LiveCuesGeneralStoredLimits, type LiveCuesGrounding, type LiveCuesV2LimitName, type LiveCuesV2Mode,
+  type LiveCuesV2SettingReader, type LiveCuesV2SettingSource, type LiveCuesV2StoredLimits,
 } from './live-cues-v2-settings.js'
 import { notesMemory } from './live-cues-v2-notes.js'
+import { GeneralCueRunner, realGeneralDeps, type GeneralCueCandidate, type GeneralCueDeps, type GeneralCueHost, type GeneralCueSettingsReader, type GeneralCueStatus, type GeneralInsight } from './live-cues-general.js'
+import { generalTriggerCalls } from './live-cues-general-prompts.js'
+import { isGenericSpeakerLabel } from './live-cues-general-topic.js'
+import { publicHttpsUrl } from './public-https-url.js'
+import { DATA_FACTS_FILE, DATA_WRITER_ADDENDUM, dataArmGate, dataCandidate, dataFactsReader, isQuiltDomain, quiltTitleSignal, type DataFactsRead } from './live-cues-v2-data.js'
+import { GROUNDED_LIMITS, SessionShingles, groundedCandidates, groundedSource, selfIdSet, usableFiles, type GroundedArm, type GroundedFile, type GroundedNote } from './live-cues-v2-grounded.js'
+import { JUDGE_B_WINDOW_CHARS, judgeBQuestions, parseJudgeB, selectJudgeB } from './live-cues-v2-judge-b.js'
 import { meetingLibraryConfigured } from './cos-operations-meetings.js'
 import { getMeetingStore } from './meeting-store.js'
+import { MeetingAskStore } from './meeting-ask-store.js'
+import { getOwnerHomeArea } from './profile.js'
 import { LensGistLimitError, runLensGistEngine } from './lens-gist-engines.js'
 import { resolveProviderBinary } from './provider-binary.js'
 import { COS_SCRIPTS_DIR, PYTHON_BIN, contextSourceAvailable } from './python-bridge.js'
 import { dataPath } from './data-dir.js'
+import { webLedger, type WebTodayView } from './web-lookup-ledger.js'
 import { durableAtomicWriteFileSync } from './atomic-fs.js'
 import { terminateProviderProcess } from './provider-process-lifecycle.js'
 import { cueBefore, liveCueVerdicts, type LiveCueLogRow } from './live-cue-verdicts.js'
-import { repeatOf, wouldWithhold } from './live-cues-filter.js'
+import { leadRepeatOf, repeatOf, wouldWithhold } from './live-cues-filter.js'
 import { errMsg } from './utils.js'
 import { CUE_GATE_QUESTIONS, CUE_JUDGE_INSTRUCTIONS, CUE_JUDGE_NONE, CUE_WRITER_SYSTEM_V2, CUE_WRITER_SYSTEM_V3 } from './live-cues-v2-prompts.js'
 import { CUE_WRITER_SYSTEM_V4 } from './live-cues-v2-prompts-kinds.js'
+import { KNOWN_NAMES_USE, knownNamesFor } from './live-cues-v2-names.js'
+import { paceAllowed, paceHorizon } from './live-cues-v2-pacing.js'
+import { OpenItemFold, openItemOf, openItemsDetail, openItemsHeadline, type FlushPlan } from './live-cues-v2-open-items.js'
 import { MAC_CAPTURE_ID } from './mac-recording.js'
 import {
-  CUE_DETAIL_MAX, CUE_FEEDBACK_REASON_MAX, CUE_HEADLINE_MAX, CUE_KINDS, LEGACY_CUE_KINDS, LIVE_CUES_V2_PROTOCOL, isLiveCueV2, legacyCueKind,
+  CUE_DETAIL_MAX, CUE_FEEDBACK_REASON_MAX, CUE_HEADLINE_MAX, CUE_KINDS, LEGACY_CUE_KINDS, LIVE_CUES_V2_PROTOCOL, isCueKind, isLiveCueV2, legacyCueKind,
   type CueKind, type CueKindSet, type CueSourceRef, type LiveCueV1Compat, type LiveCueV2, type LiveCuesV2Capability, type LiveCuesV2MemorySource,
   type LiveCuesV2SessionStatus, type LiveCuesV2StatusResponse, type LiveCuesV2StopReason,
 } from '../../shared/live-cues-v2.js'
@@ -69,6 +97,8 @@ export const LIVE_CUES_V2_LIMITS = {
   defaultWeeklyWriterCalls: 750,
   breakerFailures: 3,
   judgeKeep: 0.8,
+  /** Grounded cues (live cues v3): a candidate's own yes probability must reach this, from the replay of 2026-11-01. */
+  judgeYes: 0.65,
   judgeMaxNotes: 2,
   defaultGate: 0.8,
   memoryTimeoutMs: 6_000,
@@ -155,12 +185,43 @@ export function resolveLiveCuesV2Limits(env: NodeJS.ProcessEnv = process.env, se
   }
   return out
 }
+/** Live cues v3: the six general-cue limits, resolved like the v2 ones: an env value in bounds wins and locks, else the saved
+ *  value, else the default. An env value out of bounds is ignored with one log line per value. */
+export type LiveCuesGeneralLimits = Record<LiveCuesGeneralLimitName, LiveCuesV2Limit>
+export function resolveLiveCuesGeneralLimits(env: NodeJS.ProcessEnv = process.env, settings: LiveCuesV2SettingReader | null = liveCuesV2Settings()): LiveCuesGeneralLimits {
+  let saved: LiveCuesGeneralStoredLimits = {}
+  try { saved = settings?.generalLimits?.() ?? {} } catch { saved = {} }
+  const out = {} as LiveCuesGeneralLimits
+  for (const name of LIVE_CUES_GENERAL_LIMIT_NAMES) {
+    const b = LIVE_CUES_GENERAL_LIMIT_BOUNDS[name]
+    let e: number | null
+    if (b.integer) e = envWhole(env, b.env, b.min, b.max)
+    else {
+      const raw = env[b.env]
+      const n = raw === undefined || raw.trim() === '' ? null : Number(raw)
+      e = n === null ? null : n >= b.min && n <= b.max ? n : knobFallback<number | null>(b.env, raw!, null, `a number from ${b.min} to ${b.max}`)
+    }
+    const v = saved[name]
+    out[name] = e !== null ? { value: e, source: 'env', locked: true, min: b.min, max: b.max, default: b.default }
+      : v !== undefined ? { value: v, source: 'setting', locked: false, min: b.min, max: b.max, default: b.default }
+        : { value: b.default, source: 'default', locked: false, min: b.min, max: b.max, default: b.default }
+  }
+  return out
+}
 export function liveCuesV2JudgeKeep(env: NodeJS.ProcessEnv = process.env): number {
   const raw = env.COS_LIVE_CUES_V2_JUDGE_KEEP
   if (raw === undefined || raw.trim() === '') return LIVE_CUES_V2_LIMITS.judgeKeep
   const keep = Number(raw)
   return keep >= 0.5 && keep <= 0.95 ? keep : knobFallback('COS_LIVE_CUES_V2_JUDGE_KEEP', raw, LIVE_CUES_V2_LIMITS.judgeKeep, 'a number from 0.5 to 0.95')
 }
+/** COS_LIVE_CUES_V2_JUDGE_YES: the grounded judge's yes threshold, 0.5 to 0.95. Unset or empty is 0.65 silently; anything else
+ *  outside the range is 0.65 with one log line per value (the same rule as JUDGE_KEEP). */
+export function liveCuesV2JudgeYes(env: NodeJS.ProcessEnv = process.env): number {
+  const raw = env.COS_LIVE_CUES_V2_JUDGE_YES
+  if (raw === undefined || raw.trim() === '') return LIVE_CUES_V2_LIMITS.judgeYes
+  const yes = Number(raw)
+  return yes >= 0.5 && yes <= 0.95 ? yes : knobFallback('COS_LIVE_CUES_V2_JUDGE_YES', raw, LIVE_CUES_V2_LIMITS.judgeYes, 'a number from 0.5 to 0.95')
+}
 /** COS_LIVE_CUES_V2_REPEAT_OVERLAP: the repeat rule's threshold, 0.3 to 0.9, or null (off, today's behaviour) when unset
  *  or empty. Any other value leaves the rule off, with one log line per value. RESULTS_filter.md: 0.5 withheld no useful
  *  cue on any receipt; 0.4 withheld three. */
@@ -170,6 +231,11 @@ export function liveCuesV2RepeatOverlap(env: NodeJS.ProcessEnv = process.env): n
   const t = Number(raw)
   return t >= 0.3 && t <= 0.9 ? t : knobFallback<number | null>('COS_LIVE_CUES_V2_REPEAT_OVERLAP', raw, null, 'a number from 0.3 to 0.9 (the repeat rule stays off)')
 }
+/** 6.97.8: the four lens-tuning rules (lead repeat, pacing, open items, known names) are on unless their switch is exactly `0`.
+ *  A kill switch for the Mac, not a setting: an unset, empty or any other value leaves the rule on. */
+export function liveCuesV2Rule(name: 'LEAD_REPEAT' | 'PACING' | 'OPEN_ITEMS' | 'KNOWN_NAMES', env: NodeJS.ProcessEnv = process.env): boolean {
+  return (env[`COS_LIVE_CUES_V2_${name}`] ?? '').trim() !== '0'
+}
 export function liveCuesV2Model(env: NodeJS.ProcessEnv = process.env): string {
   const raw = (env.COS_LIVE_CUES_V2_MODEL ?? '').trim().toLowerCase()
   if (raw === 'haiku') return 'claude-haiku-5-5'
@@ -182,6 +248,11 @@ export function liveCuesV2WriterSystem(env: NodeJS.ProcessEnv = process.env, kin
   if (kinds === 'extended') return { version: 'v4', system: CUE_WRITER_SYSTEM_V4 }
   return (env.COS_LIVE_CUES_V2_PROMPT ?? '').trim() === 'v2' ? { version: 'v2', system: CUE_WRITER_SYSTEM_V2 } : { version: 'v3', system: CUE_WRITER_SYSTEM_V3 }
 }
+/** 6.97.9: the Mac-only machinery (the general web runner and its insights, cue mode `general` switching the focused cues off, the open-items
+ *  fold) keys on the session being a Mac recording, never on its kind set: a G2 meeting may be armed with all five kinds (the phone does)
+ *  and gets the five kinds and writer v4, nothing else of the Mac's. */
+const macRecording = (s: { sessionId: string }): boolean => MAC_CAPTURE_ID.test(s.sessionId)
+
 /** 6.86.0: which kinds a meeting gets when its armer does not say. A Mac recording (`mac_` capture id) is read only by COS
  *  Control, which shows any kind, so it gets the extended set; every other meeting keeps the two legacy kinds, because a
  *  companion that validates `kind` drops a cue whose kind it does not know. */
@@ -238,7 +309,12 @@ export function pyJson(value: unknown): string {
 // ── Pure helpers (exported for tests) ───────────────────────────────────────
 /** A note as the writer sees it ({id, date, title, notes}; the same keys the replay sent). `key` is the stable meeting
  *  identity from cue_memory.py; it never reaches the prompt. */
-export interface MemoryNote { id: string; date: string; title: string; notes: string; key?: string }
+export interface MemoryNote {
+  id: string; date: string; title: string; notes: string; key?: string
+  /** Live cues v3, set only on grounded candidates: the meeting domain the note was filed under, the record, memory or file it
+   *  is (a cue source's locator), and the session it was recorded from. None of them reaches a prompt. */
+  domain?: string; recordId?: string; memoryId?: string; fileId?: string; sessionId?: string
+}
 
 /** A cue's headline: the first sentence when it fits, otherwise cut at a word with an ellipsis. Never empty. */
 export function cueHeadline(detail: string): string {
@@ -265,7 +341,8 @@ export function unsupportedNumbers(cue: string, window: string, memory: MemoryNo
   return bad
 }
 
-export interface ParsedCue { detail: string; kind: CueKind; memoryIds: string[]; numberFlags: string[] }
+/** `open` (6.97.8): the writer's own item when the cue's main point is a missing owner or date (the extended-kind prompt asks for it). */
+export interface ParsedCue { detail: string; kind: CueKind; memoryIds: string[]; numberFlags: string[]; open?: string }
 export type CueRejection = 'null' | 'unparseable' | 'empty' | 'too_long' | 'unsupported_number'
 /** `enforceNumbers` withholds a cue whose numbers are not in the source. Off by default: on the held-out replay the
  *  guard fired on 3 v3 cues and only 1 was unsupported (ASR writes "300 000" and "a hundred"), so it is traced, not enforced. */
@@ -287,7 +364,7 @@ export function parseWriterCue(raw: string, fallbackKind: CueKind, window: strin
   const kind: CueKind = typeof value.kind === 'string' && (allowed as readonly string[]).includes(value.kind) ? value.kind as CueKind : fallbackKind
   const ids = new Set(kept.map(m => m.id))
   const memoryIds = Array.isArray(value.memoryIds) ? [...new Set(value.memoryIds.filter((x): x is string => typeof x === 'string' && ids.has(x)))] : []
-  return { detail: cue, kind, memoryIds, numberFlags }
+  return { detail: cue, kind, memoryIds, numberFlags, ...(typeof value.open === 'string' && value.open.trim() ? { open: value.open } : {}) }
 }
 
 /** A stable, opaque id for a past meeting (the same meeting gets the same id in every cue). */
@@ -306,7 +383,8 @@ export function localWeekStart(now: Date, zone: string): string {
 }
 
 // ── Durable state: weekly ceiling, tombstones, pauses, per-meeting counters ─────
-interface MeetingCounters { cues: number; writerCalls: number; at: number }
+/** `since` (6.97.8): when the meeting's first writer call was charged, so a restarted server keeps the pacing clock. Absent in older files. */
+interface MeetingCounters { cues: number; writerCalls: number; at: number; since?: number }
 /** 6.79.2: usage on the local calendar day (in the stored zone), for the daily writer ceiling and COS Control's readout. */
 export interface LiveCuesV2DayUsage { writerCalls: number; writerTokensIn: number; writerTokensOut: number; cues: number; jevTokens: number }
 const DAY_FIELDS = ['writerCalls', 'writerTokensIn', 'writerTokensOut', 'cues', 'jevTokens'] as const
@@ -384,7 +462,8 @@ export class LiveCuesV2Store {
     s.writerCalls += 1
     s.today.writerCalls += 1
     const m = s.meetings[sessionId] ?? { cues: 0, writerCalls: 0, at: 0 }
-    s.meetings[sessionId] = { ...m, writerCalls: m.writerCalls + 1, at: this.now().getTime() }
+    const nowMs = this.now().getTime()
+    s.meetings[sessionId] = { ...m, writerCalls: m.writerCalls + 1, at: nowMs, since: typeof m.since === 'number' ? m.since : nowMs }
     this.write(s)
     return true
   }
@@ -412,6 +491,19 @@ export class LiveCuesV2Store {
     return { cues: m?.cues ?? 0, writerCalls: m?.writerCalls ?? 0 }
   }
   /** The durable per-meeting counters, or null once they expired (24 h) or never existed. */
+  /** 6.97.8: remember when a meeting began, at arm, so the pacing clock is the meeting's and not the first writer call's. Once. */
+  noteArm(sessionId: string): void {
+    const s = this.read()
+    if (s.meetings[sessionId]) return
+    const nowMs = this.now().getTime()
+    s.meetings[sessionId] = { cues: 0, writerCalls: 0, at: nowMs, since: nowMs }
+    this.write(s)
+  }
+  /** When this meeting began (6.97.8), or null for a meeting from an older file. */
+  meetingSince(sessionId: string): number | null {
+    const since = this.read().meetings[sessionId]?.since
+    return typeof since === 'number' && Number.isFinite(since) ? since : null
+  }
   meetingCounters(sessionId: string): { cues: number; writerCalls: number } | null {
     const m = this.read().meetings[sessionId]
     return m ? { cues: m.cues, writerCalls: m.writerCalls } : null
@@ -452,14 +544,34 @@ export const CUE_MEMORY_FAILURES: ReadonlySet<string> = new Set(['no_cue_memory_
 export function cueMemoryFailed(mem: MemoryResult): boolean { return !!mem.denseError && CUE_MEMORY_FAILURES.has(mem.denseError) }
 export interface LiveCuesV2Deps {
   gate(title: string, window: string, signal: AbortSignal, provider: DecisionProvider): Promise<GateResult>
-  /** cue_memory.py (Miles's COS scripts). */
-  memory(window: string, before: string, signal: AbortSignal): Promise<MemoryResult>
+  /** cue_memory.py (Miles's COS scripts). `top` (grounded cues) asks for more than the usual four, so that excluded copies of
+   *  this meeting still leave four; classic never passes it. */
+  memory(window: string, before: string, signal: AbortSignal, top?: number): Promise<MemoryResult>
   /** The owner's own COS notes and meetings, used only when `memory` did not answer. Local search, no model call. */
   notes(window: string, before: string, signal: AbortSignal, sessionId: string): Promise<MemoryResult>
   judge(title: string, window: string, notes: MemoryNote[], signal: AbortSignal, provider: DecisionProvider): Promise<{ probs: Record<string, number>; tokens: number }>
   writer(model: string, system: string, prompt: string, signal: AbortSignal): Promise<{ text: string; costUsd?: number; inputTokens?: number; outputTokens?: number; model?: string }>
   emit(type: 'coaching_nudge' | 'coaching_nudge_v2', data: Record<string, unknown>): void
   lease(): MaintenanceWorkLease | null
+  /** Live cues v3, grounded cues only (absent means none): the files attached to this meeting (MeetingAskStore.files). May throw. */
+  files?(sessionId: string): GroundedFile[]
+  /** Live cues, grounded only (absent means no data arm): the Tableau facts file, read and checked for staleness. Never throws. */
+  dataFacts?(): DataFactsRead
+  /** The user-confirmed context of this meeting: its domain and calendar title (MeetingAskStore.orientation). May throw. */
+  orientation?(sessionId: string): { domain: string | null; title: string | null }
+  /** 6.97.8 pacing: the length of the calendar match for this meeting in ms, or null. Separate from `orientation`, which classic cues never read. May throw. */
+  meetingLength?(sessionId: string): number | null
+  /** Live cues v3, general cues (absent means none: no runner is built): the general runner's dependencies. */
+  general?: GeneralCueDeps
+  /** 6.97.8: the spellings of names the writer may use (the meeting's speakers, enrolled voices, the owner, the owner's vocabulary
+   *  names). Absent means none: the writer prompt is then byte for byte what it was. May throw or reject; a failure means none. */
+  knownNames?(speakers: readonly string[]): Promise<string[]> | string[]
+  /** Ask Public topics consent (MeetingAskStore.publicTopics), which general cues need. May throw. */
+  publicTopics?(): boolean
+  /** The owner's city-level home area (profile home_city), or null. May throw. */
+  homeArea?(): string | null
+  /** The grounded judge: one yes/no question per candidate (judge B) and the `same` choice as a diagnostic. */
+  judgeB?(title: string, window: string, cands: GroundedNote[], signal: AbortSignal, provider: DecisionProvider): Promise<{ yes: Record<string, number>; same: Record<string, number>; tokens: number }>
   /** True while the user's own query runs (Ask, a durable query): cues wait rather than compete for the provider. */
   busy(): boolean
   /** The configured decision provider for cues. Throws DecisionProviderError('decision_invalid_provider'). */
@@ -504,6 +616,13 @@ export function cueDecisionCalls(client: Pick<DecisionClient, 'ask'>) {
       const res = await client.ask(state, questions, estimateJevTokens({ state, questions }), { signal })
       return { probs: res.answers?.same?.probabilities ?? {}, tokens: res.inputTokens }
     },
+    /** Grounded cues: ONE request, a yes/no question per candidate plus the `same` choice (live-cues-v2-judge-b.ts). */
+    async judgeB(title: string, window: string, cands: GroundedNote[], signal: AbortSignal): Promise<{ yes: Record<string, number>; same: Record<string, number>; tokens: number }> {
+      const state = { meetingTitle: title, window: window.slice(-JUDGE_B_WINDOW_CHARS) }
+      const questions = judgeBQuestions(cands)
+      const res = await client.ask(state, questions, estimateJevTokens({ state, questions }), { signal })
+      return { ...parseJudgeB(res.answers, cands.map(c => c.id)), tokens: res.inputTokens }
+    },
   }
 }
 
@@ -520,15 +639,30 @@ function realDeps(): LiveCuesV2Deps {
   const subq = trackSubqDecisionClient(new SubqDecisionClient(fetch, () => new Date(), dataPath('subq-cues-usage.json'), () => resolveSubqKey()?.key, subqDailyCap))
   const calls = (provider: DecisionProvider) => cueDecisionCalls(provider === 'subq' ? subq : jev)
   const traceFile = dataPath('live-cues-trace.jsonl')
+  const trace = (row: Record<string, unknown>) => {
+    try { mkdirSync(dirname(traceFile), { recursive: true, mode: 0o700 }); appendFileSync(traceFile, JSON.stringify(row) + '\n', { mode: 0o600 }) } catch { /* trace is best effort */ }
+  }
   let memorySourceCache: { at: number; value: LiveCuesV2MemorySource } | null = null
   return {
     gate: (title, window, signal, provider) => calls(provider).gate(title, window, signal),
-    memory: (window, before, signal) => cueMemory(window, before, signal),
+    memory: (window, before, signal, top) => cueMemory(window, before, signal, undefined, undefined, top),
     async notes(window, before, signal, sessionId) {
       const r = await notesMemory(window, before, signal, { sessionId })
       return { notes: r.notes, ...(r.error ? { denseError: r.error } : {}) }
     },
     judge: (title, window, notes, signal, provider) => calls(provider).judge(title, window, notes, signal),
+    judgeB: (title, window, cands, signal, provider) => calls(provider).judgeB(title, window, cands, signal),
+    files: sessionId => new MeetingAskStore().files(sessionId),
+    dataFacts: dataFactsReader(dataPath(DATA_FACTS_FILE)),
+    meetingLength(sessionId) {
+      const cal = new MeetingAskStore().orientation(sessionId).calendar
+      const start = Date.parse(cal?.start ?? ''), end = Date.parse(cal?.end ?? '')
+      return Number.isFinite(start) && Number.isFinite(end) && end > start ? end - start : null
+    },
+    orientation(sessionId) {
+      const o = new MeetingAskStore().orientation(sessionId)
+      return { domain: o.domain, title: o.calendar?.title ?? null }
+    },
     decisionProvider: () => resolveCuesDecisionProvider(process.env).provider,
     decisionState(provider) {
       if (provider === 'subq') {
@@ -560,9 +694,17 @@ function realDeps(): LiveCuesV2Deps {
     warmMemory: () => warmCueMemory(),
     now: () => new Date(),
     store: new LiveCuesV2Store(dataPath('live-cues-v2-state.json'), () => new Date()),
-    trace(row) {
-      try { mkdirSync(dirname(traceFile), { recursive: true, mode: 0o700 }); appendFileSync(traceFile, JSON.stringify(row) + '\n', { mode: 0o600 }) } catch { /* trace is best effort */ }
-    },
+    trace,
+    general: realGeneralDeps({
+      // The trigger is one more request on the cues' own decision client, so it shares their daily cap and breaker.
+      jevTrigger: (title, window, signal) => generalTriggerCalls(resolveCuesDecisionProvider(process.env).provider === 'subq' ? subq : jev).trigger(title, window, signal),
+      writerModel: () => liveCuesV2Model(process.env),
+      statePath: dataPath('live-cues-general-state.json'),
+      trace: row => trace(row as unknown as Record<string, unknown>),
+    }),
+    knownNames: speakers => knownNamesFor(speakers),
+    publicTopics: () => new MeetingAskStore().publicTopics(),
+    homeArea: () => getOwnerHomeArea(),
     cueLog: row => liveCueVerdicts().logCue(row),
     env: process.env,
   }
@@ -588,7 +730,7 @@ export function warmCueMemory(): void {
 }
 
 /** Rank-fusion retrieval through COS scripts/cue_memory.py. Transcript text goes over stdin, never argv. Non-fatal. */
-export function cueMemory(window: string, before: string, signal: AbortSignal, p: CueMemoryPaths | null = cueMemoryPaths(), timeoutMs: number = LIVE_CUES_V2_LIMITS.memoryTimeoutMs): Promise<MemoryResult> {
+export function cueMemory(window: string, before: string, signal: AbortSignal, p: CueMemoryPaths | null = cueMemoryPaths(), timeoutMs: number = LIVE_CUES_V2_LIMITS.memoryTimeoutMs, top = 4): Promise<MemoryResult> {
   if (!p) return Promise.resolve({ notes: [], denseError: 'no_cue_memory_script' })
   const paths = p
   return new Promise(resolveNotes => {
@@ -606,16 +748,20 @@ export function cueMemory(window: string, before: string, signal: AbortSignal, p
     proc.on('close', () => {
       try {
         const res = JSON.parse(out) as { notes?: MemoryNote[]; timing?: { dense_error?: string }; index?: { ageHours?: number } }
-        const notes = (res.notes ?? []).filter(n => n && typeof n.id === 'string' && typeof n.notes === 'string').slice(0, 4)
+        const notes = (res.notes ?? []).filter(n => n && typeof n.id === 'string' && typeof n.notes === 'string').slice(0, top)
         done({ notes, denseError: res.timing?.dense_error, indexAgeH: res.index?.ageHours })
       } catch { done({ notes: [], denseError: 'bad_output' }) }
     })
     proc.stdin?.on('error', () => { /* child exited early */ })
-    proc.stdin?.end(JSON.stringify({ queries: [window.slice(-600)], keywordText: window, before, top: 4 }))
+    proc.stdin?.end(JSON.stringify({ queries: [window.slice(-600)], keywordText: window, before, top }))
   })
 }
 
 // ── Engine ──────────────────────────────────────────────────────────────────
+/** What grounded retrieval hands the rest of an evaluation: the candidates the judge saw, the ones it kept (best first), where
+ *  the notes came from, the title the writer is given, and which arms supplied a candidate. */
+interface GroundedRun { candidates: GroundedNote[]; kept: GroundedNote[]; source: LiveCuesV2MemorySource; writerTitle: string; arms: GroundedArm[] }
+
 interface Session {
   sessionId: string
   title: string
@@ -635,7 +781,27 @@ interface Session {
   skipTracedAt: Record<string, number>
   /** 6.86.0: the kinds this meeting's cues may carry, fixed at arm. */
   kinds: CueKindSet
+  /** Live cues v3: cleaned characters fed since arm. Monotonic (the chunk window is capped, this is not): the general runner
+   *  measures "about 90 s of new speech" with it. */
+  charsFed: number
+  /** Live cues v3: the speaker names the ASR path reported (at most SPEAKER_NAMES_MAX), kept for the general runner's name
+   *  gate. Stored only: the focused path never reads them. */
+  speakers: Set<string>
+  /** Live cues v3: this meeting's insights. Apart from `cues` on purpose: previousCues, the repeat rule and the shadow template
+   *  rules read `cues`, and an insight must not change what a focused cue sees. */
+  insights: LiveCueV2[]
+  /** Live cues v3: the 6-word sequences of everything said since arm, fed only while grounding is on (the self-copy check). */
+  said: SessionShingles
+  /** 6.97.8: the open-item cues held for a combined cue. Apart from `cues`: a held item was never shown. */
+  fold: OpenItemFold
+  /** 6.97.8 pacing: the cap seen on the last feed, the cue count a raised cap resumes from, and the calendar length read at most once a minute. */
+  lastCap: number
+  paceFloor: number
+  horizon: { at: number; ms: number | null }
 }
+/** A session's status row, plus (live cues v3) the general-cue state for an extended meeting. */
+export type LiveCuesV2SessionStatusV3 = LiveCuesV2SessionStatus & { general?: GeneralCueStatus }
+export interface LiveCuesV2StatusResponseV3 { protocol: 2; enabled: boolean; session: LiveCuesV2SessionStatusV3 | null }
 
 /** 6.86.0: how a meeting is armed. `kinds` defaults by session (defaultCueKindSet); `resume` makes a restarted server re-arm
  *  it on its next chunk (the Mac recording start passes it). */
@@ -653,14 +819,20 @@ function isCancel(error: unknown, signal: AbortSignal): boolean {
  *  provider's own breaker and cap already bound these; counting them would also end the meeting's cues. */
 export const QUIET_DECISION_STOPS: ReadonlySet<string> = new Set(['jev_cap_reached', 'jev_breaker_open', 'jev_not_configured',
   'decision_cap_reached', 'decision_breaker_open', 'decision_not_configured', 'decision_invalid_provider'])
+/** How many distinct speaker names a meeting remembers for the general runner's name gate. */
+export const SPEAKER_NAMES_MAX = 200
 /** Abort reason when v2 is switched off at runtime. */
 export const V2_OFF = 'v2_off'
 
 export class LiveCuesV2Engine {
   private readonly sessions = new Map<string, Session>()
-  constructor(private readonly deps: LiveCuesV2Deps) {}
+  private readonly general: GeneralCueRunner | null
+  constructor(private readonly deps: LiveCuesV2Deps) {
+    this.general = deps.general ? new GeneralCueRunner(this.generalHost(), this.generalSettings(), deps.general) : null
+  }
 
   private enabled(): boolean { return liveCuesV2Enabled(this.deps.env, this.deps.settings) }
+  private groundingOn(): boolean { return resolveLiveCuesGrounding(this.deps.env, this.deps.settings).value === 'grounded' }
   /** 6.79.2: the spend limits as they stand now (env, else COS Control's saved values, else the defaults). The writer
    *  cap per meeting stays twice the cue cap. */
   private limits(): { gate: number; maxCues: number; writerCap: number; cooldownMs: number; dailyWriterCalls: number } {
@@ -719,7 +891,8 @@ export class LiveCuesV2Engine {
     const d = this.deps.now()
     const title = `${mac ? 'Mac' : 'G2'} Recording ${d.toLocaleDateString('en-CA')} ${String(d.getHours()).padStart(2, '0')}${String(d.getMinutes()).padStart(2, '0')}`
     this.sessions.set(sessionId, { sessionId, title, armedAt: nowMs, lastSeenAt: nowMs, chunks: [], wordsSinceEval: 0, lastEvalAt: 0, lastCueAt: 0,
-      inFlight: null, cues: [], evaluations: 0, failures: 0, breaker: false, stopReason: null, skipTracedAt: {}, kinds })
+      inFlight: null, cues: [], evaluations: 0, failures: 0, breaker: false, stopReason: null, skipTracedAt: {}, kinds, charsFed: 0, speakers: new Set(), insights: [], said: new SessionShingles(), fold: new OpenItemFold(), lastCap: 0, paceFloor: 0, horizon: { at: 0, ms: null } })
+    this.deps.store.noteArm(sessionId)
     if (opts.resume) this.deps.store.setResume(sessionId, kinds)
     this.deps.warmMemory()
     return answer(this.deps.store.counters(sessionId).cues, kinds)
@@ -730,28 +903,34 @@ export class LiveCuesV2Engine {
     this.deps.store.end(sessionId)
     const s = this.sessions.get(sessionId)
     s?.inFlight?.abort()
-    const cues = s ? [...s.cues] : []
-    return { nudgesGenerated: cues.length, protocol: 2, cues,
-      // v1 readers know two types: an extended kind is shown as its legacy kind there (the cues keep the real one).
-      nudges: cues.map(c => ({ nudge: c.headline, type: legacyCueKind(c.kind), priority: 2, timestamp: c.createdAt, cueId: c.cueId })) }
+    s?.said.clear()
+    this.general?.endSession(sessionId)
+    const cues = s ? this.allCues(s) : []
+    // v1 readers know two types: an extended kind is shown as its legacy kind there (the cues keep the real one).
+    // An insight (live cues v3) has no v1 twin, so it is not counted as a nudge either.
+    const nudges = cues.flatMap(c => (isCueKind(c.kind) ? [{ nudge: c.headline, type: legacyCueKind(c.kind), priority: 2, timestamp: c.createdAt, cueId: c.cueId }] : []))
+    return { nudgesGenerated: nudges.length, protocol: 2, cues, nudges }
   }
 
   setPaused(sessionId: string, paused: boolean, seq?: number): { ok: true; paused: boolean; applied: boolean; pauseSeq: number } {
     const r = this.deps.store.setPaused(sessionId, paused, seq)
-    if (r.applied && paused) this.sessions.get(sessionId)?.inFlight?.abort()
+    if (r.applied && paused) { this.sessions.get(sessionId)?.inFlight?.abort(); this.general?.abortSession(sessionId, 'paused') }
     return { ok: true, ...r }
   }
 
-  status(sessionId: string): LiveCuesV2StatusResponse {
+  status(sessionId: string): LiveCuesV2StatusResponseV3 {
     const s = this.sessions.get(sessionId)
     const ended = this.deps.store.isEnded(sessionId)
     const paused = this.deps.store.isPaused(sessionId)
     if (!s && !ended) return { protocol: 2, enabled: this.enabled(), session: null }
     const counters = this.deps.store.counters(sessionId)
     const reason = s ? this.stopReasonOf(s, counters) : null
-    const session: LiveCuesV2SessionStatus = {
+    let general: GeneralCueStatus | null = null
+    if (s) { try { general = this.general?.status(sessionId) ?? null } catch { general = null } }       // null for a meeting the runner is not offered (G2)
+    const session: LiveCuesV2SessionStatusV3 = {
       sessionId, state: ended ? 'ended' : paused ? 'paused' : reason ? 'stopped' : 'active', ...(reason && !ended && !paused ? { reason } : {}),
-      paused, ended, pauseSeq: this.deps.store.pauseSeq(sessionId), cues: s ? [...s.cues] : [], evaluations: s?.evaluations ?? 0, writerCalls: counters.writerCalls,
+      paused, ended, pauseSeq: this.deps.store.pauseSeq(sessionId), cues: s ? this.allCues(s) : [], evaluations: s?.evaluations ?? 0, writerCalls: counters.writerCalls,
+      ...(general ? { general } : {}),
     }
     return { protocol: 2, enabled: this.enabled(), session }
   }
@@ -769,18 +948,20 @@ export class LiveCuesV2Engine {
   /** The cue, if this process emitted it and still holds it, under whichever meeting. */
   findCue(cueId: string): LiveCueV2 | null {
     for (const s of this.sessions.values()) { const cue = s.cues.find(c => c.cueId === cueId); if (cue) return cue }
+    for (const s of this.sessions.values()) { const cue = s.insights.find(c => c.cueId === cueId); if (cue) return cue }
     return null
   }
 
   recordFeedback(input: { sessionId: string; cueId: string; vote: 'up' | 'down'; reason?: string }): { ok: true; knownCue: boolean } {
-    const knownCue = !!this.sessions.get(input.sessionId)?.cues.some(c => c.cueId === input.cueId)
+    const held = this.sessions.get(input.sessionId)
+    const knownCue = !!held && (held.cues.some(c => c.cueId === input.cueId) || held.insights.some(c => c.cueId === input.cueId))
     const reason = (input.reason ?? '').replace(/\s+/g, ' ').trim().slice(0, CUE_FEEDBACK_REASON_MAX)
     this.deps.trace({ kind: 'feedback', at: this.deps.now().toISOString(), sessionId: input.sessionId, cueId: input.cueId, vote: input.vote, knownCue, ...(reason ? { reason } : {}) })
     return { ok: true, knownCue }
   }
 
   /** From the ASR path: fire-and-forget, never awaited. All gates live here. */
-  async feed(sessionId: string, text: string, asrDegraded = false): Promise<void> {
+  async feed(sessionId: string, text: string, asrDegraded = false, speakers?: readonly string[]): Promise<void> {
     if (!this.enabled()) return
     if (this.deps.store.isEnded(sessionId)) return                    // tombstone before any auto-arm
     let s = this.sessions.get(sessionId)
@@ -795,14 +976,19 @@ export class LiveCuesV2Engine {
     }
     const nowMs = this.deps.now().getTime()
     s.lastSeenAt = nowMs
+    this.noteSpeakers(s, speakers)
     const words = text.trim().split(/\s+/).filter(Boolean)
     if (words.length) {
       s.chunks.push(text.trim())
+      s.fold.noteSaid(text)                                           // 6.97.8: a held open item the room talks about again may be settled
+      s.charsFed += cleanWindow(text.trim()).length
+      if (this.groundingOn()) s.said.add(cleanWindow(text.trim()))
       s.wordsSinceEval += words.length
       let total = s.chunks.reduce((n, c) => n + c.split(/\s+/).length, 0)
       while (s.chunks.length > 1 && total > LIVE_CUES_V2_LIMITS.windowWords) { total -= s.chunks[0].split(/\s+/).length; s.chunks.shift() }
     }
     const L = LIVE_CUES_V2_LIMITS
+    if (this.focusedOff(s)) return                                    // cue mode `general`: this Mac meeting gets insights only
     if (s.inFlight || asrDegraded) return
     if (s.breaker) return this.traceSkip(s, 'breaker_open', nowMs)
     if (this.deps.store.isPaused(sessionId)) return this.traceSkip(s, 'paused', nowMs)
@@ -811,12 +997,80 @@ export class LiveCuesV2Engine {
     if (nowMs - s.lastEvalAt < L.minIntervalMs || nowMs - s.lastCueAt < lim.cooldownMs) return
     const counters = this.deps.store.counters(sessionId)
     if (counters.cues >= lim.maxCues || counters.writerCalls >= lim.writerCap) return this.traceSkip(s, 'meeting_cap', nowMs)
+    // 6.97.8 pacing, on unless COS_LIVE_CUES_V2_PACING=0: before the gate, so a paced-out minute costs no Jev call. The clock starts
+    // at arm (kept in the store, so a restart keeps it). A cap raised mid-meeting resumes at once: one more cue is allowed now.
+    if (liveCuesV2Rule('PACING', this.deps.env)) {
+      if (s.lastCap > 0 && lim.maxCues > s.lastCap) s.paceFloor = counters.cues + 1
+      s.lastCap = lim.maxCues
+      const started = Math.min(s.armedAt, this.deps.store.meetingSince(sessionId) ?? s.armedAt)
+      const allowed = Math.max(s.paceFloor, paceAllowed(lim.maxCues, lim.cooldownMs, nowMs - started, this.paceHorizonMs(s, nowMs)))
+      if (counters.cues >= allowed) return this.traceSkip(s, 'paced', nowMs)
+    }
+    // 6.97.8 open items: a held cue is shown when it is due (a combined cue, or alone after 20 minutes). No model call.
+    if (liveCuesV2Rule('OPEN_ITEMS', this.deps.env)) {
+      const plan = s.fold.next(nowMs)
+      if (plan) return this.showHeld(s, plan, nowMs)
+    }
     if (this.deps.store.weeklyUsed() >= liveCuesV2WeeklyCap(this.deps.env)) return this.traceSkip(s, 'budget_exhausted', nowMs)  // before the gate
     if (this.deps.store.dailyWriterCalls() >= lim.dailyWriterCalls) return this.traceSkip(s, 'daily_cap', nowMs)              // before the gate
     if (this.deps.busy()) return this.traceSkip(s, 'busy', nowMs)
     await this.evaluate(s)
   }
 
+  /** The pacing horizon: the calendar match's length when the meeting has one (read at most once a minute), else the default. */
+  private paceHorizonMs(s: Session, nowMs: number): number {
+    if (nowMs - s.horizon.at >= 60_000) {
+      s.horizon.at = nowMs
+      try { s.horizon.ms = this.deps.meetingLength?.(s.sessionId) ?? null } catch { s.horizon.ms = null }
+    }
+    return paceHorizon(s.horizon.ms)
+  }
+
+  /** Every cue of this meeting the writer has seen, shown or held, oldest first: the writer's previousCues and the repeat rules read it. */
+  private cueHistory(s: Session): LiveCueV2[] {
+    const held = s.fold.history()
+    if (!held.length) return s.cues
+    const seen = new Set<string>(), out: LiveCueV2[] = []
+    for (const c of [...s.cues, ...held].sort((a, b) => a.createdAt - b.createdAt)) if (!seen.has(c.cueId)) { seen.add(c.cueId); out.push(c) }
+    return out
+  }
+
+  /** 6.97.8: carry out what the fold says is due, without a model call: a combined cue (new row in the cue log), a held cue on its own
+   *  (a shown row now, beside its held row), or a stale held cue set aside because the room has talked about it again. */
+  private showHeld(s: Session, plan: FlushPlan, nowMs: number): void {
+    const items = plan.items
+    if (plan.mode === 'drop') {
+      s.fold.markShown(plan, nowMs)
+      this.deps.trace({ kind: 'flush', at: new Date(nowMs).toISOString(), sessionId: s.sessionId, mode: 'drop', items: 1, cueId: items[0].cue.cueId })
+      return
+    }
+    let cue: LiveCueV2, before: string
+    if (plan.mode === 'alone') {
+      cue = { ...items[0].cue, createdAt: nowMs }                    // the cue as written; re-stamped so the lens still flashes it
+      before = items[0].before
+    } else {
+      const labels = items.map(i => i.label)
+      cue = { protocol: 2, cueId: randomUUID(), sessionId: s.sessionId, headline: openItemsHeadline(labels), detail: openItemsDetail(labels),
+        kind: s.kinds === 'extended' ? 'followUp' : 'challenge', sources: [], gate: round(Math.max(...items.map(i => i.cue.gate))), createdAt: nowMs, model: items[items.length - 1].cue.model }
+      if (!isLiveCueV2(cue)) return
+      before = cueBefore(s.chunks.join('\n').replace(/^\[\d+\]\s*/gm, ''))
+    }
+    // Shown now, so logged now without `held`: history lists it from this row (the held row, if any, stays hidden).
+    const shadow = wouldWithhold(cue.detail, s.cues)
+    const row: LiveCueLogRow = { v: 1, cueId: cue.cueId, sessionId: s.sessionId, meetingTitle: s.title, createdAt: cue.createdAt, kind: cue.kind, headline: cue.headline,
+      detail: cue.detail, gate: cue.gate, sources: cue.sources, model: cue.model, prompt: liveCuesV2WriterSystem(this.deps.env, s.kinds).version, memorySource: 'none', kept: 0,
+      wouldWithhold: shadow, before, armedAt: s.armedAt }
+    try { this.deps.cueLog?.(row) } catch (error) { console.warn(`[live-cues-v2] cue log append failed: ${errMsg(error)}`) }
+    s.fold.markShown(plan, nowMs)
+    s.cues.push(cue)
+    s.lastCueAt = nowMs
+    this.deps.store.recordCue(s.sessionId)
+    this.deps.emit('coaching_nudge_v2', cue as unknown as Record<string, unknown>)
+    const v1: LiveCueV1Compat = { nudge: cue.headline, type: legacyCueKind(cue.kind as CueKind), priority: 2, cueId: cue.cueId, sessionId: s.sessionId, protocol: 2 }
+    this.deps.emit('coaching_nudge', v1 as unknown as Record<string, unknown>)
+    this.deps.trace({ kind: 'flush', at: new Date(nowMs).toISOString(), sessionId: s.sessionId, mode: plan.mode, items: items.length, cueId: cue.cueId })
+  }
+
   private traceSkip(s: Session, reason: string, nowMs: number): void {
     if (nowMs - (s.skipTracedAt[reason] ?? 0) < LIVE_CUES_V2_LIMITS.skipTraceEveryMs) return
     s.skipTracedAt[reason] = nowMs
@@ -853,9 +1107,18 @@ export class LiveCuesV2Engine {
 
       const t1 = Date.now()
       const before = new Date(started + 86_400_000).toLocaleDateString('en-CA')
-      let mem: MemoryResult = await this.deps.memory(window, before, abort.signal).catch((): MemoryResult => ({ notes: [], denseError: 'memory_threw' }))
-      Object.assign(trace, { memoryMs: Date.now() - t1, ...(mem.denseError ? { memoryError: mem.denseError } : {}), ...(mem.indexAgeH !== undefined ? { indexAgeH: mem.indexAgeH } : {}) })
+      // Live cues v3: read once per evaluation, so a change of setting applies from the next one.
+      const grounded = this.groundingOn()
+      let mem: MemoryResult = grounded ? { notes: [] } : await this.deps.memory(window, before, abort.signal).catch((): MemoryResult => ({ notes: [], denseError: 'memory_threw' }))
+      if (!grounded) Object.assign(trace, { memoryMs: Date.now() - t1, ...(mem.denseError ? { memoryError: mem.denseError } : {}), ...(mem.indexAgeH !== undefined ? { indexAgeH: mem.indexAgeH } : {}) })
       let source: LiveCuesV2MemorySource = 'cue_memory'
+      // Grounded: the arms and the judge run here instead of the classic steps below, which then find nothing to do.
+      let run: GroundedRun | null = null
+      if (grounded) {
+        run = await this.groundedRetrieve(s, window, before, abort.signal, provider, trace)
+        mem = { notes: run.candidates }
+        source = run.source
+      }
       if (cueMemoryFailed(mem) && !abort.signal.aborted) {
         // cue_memory.py did not answer: search the owner's own COS (no model call), inside its own 3 s budget.
         const tn = Date.now()
@@ -865,14 +1128,15 @@ export class LiveCuesV2Engine {
         source = 'notes'
       }
       Object.assign(trace, { candidates: mem.notes.length, cueMemorySource: mem.notes.length ? source : 'none' })
-      let kept: MemoryNote[] = []
-      if (mem.notes.length && !abort.signal.aborted) {
+      let kept: MemoryNote[] = run?.kept ?? []
+      if (!grounded && mem.notes.length && !abort.signal.aborted) {
         const t2 = Date.now()
         const judged = await this.deps.judge(s.title, window, mem.notes, abort.signal, provider)
         Object.assign(trace, { judgeMs: Date.now() - t2, judgeTokens: judged.tokens })
         kept = mem.notes.filter(m => (judged.probs[m.id] ?? 0) >= liveCuesV2JudgeKeep(this.deps.env)).slice(0, L.judgeMaxNotes).map((m, i) => ({ ...m, id: `M${i + 1}` }))
       }
       trace.kept = kept.length
+      if (run) trace.keptIds = kept.map(m => m.id)                      // grounded ids keep their kind (M1, N1, F1)
       if (abort.signal.aborted) { trace.outcome = 'cancelled'; return }
 
       // 6.79.2: limits lowered while this evaluation ran apply before the writer is charged.
@@ -880,12 +1144,23 @@ export class LiveCuesV2Engine {
       if (counters.cues >= lim.maxCues || counters.writerCalls >= lim.writerCap) { trace.outcome = 'meeting_cap'; return }
       if (this.deps.store.dailyWriterCalls() >= lim.dailyWriterCalls) { trace.outcome = 'daily_cap'; s.stopReason = 'budget_exhausted'; return }
       if (!this.deps.store.charge(liveCuesV2WeeklyCap(this.deps.env), s.sessionId)) { trace.outcome = 'budget_exhausted'; s.stopReason = 'budget_exhausted'; return }
-      const { version, system } = liveCuesV2WriterSystem(this.deps.env, s.kinds)
+      const { version, system: baseSystem } = liveCuesV2WriterSystem(this.deps.env, s.kinds)
+      // The Tableau scope rule rides on the rules only when a Tableau note was kept; every other cue sees the pinned text unchanged.
+      const system = kept.some(m => (m as GroundedNote).arm === 'data') ? baseSystem + DATA_WRITER_ADDENDUM : baseSystem
       if (s.kinds === 'extended') trace.kindSet = 'extended'
       const model = liveCuesV2Model(this.deps.env)
-      const previous = s.cues.slice(-3).map(c => c.detail)
+      const history = this.cueHistory(s)
+      const previous = history.slice(-3).map(c => c.detail)
       const promptMemory = kept.map(m => ({ id: m.id, date: m.date, title: m.title, notes: m.notes }))  // the replay's exact keys
-      const prompt = pyJson({ meetingTitle: s.title, liveIssue: '', suggestedKind: gate.kind, previousCues: previous, memory: promptMemory, window })
+      // 6.97.8: the known spellings ride in the prompt data, before the window, only when there are some (and the rule is on).
+      let names: string[] = []
+      if (liveCuesV2Rule('KNOWN_NAMES', this.deps.env) && this.deps.knownNames) {
+        try { names = await this.deps.knownNames([...s.speakers]) } catch { names = []; trace.knownNamesError = true }
+        if (abort.signal.aborted) { trace.outcome = 'cancelled'; return }
+        if (names.length) trace.knownNames = names.length
+      }
+      const prompt = pyJson({ meetingTitle: run?.writerTitle ?? s.title, liveIssue: '', suggestedKind: gate.kind, previousCues: previous, memory: promptMemory,
+        ...(names.length ? { knownNames: { use: KNOWN_NAMES_USE, names } } : {}), window })
       const t3 = Date.now()
       const out = await this.deps.writer(model, system, prompt, abort.signal)
       Object.assign(trace, { writerMs: Date.now() - t3, prompt: version, model: out.model ?? model, writerUsd: out.costUsd, writerIn: out.inputTokens, writerOut: out.outputTokens })
@@ -901,32 +1176,52 @@ export class LiveCuesV2Engine {
       if (this.deps.store.isEnded(s.sessionId) || this.deps.store.isPaused(s.sessionId) || !this.enabled()) { trace.outcome = 'cancelled'; return }
 
       const sources: CueSourceRef[] = parsed.memoryIds.map(id => kept.find(m => m.id === id)).filter((m): m is MemoryNote => !!m)
-        .map(m => ({ id: sourceId(m), date: m.date, title: m.title }))
-      const cue: LiveCueV2 = { protocol: 2, cueId: randomUUID(), sessionId: s.sessionId, headline: cueHeadline(parsed.detail), detail: parsed.detail,
+        .map(m => (run ? groundedSource(m as GroundedNote, sourceId(m)) : { id: sourceId(m), date: m.date, title: m.title }))
+      let cue: LiveCueV2 = { protocol: 2, cueId: randomUUID(), sessionId: s.sessionId, headline: cueHeadline(parsed.detail), detail: parsed.detail,
         kind: parsed.kind, sources, gate: round(pCue), createdAt: this.deps.now().getTime(), model: out.model ?? model }
       if (!isLiveCueV2(cue)) { trace.outcome = 'withheld_invalid'; return }       // never emit what the companion would drop
       // 6.79.0 repeat rule, off unless COS_LIVE_CUES_V2_REPEAT_OVERLAP is set: a cue that repeats an earlier SHOWN cue of
       // this meeting is not logged, emitted or counted (the writer call already counted). Ids and the overlap only.
       const repeatT = liveCuesV2RepeatOverlap(this.deps.env)
-      const repeat = repeatT === null ? null : repeatOf(cue.detail, s.cues, repeatT)
+      const repeat = repeatT === null ? null : repeatOf(cue.detail, history, repeatT)
       if (repeat) { Object.assign(trace, { outcome: 'withheld_repeat', repeatOf: repeat.blocker, repeatOverlap: repeat.overlap }); return }
+      // 6.97.8 lead repeat, on unless COS_LIVE_CUES_V2_LEAD_REPEAT=0: a cue that opens by restating a recent shown cue's opening
+      // line (the whole-cue rule misses it when the evidence after the opener differs). Same outcome; repeatRule says which.
+      const lead = liveCuesV2Rule('LEAD_REPEAT', this.deps.env) ? leadRepeatOf(cue.detail, history) : null
+      if (lead) { Object.assign(trace, { outcome: 'withheld_repeat', repeatRule: 'lead', repeatOf: lead.blocker, repeatOverlap: lead.overlap }); return }
+      // 6.97.8 open items, on unless COS_LIVE_CUES_V2_OPEN_ITEMS=0, extended meetings only (writer v4 is the one that returns `open`): a cue the
+      // writer marked as a missing owner or date (and whose wording agrees) is held, not shown. It is logged below with `held`, so history
+      // never lists or counts it, stays in the writer's history, and comes back through showHeld(). The writer call counted; the cooldown
+      // applies; the cue does not count toward the cap.
+      const item = macRecording(s) && s.kinds === 'extended' && liveCuesV2Rule('OPEN_ITEMS', this.deps.env)
+        ? openItemOf({ kind: parsed.kind, detail: parsed.detail, cited: sources.length, field: parsed.open }) : null
       // 6.79.0: logged before it is held or emitted, so a rating that arrives at once finds it. Its own try/catch: a log
       // failure is traced on this evaluation and is never a writer failure or a step toward the breaker.
       try {
         this.deps.cueLog?.({ v: 1, cueId: cue.cueId, sessionId: s.sessionId, meetingTitle: s.title, createdAt: cue.createdAt, armedAt: s.armedAt, kind: cue.kind,
           headline: cue.headline, detail: cue.detail, gate: cue.gate, sources: cue.sources, model: cue.model, prompt: version,
-          memorySource: mem.notes.length ? source : 'none', kept: kept.length, wouldWithhold: wouldWithhold(cue.detail, s.cues), before: cueBefore(said) })
+          memorySource: mem.notes.length ? source : 'none', kept: kept.length, wouldWithhold: wouldWithhold(cue.detail, s.cues), before: cueBefore(said),
+          // 'data' stays out of `arms`: an older server's isLogRow rejects an arm it does not know, and the Tableau source is already in `sources`.
+          // `dataNote` says a Tableau note was kept for this cue, so a cue grounded only in it does not read as ungrounded with arms [].
+          ...(run ? { arms: run.arms.filter((a): a is Exclude<typeof a, 'data'> => a !== 'data') } : {}),
+          ...(kept.some(m => (m as GroundedNote).arm === 'data') ? { dataNote: true as const } : {}), ...(item ? { held: true as const } : {}) })
       } catch (error) {
         trace.cueLogError = (error as NodeJS.ErrnoException)?.code ?? 'append_failed'
         console.warn(`[live-cues-v2] cue log append failed: ${errMsg(error)}`)
       }
+      if (item) {
+        s.fold.hold(item.label, cue, cue.createdAt, cueBefore(said))
+        s.lastCueAt = cue.createdAt
+        Object.assign(trace, { outcome: 'held_open_item', openWaiting: s.fold.waiting() })
+        return
+      }
       s.cues.push(cue)
       s.lastCueAt = cue.createdAt
       this.deps.store.recordCue(s.sessionId)
       this.deps.emit('coaching_nudge_v2', cue as unknown as Record<string, unknown>)
-      const v1: LiveCueV1Compat = { nudge: cue.headline, type: legacyCueKind(cue.kind), priority: 2, cueId: cue.cueId, sessionId: s.sessionId, protocol: 2 }
+      const v1: LiveCueV1Compat = { nudge: cue.headline, type: legacyCueKind(cue.kind as CueKind), priority: 2, cueId: cue.cueId, sessionId: s.sessionId, protocol: 2 }
       this.deps.emit('coaching_nudge', v1 as unknown as Record<string, unknown>)
-      Object.assign(trace, { outcome: 'cue', cueId: cue.cueId, cueChars: cue.detail.length, sources: sources.length, ...(parsed.numberFlags.length ? { numberFlags: parsed.numberFlags.length } : {}) })
+      Object.assign(trace, { outcome: 'cue', cueId: cue.cueId, cueChars: cue.detail.length, sources: cue.sources.length, ...(parsed.numberFlags.length ? { numberFlags: parsed.numberFlags.length } : {}) })
     } catch (error) {
       if (wallHit) { trace.outcome = 'failure'; trace.error = 'wall_timeout'; s.failures += 1; if (s.failures >= L.breakerFailures) s.breaker = true; return }
       if (isCancel(error, abort.signal)) { trace.outcome = 'cancelled'; return }
@@ -955,12 +1250,97 @@ export class LiveCuesV2Engine {
     }
   }
 
+  /** Live cues v3, `grounding: grounded`: the retrieval arms in parallel (cue_memory.py within its 6 s, the owner's notes within
+   *  their own 3 s), the files attached to this meeting, then ONE judge request over the candidates that survive the exclusions
+   *  (live-cues-v2-grounded.ts). Never throws for a file, orientation or arm failure: those are traced as codes and the meeting
+   *  carries on with what it has. The trace gets ids, kinds, probabilities and timings, never a candidate's or the room's text. */
+  private async groundedRetrieve(s: Session, window: string, before: string, signal: AbortSignal, provider: DecisionProvider, trace: Record<string, unknown>): Promise<GroundedRun> {
+    trace.grounding = 'grounded'
+    const codeOf = (e: unknown) => { const r = e as { reason?: unknown; code?: unknown } | null; return typeof r?.reason === 'string' ? r.reason : typeof r?.code === 'string' ? r.code : 'threw' }
+    let meetingDomain: string | null = null, calendarTitle: string | null = null, orientationFailed = false
+    try {
+      const o = this.deps.orientation?.(s.sessionId)
+      meetingDomain = typeof o?.domain === 'string' ? o.domain : null
+      calendarTitle = typeof o?.title === 'string' ? o.title : null
+    } catch (e) { trace.orientationError = codeOf(e); orientationFailed = true }
+    let files: GroundedFile[] = []
+    try { files = usableFiles(this.deps.files?.(s.sessionId)) } catch (e) { trace.filesError = codeOf(e) }
+
+    const timed = async (arm: () => Promise<MemoryResult>, threw: string): Promise<{ res: MemoryResult; ms: number | null }> => {
+      const t = Date.now()
+      try { return { res: await arm(), ms: Date.now() - t } } catch { return { res: { notes: [], denseError: threw }, ms: null } }
+    }
+    const [cm, nt] = await Promise.all([
+      timed(() => this.deps.memory(window, before, signal, GROUNDED_LIMITS.cueMemoryRaw), 'memory_threw'),
+      timed(() => this.deps.notes(window, before, signal, s.sessionId), 'notes_threw'),
+    ])
+    Object.assign(trace, { ...(cm.ms !== null ? { memoryMs: cm.ms } : {}), ...(cm.res.denseError ? { memoryError: cm.res.denseError } : {}), ...(cm.res.indexAgeH !== undefined ? { indexAgeH: cm.res.indexAgeH } : {}),
+      ...(nt.ms !== null ? { notesMs: nt.ms } : {}), ...(nt.res.denseError ? { notesError: nt.res.denseError } : {}) })
+
+    // What the room has said since arm: every chunk that came while grounding was on, plus the window now (a meeting switched to
+    // grounded part way through has only the window to start from).
+    s.said.add(cleanWindow(s.chunks.join('\n')))
+    const twins = [...this.sessions.keys()].filter(id => id !== s.sessionId)
+    // The Tableau data arm: a local file, no model call. Off (and traced why) when the file is missing, stale or invalid, when the
+    // meeting is not Quilt's, or when the speech does not name a group beside a funnel word or figure. A meeting with no confirmed
+    // domain needs a Quilt signal from this evaluation: the candidates the other arms just returned (after the self and twin
+    // exclusions) and the titles are the two places one can come from, so the others are built first.
+    const today = this.deps.now().toLocaleDateString('en-CA')
+    const common = { cueMemory: cm.res.notes, notes: nt.res.notes, files, transcript: s.said.shingles, window, selfIds: selfIdSet(s.sessionId, twins), meetingDomain, today }
+    let grounded = groundedCandidates(common)
+    const data = this.dataArm(window, { domain: meetingDomain, orientationFailed, titles: [s.title, calendarTitle],
+      memoryQuilt: grounded.candidates.some(c => (c.arm === 'cue_memory' || c.arm === 'notes') && isQuiltDomain(c.domain)) }, today, trace)
+    if (data) grounded = groundedCandidates({ ...common, data })
+    const { candidates, excludedSelf, domainUnknown } = grounded
+    Object.assign(trace, { arms: { cue_memory: cm.ms, notes: nt.ms, files: files.filter(f => f.status === 'ready').length, data: candidates.some(c => c.arm === 'data') ? 1 : 0 }, excludedSelf, domainUnknown })
+
+    const source: LiveCuesV2MemorySource = candidates.some(c => c.arm === 'cue_memory') ? 'cue_memory' : candidates.some(c => c.arm === 'notes') ? 'notes' : 'none'
+    const arms = (['cue_memory', 'notes', 'files', 'data'] as const).filter(a => candidates.some(c => c.arm === a))
+    const title = (calendarTitle ?? '').replace(/\s+/g, ' ').trim().slice(0, 120)
+    const writerTitle = title || s.title
+    let kept: GroundedNote[] = []
+    if (candidates.length && !signal.aborted) {
+      if (!this.deps.judgeB) throw new Error('judge_b_unavailable')
+      const t2 = Date.now()
+      const judged = await this.deps.judgeB(s.title, window, candidates, signal, provider)
+      Object.assign(trace, { judgeMs: Date.now() - t2, judgeTokens: judged.tokens,
+        judge: candidates.map(c => ({ id: c.id, kind: c.kind, yes: round(judged.yes[c.id] ?? 0), same: round(judged.same[c.id] ?? 0) })) })
+      kept = selectJudgeB(candidates, judged.yes, liveCuesV2JudgeYes(this.deps.env), LIVE_CUES_V2_LIMITS.judgeMaxNotes)
+    }
+    return { candidates, kept, source, writerTitle, arms }
+  }
+
+  /** The Tableau candidate for this window, or null. `trace.dataArm` says what happened in one code: offered, no_group, no_funnel,
+   *  no_stage, domain, or the file's own reason (missing, unreadable, invalid, stale, future). Never throws. */
+  private dataArm(window: string, ctx: { domain: string | null; orientationFailed: boolean; titles: Array<string | null>; memoryQuilt: boolean }, today: string, trace: Record<string, unknown>): GroundedNote | null {
+    if (!this.deps.dataFacts) return null
+    try {
+      const read = this.deps.dataFacts()
+      if (!read.ok) { trace.dataArm = read.reason; return null }
+      trace.dataAgeH = Math.round((this.deps.now().getTime() - read.facts.asOf) / 360_000) / 10
+      // Cheap exits first: another confirmed domain or an unreadable orientation never reads the speech.
+      const early = dataArmGate({ domain: ctx.domain, orientationFailed: ctx.orientationFailed, brand: true })
+      if (!early.ok) { trace.dataArm = early.why; return null }
+      const found = dataCandidate(read.facts, window, today)
+      if ('none' in found) { trace.dataArm = found.none; return null }
+      const gate = dataArmGate({ domain: ctx.domain, orientationFailed: ctx.orientationFailed, brand: found.brand, memoryQuilt: ctx.memoryQuilt, titleQuilt: quiltTitleSignal(read.facts, ctx.titles) })
+      if (!gate.ok) { trace.dataArm = gate.why; return null }
+      trace.dataArm = 'offered'
+      trace.dataSignal = gate.signal
+      return found.candidate
+    } catch { trace.dataArm = 'threw'; return null }
+  }
+
   private reap(): void {
     const nowMs = this.deps.now().getTime()
     for (const [id, s] of this.sessions) if (!s.inFlight && nowMs - s.lastSeenAt > LIVE_CUES_V2_LIMITS.sessionTtlMs) this.sessions.delete(id)
   }
 
-  shutdown(): void { for (const s of this.sessions.values()) s.inFlight?.abort(); this.sessions.clear() }
+  shutdown(): void {
+    for (const s of this.sessions.values()) s.inFlight?.abort()
+    this.sessions.clear()
+    if (this.general) { this.general.stop(); setGeneralCuesTodayProvider(null) }
+  }
 
   /** v2 switched off at runtime (6.76.2): abort every evaluation in flight, so no half-written cue is emitted and every
    *  lease is released. Sessions are kept (no new evaluation starts while off), so switching back on resumes a running
@@ -968,9 +1348,105 @@ export class LiveCuesV2Engine {
   suspend(): number {
     let aborted = 0
     for (const s of this.sessions.values()) if (s.inFlight) { s.inFlight.abort(V2_OFF); aborted += 1 }
+    if (this.general?.abortAll(V2_OFF)) aborted += 1
     return aborted
   }
 
+  // ── General cues (live cues v3) ──
+  /** Starts the general runner's poll timer and registers its counters for the settings view. Called once, where the engine
+   *  singleton is built; an engine made by a test never polls on its own. */
+  startGeneral(): void {
+    if (!this.general) return
+    setGeneralCuesTodayProvider(() => this.general!.generalCuesToday())
+    this.general.start()
+  }
+  /** The general runner, if this engine has one (tests drive its ticks directly). */
+  generalRunner(): GeneralCueRunner | null { return this.general }
+  /** The cue mode was saved: leaving general mode stops an insight in flight at once. */
+  modeChanged(): void { this.general?.modeChanged() }
+
+  private cueMode(): LiveCuesCueMode { return resolveLiveCuesCueMode(this.deps.env, this.deps.settings).value }
+  /** Ask Public topics consent, read the way the general runner reads it: unreadable, absent and off are all off. */
+  private publicTopicsOn(): boolean { try { return this.deps.publicTopics?.() === true } catch { return false } }
+  /** Cue mode `general` turns the focused cues off for a Mac recording, but only while the insights that replace them can
+   *  run: with Public topics off the general runner stops at public_topics_off, so switching the focused cues off as well would
+   *  leave the meeting with nothing, and Control cannot turn the consent on. Then the focused cues stay on and the status says
+   *  needs_public_topics. A G2 meeting keeps them too, whatever kinds it was armed with (6.97.9): it can never carry an insight. */
+  private focusedOff(s: Session): boolean { return macRecording(s) && this.cueMode() === 'general' && this.publicTopicsOn() }
+  private allCues(s: Session): LiveCueV2[] { return s.insights.length ? [...s.cues, ...s.insights].sort((a, b) => a.createdAt - b.createdAt) : [...s.cues] }
+
+  /** Remembers who the ASR path says is speaking, for the general runner's name gate. Bounded; generic labels ("Ext", "Speaker 2")
+   *  are not names. Never read by the focused path. */
+  private noteSpeakers(s: Session, speakers: readonly string[] | undefined): void {
+    for (const raw of speakers ?? []) {
+      const name = typeof raw === 'string' ? raw.replace(/\s+/g, ' ').trim() : ''
+      if (!name || name.length > 60 || isGenericSpeakerLabel(name) || s.speakers.size >= SPEAKER_NAMES_MAX) continue
+      s.speakers.add(name)
+    }
+  }
+
+  /** The meetings the general runner may look at: extended ones only, while v2 is on. The domain is the CONFIRMED Ask orientation
+   *  domain or null, never a recording sidecar's default (all saved sidecars say personal). */
+  private generalHost(): GeneralCueHost {
+    return {
+      candidates: () => {
+        if (!this.enabled()) return []
+        const out: GeneralCueCandidate[] = []
+        for (const s of this.sessions.values()) {
+          if (!macRecording(s) || s.kinds !== 'extended') continue            // a G2 meeting armed with the five kinds is still never offered to the general runner
+          // A throw is not "unconfirmed": an orientation that cannot be read may belong to a personal meeting, so it is withheld.
+          let domain: string | null = null, calendarTitle: string | null = null, domainUnreadable = false
+          try { const o = this.deps.orientation?.(s.sessionId); domain = o?.domain ?? null; calendarTitle = o?.title ?? null } catch { domainUnreadable = true }
+          // The orientation carries the calendar event's title, not its attendees: its capitalized words stand in for them.
+          const titleNames = (calendarTitle ?? '').match(/\p{Lu}[\p{L}'’-]{2,}/gu) ?? []
+          out.push({ sessionId: s.sessionId, kindSet: s.kinds, armed: !this.deps.store.isEnded(s.sessionId), paused: this.deps.store.isPaused(s.sessionId), domain,
+            ...(domainUnreadable ? { domainUnreadable } : {}), title: s.title, transcriptChars: s.charsFed, speakerNames: [...s.speakers, ...titleNames],
+            window: chars => cleanWindow(s.chunks.join('\n')).slice(-chars) })
+        }
+        return out
+      },
+      emit: (sessionId, insight) => this.emitInsight(sessionId, insight),
+    }
+  }
+  /** The general limits, the mode and the consent as they stand now (read at every tick, so a saved change applies at once). */
+  private generalSettings(): GeneralCueSettingsReader {
+    return {
+      cueMode: () => this.cueMode(),
+      limits: () => {
+        const r = resolveLiveCuesGeneralLimits(this.deps.env, this.deps.settings)
+        return { intervalSeconds: r.intervalSeconds.value, trigger: r.trigger.value, attemptsPerMeeting: r.attemptsPerMeeting.value, maxCuesPerMeeting: r.maxCuesPerMeeting.value,
+          dailyTopicCalls: r.dailyTopicCalls.value, dailyWebSearches: r.dailyWebSearches.value }
+      },
+      publicTopics: () => this.publicTopicsOn(),
+      homeArea: () => { try { return this.deps.homeArea?.() ?? null } catch { return null } },
+    }
+  }
+  /** One insight: logged, held in the meeting's own list, and emitted as `coaching_nudge_v2` ONLY (no v1 twin, so a v1 reader
+   *  never sees it). Extended meetings only. Nothing here touches the focused counters, cooldown, lastCueAt, inFlight, failures
+   *  or breaker. False when the meeting is gone, ended or not extended, or the cue would not pass isLiveCueV2. */
+  private emitInsight(sessionId: string, insight: GeneralInsight): boolean {
+    const s = this.sessions.get(sessionId)
+    if (!s || !macRecording(s) || s.kinds !== 'extended' || this.deps.store.isEnded(sessionId)) return false
+    // Every source goes through the same public https check as the cue log's: one that fails drops the whole insight.
+    const urls = insight.sources.map(src => publicHttpsUrl(src.url))
+    if (!insight.sources.length || urls.some(u => u === null)) return false
+    const sources = insight.sources.map((src, i) => ({ ...src, url: urls[i]! }))
+    const cue: LiveCueV2 = { protocol: 2, cueId: randomUUID(), sessionId, headline: insight.headline, detail: insight.detail, kind: 'insight', sources,
+      gate: round(insight.gate), createdAt: this.deps.now().getTime(), model: insight.model ?? liveCuesV2Model(this.deps.env) }
+    if (!isLiveCueV2(cue)) return false                                 // never emit what the companion would drop
+    const log = this.deps.cueLog
+    try {
+      log?.({ v: 1, cueId: cue.cueId, sessionId, meetingTitle: s.title, createdAt: cue.createdAt, kind: cue.kind, headline: cue.headline, detail: cue.detail, gate: cue.gate,
+        sources: cue.sources, model: cue.model, before: cueBefore(s.chunks.join('\n').replace(/^\[\d+\]\s*/gm, '')), general: { category: insight.category, query: insight.query },
+        armedAt: s.armedAt })
+    } catch (error) {
+      console.warn(`[live-cues-v2] insight log append failed: ${errMsg(error)}`)
+    }
+    s.insights.push(cue)
+    this.deps.emit('coaching_nudge_v2', cue as unknown as Record<string, unknown>)
+    return true
+  }
+
   /** Was this meeting armed under v2 in this process? Its stop and status stay v2 even after v2 is switched off. */
   knows(sessionId: string): boolean { return this.sessions.has(sessionId) }
 }
@@ -983,6 +1459,7 @@ let unsubscribe: (() => void) | null = null
 export function liveCuesV2(): LiveCuesV2Engine {
   if (!engine) {
     engine = new LiveCuesV2Engine(realDeps())
+    engine.startGeneral()
     // A saved meeting ends its cues even when the phone never sent Stop (orphan recovery, Control save).
     unsubscribe = onDisplay(event => {
       const sid = event.type === 'recording_stop' ? event.data?.sessionId : null
@@ -1043,16 +1520,59 @@ export function liveCuesV2SettingsViewV2(env: NodeJS.ProcessEnv = process.env):
   return { ...liveCuesV2SettingsView(env), v: 2, limits, writerCallsPerMeeting: 2 * limits.maxCuesPerMeeting.value, today: liveCuesV2().today() }
 }
 
+/** GET/POST /api/live-cues/v2/settings with v=3 (live cues v3): the v2 body (with `v: 3`) plus the cue mode, grounded cues and the
+ *  general-cue limits. An older server answers ?v=3 with 400 unsupported_version, which is Control's signal to hide these. */
+export interface GeneralCuesToday { day: string; topicCalls: number; webSearches: number; breakerOpenUntil: number | null }
+export interface LiveCuesV2SettingsResponseV3 extends Omit<LiveCuesV2SettingsResponseV2, 'v'> {
+  v: 3
+  cueMode: LiveCuesV2Mode<LiveCuesCueMode>
+  grounding: LiveCuesV2Mode<LiveCuesGrounding>
+  general: { limits: LiveCuesGeneralLimits; today: GeneralCuesToday; publicTopics: boolean; homeArea: string | null }
+  /** Additive (6.97.8): every public web lookup today by feature (cues, meeting assistant, fact check) and the ones held back. `general.today` keeps its meaning (the general cues only). */
+  webToday: WebTodayView
+}
+/** Today's general-cue counters and breaker come from the general runner, which registers itself here. Until it does (and
+ *  whenever general cues have never run) they read as zero. */
+let generalTodayProvider: (() => GeneralCuesToday) | null = null
+export function setGeneralCuesTodayProvider(provider: (() => GeneralCuesToday) | null): void { generalTodayProvider = provider }
+export function liveCuesV2SettingsViewV3(env: NodeJS.ProcessEnv = process.env): LiveCuesV2SettingsResponseV3 {
+  const v2 = liveCuesV2SettingsViewV2(env)
+  const settings = liveCuesV2Settings()
+  let today: GeneralCuesToday
+  try { today = generalTodayProvider ? generalTodayProvider() : { day: v2.today.day, topicCalls: 0, webSearches: 0, breakerOpenUntil: null } } catch { today = { day: v2.today.day, topicCalls: 0, webSearches: 0, breakerOpenUntil: null } }
+  let publicTopics = false
+  try { publicTopics = new MeetingAskStore().publicTopics() } catch { publicTopics = false }
+  let homeArea: string | null = null
+  try { homeArea = getOwnerHomeArea() } catch { homeArea = null }
+  let webToday: WebTodayView
+  try { webToday = webLedger().today() } catch { webToday = { day: v2.today.day, readable: false, cues: { searches: 0, pagesRead: 0, pagesFailed: 0 }, ask: { searches: 0, pagesRead: 0, pagesFailed: 0 }, factCheck: { searches: 0, pagesRead: 0, pagesFailed: 0 }, withheld: { total: 0, byReason: {}, byFeature: { cues: 0, ask: 0, factCheck: 0 } } } }
+  return { ...v2, v: 3, cueMode: resolveLiveCuesCueMode(env, settings), grounding: resolveLiveCuesGrounding(env, settings),
+    general: { limits: resolveLiveCuesGeneralLimits(env, settings), today, publicTopics, homeArea }, webToday }
+}
+
+/** What a v3 POST may change beyond the v2 patch. */
+export interface LiveCuesV3Patch { cueMode?: LiveCuesCueMode; grounding?: LiveCuesGrounding; general?: LiveCuesGeneralStoredLimits }
+
 /** Save the switch and any limits in ONE write, after every check passed: nothing is saved when any part is refused.
  *  Turning v2 off stops evaluations in flight; limits apply from each meeting's next evaluation. */
-export function applyLiveCuesV2Settings(patch: { enabled?: boolean; limits: LiveCuesV2StoredLimits }, env: NodeJS.ProcessEnv = process.env):
-  { ok: true } | { ok: false; error: 'env_forced' } | { ok: false; error: 'env_locked'; fields: LiveCuesV2LimitName[] } {
+export function applyLiveCuesV2Settings(patch: { enabled?: boolean; limits: LiveCuesV2StoredLimits } & LiveCuesV3Patch, env: NodeJS.ProcessEnv = process.env):
+  { ok: true } | { ok: false; error: 'env_forced'; fields?: Array<'cueMode' | 'grounding'> } | { ok: false; error: 'env_locked'; fields: string[] } {
   if (patch.enabled === false && liveCuesV2EnvForced(env)) return { ok: false, error: 'env_forced' }
+  // Live cues v3: env may force only the SAFE value, so the only refused request is one for the other value.
+  const forced: Array<'cueMode' | 'grounding'> = []
+  if (patch.cueMode !== undefined && patch.cueMode !== 'focused' && resolveLiveCuesCueMode(env, liveCuesV2Settings()).locked) forced.push('cueMode')
+  if (patch.grounding !== undefined && patch.grounding !== 'classic' && resolveLiveCuesGrounding(env, liveCuesV2Settings()).locked) forced.push('grounding')
+  if (forced.length) return { ok: false, error: 'env_forced', fields: forced }
   const current = resolveLiveCuesV2Limits(env, liveCuesV2Settings())
-  const locked = (Object.keys(patch.limits) as LiveCuesV2LimitName[]).filter(name => current[name].locked)
+  const generalNow = resolveLiveCuesGeneralLimits(env, liveCuesV2Settings())
+  const locked: string[] = [
+    ...(Object.keys(patch.limits) as LiveCuesV2LimitName[]).filter(name => current[name].locked),
+    ...(Object.keys(patch.general ?? {}) as LiveCuesGeneralLimitName[]).filter(name => generalNow[name].locked).map(name => LIVE_CUES_GENERAL_LIMIT_BOUNDS[name].field),
+  ]
   if (locked.length) return { ok: false, error: 'env_locked', fields: locked }
   const wasOn = liveCuesV2Enabled(env)
   liveCuesV2Settings().update(patch)
+  if (patch.cueMode !== undefined) engine?.modeChanged()              // leaving general mode stops an insight in flight at once
   if (wasOn && !liveCuesV2Enabled(env)) {
     const aborted = engine?.suspend() ?? 0
     console.log(`[live-cues-v2] switched off by setting; ${aborted} evaluation(s) stopped`)
@@ -1061,6 +1581,9 @@ export function applyLiveCuesV2Settings(patch: { enabled?: boolean; limits: Live
   }
   const changed = Object.entries(patch.limits).map(([k, v]) => `${k}=${v}`).join(' ')
   if (changed) console.log(`[live-cues-v2] limits saved: ${changed}`)
+  const v3 = [patch.cueMode ? `cueMode=${patch.cueMode}` : '', patch.grounding ? `grounding=${patch.grounding}` : '',
+    ...Object.entries(patch.general ?? {}).map(([k, v]) => `general.${k}=${v}`)].filter(Boolean).join(' ')
+  if (v3) console.log(`[live-cues-v2] settings saved: ${v3}`)
   return { ok: true }
 }
 /** What /api/health, /api/models and the status route advertise: NOTHING while v2 is switched off, so a 6.10.642