@gotcos/glasses-server 6.90.0 → 6.91.1

package/server/routes/dictation-polish-settings.ts

@@ -9,6 +9,22 @@
 // Clients find it through capabilities.dictationCleanup.customInstructions on /api/health and
 // /api/models; an older server omits it (and answers 404 here), so the clients hide the box.
 // The text is never logged and never returned anywhere but GET/PUT here.
+//
+// 6.91.0 (plan r2, contract frozen 2026-10-24). Token-protected too:
+//
+//   GET    /api/dictation/learned-style   {enabled, rules, text, hash, revision, updatedAt, registers, kinds, allowlist, ...}
+//   PUT    /api/dictation/learned-style   {enabled?, rules?: [{id, kind, register, param?, count, lastSeen}], baseRevision?}
+//                                         Strict keys. text, hash, revision and updatedAt are the server's
+//                                         (400); a stale baseRevision (it covers the rules AND the switch)
+//                                         is 409; over 20 rules or 1,500 characters is 413.
+//   DELETE /api/dictation/learned-style   Reset: the rules go, the switch stays as it was
+//   GET    /api/dictation/polish/options  {promptVersion, effectiveVersion, source, envOverride, updatedAt}
+//   PUT    /api/dictation/polish/options  {promptVersion: "default" | "v3"}: Control's "Previous polish"
+//
+// Clients find them through capabilities.dictationCleanup.learnedStyle {protocol, maxChars,
+// maxRules, enabled} and capabilities.dictationCleanup.polishOptions {protocol} on /api/health and
+// /api/models. learnedStyle.enabled is false with COS_DICTATION_LEARNED_STYLE=0: the routes still
+// answer, and no prompt carries the rules.
 
 import { Router } from 'express'
 import {
@@ -19,6 +35,17 @@ import {
   CUSTOM_INSTRUCTIONS_MAX_CHARS, CUSTOM_INSTRUCTIONS_PROTOCOL, customInstructionsHash, readCustomInstructions,
   sanitizeCustomInstructions, writeCustomInstructions, type StoredInstructions,
 } from '../lib/dictation-polish-instructions.js'
+import {
+  CONTRACTION_PARAMS, LEARNED_STYLE_ALLOWLIST, LEARNED_STYLE_KINDS, LEARNED_STYLE_MAX_CHARS, LEARNED_STYLE_MAX_RULES,
+  LEARNED_STYLE_PROTOCOL, LEARNED_STYLE_REGISTERS, learnedStyleEnabled, learnedStyleLinesFor, readLearnedStyle,
+  validateLearnedStyleRules, writeLearnedStyle, type StoredLearnedStyle,
+} from '../lib/dictation-learned-style.js'
+import {
+  dictationPolishPromptChoice, POLISH_MODEL_DEFAULTS, POLISH_OPTIONS_PROTOCOL, POLISH_PROMPT_OPTIONS, readPolishOptions,
+  styleAndRegisterApply, writePolishOptions, type PolishPromptOption,
+} from '../lib/dictation-polish-options.js'
+import { LEARNED_STYLE_INTRO, LEARNED_STYLE_LIMITS, learnedStyleBlock, LITERAL_REGISTER_RULES, V4_CLOSING_RULE, V4_LITERAL_CLOSING_RULE } from '../lib/dictation-clean.js'
+import { publishedRegisters, registersEnabled } from '../lib/dictation-register.js'
 
 /** Where the instructions apply (prompt-drafts.ts polishInstructionsFor): never meeting lines. */
 export const CUSTOM_INSTRUCTIONS_APPLY_TO = ['message', 'prompt_draft'] as const
@@ -28,6 +55,21 @@ export function customInstructionsCapability() {
   return { protocol: CUSTOM_INSTRUCTIONS_PROTOCOL, maxChars: CUSTOM_INSTRUCTIONS_MAX_CHARS }
 }
 
+/**
+ * 6.91.0: capabilities.dictationCleanup.learnedStyle on both health surfaces. Present on every
+ * 6.91.0 server; `enabled` is the server's switch (COS_DICTATION_LEARNED_STYLE). Codes and numbers only.
+ */
+export function learnedStyleCapability() {
+  return { protocol: LEARNED_STYLE_PROTOCOL, maxChars: LEARNED_STYLE_MAX_CHARS, maxRules: LEARNED_STYLE_MAX_RULES, enabled: learnedStyleEnabled() }
+}
+/** 6.91.0: capabilities.dictationCleanup.polishOptions ("Previous polish"). */
+export function polishOptionsCapability() {
+  return { protocol: POLISH_OPTIONS_PROTOCOL }
+}
+
+/** Where the learned style applies (lib/dictation-polish-pipeline.ts learnedStyleFor): never meeting lines. */
+export const LEARNED_STYLE_APPLY_TO = ['message', 'prompt_draft'] as const
+
 function view(stored: StoredInstructions) {
   return {
     customInstructions: stored.customInstructions,
@@ -76,16 +118,164 @@ dictationPolishSettingsRouter.delete('/dictation/polish/instructions', (_req, re
   }
 })
 
-dictationPolishSettingsRouter.get('/dictation/polish/rules', (_req, res) => {
-  const version = dictationPolishPromptVersion()
+dictationPolishSettingsRouter.get('/dictation/polish/rules', (req, res) => {
+  // 6.91.0 option C: each model has its own default (v4 on Sonnet, v3 otherwise). `?model=` picks
+  // whose view `version` and `rules` describe; without it they describe the newest default.
+  const wanted = typeof req.query?.model === 'string' && (POLISH_MODEL_DEFAULTS as readonly string[]).includes(req.query.model) ? req.query.model : undefined
+  const choice = dictationPolishPromptChoice(process.env, wanted)
+  const version = choice.version
+  const promptByModel = Object.fromEntries(POLISH_MODEL_DEFAULTS.map(model => [model, dictationPolishPromptVersion(process.env, model)]))
+  // Learned style and the literal register apply only to the pairs they were canaried on.
+  const stylePairs = POLISH_MODEL_DEFAULTS.filter(model => styleAndRegisterApply(model, promptByModel[model])).map(model => ({ model, prompt: promptByModel[model] }))
+  const styled = wanted === undefined ? stylePairs.length > 0 : styleAndRegisterApply(wanted, version)
   res.json({
     version,
     defaultVersion: DEFAULT_DICTATION_POLISH_PROMPT,
-    rolledBack: version !== DEFAULT_DICTATION_POLISH_PROMPT,
+    rolledBack: choice.source !== 'default',
     systemPrompt: DICTATION_POLISH_SYSTEM_PROMPTS[version],
     rules: dictationPolishRules(version).join('\n'),
     // The block exactly as the model sees it, with a placeholder for the user's words.
     userBlock: [...USER_PREFERENCES_INTRO, '<user-style-preferences>', INSTRUCTIONS_PLACEHOLDER, '</user-style-preferences>', USER_PREFERENCES_PRECEDENCE].join('\n'),
     maxChars: CUSTOM_INSTRUCTIONS_MAX_CHARS,
+    // 6.91.0: which prompt each model gets, the rules of each prompt in use, and where the learned
+    // style and the literal register apply (Sonnet with v4 only: the pair canaries C2 and C3 ran on).
+    ...(wanted ? { model: wanted } : {}),
+    promptByModel,
+    rulesByPrompt: Object.fromEntries([...new Set(Object.values(promptByModel))].map(v => [v, dictationPolishRules(v).join('\n')])),
+    stylePairs,
+    registersEnabled: registersEnabled(),
+    // The other blocks exactly as the model sees them. The learned style is the saved rules rendered
+    // from the server's templates ('' when none apply); the literal block goes to terminals only
+    // (none with COS_DICTATION_REGISTERS=0); the closing line is v4's.
+    learnedStyleBlock: styled && learnedStyleEnabled() ? learnedStyleBlock(learnedStyleLinesFor(readLearnedStyle(), 'default')).join('\n').trim() : '',
+    learnedStyleFrame: [LEARNED_STYLE_INTRO, '<learned-style>', LEARNED_STYLE_PLACEHOLDER, '</learned-style>', LEARNED_STYLE_LIMITS].join('\n'),
+    registerBlocks: styled && registersEnabled() && version === 'v4' ? { literal: LITERAL_REGISTER_RULES.join('\n') } : {},
+    closingRules: version === 'v4' ? { default: V4_CLOSING_RULE, literal: V4_LITERAL_CLOSING_RULE } : {},
   })
 })
+
+/** The placeholder the rules view shows where the learned-style lines go. */
+export const LEARNED_STYLE_PLACEHOLDER = '(your learned style rules)'
+
+// ---------------------------------------------------------------------------------------------
+// 6.91.0 learned style and polish options.
+
+function styleView(stored: StoredLearnedStyle) {
+  return {
+    enabled: stored.enabled,
+    rules: stored.rules,
+    text: stored.text,
+    hash: stored.hash,
+    revision: stored.revision,
+    updatedAt: stored.updatedAt,
+    // Control reads the app-to-register map here, so it never keeps a second table. The literal
+    // register is opt-in (COS_DICTATION_REGISTERS=1); `registersEnabled` says whether it applies.
+    registers: publishedRegisters(),
+    registersEnabled: registersEnabled(),
+    kinds: LEARNED_STYLE_KINDS,
+    registerValues: LEARNED_STYLE_REGISTERS,
+    allowlist: LEARNED_STYLE_ALLOWLIST,
+    contractionParams: CONTRACTION_PARAMS,
+    maxChars: LEARNED_STYLE_MAX_CHARS,
+    maxRules: LEARNED_STYLE_MAX_RULES,
+    serverEnabled: learnedStyleEnabled(),
+    appliesTo: LEARNED_STYLE_APPLY_TO,
+  }
+}
+
+const STYLE_PUT_KEYS = new Set(['enabled', 'rules', 'baseRevision'])
+const SERVER_OWNED = new Set(['text', 'hash', 'revision', 'updatedAt'])
+
+/** A Node error code ("EACCES") for the log, never a message (a message can carry the path). */
+function errorCode(err: unknown): string {
+  const code = (err as { code?: unknown } | null)?.code
+  return typeof code === 'string' && /^[A-Z][A-Z0-9_]{1,23}$/.test(code) ? code : 'error'
+}
+
+dictationPolishSettingsRouter.get('/dictation/learned-style', (_req, res) => {
+  res.json(styleView(readLearnedStyle()))
+})
+
+dictationPolishSettingsRouter.put('/dictation/learned-style', (req, res) => {
+  const body = req.body
+  if (!body || typeof body !== 'object' || Array.isArray(body)) return res.status(400).json({ error: 'invalid_body' })
+  const keys = Object.keys(body)
+  const owned = keys.find(key => SERVER_OWNED.has(key))
+  if (owned) return res.status(400).json({ error: 'server_owned_field', field: owned })
+  if (!keys.every(key => STYLE_PUT_KEYS.has(key)) || !('rules' in body || 'enabled' in body)) {
+    return res.status(400).json({ error: 'invalid_body', expected: { enabled: 'boolean?', rules: '[{id, kind, register, param, count, lastSeen}]?', baseRevision: 'string?' } })
+  }
+  if ('enabled' in body && typeof body.enabled !== 'boolean') return res.status(400).json({ error: 'invalid_enabled' })
+  if ('baseRevision' in body && (typeof body.baseRevision !== 'string' || !/^[0-9a-f]{8}$/.test(body.baseRevision))) {
+    return res.status(400).json({ error: 'invalid_base_revision' })
+  }
+  const current = readLearnedStyle()
+  if (typeof body.baseRevision === 'string' && body.baseRevision !== current.revision) {
+    // Someone else saved first (rules or the switch): re-GET and merge.
+    return res.status(409).json({ error: 'base_revision_mismatch', revision: current.revision })
+  }
+  let rules = current.rules
+  if ('rules' in body) {
+    const clean = validateLearnedStyleRules(body.rules)
+    if (!clean.ok) {
+      return res.status(clean.status).json({
+        error: clean.error,
+        ...(clean.index !== undefined ? { index: clean.index } : {}),
+        ...(clean.max !== undefined ? { max: clean.max } : {}),
+      })
+    }
+    rules = clean.rules
+  }
+  try {
+    res.json(styleView(writeLearnedStyle(typeof body.enabled === 'boolean' ? body.enabled : current.enabled, rules)))
+  } catch (err) {
+    // The reason stays generic: an fs error can carry the path, never the rules, but say less.
+    console.warn(`[dictation-polish] learned_style_not_saved put (${errorCode(err)})`)
+    res.status(500).json({ error: 'learned_style_not_saved' })
+  }
+})
+
+dictationPolishSettingsRouter.delete('/dictation/learned-style', (_req, res) => {
+  try {
+    // Reset clears the rules and leaves the person's switch as it was: an Off stays off.
+    res.json(styleView(writeLearnedStyle(readLearnedStyle().enabled, [])))
+  } catch (err) {
+    console.warn(`[dictation-polish] learned_style_not_saved delete (${errorCode(err)})`)
+    res.status(500).json({ error: 'learned_style_not_saved' })
+  }
+})
+
+function optionsView() {
+  const stored = readPolishOptions()
+  const choice = dictationPolishPromptChoice()
+  return {
+    promptVersion: stored.promptVersion,
+    effectiveVersion: choice.version,
+    // 6.91.0 option C: the prompt each model actually gets.
+    effectiveByModel: Object.fromEntries(POLISH_MODEL_DEFAULTS.map(model => [model, dictationPolishPromptChoice(process.env, model).version])),
+    source: choice.source,
+    // The environment named a version, so this option has no effect until it is removed.
+    envOverride: choice.source === 'env',
+    options: POLISH_PROMPT_OPTIONS,
+    updatedAt: stored.updatedAt,
+  }
+}
+
+dictationPolishSettingsRouter.get('/dictation/polish/options', (_req, res) => {
+  res.json(optionsView())
+})
+
+dictationPolishSettingsRouter.put('/dictation/polish/options', (req, res) => {
+  const body = req.body
+  if (!body || typeof body !== 'object' || Array.isArray(body) || !Object.keys(body).every(key => key === 'promptVersion')
+    || !(POLISH_PROMPT_OPTIONS as readonly string[]).includes(body.promptVersion)) {
+    return res.status(400).json({ error: 'invalid_body', expected: { promptVersion: POLISH_PROMPT_OPTIONS } })
+  }
+  try {
+    writePolishOptions(body.promptVersion as PolishPromptOption)
+    res.json(optionsView())
+  } catch (err) {
+    console.warn(`[dictation-polish] options_not_saved (${errorCode(err)})`)
+    res.status(500).json({ error: 'options_not_saved' })
+  }
+})

package/server/routes/health.ts

@@ -1,5 +1,5 @@
 import { DICTATION_CLEAN_MODELS } from '../lib/dictation-clean-models.js'
-import { customInstructionsCapability } from './dictation-polish-settings.js'
+import { customInstructionsCapability, learnedStyleCapability, polishOptionsCapability } from './dictation-polish-settings.js'
 import { PAIRING_PROTOCOL_VERSION } from '../lib/glasses-pairing.js'
 import { taskBridgeAvailable } from '../lib/task-bridge.js'
 import { Router } from 'express'
@@ -491,7 +491,11 @@ healthRouter.get('/health', async (_req, res) => {
     ...(voiceProvenance ? { voice_provenance: voiceProvenance } : {}),
     capabilities: {
       meetingAsk: { ...meetingAskCapabilities(), webRetrieval: meetingWebCapability().available },
-      dictationCleanup: { models: DICTATION_CLEAN_MODELS, customInstructions: customInstructionsCapability() },
+      // 6.91.0: learnedStyle ("Your style", enabled = the server switch) and polishOptions ("Previous polish").
+      dictationCleanup: {
+        models: DICTATION_CLEAN_MODELS, customInstructions: customInstructionsCapability(),
+        learnedStyle: learnedStyleCapability(), polishOptions: polishOptionsCapability(),
+      },
       // 6.67.0: glasses pairing (docs/pairing-contract.md). Public on purpose: the phone
       // reads it before it holds a token, and an older server omits it, which is how
       // the phone knows to say "Update COS on your Mac (server 6.67 or newer)".
@@ -679,7 +683,11 @@ healthRouter.get('/models', async (req, res) => {
     ...(apiToken ? { displayStreamTicket: mintDisplayTicket(apiToken) } : {}),
     capabilities: {
       meetingAsk: { ...meetingAskCapabilities(), webRetrieval: meetingWebCapability().available },
-      dictationCleanup: { models: DICTATION_CLEAN_MODELS, customInstructions: customInstructionsCapability() },
+      // 6.91.0: learnedStyle ("Your style", enabled = the server switch) and polishOptions ("Previous polish").
+      dictationCleanup: {
+        models: DICTATION_CLEAN_MODELS, customInstructions: customInstructionsCapability(),
+        learnedStyle: learnedStyleCapability(), polishOptions: polishOptionsCapability(),
+      },
       durableQueryJobs: {
         enabled: durableJobs.enabled,
         protocolVersion: durableJobs.protocolVersion,

package/server/routes/prompt-drafts.ts

@@ -33,28 +33,16 @@ import {
   isCaptionCreditHallucination,
   isBrandUrlOnly,
   clearSessionHallucinationState,
-  applyNegativeRules,
 } from '../lib/hallucination-filter.js'
-import { applyCorrections } from '../lib/whisper-local.js'
-import { applyFuzzyCorrections } from '../lib/fuzzy-correct.js'
-import { getAllSpeakerNames } from '../lib/speaker-embeddings.js'
 import { transcribeWhisperPreview } from '../lib/whisper-preview.js'
 import { currentDictationPlan, runParakeetDictation } from '../lib/dictation-stt.js'
 import { dictationSlotForMode, legacyDictationKey, type DictationPlan } from '../lib/stt-settings.js'
-import { autoCleanDictation, AUTOCLEAN_MAX_CHARS } from '../lib/dictation-clean.js'
-import { fillerPassEnabled, stripDisfluencies } from '../lib/dictation-fillers.js'
-import { polishBudgetExhausted, recordPolishCall, type PolishBucket } from '../lib/dictation-polish-budget.js'
-import { polishNeed, skipCleanEnabled } from '../lib/dictation-polish-need.js'
-import {
-  discardPolishPrewarm, isPrewarmModel, prewarmEnabled, PrewarmUnavailableError, runWarmPolish,
-  startPolishPrewarm, takePolishPrewarm,
-} from '../lib/dictation-prewarm.js'
-import { getVocabulary, getWhisperCorrections } from '../lib/profile.js'
-import { correctionOnlyForms } from '../lib/glossary-learn.js'
-import { polishLinkProblem, renderSpokenPaths, spokenPathsEnabled } from '../lib/dictation-format.js'
-import { customInstructionsHash, readCustomInstructions } from '../lib/dictation-polish-instructions.js'
-import { createBreaker } from '../lib/claude-circuit.js'
-import { logTokenAudit } from '../lib/token-audit.js'
+import { AUTOCLEAN_MAX_CHARS } from '../lib/dictation-clean.js'
+import { polishBudgetExhausted } from '../lib/dictation-polish-budget.js'
+import { discardPolishPrewarm, isPrewarmModel, prewarmEnabled, startPolishPrewarm } from '../lib/dictation-prewarm.js'
+import { applyCorrections } from '../lib/whisper-local.js'
+import { registerFromContext } from '../lib/dictation-register.js'
+import { autoCleanBreakers, cleanOutboundDictation, type AutoCleanRequest, type PolishResult } from '../lib/dictation-polish-pipeline.js'
 import { emitDisplay } from '../lib/display-bus.js'
 import {
   acquireMaintenanceWork,
@@ -85,19 +73,8 @@ function speculativeHqWarmEnabled(): boolean {
   return !['0', 'false', 'off'].includes((process.env.COS_HQ_SPECULATIVE_WARM ?? '1').toLowerCase())
 }
 
-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). */
-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'
-
-interface AutoCleanRequest { enabled?: boolean; model?: DictationCleanModel }
+// 6.91.0: the outbound polish pipeline (breakers, gates, model, guards) lives in
+// lib/dictation-polish-pipeline.ts, so the offline evals call it rather than a copy.
 function routeAutoClean(req: { body?: any; query?: any }): AutoCleanRequest {
   const rawEnabled = req.body?.autoclean ?? req.query?.autoclean
   const enabled = rawEnabled === undefined ? undefined : ['1', 'true', 'on'].includes(String(rawEnabled).toLowerCase())
@@ -107,113 +84,6 @@ function routeAutoClean(req: { body?: any; query?: any }): AutoCleanRequest {
   return { enabled, model: isDictationCleanModel(rawModel) ? rawModel : undefined }
 }
 
-async function cleanOutboundDictation(
-  text: string,
-  opts: AutoCleanRequest & { bucket: PolishBucket; signal?: AbortSignal; prewarmToken?: string },
-): 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, additive and present only when the model was given the user's polish instructions. */
-interface PolishInstructionsUse { customInstructions?: true; instructionsHash?: string }
-type PolishResult = { text: string; polishSkipped?: PolishSkipped; prewarm?: PrewarmOutcome } & PolishInstructionsUse
-
-/**
- * 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
-}
-
-async function polishOutboundDictation(
-  text: string,
-  opts: AutoCleanRequest & { bucket: PolishBucket; signal?: AbortSignal; prewarmToken?: string },
-): Promise<PolishResult> {
-  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 (opts.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 (opts.bucket !== 'meeting' && spokenPathsEnabled()) cleaned = renderSpokenPaths(cleaned)
-  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 instructions.
-  const customInstructions = polishInstructionsFor(opts.bucket)
-  const instructionsHash = customInstructionsHash(customInstructions)
-  const used: PolishInstructionsUse = customInstructions ? { customInstructions: true, instructionsHash } : {}
-  // 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, customInstructions })).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, customInstructions })).trim()
-    autoCleanBreaker.recordSuccess()
-    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.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, ...(prewarm ? { prewarm } : {}), polishSkipped: 'link_guard', ...used }
-    }
-    return { text: polished || cleaned, ...(prewarm ? { prewarm } : {}), ...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 }
-  }
-}
-
 /** Finalize already-transcribed phone text through the same glossary + optional
  * AI cleanup used by server-owned prompt drafts. This route accepts text only:
  * Moonshine audio and rolling preview audio never leave the phone. */
@@ -238,13 +108,17 @@ promptDraftsRouter.post('/dictation/finalize', async (req, res) => {
 
   const abort = new AbortController()
   res.on('close', () => { if (!res.writableEnded) abort.abort() })
-  const { text: finalText, polishSkipped, prewarm, customInstructions, instructionsHash } = await cleanOutboundDictation(text, {
+  const result = await cleanOutboundDictation(text, {
     enabled: true,
     model,
     bucket: surface,
     signal: abort.signal,
     prewarmToken: rawToken,
+    // 6.91.0: the target app (Control has sent it since 0.5.325) picks the register. Read here,
+    // never logged or echoed; anything that is not a short one-line name is the default register.
+    register: registerFromContext(req.body?.context),
   })
+  const { text: finalText, polishSkipped, prewarm, customInstructions, instructionsHash } = result
   // 6.79.1: polishSkipped only when the model did not polish, so a polished answer is unchanged.
   // 6.79.2: prewarm only when the request carried a prewarmToken.
   res.json({
@@ -252,9 +126,27 @@ promptDraftsRouter.post('/dictation/finalize', async (req, res) => {
     ...(polishSkipped ? { polishSkipped } : {}), ...(prewarm ? { prewarm } : {}),
     // 6.85.0: only when the model was given the user's polish instructions (a hash, never the text).
     ...(customInstructions ? { customInstructions, instructionsHash } : {}),
+    ...polishFields(result),
   })
 })
 
+/**
+ * 6.91.0, additive on both finalize answers, every field optional (old clients ignore them):
+ * polishOutcome (only when the model answered: polished, unchanged or guarded, about the model
+ * step), guard (the guard that refused it), and whenever the model was called: polishPrompt (v3
+ * or v4), learnedStyle (true with its hash, or false), and polishRegister on the one pair it was
+ * canaried on (Sonnet with v4). Never the model's own text.
+ */
+function polishFields(result: PolishResult) {
+  return {
+    ...(result.polishOutcome ? { polishOutcome: result.polishOutcome } : {}),
+    ...(result.guard ? { guard: result.guard } : {}),
+    ...(result.polishRegister ? { polishRegister: result.polishRegister } : {}),
+    ...(result.polishPrompt ? { polishPrompt: result.polishPrompt } : {}),
+    ...(result.learnedStyle ? { learnedStyle: true, learnedStyleHash: result.learnedStyleHash } : result.learnedStyleOff ? { learnedStyle: false } : {}),
+  }
+}
+
 const PREWARM_TOKEN = /^[0-9a-f-]{36}$/
 
 /** 6.79.2: start the polish process at key press. Fire and forget: every refusal is a normal
@@ -539,7 +431,8 @@ async function finalizeDraft(draftId: string, mode: 'hq' | 'fast', autoClean: Au
     await markPromptDraftError(draftId, 'No speech detected')
     throw new NoSpeechDetectedError()
   }
-  const { text: finalText, polishSkipped, customInstructions, instructionsHash } = await cleanOutboundDictation(text, { ...autoClean, bucket: 'prompt_draft', signal })
+  const polish = await cleanOutboundDictation(text, { ...autoClean, bucket: 'prompt_draft', signal })
+  const { text: finalText, polishSkipped, customInstructions, instructionsHash } = polish
   const finalized = await markPromptDraftFinalized(draftId, finalText)
   const qualities = transcriptRecords.map(record => record.actualQuality)
   const actualQuality: 'hq' | 'fast' | 'cloud' = qualities.includes('cloud')
@@ -571,6 +464,8 @@ async function finalizeDraft(draftId: string, mode: 'hq' | 'fast', autoClean: Au
     ...(polishSkipped ? { polishSkipped } : {}),
     // 6.85.0, additive.
     ...(customInstructions ? { customInstructions, instructionsHash } : {}),
+    // 6.91.0, additive.
+    ...polishFields(polish),
   }
 }