@gotcos/glasses-server 6.91.0 → 6.92.0

package/server/lib/dictation-fillers.ts

@@ -20,9 +20,22 @@
  *   still loses "uh"), and any quoted mention ('"um"').
  * - "uh huh", "uh oh" and "mm hmm" written without a hyphen: answers, not hesitations.
  * - "like", "you know", "I mean": filler only sometimes, so the model decides, not a regex.
+ * - 6.92.0: a token that touches a path, handle or code character is part of that token, not a
+ *   hesitation: "src/um.txt", "~/uh", "@uh", "#um", "$um", "my_um", "um.py", "um:8080", "um/bin".
+ *   Kept when the character right before it is one of / . @ _ : # $ (a leading - is already
+ *   outside the token pattern), or the character right after it is one of / @ _ # $, or a . or :
+ *   followed by a letter or digit. A sentence-final "um." or "um:" (a space or the end after it)
+ *   still goes.
  * A filler inside a longer quote ("um, no") is removed like any other.
  * If nothing but fillers was said, the original text is returned unchanged.
+ *
+ * 6.92.0: the language gate lives in the caller, not here (`stripFillersIfEnglish`): "um" and "er"
+ * are words in German, Portuguese, Danish, Norwegian and Dutch ("um 5 Uhr", "um carro", "Er kommt
+ * morgen"). This function stays the pure token rules that the canonical fixture
+ * (__fixtures__/dictation-fillers.json, scope "both") pins for COS Control's port.
  */
+import { fillerTextLooksEnglish } from './dictation-meaning-guard.js'
+
 
 const FILLER = /(?<![\p{L}\p{N}'’-])(um+|uhm|uh+|erm?|ah+|hm+|mm+|mhm)(?![\p{L}\p{N}'’-])/giu
 /** After a filler: a pause mark (comma, ellipsis, dash) with its spacing. */
@@ -38,6 +51,10 @@ const QUOTE_OPEN = /["“”'‘’]$/
 const QUOTE_CLOSE = /^["“”'‘’]/
 /** A pause mark right after the token: a Titlecase filler set off this way is a hesitation. */
 const PAUSE_AFTER = /^[ \t]*(?:,|\.{2,}|…)/
+/** 6.92.0: a path, handle or code character right before the token ("~/uh", "@uh", "#um", ".um"). */
+const TOUCH_BEFORE = /[/.@_:#$]$/
+/** 6.92.0: right after it: / @ _ # $ ("um/bin", "um_id"), or . or : with a letter or digit next ("um.py", "um:8080"). */
+const TOUCH_AFTER = /^(?:[/@_#$]|[.:][\p{L}\p{N}])/u
 
 function afterAbbreviation(before: string): boolean {
   const trimmed = before.replace(/[ \t]+$/, '')
@@ -73,6 +90,9 @@ export function stripDisfluencies(text: string): string {
     const atStart = sentenceStart(out + before)
     const keep = (token.length > 1 && token === token.toUpperCase())
       || (/^mm+$/i.test(token) && /\d[ \t]*$/.test(out + before))
+      // 6.92.0: part of a path, handle or code token, never a hesitation.
+      || TOUCH_BEFORE.test(out + before)
+      || TOUCH_AFTER.test(after)
       // A capital away from a sentence start is a name ("Ask Ah Kow"), unless a pause mark
       // sets it off as a hesitation ("I think, Um, we should").
       || (!atStart && /^[A-Z]/.test(token) && !PAUSE_AFTER.test(after))
@@ -114,3 +134,13 @@ export function stripDisfluencies(text: string): string {
   const result = (out + rest).replace(/^[ \t]*[,;][ \t]*/, '')
   return result.trim() === '' ? text : result
 }
+
+/**
+ * 6.92.0: the server's outbound filler step. The token rules (stripDisfluencies) run only when the
+ * text is mostly English (dictation-meaning-guard.ts fillerTextLooksEnglish), so "Wir treffen uns um 5 Uhr",
+ * "Comprei um carro" and "Er kommt morgen." go out as said. COS Control gates its own port with
+ * its own language detector; that is why the fixture tags these rows scope "server".
+ */
+export function stripFillersIfEnglish(text: string): string {
+  return fillerTextLooksEnglish(text) ? stripDisfluencies(text) : text
+}

package/server/lib/dictation-meaning-guard.ts

@@ -11,9 +11,16 @@
  *   "cant"), all one NEG token; never, no, none, nothing, nobody, neither, nor, without, unless,
  *   except;
  * - number: digits, number words, ordinals ("twenty fifth" is 25, like "25th"), %, $, a digit with a
- *   scale word ("2 million" is two million, like "two million"), clock times ("half past ten" is
- *   10:30, "quarter to five" 4:45) and am/pm. A decimal point splits a number on both sides ("one
- *   point five" and "1.5" are both 1 then 5);
+ *   scale word ("2 million" is two million, like "two million"), and clock times. A decimal point
+ *   splits a number on both sides ("one point five" and "1.5" are both 1 then 5);
+ * - times (6.91.1): every clock time, spoken or written, in the dictation and in the answer, is read
+ *   as minutes since midnight: "ten thirty", "half past ten", "quarter to five", "ten o'clock",
+ *   "10:30", "10:30 am", "ten thirty pm", "22:30", "twenty two thirty". Without am or pm an hour
+ *   from 1 to 12 reads both ways, so "ten thirty pm" written "22:30" is kept and "ten thirty" written
+ *   "11:30" is a changed number. am, pm and a trailing ":00" are format only: "at ten" written
+ *   "at 10:00 am" is kept. A time is kept when the answer has the same time, when it is on the hour
+ *   and the answer says just that hour (and the dictation said no am or pm), or when every part of
+ *   it survives as a plain number ("nineteen fifty" written "1950");
  * - date: a weekday or a month;
  * - name: a mid-sentence capital, a dictionary term or a speaker name. A sentence-initial word and
  *   "I" are not names unless they are dictionary terms. Skipped for a dictation that is not English.
@@ -52,8 +59,10 @@ export function meaningGuardEnabled(env: NodeJS.ProcessEnv = process.env): boole
   return !(raw === '0' || raw === 'false' || raw === 'off')
 }
 
-interface Tok { raw: string; low: string; sentenceStart: boolean; pause: boolean; listMarker: boolean }
-interface Item { kind: MeaningGuardKind; key: string; pos: number; list?: boolean }
+interface Tok { raw: string; low: string; sentenceStart: boolean; pause: boolean; listMarker: boolean; colonNext: boolean }
+interface Item { kind: MeaningGuardKind; key: string; pos: number; list?: boolean; inTime?: boolean; time?: TimeSpan }
+/** A clock time: the tokens it covers, its minutes since midnight (two readings without am/pm), its parts. */
+interface TimeSpan { start: number; end: number; times: number[]; explicit: boolean; parts: string[] }
 
 const ONES = new Map(['zero', 'one', 'two', 'three', 'four', 'five', 'six', 'seven', 'eight', 'nine', 'ten', 'eleven', 'twelve',
   'thirteen', 'fourteen', 'fifteen', 'sixteen', 'seventeen', 'eighteen', 'nineteen'].map((w, i) => [w, i]))
@@ -148,7 +157,8 @@ function tokenize(text: string): Tok[] {
     const sentenceStart = before.length === 0 || /[.!?:\n•]$/.test(before) || /\n\s*(?:[-*•]|\d+[.)])?\s*$/.test(text.slice(0, m.index))
     // "1." or "2)" at the start of a line: a list number.
     const listMarker = /^\d+$/.test(m[0]) && /(?:^|\n)[ \t]*$/.test(text.slice(0, m.index)) && /^[.)]/.test(text.slice(m.index + m[0].length))
-    out.push({ raw: m[0], low: m[0].toLowerCase(), sentenceStart, pause: /[,;.!?—–()]/.test(gap), listMarker })
+    const colonNext = /^:\d/.test(text.slice(m.index + m[0].length))
+    out.push({ raw: m[0], low: m[0].toLowerCase(), sentenceStart, pause: /[,;.!?—–()]/.test(gap), listMarker, colonNext })
     last = m.index + m[0].length
   }
   return out
@@ -230,6 +240,74 @@ function numberRun(tokens: Tok[], i: number): { value: number; end: number } | n
   return { value: total + group, end: j - 1 }
 }
 
+const MERIDIEM = new Set(['am', 'pm'])
+
+/** Minutes since midnight: one reading with am/pm or a 24-hour hour, both readings for 1 to 12 without. */
+function clockMinutes(hour: number, minute: number, meridiem: string | undefined): { times: number[]; explicit: boolean } {
+  if (meridiem && hour >= 1 && hour <= 12) return { times: [((hour % 12) + (meridiem === 'pm' ? 12 : 0)) * 60 + minute], explicit: true }
+  if (hour >= 1 && hour <= 12) return { times: [(hour % 12) * 60 + minute, ((hour % 12) + 12) * 60 + minute], explicit: false }
+  return { times: [hour * 60 + minute], explicit: true }
+}
+
+/** The readings of a bare hour ("ten" or "10") as a time on the hour. */
+function hourReadings(n: number): number[] {
+  if (n >= 1 && n <= 12) return [(n % 12) * 60, ((n % 12) + 12) * 60]
+  return n === 0 || (n >= 13 && n <= 23) ? [n * 60] : []
+}
+
+/** A spoken hour: one to nineteen, twenty, twenty one to twenty three. */
+function spokenHour(tokens: Tok[], i: number): { value: number; end: number } | null {
+  const w = tokens[i]?.low ?? ''
+  const v = ONES.get(w)
+  if (v !== undefined) return v >= 1 ? { value: v, end: i } : null
+  if (w !== 'twenty') return null
+  const ones = ONES.get(tokens[i + 1]?.low ?? '')
+  return ones !== undefined && ones >= 1 && ones <= 3 ? { value: 20 + ones, end: i + 1 } : { value: 20, end: i }
+}
+
+/** Spoken minutes after an hour: "oh five", ten to nineteen, twenty to fifty nine. */
+function spokenMinutes(tokens: Tok[], i: number): { value: number; end: number } | null {
+  const w = tokens[i]?.low ?? ''
+  const next = ONES.get(tokens[i + 1]?.low ?? '')
+  if (w === 'oh' || w === 'o') return next !== undefined && next >= 1 && next <= 9 ? { value: next, end: i + 1 } : null
+  const v = ONES.get(w)
+  if (v !== undefined) return v >= 10 ? { value: v, end: i } : null
+  const tens = TENS.get(w)
+  if (tens === undefined || tens > 50) return null
+  return next !== undefined && next >= 1 && next <= 9 ? { value: tens + next, end: i + 1 } : { value: tens, end: i }
+}
+
+/** One clock time starting at token i, or null. An hour alone is not a time; it needs minutes or am/pm. */
+function timeAt(tokens: Tok[], i: number): Omit<TimeSpan, 'parts'> | null {
+  const t = tokens[i]
+  let hour: number, end: number
+  if (/^\d{1,2}$/.test(t.low)) { hour = Number.parseInt(t.low, 10); end = i }
+  else { const h = spokenHour(tokens, i); if (!h) return null; hour = h.value; end = h.end }
+  let minute = 0, hasMinutes = false
+  const next = tokens[end + 1]?.low ?? ''
+  if (tokens[end].colonNext && /^\d{2}$/.test(next)) { minute = Number.parseInt(next, 10); end++; hasMinutes = true }
+  else if (!/^\d/.test(t.low)) { const m = spokenMinutes(tokens, end + 1); if (m) { minute = m.value; end = m.end; hasMinutes = true } }
+  const meridiem = MERIDIEM.has(tokens[end + 1]?.low ?? '') ? tokens[end + 1].low : undefined
+  if (!hasMinutes && !meridiem) return null
+  if (meridiem) end++
+  if (hour > 23 || minute > 59) return null
+  const { times, explicit } = clockMinutes(hour, minute, meridiem)
+  return { start: i, end, times, explicit }
+}
+
+/** Every clock time in the text, as time items; the number items inside one become its parts. */
+function addTimes(tokens: Tok[], items: Item[]): void {
+  for (let i = 0; i < tokens.length; i++) {
+    const found = timeAt(tokens, i)
+    if (!found) continue
+    const parts = items.filter(it => it.kind === 'number' && it.pos >= found.start && it.pos <= found.end)
+    parts.forEach(it => { it.inTime = true })
+    const time: TimeSpan = { ...found, parts: parts.map(it => it.key) }
+    items.push({ kind: 'number', key: `time:${time.times.join('/')}`, pos: found.start, time })
+    i = found.end
+  }
+}
+
 interface Extract { items: Item[]; tokens: Tok[] }
 
 function extract(text: string, knownPhrases: string[][], withNames: boolean): Extract {
@@ -281,6 +359,7 @@ function extract(text: string, knownPhrases: string[][], withNames: boolean): Ex
       if (!t.sentenceStart || midCapital.has(fold(t.low))) items.push({ kind: 'name', key: fold(t.low), pos: i })
     }
   }
+  addTimes(tokens, items)
   // Dictionary terms and speaker names, in any case and position, as whole phrases.
   if (withNames) {
     for (const phrase of knownPhrases) {
@@ -317,6 +396,53 @@ export function looksEnglish(text: string): boolean {
   return words.filter(w => ENGLISH.has(w)).length / words.length >= 0.12
 }
 
+/**
+ * 6.92.0: common function words of German, Portuguese, Spanish, French and Dutch that are not
+ * English words, not name particles or place words ("de", "la", "von", "Los", "Las") and not words
+ * dictation says in English ("dot com", "em dash", "est", "eu"). Evidence that a short text is not
+ * English. An all-caps token ("MIT") never counts.
+ */
+const FOREIGN = new Set(['der', 'das', 'ein', 'eine', 'einen', 'einem', 'einer', 'und', 'ist', 'sind', 'nicht', 'ich', 'wir', 'ihr',
+  'sie', 'mit', 'uns', 'auf', 'für', 'uhr', 'auch', 'noch', 'oder', 'aber', 'wie', 'kommt', 'heute', 'morgen', 'bitte', 'danke',
+  'haben', 'wird', 'kann', 'zum', 'zur', 'bei', 'nach', 'ja', 'nein',
+  'uma', 'não', 'nao', 'por', 'que', 'você', 'voce', 'ele', 'ela', 'nós', 'isso', 'este', 'esta', 'muito', 'obrigado', 'obrigada',
+  'amanhã', 'hoje',
+  'una', 'unos', 'está', 'pero', 'muy', 'gracias', 'mañana', 'hoy',
+  'une', 'je', 'nous', 'vous', 'avec', 'pour', 'pas', 'mais', 'oui', 'merci',
+  'het', 'een', 'ik', 'niet', 'wij', 'voor'])
+/** 6.92.0: an English filler sound that is also a word in German, Portuguese, Danish, Norwegian or Dutch. */
+const AMBIGUOUS_FILLERS = new Set(['um', 'er'])
+/**
+ * 6.92.0 QA: English evidence beyond the function words, for short replies and commands ("um yes",
+ * "er no", "um thanks Dana", "um sounds good", "um Tuesday", "um 5 pm works"). None is a word of
+ * the languages above.
+ */
+const SHORT_REPLY_ENGLISH = new Set(['yes', 'no', 'yeah', 'yep', 'ok', 'okay', 'sure', 'thanks', 'thank', 'please', 'sorry', 'hi', 'hey',
+  'hello', 'good', 'great', 'fine', 'cool', 'done', 'right', 'maybe', 'sounds', 'call', 'send', 'tell', 'ask', 'am', 'pm',
+  'monday', 'tuesday', 'wednesday', 'thursday', 'friday', 'saturday', 'sunday',
+  'january', 'february', 'march', 'april', 'june', 'july', 'august', 'september', 'october', 'november', 'december'])
+
+/**
+ * 6.92.0: the filler pass's language gate (dictation-fillers.ts stripFillersIfEnglish), separate
+ * from looksEnglish, which the meaning guard keeps exactly as 6.91.1 had it. Not English when
+ * looksEnglish says so (a long text with few English function words, or mostly non-Latin letters).
+ * Under 12 words: with a foreign function word in it, English words (function words or the short
+ * reply list) must outnumber the foreign ones ("Wir treffen uns um 5 Uhr" is not English); with "um"
+ * or "er" said inline (no pause after it), at least one English word must be there ("Comprei um
+ * carro" and "Er kommt morgen." keep their um and er; "um yes" and "ship it er tomorrow" do not).
+ */
+export function fillerTextLooksEnglish(text: string): boolean {
+  if (!looksEnglish(text)) return false
+  const tokens = tokenize(text)
+  if (tokens.length > 11) return true
+  const english = tokens.filter(t => ENGLISH.has(t.low) || SHORT_REPLY_ENGLISH.has(t.low)).length
+  const foreign = tokens.filter(t => FOREIGN.has(t.low) && !(t.raw.length > 1 && t.raw === t.raw.toUpperCase())).length
+  if (foreign > 0) return english > foreign
+  const inlineAmbiguous = tokens.some((t, i) => AMBIGUOUS_FILLERS.has(t.low) && i + 1 < tokens.length && !tokens[i + 1].pause)
+  if (inlineAmbiguous) return english > 0
+  return true
+}
+
 const zero = (): Record<MeaningGuardKind, number> => ({ negation: 0, number: 0, date: 0, name: 0 })
 
 /** How many of each negation, a stutter (the same one twice in a row) counted once. */
@@ -390,13 +516,35 @@ export function meaningGuardProblem(cleaned: string, answer: string, known: stri
     return respelled
   }
 
+  // 6.91.1: clock times, compared as minutes since midnight (see the header).
+  const inTimes = input.items.filter(i => i.time).map(i => i.time!)
+  const outTimes = output.items.filter(i => i.time).map(i => i.time!)
+  const bareHours = (items: Item[]) => items.filter(i => i.kind === 'number' && !i.time && !i.inTime && /^\d+$/.test(i.key)).map(i => Number(i.key))
+  const inBare = bareHours(input.items)
+  const outBare = bareHours(output.items)
+  const sameTime = (a: TimeSpan, b: TimeSpan) => a.times.some(t => b.times.includes(t))
+  // A bare hour matches a time only on that hour: its readings are all on the hour.
+  const onTheHour = (time: TimeSpan, n: number) => hourReadings(n).some(t => time.times.includes(t))
+  const numberKept = (key: string) => outKeys.get('number')!.has(key) || keptByJoin.has(key)
+  const timeKept = (time: TimeSpan) => outTimes.some(o => sameTime(time, o))
+    || (!time.explicit && outBare.some(n => onTheHour(time, n)))
+    || time.parts.every(numberKept)
+  // A time in the answer is not new when the dictation had it, had its hour ("at ten" as "10:00 am"),
+  // or had its parts as numbers. am, pm and ":00" are format only.
+  const timeAccounted = (time: TimeSpan) => inTimes.some(i => sameTime(i, time))
+    || inBare.some(n => onTheHour(time, n))
+    || time.parts.filter(p => !MERIDIEM.has(p) && p !== '0').every(p => inKeys.get('number')!.has(p))
+  const kept = (item: Item): boolean => item.kind === 'name' ? nameKept(item.key)
+    : item.time ? timeKept(item.time)
+    : item.kind === 'number' ? numberKept(item.key) || (/^\d+$/.test(item.key) && outTimes.some(o => onTheHour(o, Number(item.key))))
+    : outKeys.get(item.kind)!.has(item.key)
+
   // A dropped token with a correction marker after it and a same-kind replacement the answer kept.
   const exempt = (item: Item): boolean => {
     if (item.kind === 'negation') return false
     for (const { start, end, reach } of spans) {
       if (start <= item.pos || start - item.pos > DROP_TO_MARKER) continue
-      const replaced = input.items.some(r => r.kind === item.kind && r.key !== item.key && r.pos > end && r.pos - end <= reach
-        && (r.kind === 'name' ? nameKept(r.key) : outKeys.get(r.kind)!.has(r.key)))
+      const replaced = input.items.some(r => r.kind === item.kind && r.key !== item.key && r.pos > end && r.pos - end <= reach && kept(r))
       if (replaced) return true
     }
     return false
@@ -414,9 +562,9 @@ export function meaningGuardProblem(cleaned: string, answer: string, known: stri
     const id = `${item.kind}:${item.key}`
     if (seen.has(id)) continue
     if (item.kind === 'negation' && countNegations) continue
-    const kept = item.kind === 'name' ? nameKept(item.key)
-      : outKeys.get(item.kind)!.has(item.key) || (item.kind === 'number' && keptByJoin.has(item.key))
-    if (kept) { seen.add(id); continue }
+    // A number inside a clock time is judged with its time.
+    if (item.inTime) continue
+    if (kept(item)) { seen.add(id); continue }
     // Every occurrence must be exempt for a drop to be excused.
     const occurrences = input.items.filter(i => i.kind === item.kind && i.key === item.key)
     seen.add(id)
@@ -437,7 +585,9 @@ export function meaningGuardProblem(cleaned: string, answer: string, known: stri
     const outNumberItems = output.items.filter(i => i.kind === 'number')
     for (const key of outNumbers) if (outNumberItems.filter(i => i.key === key).every(i => i.list)) listOnly.add(key)
   }
-  for (const key of outNumbers) if (!inKeys.get('number')!.has(key) && !joinedOut.has(key) && !listOnly.has(key)) added.number++
+  const plainOut = new Set(output.items.filter(i => i.kind === 'number' && !i.time && !i.inTime).map(i => i.key))
+  for (const key of plainOut) if (!inKeys.get('number')!.has(key) && !joinedOut.has(key) && !listOnly.has(key)) added.number++
+  for (const time of outTimes) if (!timeAccounted(time)) added.number++
 
   const kind = MEANING_GUARD_KINDS.find(k => dropped[k] > 0 || added[k] > 0)
   return kind ? { kind, dropped, added, namesSkipped: !withNames } : null

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

@@ -5,7 +5,7 @@ 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 { fillerPassEnabled, stripFillersIfEnglish } 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'
@@ -16,7 +16,7 @@ import { customInstructionsHash, readCustomInstructions } from './dictation-poli
 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 { createBreaker, type ClaudeBreaker } from './claude-circuit.js'
 import { logTokenAudit } from './token-audit.js'
 
 /**
@@ -34,10 +34,60 @@ import { logTokenAudit } from './token-audit.js'
  * 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' }),
+/**
+ * 6.92.0 (plan r3, A-W0a): the breakers are keyed by (model, bucket group). Meeting lines have their
+ * own, so a G2 meeting that fails can no longer turn off Mac dictation and G2 message polish; message
+ * and prompt_draft share the `dictation` group. Each key has two breakers:
+ *
+ * - failure: 2 consecutive CLI failures open it for 30 minutes, as before. A client abort (the
+ *   request closed, `signal.aborted`) is neutral: it neither counts nor resets.
+ * - slow: COS_DICTATION_SLOW_BREAKER_ABORTS (default 4) consecutive aborts, each after at least
+ *   SLOW_ABORT_MIN_MODEL_MS of model time, with no success between, open it for
+ *   COS_DICTATION_SLOW_BREAKER_MS (default 300000, 5 minutes). An abort sooner than that (a disconnect
+ *   right after a sidecar restart) does not count.
+ *
+ * Either one open skips the polish as `breaker_open`; any success closes both.
+ */
+export type PolishBreakerGroup = 'dictation' | 'meeting'
+export const SLOW_ABORT_MIN_MODEL_MS = 4_000
+
+export function breakerGroupFor(bucket: PolishBucket): PolishBreakerGroup {
+  return bucket === 'meeting' ? 'meeting' : 'dictation'
+}
+
+function envPositiveInt(raw: string | undefined, fallback: number): number {
+  const trimmed = raw?.trim() ?? ''
+  if (!/^\d+$/.test(trimmed)) return fallback
+  const value = Number(trimmed)
+  return value > 0 ? value : fallback
+}
+export const slowBreakerAborts = (env: NodeJS.ProcessEnv = process.env) => envPositiveInt(env.COS_DICTATION_SLOW_BREAKER_ABORTS, 4)
+export const slowBreakerMs = (env: NodeJS.ProcessEnv = process.env) => envPositiveInt(env.COS_DICTATION_SLOW_BREAKER_MS, 300_000)
+
+interface PolishBreakers { failure: ClaudeBreaker; slow: ClaudeBreaker }
+const BREAKER_MODELS = ['sonnet', 'luna-5.6-fast', 'haiku'] as const
+function breakersFor(group: PolishBreakerGroup): Record<DictationCleanModel, PolishBreakers> {
+  return Object.fromEntries(BREAKER_MODELS.map(model => {
+    const label = `dictation-autoclean-${model === 'luna-5.6-fast' ? 'luna' : model}${group === 'meeting' ? '-meeting' : ''}`
+    return [model, {
+      failure: createBreaker({ label }),
+      slow: createBreaker({ label: `${label}-slow`, maxFailures: () => slowBreakerAborts(), cooldownMs: () => slowBreakerMs() }),
+    }]
+  })) as Record<DictationCleanModel, PolishBreakers>
+}
+export const autoCleanBreakers: Record<PolishBreakerGroup, Record<DictationCleanModel, PolishBreakers>> = {
+  dictation: breakersFor('dictation'),
+  meeting: breakersFor('meeting'),
+}
+
+export function polishBreakersFor(model: DictationCleanModel, bucket: PolishBucket): PolishBreakers {
+  return autoCleanBreakers[breakerGroupFor(bucket)][model]
+}
+
+/** The keyed breakers for this model and bucket: open when either is. The prewarm route asks this too. */
+export function polishBreakerOpen(model: DictationCleanModel, bucket: PolishBucket): boolean {
+  const breakers = polishBreakersFor(model, bucket)
+  return breakers.failure.isOpen() || breakers.slow.isOpen()
 }
 const autoCleanDefaultEnabled = () => ['1', 'true', 'on'].includes((process.env.COS_DICTATION_AUTOCLEAN ?? '').toLowerCase())
 
@@ -155,7 +205,8 @@ export function prepareOutboundDictation(text: string, bucket: PolishBucket): st
     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.92.0: only when the text is mostly English ("um 5 Uhr" and "um carro" are words).
+  if (bucket !== 'meeting' && fillerPassEnabled()) cleaned = stripFillersIfEnglish(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)
@@ -221,11 +272,11 @@ export async function polishOutboundDictation(
   const cleaned = prepareOutboundDictation(text, opts.bucket)
   if (!(opts.enabled ?? autoCleanDefaultEnabled())) return { text: cleaned, polishSkipped: 'disabled' }
   const model = opts.model ?? 'haiku'
-  const autoCleanBreaker = autoCleanBreakers[model]
+  const breakers = polishBreakersFor(model, opts.bucket)
   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 (polishBreakerOpen(model, opts.bucket)) return { text: cleaned, polishSkipped: 'breaker_open' }
   if (polishBudgetExhausted(opts.bucket)) return { text: cleaned, polishSkipped: 'daily_cap' }
   const startedAt = Date.now()
   recordPolishCall(opts.bucket)
@@ -250,6 +301,11 @@ export async function polishOutboundDictation(
   // 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
+  // 6.92.0 QA S1: the model time of an abort is stamped when the abort happens, not in the catch,
+  // which runs only after the provider process is terminated (up to 4 s on the cold path).
+  let abortedAt: number | null = null
+  const onAbort = () => { abortedAt = Date.now() }
+  opts.signal?.addEventListener('abort', onAbort, { once: true })
   try {
     let polished: string | null = null
     if (warmEntry) {
@@ -266,7 +322,8 @@ export async function polishOutboundDictation(
     // 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()
+    breakers.failure.recordSuccess()
+    breakers.slow.recordSuccess()
     const guarded = guardPolishAnswer(cleaned, polished, opts.bucket, register, canaried)
     logTokenAudit({
       source: 'g2-dictation-autoclean', model, inputChars: cleaned.length, outputChars: polished.length,
@@ -285,8 +342,29 @@ export async function polishOutboundDictation(
       modelText: polished, ...used,
     }
   } catch (err: any) {
-    autoCleanBreaker.recordFailure()
-    console.warn(`[prompt-draft] auto-clean failed (glossary-only): ${err?.message ?? err}`)
+    if (opts.signal?.aborted) {
+      // 6.92.0: the client went away (Control stopped waiting, the phone closed the request). Not a
+      // CLI failure: only the slow breaker hears it, and only after real model time. The audit row
+      // says `aborted`, codes only; the answer (nobody reads it) keeps PolishOutcome's three values.
+      const durationMs = (abortedAt ?? Date.now()) - startedAt
+      if (durationMs >= SLOW_ABORT_MIN_MODEL_MS) breakers.slow.recordFailure()
+      logTokenAudit({
+        source: 'g2-dictation-autoclean', model, inputChars: cleaned.length, outputChars: 0,
+        durationMs, caller: `dictation_autoclean_${opts.bucket}`,
+        // Key order differs from the answered row's on purpose: each gate anchor matches one row.
+        polishInstructions: { hash: instructionsHash, on: Boolean(customInstructions) },
+        learnedStyle: { hash: style.hash, on: Boolean(style.lines) },
+        ...(canaried ? { polishRegister: register } : {}),
+        ...(used.polishPrompt ? { polishPrompt: used.polishPrompt } : {}),
+        polishOutcome: 'aborted',
+      })
+      console.warn('[prompt-draft] auto-clean aborted by the client (glossary-only)')
+    } else {
+      breakers.failure.recordFailure()
+      console.warn(`[prompt-draft] auto-clean failed (glossary-only): ${err?.message ?? err}`)
+    }
     return { text: cleaned, polishSkipped: 'failed', ...(prewarm ? { prewarm } : {}), ...used }
+  } finally {
+    opts.signal?.removeEventListener('abort', onAbort)
   }
 }

package/server/lib/prompt-edit.ts

@@ -1,5 +1,13 @@
 import { spawn } from 'node:child_process'
+import { existsSync, mkdirSync, readFileSync } from 'node:fs'
+import { dirname } from 'node:path'
 import { claudeKeySecretsGuardArgs } from './key-secrets-guard.js'
+import { runClaudeText } from './claude-text-runner.js'
+import { createBreaker } from './claude-circuit.js'
+import { readSwitch } from './env-switch.js'
+import { atomicWriteFileSync } from './atomic-fs.js'
+import { dataPath } from './data-dir.js'
+import { localDay } from './dictation-polish-budget.js'
 
 export const PROMPT_EDIT_DRAFT_MAX_CHARS = 24_000
 export const PROMPT_EDIT_INSTRUCTION_MAX_CHARS = 2_000
@@ -178,17 +186,90 @@ export function spawnClaudeText(prompt: string, opts: SpawnClaudeTextOptions = {
   })
 }
 
+export const PROMPT_EDIT_SYSTEM_PROMPT = 'You revise dictated prompt drafts. Output only the revised prompt text.'
+export const promptEditModel = (env: NodeJS.ProcessEnv = process.env) => env.COS_PROMPT_EDIT_MODEL || 'sonnet'
+
+/**
+ * G2's prompt edit (POST /api/prompt-edit). 6.92.0: through the isolated text runner
+ * (claude-text-runner.ts: no tools, MCP, hooks or session, a scratch directory), with the same
+ * model, effort and 45 s timeout settings as before.
+ */
 export async function applyPromptEdit(input: PromptEditInput, signal?: AbortSignal): Promise<string> {
-  return spawnClaudeText(buildPromptEditPrompt(input), {
-    model: process.env.COS_PROMPT_EDIT_MODEL || 'sonnet',
+  return runClaudeText(buildPromptEditPrompt(input), {
+    model: promptEditModel(),
     effort: process.env.COS_PROMPT_EDIT_EFFORT || 'low',
     timeoutMs: Number.parseInt(process.env.COS_PROMPT_EDIT_TIMEOUT_MS || '45000', 10),
-    systemPrompt: 'You revise dictated prompt drafts. Output only the revised prompt text.',
+    systemPrompt: PROMPT_EDIT_SYSTEM_PROMPT,
     label: 'Prompt edit',
     signal,
   })
 }
 
+// ── 6.92.0 (plan r3, A-W0b): how prompt edit stops ───────────────────
+//
+// Every `claude -p` caller answers how it stops. Prompt edit had no answer through 6.91.1:
+// - master switch: COS_PROMPT_EDIT (readSwitch; on by default, 0/false/off answers 503);
+// - daily cap: COS_PROMPT_EDIT_DAILY_CAP (default 200 a local day) in its OWN counter file, never
+//   the dictation polish counter, so editing a prompt never spends Mac dictation's budget;
+// - breaker: 3 consecutive CLI failures open it for 10 minutes; a client abort is neutral;
+// - an audit row per call that ran (caller prompt_edit, codes and sizes only).
+// Refusals are text/plain bodies of 24 characters or fewer, so G2 6.10.654 renders
+// "Edit failed.\nAPI <status>: <body>" in 40 characters or fewer.
+
+export const PROMPT_EDIT_REFUSALS = {
+  cap: { status: 429, body: 'Edit limit reached' },
+  off: { status: 503, body: 'Edit is off' },
+  paused: { status: 503, body: 'Edit paused' },
+  failed: { status: 500, body: 'Edit failed' },
+} as const
+export type PromptEditRefusal = keyof typeof PROMPT_EDIT_REFUSALS
+
+export const PROMPT_EDIT_DEFAULT_DAILY_CAP = 200
+export const PROMPT_EDIT_BREAKER_FAILURES = 3
+export const PROMPT_EDIT_BREAKER_MS = 10 * 60 * 1000
+export const PROMPT_EDIT_COUNT_FILE = '.prompt_edit_count.json'
+
+export function promptEditEnabled(env: NodeJS.ProcessEnv = process.env): boolean {
+  return readSwitch(env.COS_PROMPT_EDIT, true)
+}
+
+export function promptEditDailyCap(env: NodeJS.ProcessEnv = process.env): number {
+  const trimmed = env.COS_PROMPT_EDIT_DAILY_CAP?.trim() ?? ''
+  if (!/^\d+$/.test(trimmed)) return PROMPT_EDIT_DEFAULT_DAILY_CAP
+  const value = Number(trimmed)
+  return value > 0 ? value : PROMPT_EDIT_DEFAULT_DAILY_CAP
+}
+
+export const promptEditBreaker = createBreaker({
+  label: 'prompt-edit', maxFailures: PROMPT_EDIT_BREAKER_FAILURES, cooldownMs: PROMPT_EDIT_BREAKER_MS,
+})
+
+const countFile = () => dataPath(PROMPT_EDIT_COUNT_FILE)
+
+export function promptEditCountToday(): number {
+  try {
+    const raw = JSON.parse(readFileSync(countFile(), 'utf8'))
+    if (raw?.date !== localDay() || !Number.isInteger(raw.count) || raw.count < 0) return 0
+    return raw.count
+  } catch { return 0 }
+}
+
+export function recordPromptEditCall(): void {
+  try {
+    const file = countFile()
+    if (!existsSync(dirname(file))) mkdirSync(dirname(file), { recursive: true })
+    atomicWriteFileSync(file, JSON.stringify({ date: localDay(), count: promptEditCountToday() + 1 }), { mode: 0o600 })
+  } catch {}
+}
+
+/** The refusal for this request, before any call, or null when the edit may run. Switch, breaker, cap. */
+export function promptEditRefusal(env: NodeJS.ProcessEnv = process.env): PromptEditRefusal | null {
+  if (!promptEditEnabled(env)) return 'off'
+  if (promptEditBreaker.isOpen()) return 'paused'
+  if (promptEditCountToday() >= promptEditDailyCap(env)) return 'cap'
+  return null
+}
+
 // ── Outbound dictation auto-clean ────────────────────────────────────
 export const AUTOCLEAN_MAX_CHARS = 8_000
 

package/server/lib/token-audit.ts

@@ -42,9 +42,12 @@ export interface TokenAuditEntry extends TokenAuditKeyFields {
   polishRegister?: string
   /** 6.91.0, dictation polish only: the prompt that ran (v3 or v4). */
   polishPrompt?: string
-  /** 6.91.0, dictation polish only: what became of the model's answer (polished, unchanged, guarded) and the guard kind. */
+  /** 6.91.0, dictation polish only: what became of the model's answer (polished, unchanged, guarded) and the guard kind.
+   * 6.92.0: `aborted` (audit only, never in a finalize answer) when the client went away mid-call. */
   polishOutcome?: string
   polishGuard?: string
+  /** 6.92.0, prompt edit only: ok, failed or aborted. */
+  promptEditOutcome?: 'ok' | 'failed' | 'aborted'
 }
 
 /**
@@ -86,6 +89,8 @@ export function buildTokenAuditRecord(entry: TokenAuditEntry, now: Date = new Da
     ...(entry.polishPrompt ? { polish_prompt: entry.polishPrompt } : {}),
     ...(entry.polishOutcome ? { polish_outcome: entry.polishOutcome } : {}),
     ...(entry.polishGuard ? { polish_guard: entry.polishGuard } : {}),
+    // 6.92.0: set only by the prompt-edit caller.
+    ...(entry.promptEditOutcome ? { prompt_edit_outcome: entry.promptEditOutcome } : {}),
   }
 }
 

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

@@ -46,6 +46,7 @@ import {
 } 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'
+import { meaningGuardEnabled } from '../lib/dictation-meaning-guard.js'
 
 /** Where the instructions apply (prompt-drafts.ts polishInstructionsFor): never meeting lines. */
 export const CUSTOM_INSTRUCTIONS_APPLY_TO = ['message', 'prompt_draft'] as const
@@ -248,11 +249,17 @@ dictationPolishSettingsRouter.delete('/dictation/learned-style', (_req, res) =>
 function optionsView() {
   const stored = readPolishOptions()
   const choice = dictationPolishPromptChoice()
+  const effectiveByModel = Object.fromEntries(POLISH_MODEL_DEFAULTS.map(model => [model, dictationPolishPromptChoice(process.env, model).version]))
   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])),
+    effectiveByModel,
+    // 6.92.0 (plan r3, A-W2): what Control's picker line needs, additive. The pairs the meaning guard,
+    // Your style and the register apply to (the same list GET /rules computes), and whether the
+    // meaning guard is on (COS_DICTATION_MEANING_GUARD). Older servers omit both.
+    stylePairs: POLISH_MODEL_DEFAULTS.filter(model => styleAndRegisterApply(model, effectiveByModel[model])).map(model => ({ model, prompt: effectiveByModel[model] })),
+    meaningGuard: meaningGuardEnabled(),
     source: choice.source,
     // The environment named a version, so this option has no effect until it is removed.
     envOverride: choice.source === 'env',

package/server/routes/prompt-drafts.ts

@@ -42,7 +42,7 @@ 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 { cleanOutboundDictation, polishBreakerOpen, type AutoCleanRequest, type PolishResult } from '../lib/dictation-polish-pipeline.js'
 import { emitDisplay } from '../lib/display-bus.js'
 import {
   acquireMaintenanceWork,
@@ -158,7 +158,8 @@ promptDraftsRouter.post('/dictation/polish/prewarm', (req, res) => {
   if (surface !== 'message' && surface !== 'meeting') return res.status(400).json({ error: 'invalid_surface' })
   if (!prewarmEnabled()) return res.status(409).json({ error: 'prewarm_unavailable', reason: 'disabled' })
   if (!isPrewarmModel(model)) return res.status(409).json({ error: 'prewarm_unavailable', reason: 'model' })
-  if (autoCleanBreakers[model].isOpen()) return res.status(409).json({ error: 'prewarm_unavailable', reason: 'breaker_open' })
+  // 6.92.0: the same keyed breaker (model, bucket group) the finalize for this surface would ask.
+  if (polishBreakerOpen(model, surface)) return res.status(409).json({ error: 'prewarm_unavailable', reason: 'breaker_open' })
   if (polishBudgetExhausted(surface)) return res.status(409).json({ error: 'prewarm_unavailable', reason: 'daily_cap' })
   try {
     res.json(startPolishPrewarm(model))