@gotcos/glasses-server 6.91.1 → 6.92.0

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

@@ -396,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. */

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))

package/server/routes/prompt-edit.ts

@@ -1,13 +1,28 @@
 import { Router } from 'express'
+import type { Response } from 'express'
 import {
+  PROMPT_EDIT_REFUSALS,
   PromptEditValidationError,
   applyPromptEdit,
+  buildPromptEditPrompt,
   normalizePromptEditInput,
+  promptEditBreaker,
+  promptEditModel,
+  promptEditRefusal,
+  recordPromptEditCall,
+  type PromptEditRefusal,
 } from '../lib/prompt-edit.js'
-import { errMsg } from '../lib/utils.js'
+import { ClaudeTextError } from '../lib/claude-text-runner.js'
+import { logTokenAudit } from '../lib/token-audit.js'
 
 export const promptEditRouter = Router()
 
+/** 6.92.0: a short text/plain body (24 characters or fewer), which G2 6.10.654 shows after "Edit failed.". */
+function refuse(res: Response, refusal: PromptEditRefusal): void {
+  const { status, body } = PROMPT_EDIT_REFUSALS[refusal]
+  res.status(status).type('text/plain').send(body)
+}
+
 promptEditRouter.post('/prompt-edit', async (req, res) => {
   const abort = new AbortController()
   // Abort the model spawn ONLY if the client disconnects before we respond.
@@ -19,15 +34,42 @@ promptEditRouter.post('/prompt-edit', async (req, res) => {
   res.on('close', () => {
     if (!res.writableEnded) abort.abort()
   })
+  // 6.92.0: the switch first, so "off" answers the same whatever the body.
+  if (promptEditRefusal() === 'off') return refuse(res, 'off')
+  let input
   try {
-    const input = normalizePromptEditInput(req.body)
-    const revisedText = await applyPromptEdit(input, abort.signal)
-    res.json({ revisedText })
+    input = normalizePromptEditInput(req.body)
   } catch (err) {
     if (err instanceof PromptEditValidationError) {
       res.status(err.status).json({ error: err.message })
       return
     }
-    res.status(500).json({ error: errMsg(err) })
+    return refuse(res, 'failed')
+  }
+  const refusal = promptEditRefusal()
+  if (refusal) return refuse(res, refusal)
+  // Counted before the call, as the dictation polish counts: a call that started was spent.
+  recordPromptEditCall()
+  const startedAt = Date.now()
+  const audit = (outcome: 'ok' | 'failed' | 'aborted', outputChars: number) => logTokenAudit({
+    source: 'g2-prompt-edit', model: promptEditModel(), inputChars: buildPromptEditPrompt(input).length, outputChars,
+    durationMs: Date.now() - startedAt, caller: 'prompt_edit', promptEditOutcome: outcome,
+  })
+  try {
+    const revisedText = await applyPromptEdit(input, abort.signal)
+    promptEditBreaker.recordSuccess()
+    audit('ok', revisedText.length)
+    res.json({ revisedText })
+  } catch (err) {
+    if (abort.signal.aborted) {
+      // The phone went away: not a CLI failure, so the breaker neither counts nor resets.
+      audit('aborted', 0)
+      return
+    }
+    promptEditBreaker.recordFailure()
+    audit('failed', 0)
+    // A code only: the CLI's stdout and stderr can carry the draft.
+    console.warn(`[prompt-edit] failed (${err instanceof ClaudeTextError ? err.code : 'error'})`)
+    refuse(res, 'failed')
   }
 })