@gotcos/glasses-server 6.95.0 → 6.98.1

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

@@ -0,0 +1,262 @@
+// Live cues v3 grounded retrieval: pure helpers that turn the three retrieval arms (cue_memory.py, the owner's COS notes, and the
+// files attached to this meeting) into the candidates the grounded judge sees. Nothing here calls a model, reads a disk or
+// logs; live-cues-v2.ts runs the arms and the judge and passes what they returned.
+//
+// Rules, each from the 2026-11-01 replay and its validation:
+//   - self and twin exclusion: a meeting's own filed copy, or its twin's, was in cue_memory's raw top 8 for 579 of 614 windows
+//     and rank 1 for 432, so a candidate is dropped when its record is this session or a known twin, or when its text shares
+//     at least 15% of its 6-word sequences with what has been said so far;
+//   - personal-domain notes stay out of a meeting that is not personal;
+//   - one meeting is one candidate however many arms found it (date and normalised title, memory id, record id, file id);
+//   - at most M1..M4 from cue_memory, N1 from the notes, F1 from the files, D1 from the Tableau data arm, six in all. The data
+//     candidate (live-cues-v2-data.ts) is deterministic and rare, so it keeps a slot: when the six are full it displaces the lowest-ranked
+//     cue_memory candidate (never the file passage the room reads from). It is not a copy of any meeting, so the self and twin rules do not apply to it, and it has no domain.
+
+import { notesQueryTerms } from './live-cues-v2-notes.js'
+import type { MemoryNote } from './live-cues-v2.js'
+import type { CueSourceRef } from '../../shared/live-cues-v2.js'
+
+export const GROUNDED_LIMITS = {
+  /** Shared 6-word sequences, as a share of the candidate's own, at which it counts as this conversation. */
+  selfOverlap: 0.15,
+  shingleWords: 6,
+  /** cue_memory.py is asked for this many so that exclusions still leave `cueMemoryTop` (the replay's rule). */
+  cueMemoryRaw: 8,
+  cueMemoryTop: 4,
+  notesTop: 1,
+  filesTop: 1,
+  maxCandidates: 6,
+  /** A file passage is at most this long, and so is what the judge reads of it. */
+  fileChars: 300,
+  /** 6-word sequences kept for the whole meeting so far, oldest dropped first: 50,000 is about 50,000 spoken words, a 5 to 6 hour
+   *  meeting at a normal pace, and a few megabytes. */
+  historyShingles: 50_000,
+  /** A passage must share this many of the window's salient words to be offered at all. */
+  fileMinTerms: 2,
+  fileWindowTerms: 12,
+} as const
+
+export type GroundedArm = 'cue_memory' | 'notes' | 'files' | 'data'
+export type GroundedKind = 'meeting' | 'memory' | 'file' | 'data'
+/** A candidate for the judge: the note fields the judge and the writer read, plus where it came from. */
+export interface GroundedNote extends MemoryNote { arm: GroundedArm; kind: GroundedKind }
+
+/** The file fields grounded cues read (a MeetingAskFile). */
+export interface GroundedFile { id: string; name: string; status: string; text: string }
+
+/** Python's meeting_canonical.normalize_title: lower case, ASCII punctuation to spaces, whitespace collapsed. */
+export function normalizeMeetingTitle(title: string): string {
+  return title.toLowerCase().replace(/[!-/:-@[-`{-~]/g, ' ').split(/\s+/).filter(Boolean).join(' ')
+}
+
+/** Every identity a candidate answers to; two candidates sharing one are the same meeting, memory or file. */
+export function candidateIdentities(c: Pick<MemoryNote, 'date' | 'title' | 'recordId' | 'memoryId' | 'fileId'>): string[] {
+  const ids: string[] = []
+  // A file is dated with the meeting it was attached to and named by its file name; that says nothing about a past meeting.
+  if (c.date && c.title && !c.fileId) ids.push(`meeting:${c.date}|${normalizeMeetingTitle(c.title)}`)
+  if (c.recordId) ids.push(`record:${c.recordId}`)
+  if (c.memoryId) ids.push(`memory:${c.memoryId}`)
+  if (c.fileId) ids.push(`file:${c.fileId}`)
+  return ids
+}
+
+const wordsOf = (text: string): string[] => text.toLowerCase().match(/[a-z0-9']+/g) ?? []
+
+/** The set of 6-word sequences in `text` (lower case, letters, digits and apostrophes). */
+export function shingleSet(text: string, n: number = GROUNDED_LIMITS.shingleWords): Set<string> {
+  const words = wordsOf(text)
+  const out = new Set<string>()
+  for (let i = 0; i + n <= words.length; i += 1) out.add(words.slice(i, i + n).join(' '))
+  return out
+}
+
+/** Every 6-word sequence said in one meeting since it was armed, for the self-copy check. The engine's window keeps only the last
+ *  ~400 words, so a copy of something said an hour ago would pass a check against the window alone. Chunks are added as they
+ *  arrive; the last five words of one chunk join the next, so a sequence across a chunk boundary is counted. Over its cap the
+ *  oldest go first. */
+export class SessionShingles {
+  private readonly seen = new Set<string>()
+  private tail: string[] = []
+  constructor(readonly cap: number = GROUNDED_LIMITS.historyShingles) {}
+  add(text: string): void {
+    const n = GROUNDED_LIMITS.shingleWords
+    const words = [...this.tail, ...wordsOf(text)]
+    for (let i = 0; i + n <= words.length; i += 1) {
+      this.seen.add(words.slice(i, i + n).join(' '))
+    }
+    this.tail = words.slice(-(n - 1))
+    while (this.seen.size > this.cap) this.seen.delete(this.seen.values().next().value as string)
+  }
+  get shingles(): ReadonlySet<string> { return this.seen }
+  clear(): void { this.seen.clear(); this.tail = [] }
+}
+
+/** The share of the candidate's own 6-word sequences that also appear in the transcript so far (0 when it has none). */
+export function sixGramOverlap(candidateText: string, transcript: ReadonlySet<string>): number {
+  const own = shingleSet(candidateText)
+  if (!own.size) return 0
+  let shared = 0
+  for (const s of own) if (transcript.has(s)) shared += 1
+  return shared / own.size
+}
+
+/** Ids that mean "this conversation": the session and its known twins, also in the library's `standalone:` form. */
+export function selfIdSet(sessionId: string, twins: Iterable<string> = []): Set<string> {
+  const out = new Set<string>()
+  for (const id of [sessionId, ...twins]) { out.add(id); out.add(`standalone:${id}`) }
+  return out
+}
+
+export function isSelfCopy(c: Pick<MemoryNote, 'notes' | 'recordId' | 'sessionId'>, transcript: ReadonlySet<string>, selfIds: ReadonlySet<string>): boolean {
+  if ((c.recordId && selfIds.has(c.recordId)) || (c.sessionId && selfIds.has(c.sessionId))) return true
+  return sixGramOverlap(c.notes, transcript) >= GROUNDED_LIMITS.selfOverlap
+}
+
+/** A personal-domain note never reaches a meeting that is not personal. An unknown meeting domain counts as not personal. */
+export function isForeignPersonal(noteDomain: string | undefined, meetingDomain: string | null): boolean {
+  const norm = (v: unknown) => (typeof v === 'string' ? v.trim().toLowerCase() : '')
+  return norm(noteDomain) === 'personal' && norm(meetingDomain) !== 'personal'
+}
+
+const nonEmpty = (v: unknown): v is string => typeof v === 'string' && v.trim() !== ''
+
+/** A retrieved note the code below can read: the four fields it calls string methods on are strings. cue_memory.py's answer is
+ *  parsed JSON from a subprocess, so a malformed row is skipped here instead of throwing into the evaluation. */
+function wellFormed(n: unknown): n is MemoryNote {
+  const r = n as Partial<Record<keyof MemoryNote, unknown>> | null
+  return !!r && typeof r === 'object' && typeof r.id === 'string' && typeof r.date === 'string' && typeof r.title === 'string' && typeof r.notes === 'string'
+}
+
+/** Kind and locator from a retrieved note's key: `memory:<id>` and `meeting:<recordId>` come from the notes arm, anything
+ *  else (cue_memory.py's `date|title`, or no key) is a meeting with no record id known. Only the fields the arms produce are
+ *  copied: the note's own id, date, title, notes and key, its domain (cue_memory.py and the notes arm say it when they know
+ *  it) and the session it was recorded from, each only when it is a non-empty string. */
+function describe(note: MemoryNote, arm: GroundedArm): Omit<GroundedNote, 'id'> {
+  const key = typeof note.key === 'string' ? note.key : ''
+  const base = { date: note.date, title: note.title, notes: note.notes, key, arm, ...(nonEmpty(note.domain) ? { domain: note.domain } : {}),
+    ...(nonEmpty(note.sessionId) ? { sessionId: note.sessionId } : {}) }
+  if (key.startsWith('memory:') && key.length > 'memory:'.length) return { ...base, kind: 'memory', memoryId: key.slice('memory:'.length) }
+  if (key.startsWith('meeting:') && key.length > 'meeting:'.length) return { ...base, kind: 'meeting', recordId: key.slice('meeting:'.length) }
+  return { ...base, kind: 'meeting' }
+}
+
+/** The files with the four fields grounded cues read, all strings; anything else in the list is dropped. */
+export function usableFiles(raw: unknown): GroundedFile[] {
+  if (!Array.isArray(raw)) return []
+  return raw.filter((f): f is GroundedFile => !!f && typeof f === 'object' && typeof f.id === 'string' && typeof f.name === 'string' && typeof f.status === 'string' && typeof f.text === 'string')
+}
+
+/** Passages of at most `max` characters: blank-line blocks, then sentences, then a hard cut. */
+export function passagesOf(text: string, max: number = GROUNDED_LIMITS.fileChars): string[] {
+  const out: string[] = []
+  for (const block of text.split(/\n\s*\n/)) {
+    const flat = block.replace(/\s+/g, ' ').trim()
+    if (!flat) continue
+    if (flat.length <= max) { out.push(flat); continue }
+    let cur = ''
+    for (const sentence of flat.split(/(?<=[.!?])\s+/)) {
+      if (cur && cur.length + 1 + sentence.length > max) { out.push(cur); cur = '' }
+      cur = cur ? `${cur} ${sentence}` : sentence
+      while (cur.length > max) { out.push(cur.slice(0, max)); cur = cur.slice(max) }
+    }
+    if (cur) out.push(cur)
+  }
+  return out
+}
+
+/** The one file passage that best matches the window, or null. Only `ready` files count (a secret-held file has no text and is
+ *  never read, whatever it carries), a passage must share at least fileMinTerms of the window's salient words, and the first
+ *  best passage wins a tie. */
+export function bestFilePassage(files: GroundedFile[], window: string): { file: GroundedFile; passage: string } | null {
+  const terms = notesQueryTerms(window, GROUNDED_LIMITS.fileWindowTerms)
+  if (!terms.length) return null
+  let best: { file: GroundedFile; passage: string; score: number } | null = null
+  for (const file of files) {
+    if (file.status !== 'ready' || typeof file.text !== 'string' || !file.text.trim()) continue
+    for (const passage of passagesOf(file.text)) {
+      const words = new Set(passage.toLowerCase().match(/[a-z0-9]+/g) ?? [])
+      const score = terms.reduce((n, t) => n + (words.has(t) ? 1 : 0), 0)
+      if (score >= GROUNDED_LIMITS.fileMinTerms && (!best || score > best.score)) best = { file, passage, score }
+    }
+  }
+  return best ? { file: best.file, passage: best.passage } : null
+}
+
+export interface GroundedInputs {
+  /** cue_memory.py's answer, up to cueMemoryRaw, best first. */
+  cueMemory: MemoryNote[]
+  /** The owner's COS notes, best first. */
+  notes: MemoryNote[]
+  files: unknown
+  /** The 6-word sequences of everything said in this meeting so far (SessionShingles; speaker labels removed). */
+  transcript: ReadonlySet<string>
+  /** The last part of it: what the room is on now. */
+  window: string
+  selfIds: ReadonlySet<string>
+  /** The confirmed domain of this meeting, or null. */
+  meetingDomain: string | null
+  /** This meeting's local date (YYYY-MM-DD): a file is dated with the meeting it was attached to. */
+  today: string
+  /** The Tableau data candidate (live-cues-v2-data.ts dataCandidate), already triggered and domain-checked, or none. */
+  data?: GroundedNote | null
+}
+
+/** The candidates for the judge, in order M1..M4, N1, F1, with ids that keep their kind. `excludedSelf` counts the notes dropped
+ *  as this conversation or its twin. Files are the owner's own attachments to this meeting, so the self rule does not apply
+ *  to them: a document the room reads from is what a file cue is for. */
+export function groundedCandidates(i: GroundedInputs): { candidates: GroundedNote[]; excludedSelf: number; domainUnknown: number } {
+  const transcript = i.transcript
+  const seen = new Set<string>()
+  const out: GroundedNote[] = []
+  let excludedSelf = 0
+  const take = (list: MemoryNote[], arm: GroundedArm, limit: number, prefix: string) => {
+    let n = 0
+    for (const raw of list) {
+      if (n >= limit || out.length >= GROUNDED_LIMITS.maxCandidates) return
+      if (!wellFormed(raw)) continue
+      const note = describe(raw, arm)
+      const identities = candidateIdentities(note)
+      // A copy of this conversation also keeps every other copy of the same meeting out, whatever its text says.
+      if (isSelfCopy(note, transcript, i.selfIds)) { for (const id of identities) seen.add(id); excludedSelf += 1; continue }
+      if (isForeignPersonal(note.domain, i.meetingDomain)) continue
+      if (identities.some(id => seen.has(id))) continue
+      for (const id of identities) seen.add(id)
+      n += 1
+      out.push({ ...note, id: `${prefix}${n}` })
+    }
+  }
+  take(i.cueMemory, 'cue_memory', GROUNDED_LIMITS.cueMemoryTop, 'M')
+  take(i.notes, 'notes', GROUNDED_LIMITS.notesTop, 'N')
+  if (out.length < GROUNDED_LIMITS.maxCandidates) {
+    const hit = bestFilePassage(usableFiles(i.files), i.window)
+    if (hit) {
+      out.push({ id: 'F1', date: i.today, title: hit.file.name.replace(/\s+/g, ' ').trim().slice(0, 90), notes: hit.passage, key: `file:${hit.file.id}`,
+        arm: 'files', kind: 'file', fileId: hit.file.id })
+    }
+  }
+  if (i.data) {
+    // When the six are full, D1 displaces the lowest-ranked cue_memory candidate (the last one), never the file passage the room is
+    // reading from. Memory ranks below it: the data candidate only exists when the room named a group beside a figure.
+    if (out.length >= GROUNDED_LIMITS.maxCandidates) {
+      const at = out.map(c => c.arm).lastIndexOf('cue_memory')
+      if (at >= 0) out.splice(at, 1)
+    }
+    if (out.length < GROUNDED_LIMITS.maxCandidates) out.push({ ...i.data, id: 'D1', arm: 'data', kind: 'data' })
+  }
+  // The personal-domain rule can only work on a note that says its domain; this counts the notes that did not.
+  const domainUnknown = out.filter(c => c.arm !== 'files' && c.arm !== 'data' && !c.domain).length
+  return { candidates: out, excludedSelf, domainUnknown }
+}
+
+/** The cue source for a kept candidate: the opaque id, the date and title as before, and (v3) its kind with its one locator. */
+export function groundedSource(note: GroundedNote, id: string): CueSourceRef {
+  // A Tableau data note (kind 'data') is not a meeting, memory, file or page, and has no locator. It goes out as a `file` source with none, which
+  // every reader already shows as plain text with its title and date: Control 0.5.363 reads only id, date and title; 0.5.364 keeps
+  // `kind` as a free string and opens nothing without a fileId; the companion shows the headline only. A new kind would be one
+  // that a rolled-back server rejects when it reloads the cue log (isCueSourceExtras).
+  const base: CueSourceRef = { id, date: note.date, title: note.title, kind: note.kind === 'data' ? 'file' : note.kind }
+  if (note.kind === 'memory' && note.memoryId) return { ...base, memoryId: note.memoryId }
+  if (note.kind === 'file' && note.fileId) return { ...base, fileId: note.fileId }
+  if (note.kind === 'meeting' && note.recordId) return { ...base, recordId: note.recordId }
+  return base
+}

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

@@ -0,0 +1,59 @@
+// Live cues v3 grounded judge ("judge B"): ONE Jev request per evaluation that asks, for each candidate, whether it is directly
+// relevant to what is being said now (a `choice` {yes, no} question per candidate), plus production's own `same` choice as a
+// logged diagnostic. The wording below is copied verbatim from the replay that measured it (cue_rrf_replay prompts.py:
+// REL_YES, REL_NO, the rel_<id> instructions, note_line at 300 characters). A candidate is kept when its own yes probability
+// reaches judgeYes, so two relevant notes no longer split one probability and both lose, which is what the single `same`
+// question did (the replay's kept>0 rate went from 18% to 45% with 79% directly useful and none irrelevant).
+//
+// Hand-written on purpose: live-cues-v2-prompts.ts is GENERATED and its hash is pinned. The `same` question reuses that
+// file's instructions and none sentence unchanged.
+
+import { CUE_JUDGE_INSTRUCTIONS, CUE_JUDGE_NONE } from './live-cues-v2-prompts.js'
+
+export const JUDGE_B_WINDOW_CHARS = 2_200
+export const JUDGE_B_NOTE_CHARS = 300
+export const CUE_REL_YES = 'Yes: the note is about the same client, project, brand, person or decision as the conversation, and would help the wearer right now.'
+export const CUE_REL_NO = 'No: the note is about something else, or is only loosely related to the conversation.'
+
+export interface JudgeBCandidate { id: string; date: string; title: string; notes: string }
+
+/** The note as the judge reads it: date, title, then the first 300 characters of the note. */
+export function judgeNoteLine(c: JudgeBCandidate): string {
+  return `${c.date} ${c.title}: ${c.notes.slice(0, JUDGE_B_NOTE_CHARS)}`
+}
+
+/** The `same` question first (production's wording and criteria, so it stays comparable), then one yes/no question per candidate. */
+export function judgeBQuestions(cands: JudgeBCandidate[]): Record<string, unknown> {
+  const criteria: Record<string, string> = Object.fromEntries(cands.map(c => [c.id, judgeNoteLine(c)]))
+  criteria.none = CUE_JUDGE_NONE
+  const questions: Record<string, unknown> = { same: { type: 'choice', instructions: CUE_JUDGE_INSTRUCTIONS, criteria } }
+  for (const c of cands) {
+    questions['rel_' + c.id] = { type: 'choice',
+      instructions: 'Is this past meeting note directly relevant to what is being discussed in the last part of `window`? Past note: ' + judgeNoteLine(c),
+      criteria: { yes: CUE_REL_YES, no: CUE_REL_NO } }
+  }
+  return questions
+}
+
+/** Each candidate's yes probability and its `same` probability. A missing, non-numeric or out-of-range value reads as 0, so a
+ *  malformed answer can never keep a note. */
+export function parseJudgeB(answers: Record<string, { probabilities?: Record<string, number> } | undefined> | undefined,
+  ids: string[]): { yes: Record<string, number>; same: Record<string, number> } {
+  const prob = (v: unknown) => (typeof v === 'number' && Number.isFinite(v) && v >= 0 && v <= 1 ? v : 0)
+  const yes: Record<string, number> = {}, same: Record<string, number> = {}
+  for (const id of ids) {
+    yes[id] = prob(answers?.['rel_' + id]?.probabilities?.yes)
+    same[id] = prob(answers?.same?.probabilities?.[id])
+  }
+  return { yes, same }
+}
+
+/** The candidates the writer sees: yes at or above the threshold, best first (ties keep candidate order), at most `max`. */
+export function selectJudgeB<T extends { id: string }>(cands: T[], yes: Record<string, number>, threshold: number, max: number): T[] {
+  return cands
+    .map((c, order) => ({ c, order, p: yes[c.id] ?? 0 }))
+    .filter(x => x.p >= threshold)
+    .sort((a, b) => b.p - a.p || a.order - b.order)
+    .slice(0, max)
+    .map(x => x.c)
+}

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

@@ -0,0 +1,49 @@
+// 6.97.8: the spellings the cue writer may use for a name. The transcript misspells names ("Bori" for Vori, "Niall" for
+// Niala), and the server already knows the right ones: the speakers the ASR path reported for THIS meeting, the owner, and the
+// terms the owner taught the decoder that are written like names. Enrolled voice profiles are deliberately left out: that store holds
+// everyone the glasses ever heard, household included, and none of it belongs in a work meeting's prompt. No new data source and
+// no network: the same readers the general-cue name gate uses (live-cues-general-topic.ts ProfileNameSource), handed to the same
+// local writer that already sees the transcript. Pure but for those readers; a reader that fails just contributes nothing.
+
+import { isGenericSpeakerLabel, realProfileNames, type ProfileNameSource } from './live-cues-general-topic.js'
+
+/** Most names a prompt carries. A meeting names a handful of people and products; the rest is the owner's whole vocabulary. */
+export const KNOWN_NAMES_MAX = 60
+/** Most characters of names a prompt carries. */
+export const KNOWN_NAMES_CHARS = 700
+const NAME_MAX_CHARS = 32
+const NAME_MAX_WORDS = 3
+
+/** What the writer is told about the list. It rides in the prompt data, so no writer rule text changes. */
+export const KNOWN_NAMES_USE = 'Spell a person, company or product exactly as listed when a word in the window sounds like it and the context fits. Speech to text misspells names. Never add a name the window does not hint at.'
+
+/** A vocabulary term worth listing: short, and written like a name or a product (a capital letter somewhere). Plain work words
+ *  the owner taught the decoder ("retail", "pos") are not names, and a long phrase is not a spelling. */
+function looksLikeName(term: string): boolean {
+  return term.length >= 3 && term.length <= NAME_MAX_CHARS && term.split(/\s+/).length <= NAME_MAX_WORDS && /\p{Lu}/u.test(term) && !/[\x00-\x1f\x7f]/.test(term)
+}
+
+/** Per name in the prompt: the quotes, the comma and the space the JSON adds around it. */
+const NAME_OVERHEAD_CHARS = 4
+
+/** The names for one meeting, most useful first: the meeting's speakers, the owner, then the vocabulary names. A name that does not
+ *  fit is skipped, not the end of the list. */
+export async function knownNamesFor(speakers: readonly string[], src: ProfileNameSource = realProfileNames): Promise<string[]> {
+  const candidates: string[] = []
+  for (const s of speakers) if (typeof s === 'string') candidates.push(s)
+  try { candidates.push(src.ownerName()) } catch { /* no profile */ }
+  try { candidates.push(...src.vocabulary().filter(looksLikeName)) } catch { /* no vocabulary */ }
+  const seen = new Set<string>(), out: string[] = []
+  let chars = 0
+  for (const raw of candidates) {
+    if (typeof raw !== 'string') continue
+    const name = raw.replace(/\s+/g, ' ').trim()
+    const key = name.toLowerCase()
+    // The owner's placeholder name ("User") and the ASR's generic labels ("Speaker 2") are not names, wherever they came from.
+    if (!name || name.length > NAME_MAX_CHARS || seen.has(key) || key === 'user' || isGenericSpeakerLabel(name)) continue
+    if (out.length >= KNOWN_NAMES_MAX) break
+    if (chars + name.length + NAME_OVERHEAD_CHARS > KNOWN_NAMES_CHARS) continue
+    seen.add(key); out.push(name); chars += name.length + NAME_OVERHEAD_CHARS
+  }
+  return out
+}

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

@@ -18,7 +18,9 @@ export const NOTES_TOP = 4
 const NOTE_CHARS = 520
 const TITLE_CHARS = 90
 
-export interface NoteCandidate { id: string; date: string; title: string; notes: string; key: string }
+/** `domain` and `sessionId` (live cues v3) are set only when the source said them; grounded cues use them to keep personal notes
+ *  out of other meetings and to recognise this meeting's own filed copy. The judge and the writer never see them. */
+export interface NoteCandidate { id: string; date: string; title: string; notes: string; key: string; domain?: string; sessionId?: string }
 export interface NotesResult { notes: NoteCandidate[]; error?: string }
 
 export interface NotesSearchers {
@@ -73,18 +75,20 @@ export function notesQueries(terms: string[]): string[] {
 
 const dateOf = localDateOf
 const flat = (v: unknown, max: number): string => (typeof v === 'string' ? v.replace(/\s+/g, ' ').trim().slice(0, max) : '')
+const domainOf = (v: unknown): { domain?: string } => (typeof v === 'string' && v.trim() ? { domain: v.trim() } : {})
 
 function memoryCandidate(hit: ContextSearchHit): NoteCandidate | null {
   if (!hit.id) return null
-  return { id: '', date: dateOf(hit.created_at), title: flat(hit.title || hit.id, TITLE_CHARS), notes: flat(hit.snippet || hit.title, NOTE_CHARS), key: `memory:${hit.id}` }
+  return { id: '', date: dateOf(hit.created_at), title: flat(hit.title || hit.id, TITLE_CHARS), notes: flat(hit.snippet || hit.title, NOTE_CHARS), key: `memory:${hit.id}`, ...domainOf(hit.domain) }
 }
 function meetingCandidate(hit: MeetingSearchHit): NoteCandidate | null {
   if (!hit.recordId) return null
-  return { id: '', date: dateOf(hit.date), title: flat(hit.title, TITLE_CHARS), notes: flat(hit.snippet || hit.title, NOTE_CHARS), key: `meeting:${hit.recordId}` }
+  return { id: '', date: dateOf(hit.date), title: flat(hit.title, TITLE_CHARS), notes: flat(hit.snippet || hit.title, NOTE_CHARS), key: `meeting:${hit.recordId}`,
+    ...domainOf(hit.domain), ...(hit.sessionId ? { sessionId: hit.sessionId } : {}) }
 }
 function bridgeCandidate(row: BridgeMemory): NoteCandidate {
   const firstLine = row.content.split('\n').find(l => l.trim()) ?? row.id
-  return { id: '', date: dateOf(row.created_at), title: flat(row.summary || firstLine, TITLE_CHARS), notes: flat(row.content, NOTE_CHARS), key: `memory:${row.id}` }
+  return { id: '', date: dateOf(row.created_at), title: flat(row.summary || firstLine, TITLE_CHARS), notes: flat(row.content, NOTE_CHARS), key: `memory:${row.id}`, ...domainOf(row.domain) }
 }
 
 /** Bridge rows ranked for one query, best first (the shared scorer). */

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

@@ -0,0 +1,132 @@
+// 6.97.8: fold the "nobody named an owner or a date, settle it" cues into one combined cue.
+//
+// On 2026-11-02, 34 of 100 cues were that one template, each taking a lens slot. This module decides which cues are open items
+// and keeps the held ones for a combined cue: at most one every 10 minutes, at most 3 items, each short.
+//
+// What counts as an open item (QA fix: the item must come from the writer, never from a guess at the wording):
+//   1. the writer returned its own `open` item (the extended-kind prompt, writer v4, asks for it; the legacy prompt never returns
+//      one, so a legacy meeting folds nothing and every cue is shown as written);
+//   2. the cue is also, in its wording, an owner or date gap (a cue that carries a risk or a figure and merely mentions an owner is
+//      never reduced to a label);
+//   3. never a decision, and never a cue that cites a past meeting or note.
+// A held cue is never lost: the engine logs it when it is held, keeps it in the writer's recent-cue history, and the fold hands
+// it back for display: in a combined cue (the newest three, once 10 minutes have passed since the last), or, when nothing joined
+// it within 20 minutes, on its own exactly as the writer wrote it.
+// Pure: no clock, no model, no I/O. The engine owns the session state and the emit.
+
+import { cueOverlap, cueTokens } from './live-cues-filter.js'
+import type { CueKind, LiveCueV2 } from '../../shared/live-cues-v2.js'
+
+/** At most one combined cue per this long. */
+export const OPEN_ITEMS_EVERY_MS = 10 * 60_000
+/** At most this many items in one combined cue. */
+export const OPEN_ITEMS_MAX = 3
+/** A held item that nothing joined for this long is shown on its own. */
+export const OPEN_ITEM_STALE_MS = 20 * 60_000
+/** Longest item, in characters: the writer is asked for 50. Three of them and the lead-in stay inside the 220-character cue detail, one with " +2" inside the 64-character headline. */
+export const OPEN_ITEM_MAX_CHARS = 50
+/** Two items this alike (token overlap) are the same item. */
+const SAME_ITEM = 0.6
+
+const ABSENT = /\b(?:no|nobody|none|not yet|hasn'?t|haven'?t|wasn'?t|weren'?t|isn'?t|never)\b[^.!?]{0,60}?\b(?:owner|owners|date|dates|deadline|named|taken|assigned)\b/i
+const ASK = /\b(?:name|pick|assign|set|settle|pin|pin down|agree|choose|decide|fix|confirm)\b[^.!?]{0,40}?\b(?:an? owner|the owner|who|when|an? date|the date|a deadline|a day|cadence)\b/i
+
+/** The wording rule alone (rule 3 above). */
+export function isOwnerDateGap(detail: string, kind: CueKind): boolean {
+  const text = detail || ''
+  if (!ABSENT.test(text)) return false
+  return ASK.test(text) || kind === 'followUp' || kind === 'promise'
+}
+
+/** One item in the writer's words, trimmed to the item limit; null when it says nothing. */
+export function cleanOpenItem(raw: unknown): string | null {
+  if (typeof raw !== 'string') return null
+  const text = raw.replace(/[—–]/g, '-').replace(/\s+/g, ' ').trim().replace(/^[\s:;,.-]+|[\s:;,.-]+$/g, '')
+  if (text.length < 3) return null
+  return clipAtWord(text, OPEN_ITEM_MAX_CHARS)
+}
+
+function clipAtWord(text: string, max: number): string {
+  if (text.length <= max) return text
+  const cut = text.slice(0, max - 1)
+  const space = cut.lastIndexOf(' ')
+  return (space > max / 2 ? cut.slice(0, space) : cut).replace(/[,;:.\s]+$/, '') + '…'
+}
+
+export interface OpenItemVerdict { label: string }
+
+/** Is this cue an open item, and what is the item? `field` is the writer's own `open` value, `cited` how many past sources it has. */
+export function openItemOf(cue: { kind: CueKind; detail: string; cited: number; field?: unknown }): OpenItemVerdict | null {
+  if (cue.kind === 'decision' || cue.cited > 0) return null
+  const label = cleanOpenItem(cue.field)
+  return label && isOwnerDateGap(cue.detail, cue.kind) ? { label } : null
+}
+
+/** The combined cue's wording. Plain words, one sentence, no dashes. */
+export function openItemsDetail(items: readonly string[]): string {
+  return `Still open, no owner or date: ${items.join('; ')}.`
+}
+/** The lens footer shows only this: the first item, and how many more are in the cue. */
+export function openItemsHeadline(items: readonly string[]): string {
+  return items.length > 1 ? `${items[0]} +${items.length - 1}` : items[0]
+}
+
+export interface HeldItem { label: string; at: number; cue: LiveCueV2; before: string; tokens: Set<string>; seen: Set<string> }
+/** What the fold hands back when something is due: a combined cue of the newest three, the oldest stale item on its own, or the
+ *  oldest stale item dropped because the room has talked about it again since it was held (it may well be settled now). */
+export type FlushPlan = { mode: 'digest'; items: HeldItem[] } | { mode: 'alone'; items: [HeldItem] } | { mode: 'drop'; items: [HeldItem] }
+
+/** The share of an item's scored words that must have been said again since it was held for the item to count as talked about. */
+export const OPEN_ITEM_SAID_SHARE = 0.6
+
+/** The held items of one meeting, and when something is due. */
+export class OpenItemFold {
+  private pending: HeldItem[] = []
+  private everHeld: LiveCueV2[] = []
+  private shownLabels: string[] = []
+  private lastDigestAt: number | null = null
+
+  /** Hold a cue as an item, unless it is the same item as one held or already shown (it is then only remembered). Returns whether it waits. */
+  hold(label: string, cue: LiveCueV2, now: number, before = ''): boolean {
+    this.everHeld.push(cue)
+    const tokens = cueTokens(label)
+    const same = (other: string) => cueOverlap(tokens, cueTokens(other)) >= SAME_ITEM
+    if (this.pending.some(p => same(p.label)) || this.shownLabels.some(same)) return false
+    this.pending.push({ label, at: now, cue, before, tokens, seen: new Set() })
+    return true
+  }
+
+  /** How many items wait. */
+  waiting(): number { return this.pending.length }
+
+  /** Every cue ever held, for the writer's recent-cue history and the repeat rules: a held item must not be raised again. */
+  history(): readonly LiveCueV2[] { return this.everHeld }
+
+  /** What the room says after an item was held: remember which of each waiting item's scored words came up again. */
+  noteSaid(text: string): void {
+    if (!this.pending.length) return
+    const said = cueTokens(text)
+    for (const p of this.pending) for (const t of p.tokens) if (said.has(t)) p.seen.add(t)
+  }
+
+  /** Has the room talked about this item again since it was held (most of its scored words, at least one)? */
+  talkedAbout(item: HeldItem): boolean {
+    return item.seen.size >= Math.max(1, Math.ceil(item.tokens.size * OPEN_ITEM_SAID_SHARE))   // a label with no scored words can never be seen again
+  }
+
+  /** What is due now. A combined cue needs two waiting and 10 minutes since the last; a stale item is shown alone. */
+  next(now: number): FlushPlan | null {
+    const spaced = this.lastDigestAt === null || now - this.lastDigestAt >= OPEN_ITEMS_EVERY_MS
+    if (spaced && this.pending.length >= 2) return { mode: 'digest', items: this.pending.slice(-OPEN_ITEMS_MAX) }
+    const stale = this.pending.find(p => now - p.at >= OPEN_ITEM_STALE_MS)
+    if (!stale) return null
+    return this.talkedAbout(stale) ? { mode: 'drop', items: [stale] } : { mode: 'alone', items: [stale] }
+  }
+
+  /** The plan was carried out (shown, or for a drop, set aside). */
+  markShown(plan: FlushPlan, now: number): void {
+    this.pending = this.pending.filter(p => !plan.items.includes(p))
+    if (plan.mode !== 'drop') this.shownLabels.push(...plan.items.map(i => i.label))
+    if (plan.mode === 'digest') this.lastDigestAt = now
+  }
+}

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

@@ -0,0 +1,45 @@
+// 6.97.8: pace the per-meeting cue cap so a meeting cannot spend it all early. On 2026-11-02 three of the four long meetings
+// reached the 25-cue cap in 18 to 30 minutes of a 35 to 47 minute meeting, and the last 5 to 22 minutes got nothing.
+//
+// The user's two settings keep their meaning: the cap is still the most cues a meeting can ever show, and the gap (cooldown) is
+// still the least time between two cues. The pace only decides how soon the cap is available.
+//
+//   burst   = ceil(cap / 2)                          half the cap is open from the first minute, at the gap pace
+//   refill  = max(gap, horizon / (cap - burst))      the other half comes back one cue at a time, evenly, over the horizon
+//   allowed(t) = min(cap, burst + floor(t / refill))
+//
+// The horizon is the meeting's own length when the calendar match gives one (clamped to 15 to 180 minutes), else one meeting
+// hour. With the defaults (cap 25, gap 60 s, one hour): burst 13, one more cue every 5 minutes, the 25th at minute 60. A meeting
+// that runs longer than the horizon simply has its whole cap open after it. A cap of 4 or fewer is not paced at all: with so few
+// cues the first minutes are the only ones worth spending them on, and the engine tests of a small cap rely on it.
+
+/** The meeting length the cap is spread over when the calendar does not say: one hour. */
+export const PACE_HORIZON_MS = 60 * 60_000
+export const PACE_HORIZON_MIN_MS = 15 * 60_000
+export const PACE_HORIZON_MAX_MS = 180 * 60_000
+/** Caps up to this are not paced. */
+export const PACE_MIN_CAP = 5
+
+/** A calendar length as a horizon: null or nonsense falls back to the default, anything else is clamped. */
+export function paceHorizon(durationMs: number | null | undefined): number {
+  if (typeof durationMs !== 'number' || !Number.isFinite(durationMs) || durationMs <= 0) return PACE_HORIZON_MS
+  return Math.min(PACE_HORIZON_MAX_MS, Math.max(PACE_HORIZON_MIN_MS, durationMs))
+}
+
+export function paceBurst(maxCues: number): number {
+  return Math.min(maxCues, Math.ceil(maxCues / 2))
+}
+
+/** Milliseconds between two refills; Infinity when the whole cap is already open (a cap of 1). */
+export function paceRefillMs(maxCues: number, cooldownMs: number, horizonMs: number = PACE_HORIZON_MS): number {
+  const rest = maxCues - paceBurst(maxCues)
+  return rest <= 0 ? Number.POSITIVE_INFINITY : Math.max(cooldownMs, Math.floor(horizonMs / rest))
+}
+
+/** How many cues a meeting may have shown `elapsedMs` after it started. Never more than the cap; a negative elapsed counts as 0. */
+export function paceAllowed(maxCues: number, cooldownMs: number, elapsedMs: number, horizonMs: number = PACE_HORIZON_MS): number {
+  if (maxCues < PACE_MIN_CAP) return maxCues
+  const refill = paceRefillMs(maxCues, cooldownMs, horizonMs)
+  const refilled = Number.isFinite(refill) ? Math.floor(Math.max(0, elapsedMs) / refill) : 0
+  return Math.min(maxCues, paceBurst(maxCues) + refilled)
+}

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

@@ -3,8 +3,9 @@
 // byte-identical to what the dev and held-out replays measured, and every meeting without the extended kinds (every
 // glasses meeting today) still runs them.
 //
-// v4 is v3 with three segments swapped: rule 3 (the kinds), rule 4 (a record of what the room settled is allowed to say
-// what the room said) and the kind list in the schema line. Nothing else changes: one cue, at most 200 characters, the
+// v4 is v3 with four segments swapped: rule 3 (the kinds), rule 4 (a record of what the room settled is allowed to say
+// what the room said, and 6.97.8: an optional `open` item when the cue's main point is a missing owner or date) and the
+// kind list and the optional `open` key in the schema line. Nothing else changes: one cue, at most 200 characters, the
 // same evidence rules, the same null. The swap throws when v3 no longer holds a segment, so a regenerated v3 fails the
 // suite (live-cues-v2-kinds.test.ts) instead of silently shipping v3 under the v4 label.
 //
@@ -24,9 +25,13 @@ export const V3_RULE_4 = '4. Add something the room has not said: the missing ow
   + '   If the cue would only restate what was just said, output null.\n'
 export const V4_RULE_4 = '4. A reinforce or challenge cue must add something the room has not said: the missing owner, deadline or criterion, a risk, a contradiction, or a past decision from memory.\n'
   + '   If it would only restate what was just said, output null. A decision, promise or followUp records what the room settled, took on or left open, in a few plain words.\n'
+  + '   When the main point of a cue is that nobody named an owner or a date for something, add "open": that thing in at most 50 characters, in plain words (for example "Thanksgiving week agenda"). Otherwise leave "open" out.\n'
 
 export const V3_SCHEMA_KIND = '"kind":"reinforce|challenge"'
 export const V4_SCHEMA_KIND = '"kind":"reinforce|challenge|decision|promise|followUp"'
+/** 6.97.8: the optional `open` key, added after `specific`. */
+export const V3_SCHEMA_OPEN = '"specific":"the specific fact used, copied"}'
+export const V4_SCHEMA_OPEN = '"specific":"the specific fact used, copied","open":"<=50 chars, optional"}'
 
 function swap(text: string, from: string, to: string): string {
   const at = text.indexOf(from)
@@ -34,5 +39,5 @@ function swap(text: string, from: string, to: string): string {
   return text.slice(0, at) + to + text.slice(at + from.length)
 }
 
-/** Writer v4: v3 plus the decision, promise and followUp kinds. */
-export const CUE_WRITER_SYSTEM_V4 = swap(swap(swap(CUE_WRITER_SYSTEM_V3, V3_RULE_3, V4_RULE_3), V3_RULE_4, V4_RULE_4), V3_SCHEMA_KIND, V4_SCHEMA_KIND)
+/** Writer v4: v3 plus the decision, promise and followUp kinds, and the optional `open` item. */
+export const CUE_WRITER_SYSTEM_V4 = swap(swap(swap(swap(CUE_WRITER_SYSTEM_V3, V3_RULE_3, V4_RULE_3), V3_RULE_4, V4_RULE_4), V3_SCHEMA_KIND, V4_SCHEMA_KIND), V3_SCHEMA_OPEN, V4_SCHEMA_OPEN)