@gotcos/glasses-server 6.89.0 → 6.91.0

package/server/lib/dictation-polish-instructions.ts

@@ -26,9 +26,9 @@ export const CUSTOM_INSTRUCTIONS_PROTOCOL = 1
 /**
  * The prompt's own delimiters. A preference that contains one could close its block early and
  * write text the model would read as COS's, so every one of them is removed, in any case and
- * with any spacing or attributes.
+ * with any spacing or attributes. 6.91.0: the learned-style block's tag too.
  */
-const RESERVED_TAG = /<\s*\/?\s*(?:user-style-preferences|known-spellings|dictation)\b[^>]*>/gi
+const RESERVED_TAG = /<\s*\/?\s*(?:user-style-preferences|learned-style|known-spellings|dictation)\b[^>]*>/gi
 /** C0 and C1 controls other than line feed and tab, plus DEL. */
 const CONTROL = /[\u0000-\u0008\u000B-\u001F\u007F-\u009F]/g
 /** Invisible format characters: zero-width, bidi embeddings, overrides and isolates, BOM, soft hyphen. */

package/server/lib/dictation-polish-options.ts

@@ -0,0 +1,98 @@
+import { readFileSync, statSync, unlinkSync } from 'node:fs'
+import { atomicWriteFileSync } from './atomic-fs.js'
+import { dataPath } from './data-dir.js'
+
+/**
+ * 6.91.0: "Previous polish", the one polish option COS Control can set (plan r2). The person can
+ * go back to the 6.90.0 prompt (v3) from Control's own Settings, with no terminal and no restart,
+ * and G2 follows because the option lives on the server.
+ *
+ * - `promptVersion: "default"` (prompt v4, the default) or `"v3"`.
+ * - The environment wins when it names a version (COS_DICTATION_POLISH_PROMPT, or the
+ *   COS_DICTATION_PROMPT_VERSION alias): dictation-clean.ts dictationPolishPromptVersion.
+ * - Stored atomically in the data dir, mode 0600; "default" deletes the file. A missing or
+ *   malformed file reads as "default".
+ */
+export const POLISH_OPTIONS_PROTOCOL = 1
+export const POLISH_OPTIONS_FILE = 'dictation-polish-options.json'
+export const POLISH_PROMPT_OPTIONS = ['default', 'v3'] as const
+export type PolishPromptOption = typeof POLISH_PROMPT_OPTIONS[number]
+
+export interface PolishOptions { promptVersion: PolishPromptOption; updatedAt: string | null }
+
+const filePath = () => dataPath(POLISH_OPTIONS_FILE)
+let cache: { mtimeMs: number; size: number; value: PolishOptions } | null = null
+
+export function readPolishOptions(): PolishOptions {
+  const off: PolishOptions = { promptVersion: 'default', updatedAt: null }
+  let stat: { mtimeMs: number; size: number }
+  try { const s = statSync(filePath()); stat = { mtimeMs: s.mtimeMs, size: s.size } } catch { cache = null; return off }
+  if (cache && cache.mtimeMs === stat.mtimeMs && cache.size === stat.size) return { ...cache.value }
+  let value = off
+  try {
+    const parsed = JSON.parse(readFileSync(filePath(), 'utf8'))
+    if ((POLISH_PROMPT_OPTIONS as readonly string[]).includes(parsed?.promptVersion)) {
+      value = { promptVersion: parsed.promptVersion, updatedAt: typeof parsed.updatedAt === 'string' ? parsed.updatedAt : null }
+    }
+  } catch { /* malformed reads as default */ }
+  cache = { ...stat, value }
+  return { ...value }
+}
+
+export function writePolishOptions(promptVersion: PolishPromptOption, now: Date = new Date()): PolishOptions {
+  cache = null
+  if (promptVersion === 'default') {
+    try { unlinkSync(filePath()) } catch (err: any) { if (err?.code !== 'ENOENT') throw err }
+    return { promptVersion, updatedAt: null }
+  }
+  const stored: PolishOptions = { promptVersion, updatedAt: now.toISOString() }
+  atomicWriteFileSync(filePath(), JSON.stringify(stored, null, 2) + '\n', { mode: 0o600 })
+  return stored
+}
+
+export function __resetPolishOptionsCacheForTests(): void { cache = null }
+
+export type DictationPolishPromptVersion = 'v1' | 'v2' | 'v3' | 'v4'
+/** The newest prompt, the default on the models in V4_DEFAULT_MODELS. */
+export const DEFAULT_DICTATION_POLISH_PROMPT: DictationPolishPromptVersion = 'v4'
+export const DICTATION_POLISH_PROMPT_VERSIONS: readonly DictationPolishPromptVersion[] = ['v1', 'v2', 'v3', 'v4']
+export type PromptVersionSource = 'env' | 'option' | 'default'
+
+/**
+ * 6.91.0 (canary C1): prompt v4 passed on Sonnet and failed on Haiku (CHANGELOG), so it is the
+ * default on Sonnet only. Haiku, Luna and any other or unnamed model keep v3, byte for byte the
+ * 6.90.0 prompt. The environment and the "Previous polish" option still override every model.
+ */
+export const V4_DEFAULT_MODELS: readonly string[] = ['sonnet']
+export const POLISH_MODEL_DEFAULTS = ['haiku', 'sonnet', 'luna-5.6-fast'] as const
+
+export function defaultPromptFor(model: string | undefined): DictationPolishPromptVersion {
+  return model !== undefined && V4_DEFAULT_MODELS.includes(model) ? DEFAULT_DICTATION_POLISH_PROMPT : 'v3'
+}
+
+/**
+ * Which prompt runs, and why: COS_DICTATION_POLISH_PROMPT (v1 to v4) when it names one, else the
+ * alias COS_DICTATION_PROMPT_VERSION (3 or v3), else this file's option ("v3"), else the model's
+ * default (v4 on Sonnet, v3 otherwise). With no model named, the newest default (v4) is reported.
+ */
+export function dictationPolishPromptChoice(env: NodeJS.ProcessEnv = process.env, model?: string): { version: DictationPolishPromptVersion; source: PromptVersionSource } {
+  const raw = (env.COS_DICTATION_POLISH_PROMPT ?? '').trim().toLowerCase()
+  if ((DICTATION_POLISH_PROMPT_VERSIONS as readonly string[]).includes(raw)) return { version: raw as DictationPolishPromptVersion, source: 'env' }
+  const alias = (env.COS_DICTATION_PROMPT_VERSION ?? '').trim().toLowerCase().replace(/^(\d)$/, 'v$1')
+  if ((DICTATION_POLISH_PROMPT_VERSIONS as readonly string[]).includes(alias)) return { version: alias as DictationPolishPromptVersion, source: 'env' }
+  if (readPolishOptions().promptVersion === 'v3') return { version: 'v3', source: 'option' }
+  return { version: model === undefined ? DEFAULT_DICTATION_POLISH_PROMPT : defaultPromptFor(model), source: 'default' }
+}
+
+export function dictationPolishPromptVersion(env: NodeJS.ProcessEnv = process.env, model?: string): DictationPolishPromptVersion {
+  return dictationPolishPromptChoice(env, model).version
+}
+
+/**
+ * 6.91.0: the model and prompt pairs the learned style and the literal register were canaried on
+ * (C2 and C3 ran on Sonnet with v4 only). Any other pair gets neither: no learned style, no
+ * register block, no literal check, and no `polishRegister` in the answer.
+ */
+export function styleAndRegisterApply(model: string | undefined, version: DictationPolishPromptVersion): boolean {
+  return model === 'sonnet' && version === 'v4'
+}

package/server/lib/dictation-polish-pipeline.ts

@@ -0,0 +1,292 @@
+import type { DictationCleanModel } from './dictation-clean-models.js'
+import { applyNegativeRules } from './hallucination-filter.js'
+import { applyCorrections } from './whisper-local.js'
+import { applyFuzzyCorrections } from './fuzzy-correct.js'
+import { getAllSpeakerNames } from './speaker-embeddings.js'
+import { autoCleanDictation, AUTOCLEAN_MAX_CHARS } from './dictation-clean.js'
+import { dictationPolishPromptVersion, styleAndRegisterApply, type DictationPolishPromptVersion } from './dictation-polish-options.js'
+import { fillerPassEnabled, stripDisfluencies } from './dictation-fillers.js'
+import { polishBudgetExhausted, recordPolishCall, type PolishBucket } from './dictation-polish-budget.js'
+import { polishNeed, skipCleanEnabled } from './dictation-polish-need.js'
+import { discardPolishPrewarm, PrewarmUnavailableError, runWarmPolish, takePolishPrewarm } from './dictation-prewarm.js'
+import { getVocabulary, getWhisperCorrections } from './profile.js'
+import { correctionOnlyForms } from './glossary-learn.js'
+import { polishLinkProblem, renderSpokenPaths, spokenPathsEnabled } from './dictation-format.js'
+import { customInstructionsHash, readCustomInstructions } from './dictation-polish-instructions.js'
+import { learnedStyleEnabled, learnedStyleLinesFor, readLearnedStyle } from './dictation-learned-style.js'
+import { literalAnswer, type DictationRegister } from './dictation-register.js'
+import { meaningGuardCounts, meaningGuardEnabled, meaningGuardProblem, type MeaningGuardKind } from './dictation-meaning-guard.js'
+import { createBreaker } from './claude-circuit.js'
+import { logTokenAudit } from './token-audit.js'
+
+/**
+ * The outbound dictation polish: the one pipeline behind POST /api/dictation/finalize and the
+ * prompt-draft finalize (routes/prompt-drafts.ts). 6.91.0 moved it here, unchanged in order, so
+ * the offline evals call this function itself instead of a copy of it:
+ *
+ *   dictionary (exact corrections and negative rules), the fuzzy name pass, the filler pass and
+ *   spoken paths (not for meeting lines), the gates (disabled, too long, clean, breaker, daily
+ *   cap), the model (warm when a prewarm token matches, else cold), then the guards: the link
+ *   guard on every surface; for message and prompt_draft on the canaried pair only (Sonnet with
+ *   prompt v4), the literal register's word check and the meaning guard.
+ *
+ * Meeting lines are a faithful record and stay as 6.90.0 had them: prompt v3 (or older), no
+ * register, no instructions, no learned style, no meaning guard.
+ */
+
+export const autoCleanBreakers = {
+  sonnet: createBreaker({ label: 'dictation-autoclean-sonnet' }),
+  'luna-5.6-fast': createBreaker({ label: 'dictation-autoclean-luna' }),
+  haiku: createBreaker({ label: 'dictation-autoclean-haiku' }),
+}
+const autoCleanDefaultEnabled = () => ['1', 'true', 'on'].includes((process.env.COS_DICTATION_AUTOCLEAN ?? '').toLowerCase())
+
+/** 6.79.1, additive on finalize answers: why the polish model did not run (or did not finish).
+ * 6.91.0: a guard that refuses the model's answer says "failed" too (link_guard keeps its own
+ * code), so 0.5.325 to 0.5.343 log fillers_only:failed and never claim polish. */
+export type PolishSkipped = 'disabled' | 'too_long' | 'breaker_open' | 'daily_cap' | 'failed' | 'clean' | 'link_guard'
+/** 6.79.2, additive when finalize was given a prewarmToken: what became of that warm process. */
+export type PrewarmOutcome = 'used' | 'missed' | 'discarded'
+/** 6.91.0, additive, present exactly when the model answered: what became of its answer. */
+export type PolishOutcome = 'polished' | 'unchanged' | 'guarded'
+export type PolishGuard = 'link' | 'literal' | MeaningGuardKind
+/** 6.91.0, additive: the prompt the model ran, as a closed set (v1 and v2 are not reported). */
+export type PolishPrompt = 'v3' | 'v4'
+
+export interface AutoCleanRequest { enabled?: boolean; model?: DictationCleanModel }
+export type OutboundOptions = AutoCleanRequest & {
+  bucket: PolishBucket
+  signal?: AbortSignal
+  prewarmToken?: string
+  /** 6.91.0: the target app's register (finalize reads it from `context.app`). */
+  register?: DictationRegister
+  /** Offline evals only: the prompt to use instead of the configured one. */
+  promptVersion?: DictationPolishPromptVersion
+}
+
+/** 6.85.0 and 6.91.0: additive, present only when the model was given them. */
+export interface PolishInstructionsUse {
+  customInstructions?: true
+  instructionsHash?: string
+  learnedStyle?: true
+  learnedStyleHash?: string
+  /** 6.91.0: the register the model was given, only on a pair the register was canaried on (Sonnet with v4). */
+  polishRegister?: DictationRegister
+  /** 6.91.0: the prompt the model ran (v3 or v4), whenever the model was called. */
+  polishPrompt?: PolishPrompt
+  /** 6.91.0: false whenever the model was called without the learned style. */
+  learnedStyleOff?: true
+}
+export type PolishResult = {
+  text: string
+  polishSkipped?: PolishSkipped
+  prewarm?: PrewarmOutcome
+  polishOutcome?: PolishOutcome
+  guard?: PolishGuard
+  /** Never sent by a route: the model's own answer, before any guard (the offline evals score it). */
+  modelText?: string
+} & PolishInstructionsUse
+
+export async function cleanOutboundDictation(
+  text: string,
+  opts: OutboundOptions,
+): Promise<PolishResult> {
+  const result = await polishOutboundDictation(text, opts)
+  // A warm process the model call did not take must not sit until its TTL.
+  if (opts.prewarmToken && !result.prewarm) {
+    return { ...result, prewarm: discardPolishPrewarm(opts.prewarmToken) ? 'discarded' : 'missed' }
+  }
+  return result
+}
+
+/**
+ * 6.85.0: the user's polish instructions apply to dictation (Mac dictation and G2 messages, which
+ * are surface "message", and prompt drafts). Meeting lines are a faithful record, so they stay on
+ * the built-in rules alone, the same way they skip the filler pass and spoken paths.
+ */
+export function polishInstructionsFor(bucket: PolishBucket): string {
+  return bucket === 'meeting' ? '' : readCustomInstructions().customInstructions
+}
+
+/**
+ * 6.91.0: the learned style for one polish: the lines for its register and the setting's hash.
+ * Never for meeting lines or a literal target, and nothing at all when the server switch
+ * (COS_DICTATION_LEARNED_STYLE=0) or the person's own switch (enabled: false) is off.
+ */
+export function learnedStyleFor(bucket: PolishBucket, register: DictationRegister): { lines: string; hash: string } {
+  if (bucket === 'meeting' || !learnedStyleEnabled()) return { lines: '', hash: '' }
+  const stored = readLearnedStyle()
+  const lines = learnedStyleLinesFor(stored, register)
+  return lines ? { lines, hash: stored.hash } : { lines: '', hash: '' }
+}
+
+/**
+ * 6.91.0: the prompt for one polish. The configured prompt for its model (v4 on Sonnet, v3 on Haiku,
+ * Luna or anything else, unless the environment or "Previous polish" says otherwise); meeting lines
+ * never take v4.
+ */
+export function polishPromptVersionFor(bucket: PolishBucket, wanted?: DictationPolishPromptVersion, model?: string): DictationPolishPromptVersion {
+  const version = wanted ?? dictationPolishPromptVersion(process.env, model)
+  return bucket === 'meeting' && version === 'v4' ? 'v3' : version
+}
+
+/** The deterministic passes, in route order: what the model is given ("cleaned"). */
+export function prepareOutboundDictation(text: string, bucket: PolishBucket): string {
+  let cleaned = applyNegativeRules(applyCorrections(text)).replace(/\s+/g, ' ').trim() || text
+  // applyCorrections above is an EXACT string map, so it only fixes misspellings someone
+  // already hand-authored. A novel miss ("Rileyy" for Riley, "Exampel" for Example) sails
+  // through it. The Levenshtein pass is what catches those, and until now it had exactly
+  // ONE call site — transcribe-audio.ts:252, the server-transcription route — so phone
+  // Moonshine dictation, which arrives here as text, never got it. Same construction and
+  // same non-fatal posture as that site, deliberately: targets are speaker names plus
+  // vocabulary, and a throw must never cost the user their transcript.
+  //
+  // Runs BEFORE the autoclean LLM so the model sees corrected proper nouns rather than
+  // being asked to guess at them, and it still helps on every path where autoclean is
+  // off, over the char cap, or breaker-open.
+  try {
+    const fuzzyTargets = [...getAllSpeakerNames(), ...getVocabulary()]
+    const { text: corrected, replacements } = applyFuzzyCorrections(cleaned, fuzzyTargets)
+    if (replacements > 0) {
+      console.log(`[prompt-draft] Fuzzy corrected ${replacements} word(s)`)
+      cleaned = corrected
+    }
+  } catch (fuzzyErr: any) {
+    console.warn(`[prompt-draft] Fuzzy correction failed (non-fatal): ${fuzzyErr?.message ?? fuzzyErr}`)
+  }
+  // 6.79.1: um/uh never survive a skipped polish. Meeting lines stay faithful.
+  if (bucket !== 'meeting' && fillerPassEnabled()) cleaned = stripDisfluencies(cleaned)
+  // 6.83.1: "forward slash pricing," is "/pricing," even when the model is skipped. One word
+  // at a phrase end only; slugs of several words are the model's (dictation-format.ts).
+  if (bucket !== 'meeting' && spokenPathsEnabled()) cleaned = renderSpokenPaths(cleaned)
+  return cleaned
+}
+
+/**
+ * 6.91.0: the guards after the model, for one answer. Pure apart from reading the dictionary.
+ * `text` is what goes out: the answer (repaired for a literal target), or `cleaned` when a guard
+ * refused it. The link guard runs on every answer, as in 6.83.1. The literal check and the meaning
+ * guard run only on the canaried pair (Sonnet with prompt v4, `canaried`), never on meeting lines:
+ * Haiku, Luna, any other model and prompt v3 (the environment or "Previous polish") get 6.90.0's
+ * answer, guard for guard.
+ */
+export function guardPolishAnswer(
+  cleaned: string, polished: string, bucket: PolishBucket, register: DictationRegister, canaried: boolean,
+): { text: string; outcome: PolishOutcome; guard?: PolishGuard; polishSkipped?: PolishSkipped } {
+  // 6.83.1: the model never invents a link and never drops one the dictionary wrote. Its
+  // answer is refused (the pre-polish text goes out, polishSkipped "link_guard") rather than
+  // pasting a URL nobody said. The call still counted: it ran.
+  const linkProblem = polished ? polishLinkProblem(cleaned, polished, correctionOnlyForms(getWhisperCorrections()), getVocabulary()) : null
+  if (linkProblem) {
+    console.warn(`[prompt-draft] auto-clean answer refused: ${linkProblem}`)
+    return { text: cleaned, outcome: 'guarded', guard: 'link', polishSkipped: 'link_guard' }
+  }
+  let answer = polished || cleaned
+  if (canaried && bucket !== 'meeting') {
+    // 6.91.0: a terminal gets the speaker's words. Anything but fillers, stutters, punctuation and
+    // case changed means the input goes out; otherwise the input's casing is put back and no
+    // closing period is added (dictation-register.ts literalAnswer).
+    if (register === 'literal') {
+      const literal = literalAnswer(cleaned, answer)
+      if (literal === null) {
+        console.warn('[prompt-draft] auto-clean answer guarded: literal')
+        return { text: cleaned, outcome: 'guarded', guard: 'literal', polishSkipped: 'failed' }
+      }
+      answer = literal || cleaned
+    }
+    // 6.91.0: nor may it lose (or add) a negation, number, date or name the speaker kept. A
+    // self-correction may drop what it replaced. Counts only in the log, never a word.
+    if (meaningGuardEnabled()) {
+      let problem: ReturnType<typeof meaningGuardProblem>
+      try {
+        problem = meaningGuardProblem(cleaned, answer, [...getVocabulary(), ...getAllSpeakerNames()])
+      } catch {
+        // A guard that could not read the answer does not vouch for it.
+        console.warn('[prompt-draft] auto-clean answer guarded: unverified')
+        return { text: cleaned, outcome: 'guarded', polishSkipped: 'failed' }
+      }
+      if (problem) {
+        console.warn(`[prompt-draft] auto-clean answer guarded: ${meaningGuardCounts(problem)}`)
+        return { text: cleaned, outcome: 'guarded', guard: problem.kind, polishSkipped: 'failed' }
+      }
+    }
+  }
+  return { text: answer, outcome: answer !== cleaned ? 'polished' : 'unchanged' }
+}
+
+export async function polishOutboundDictation(
+  text: string,
+  opts: OutboundOptions,
+): Promise<PolishResult> {
+  const cleaned = prepareOutboundDictation(text, opts.bucket)
+  if (!(opts.enabled ?? autoCleanDefaultEnabled())) return { text: cleaned, polishSkipped: 'disabled' }
+  const model = opts.model ?? 'haiku'
+  const autoCleanBreaker = autoCleanBreakers[model]
+  if (cleaned.length > AUTOCLEAN_MAX_CHARS) return { text: cleaned, polishSkipped: 'too_long' }
+  // 6.79.2, off by default: nothing for the model to fix (see dictation-polish-need.ts).
+  if (skipCleanEnabled() && polishNeed(cleaned) === null) return { text: cleaned, polishSkipped: 'clean' }
+  if (autoCleanBreaker.isOpen()) return { text: cleaned, polishSkipped: 'breaker_open' }
+  if (polishBudgetExhausted(opts.bucket)) return { text: cleaned, polishSkipped: 'daily_cap' }
+  const startedAt = Date.now()
+  recordPolishCall(opts.bucket)
+  // Read once per polish: the warm and cold paths see the same prompt.
+  const meeting = opts.bucket === 'meeting'
+  const promptVersion = polishPromptVersionFor(opts.bucket, opts.promptVersion, model)
+  const customInstructions = polishInstructionsFor(opts.bucket)
+  const instructionsHash = customInstructionsHash(customInstructions)
+  // 6.91.0: the register, the learned style and the meaning guard only where they were canaried
+  // (Sonnet with v4); every other pair gets none of them, so its prompt and its answer are 6.90.0's.
+  // Meeting lines never reach v4 (polishPromptVersionFor), so they never get any.
+  const canaried = styleAndRegisterApply(model, promptVersion)
+  const register: DictationRegister = canaried ? opts.register ?? 'default' : 'default'
+  const style = canaried ? learnedStyleFor(opts.bucket, register) : { lines: '', hash: '' }
+  const used: PolishInstructionsUse = {
+    ...(customInstructions ? { customInstructions: true, instructionsHash } : {}),
+    ...(style.lines ? { learnedStyle: true, learnedStyleHash: style.hash } : { learnedStyleOff: true }),
+    ...(canaried ? { polishRegister: register } : {}),
+    ...(promptVersion === 'v3' || promptVersion === 'v4' ? { polishPrompt: promptVersion } : {}),
+  }
+  const promptExtras = { customInstructions, learnedStyle: style.lines, register, promptVersion }
+  // 6.79.2: a warm process started at key press answers without the CLI's start-up cost.
+  const warmEntry = opts.prewarmToken ? takePolishPrewarm(opts.prewarmToken, model) : null
+  let prewarm: PrewarmOutcome | undefined = opts.prewarmToken ? 'missed' : undefined
+  try {
+    let polished: string | null = null
+    if (warmEntry) {
+      try {
+        polished = (await runWarmPolish(warmEntry, cleaned, getVocabulary(), { signal: opts.signal, ...promptExtras })).trim()
+        prewarm = 'used'
+      } catch (err) {
+        // Nothing was sent: the cold path below is the same call, not a second one.
+        if (!(err instanceof PrewarmUnavailableError)) throw err
+      }
+    }
+    if (polished === null) polished = (await autoCleanDictation(cleaned, getVocabulary(), { model, signal: opts.signal, ...promptExtras })).trim()
+    // An empty answer is a failed polish, as 6.90.0 reported it (both model paths already refuse
+    // one; this holds if either ever stops): the input goes out, polishSkipped "failed", and the
+    // breaker counts it. Never "unchanged".
+    if (!polished) throw new Error('Auto-clean returned empty text')
+    autoCleanBreaker.recordSuccess()
+    const guarded = guardPolishAnswer(cleaned, polished, opts.bucket, register, canaried)
+    logTokenAudit({
+      source: 'g2-dictation-autoclean', model, inputChars: cleaned.length, outputChars: polished.length,
+      durationMs: Date.now() - startedAt, caller: `dictation_autoclean_${opts.bucket}`,
+      polishInstructions: { on: Boolean(customInstructions), hash: instructionsHash },
+      // 6.91.0: codes and a hash only, never the app name or a word.
+      learnedStyle: { on: Boolean(style.lines), hash: style.hash },
+      ...(canaried ? { polishRegister: register } : {}),
+      ...(used.polishPrompt ? { polishPrompt: used.polishPrompt } : {}),
+      polishOutcome: guarded.outcome, ...(guarded.guard ? { polishGuard: guarded.guard } : {}),
+    })
+    return {
+      text: guarded.text, ...(prewarm ? { prewarm } : {}),
+      ...(guarded.polishSkipped ? { polishSkipped: guarded.polishSkipped } : {}),
+      polishOutcome: guarded.outcome, ...(guarded.guard ? { guard: guarded.guard } : {}),
+      modelText: polished, ...used,
+    }
+  } catch (err: any) {
+    autoCleanBreaker.recordFailure()
+    console.warn(`[prompt-draft] auto-clean failed (glossary-only): ${err?.message ?? err}`)
+    return { text: cleaned, polishSkipped: 'failed', ...(prewarm ? { prewarm } : {}), ...used }
+  }
+}

package/server/lib/dictation-prewarm.ts

@@ -6,8 +6,8 @@ import { join } from 'node:path'
 import { resolveProviderBinary } from './provider-binary.js'
 import { terminateProviderProcess } from './provider-process-lifecycle.js'
 import {
-  buildDictationPolishPrompt, claudePolishArgs, dictationChildEnv, dictationPolishPromptVersion,
-  type DictationPolishPromptVersion,
+  buildDictationPolishPrompt, claudePolishArgs, DICTATION_POLISH_SYSTEM_PROMPTS, dictationChildEnv, dictationPolishPromptVersion,
+  type DictationPolishPromptVersion, type DictationPromptExtras,
 } from './dictation-clean.js'
 
 /**
@@ -67,11 +67,11 @@ function retire(entry: WarmPolish): void {
   if (!entry.exited) void terminateProviderProcess(entry.proc).catch(() => {})
 }
 
-export function startPolishPrewarm(model: PrewarmModel): { token: string; expiresMs: number } {
+/** `version` defaults to the configured prompt; only the offline evals pass one (6.91.0). */
+export function startPolishPrewarm(model: PrewarmModel, version: DictationPolishPromptVersion = dictationPolishPromptVersion(process.env, model)): { token: string; expiresMs: number } {
   const binary = resolveProviderBinary('claude')
   if (!binary.ok) throw new PrewarmUnavailableError('Dictation cleanup Claude CLI unavailable')
   while (warm.size >= PREWARM_MAX) retire(warm.values().next().value!)
-  const version = dictationPolishPromptVersion()
   const scratch = mkdtempSync(join(tmpdir(), 'cos-dictation-prewarm-'))
   const workspace = join(scratch, 'workspace')
   mkdirSync(workspace, { mode: 0o700 })
@@ -134,6 +134,15 @@ export function takePolishPrewarm(token: string | undefined, model: string): War
   return entry
 }
 
+/**
+ * 6.91.0: the version the one message is built with. A caller may ask for another version (meeting
+ * lines stay on v3 while dictation runs v4) only when both share the system prompt the process was
+ * started with; otherwise the process's own version is used, as before.
+ */
+export function messageVersion(started: DictationPolishPromptVersion, wanted: DictationPolishPromptVersion | undefined): DictationPolishPromptVersion {
+  return wanted && DICTATION_POLISH_SYSTEM_PROMPTS[wanted] === DICTATION_POLISH_SYSTEM_PROMPTS[started] ? wanted : started
+}
+
 /**
  * Write the one message and read the one result. PrewarmUnavailableError means nothing was
  * sent (the process had already gone), so the caller may spawn cold. Any later failure means
@@ -143,7 +152,7 @@ export async function runWarmPolish(
   entry: WarmPolish,
   text: string,
   terms: string[],
-  opts: { signal?: AbortSignal; customInstructions?: string } = {},
+  opts: { signal?: AbortSignal; customInstructions?: string; promptVersion?: DictationPolishPromptVersion } & DictationPromptExtras = {},
 ): Promise<string> {
   if (entry.exited || !entry.proc.stdin || entry.proc.stdin.destroyed) {
     retire(entry)
@@ -180,7 +189,10 @@ export async function runWarmPolish(
     opts.signal?.addEventListener('abort', abort, { once: true })
     const message = JSON.stringify({
       type: 'user',
-      message: { role: 'user', content: buildDictationPolishPrompt(text, terms, entry.version, opts.customInstructions ?? '') },
+      message: {
+        role: 'user',
+        content: buildDictationPolishPrompt(text, terms, messageVersion(entry.version, opts.promptVersion), opts.customInstructions ?? '', { learnedStyle: opts.learnedStyle, register: opts.register }),
+      },
     })
     try {
       entry.proc.stdin!.write(message + '\n')

package/server/lib/dictation-register.ts

@@ -0,0 +1,114 @@
+import { readSwitch } from './env-switch.js'
+
+/**
+ * 6.91.0: the register a dictation is written in, chosen from the app it is going to.
+ *
+ * COS Control has sent the frontmost app's localized name as `context.app` on every Mac polish
+ * since 0.5.325; until 6.91.0 the server ignored it. The MVP has two registers (plan r2):
+ *
+ * - literal: terminals (iTerm2, Terminal, Ghostty, Warp, WezTerm, Alacritty, kitty). The model
+ *   adds no sentence capital, no trailing period and no learned style, and keeps the speaker's
+ *   words (self-corrections and spoken paths included); a deterministic check then requires the
+ *   answer's words to equal its input's apart from fillers, stutters, punctuation and case, and
+ *   falls back to the input otherwise (finalize `guard: "literal"`).
+ * - default: everything else, Claude, Cursor and Codex included, and an unknown, blank or
+ *   malformed app name. G2 messages (no app) and meeting lines are default too.
+ *
+ * ONE table, matched on the exact name (case and surrounding space ignored), published to Control
+ * by GET /api/dictation/learned-style (`registers`) so Control never keeps a second copy. The app
+ * name is read here, never logged, audited or echoed.
+ *
+ * The literal register is OPT-IN (COS_DICTATION_REGISTERS=1): terminal targets are mostly AI
+ * prompts in prose (Claude Code, Codex), not shell commands, and literal would stop resolving
+ * corrections, fixing grammar and capitalizing them. Off (the default), a terminal gets the
+ * default register, and the prompt carries no register block at all. The map is published either
+ * way; `registersEnabled` says whether it is applied.
+ */
+export type DictationRegister = 'literal' | 'default'
+export const DICTATION_REGISTERS: readonly DictationRegister[] = ['literal', 'default']
+
+export const LITERAL_APPS: readonly string[] = ['iTerm2', 'Terminal', 'Ghostty', 'Warp', 'WezTerm', 'Alacritty', 'kitty']
+
+const LITERAL = new Set(LITERAL_APPS.map(app => app.toLowerCase()))
+
+/** Off unless COS_DICTATION_REGISTERS is 1, true or on. */
+export function registersEnabled(env: NodeJS.ProcessEnv = process.env): boolean {
+  return readSwitch(env.COS_DICTATION_REGISTERS, false)
+}
+
+/**
+ * The register for a frontmost-app name: an exact table match (case and surrounding space ignored)
+ * or `default`. A long, multi-line or non-string value can never match the table, so it is default
+ * without a separate check (the 6.91.0 mutation gate showed one was unreachable).
+ */
+export function registerForApp(app: unknown, env: NodeJS.ProcessEnv = process.env): DictationRegister {
+  if (!registersEnabled(env) || typeof app !== 'string') return 'default'
+  return LITERAL.has(app.trim().toLowerCase()) ? 'literal' : 'default'
+}
+
+/** `context.app` from a finalize body, without trusting its shape (a primitive or array has no `app`). */
+export function registerFromContext(context: unknown, env: NodeJS.ProcessEnv = process.env): DictationRegister {
+  return registerForApp((context as { app?: unknown } | null | undefined)?.app, env)
+}
+
+/** What GET /api/dictation/learned-style publishes: every app that is not default, applied or not. */
+export function publishedRegisters(): Record<string, 'literal'> {
+  return Object.fromEntries(LITERAL_APPS.map(app => [app, 'literal' as const]))
+}
+
+/** Verbal tics the literal check lets the model drop (one word or two). Never a negation or number. */
+const LITERAL_DROPPABLE = new Set(['um', 'umm', 'uh', 'uhh', 'uhm', 'er', 'erm', 'ah', 'ahh', 'hmm', 'hm', 'mm', 'mhm',
+  'like', 'basically', 'so', 'well'])
+const LITERAL_DROPPABLE_PAIRS = new Set(['you know', 'i mean', 'kind of', 'sort of'])
+
+interface Word { lower: string; start: number; end: number }
+function words(text: string): Word[] {
+  const out: Word[] = []
+  const re = /[\p{L}\p{N}]+(?:['’][\p{L}]+)*/gu
+  let m: RegExpExecArray | null
+  while ((m = re.exec(text))) out.push({ lower: m[0].toLowerCase().replace(/’/g, "'"), start: m.index, end: m.index + m[0].length })
+  return out
+}
+
+/** The words that carry the text: fillers out, a stutter ("the the") collapsed. */
+function core(list: Word[]): Word[] {
+  const out: Word[] = []
+  for (let i = 0; i < list.length; i++) {
+    const pair = i + 1 < list.length ? `${list[i].lower} ${list[i + 1].lower}` : ''
+    if (pair && LITERAL_DROPPABLE_PAIRS.has(pair)) { i++; continue }
+    if (LITERAL_DROPPABLE.has(list[i].lower)) continue
+    if (out.length && out[out.length - 1].lower === list[i].lower) continue
+    out.push(list[i])
+  }
+  return out
+}
+
+/**
+ * The literal register's deterministic check and repair. Pure.
+ *
+ * `null` when the answer changed a word (beyond fillers, stutters, punctuation and case): the
+ * caller sends the input instead. Otherwise the answer with the input's own casing put back on
+ * every word, and without a trailing period the input did not have, so a terminal gets no added
+ * capital and no added period whatever the model did.
+ */
+export function literalAnswer(input: string, answer: string): string | null {
+  const a = core(words(answer))
+  const b = core(words(input))
+  if (a.length !== b.length || a.some((w, i) => w.lower !== b[i].lower)) return null
+  const inputWords = words(input)
+  const original = new Map<string, string[]>()
+  for (const w of inputWords) original.set(w.lower, [...(original.get(w.lower) ?? []), input.slice(w.start, w.end)])
+  let out = ''
+  let last = 0
+  const seen = new Map<string, number>()
+  for (const w of words(answer)) {
+    const forms = original.get(w.lower)
+    const k = seen.get(w.lower) ?? 0
+    seen.set(w.lower, k + 1)
+    out += answer.slice(last, w.start) + (forms ? forms[Math.min(k, forms.length - 1)] : answer.slice(w.start, w.end))
+    last = w.end
+  }
+  out += answer.slice(last)
+  if (/\.\s*$/.test(out) && !/\.\s*$/.test(input)) out = out.replace(/\.(\s*)$/, '$1')
+  return out.trim()
+}

package/server/lib/mac-voice-labels.ts

@@ -0,0 +1,50 @@
+// 6.90.0: unnamed, meeting-stable voice labels for Mac recordings.
+//
+// A Mac recording hears call audio, video and podcasts through one global tap.
+// Naming a voice from that audio is not safe (no calibration exists, see
+// CHANGELOG 6.73.6 and the 2026-10-14 Mac plan section 5), so every Mac chunk is
+// `Ext`. What IS safe is telling voices apart: one Nemotron pass over the whole
+// saved meeting gives channels that are consistent for the call, and each
+// confident channel becomes `Voice 1`, `Voice 2`, ... in order of first speech.
+//
+// A `Voice N` label asserts NO identity. Everywhere a real name is checked it is
+// a placeholder, exactly like `Ext` and `Unidentified N`: it is never a profile
+// name, never enrolled, never trained, never written into the meeting's
+// `speakers` list. A person may rename it (text only) through the relabel route.
+//
+// Switch: COS_MAC_VOICE_LABELS, on by default; 0, false, off or no turns it off
+// and Mac recordings stay all `Ext` exactly as 6.89.0 saved them.
+
+// No imports on purpose: placeholder checks are read from the speaker-review,
+// relabel and store layers, and this must never pull the Mac registry into them.
+const MAC_SOURCE_TYPE = 'mac_system_audio'
+
+/** `Voice 1` .. `Voice 99`. No leading zero, single space, nothing after. */
+export const VOICE_LABEL = /^Voice [1-9]\d?$/
+
+export function isVoiceLabel(label: unknown): boolean {
+  return typeof label === 'string' && VOICE_LABEL.test(label)
+}
+
+export function voiceLabel(n: number): string {
+  if (!Number.isInteger(n) || n < 1 || n > 99) throw new Error('voice number out of range')
+  return `Voice ${n}`
+}
+
+/** On unless explicitly switched off. Read at use, so a managed restart is not needed to turn it off. */
+export function macVoiceLabelsEnabled(env: NodeJS.ProcessEnv = process.env): boolean {
+  const raw = String(env.COS_MAC_VOICE_LABELS ?? '').trim().toLowerCase()
+  return !['0', 'false', 'off', 'no'].includes(raw)
+}
+
+/**
+ * A sidecar written by the Mac recording save path (`sourceType`), or any `mac_`
+ * id. Deliberately broader than MAC_CAPTURE_ID: this answers "could this be Mac
+ * audio", and a guard that asks it must fail closed on a malformed Mac id too.
+ */
+export function isMacCaptureSidecar(sidecar: Record<string, unknown> | null | undefined, sessionId?: string): boolean {
+  if (typeof sessionId === 'string' && sessionId.startsWith('mac_')) return true
+  if (!sidecar || typeof sidecar !== 'object') return false
+  if (sidecar.sourceType === MAC_SOURCE_TYPE) return true
+  return typeof sidecar.sessionId === 'string' && sidecar.sessionId.startsWith('mac_')
+}