@gotcos/glasses-server 6.82.0 → 6.84.0

package/server/lib/dictation-format.ts

@@ -0,0 +1,119 @@
+/**
+ * 6.83.1: spoken paths and links in dictated messages. Miles, 2026-10-21, dictating funnel
+ * pages: "demo, forward slash pricing, forward slash build and price". He meant /pricing and
+ * /build-and-price, and COS gave him the words.
+ *
+ * Two pieces, both pure, both used by the outbound dictation pass in routes/prompt-drafts.ts:
+ *
+ * 1. renderSpokenPaths: the ONE case a rule can do safely. "forward slash" plus a single word
+ *    that ends a phrase (a comma, a sentence end, a line end, or the end of the text) becomes
+ *    "/word" in lowercase: "go to forward slash pricing." becomes "go to /pricing.". Anything
+ *    longer ("forward slash build and price") is left to the polish model, which can tell
+ *    where a slug ends; a rule cannot. Not rewritten:
+ *    - "slash" without "forward": "and slash or", "slash prices" are ordinary speech.
+ *    - the character itself: "the forward slash key", "a forward slash", "forward slash
+ *      character" (an article before it, or a word that names the key after it).
+ *    - ordinary speech after it: "with forward slash instead", "type forward slash twice"
+ *      (an adverb or function word, NOT_A_SLUG).
+ *    Off with COS_DICTATION_SPOKEN_PATHS=0. Meeting lines never come here (they stay faithful).
+ *
+ * 2. polishLinkProblem: a guard on the model's answer. The polish must never invent a link
+ *    and must keep a link the dictionary already wrote. It returns why an answer is refused,
+ *    or null. A refused answer means the caller sends the pre-polish text instead.
+ */
+
+import { HANDLE, LINK_TLDS } from './glossary-learn.js'
+
+const ARTICLE_BEFORE = /(?:^|[^\p{L}\p{N}])(?:the|a|an|this|that|one)[ \t]+$/iu
+/**
+ * Words that follow "forward slash" in ordinary speech about the character, never a page name
+ * (6.83.1 QA W1): "with forward slash instead", "type forward slash twice", "two forward slash
+ * marks". The names of the key, singular and plural, adverbs, and common function words.
+ */
+export const NOT_A_SLUG = new Set([
+  'key', 'keys', 'character', 'characters', 'char', 'chars', 'sign', 'signs', 'symbol', 'symbols', 'mark', 'marks', 'button', 'buttons',
+  'instead', 'too', 'twice', 'once', 'again', 'everywhere', 'here', 'there', 'only', 'please', 'first', 'last', 'also', 'now', 'then',
+  'either', 'neither', 'always', 'never', 'anywhere', 'somewhere', 'before', 'after', 'later', 'yet', 'still', 'though', 'anyway',
+  'the', 'a', 'an', 'and', 'or', 'but', 'nor', 'so', 'to', 'of', 'in', 'on', 'at', 'for', 'with', 'by', 'from', 'as', 'it', 'its',
+  'this', 'that', 'these', 'those', 'is', 'are', 'was', 'were', 'be', 'if', 'not', 'no', 'yes', 'all', 'each', 'every', 'both',
+  'more', 'less', 'one', 'two', 'three', 'thanks', 'ok', 'okay',
+])
+/** "forward slash" (or "forward-slash"), one word, then a phrase end. */
+const SPOKEN_PATH = /(?<![\p{L}\p{N}])forward[ \t-]+slash[ \t]+([\p{L}\p{N}]+)(?=[ \t]*(?:[,.;:!?)]|\n|$))/giu
+
+export function spokenPathsEnabled(env: NodeJS.ProcessEnv = process.env): boolean {
+  return !['0', 'false', 'off'].includes((env.COS_DICTATION_SPOKEN_PATHS ?? '').trim().toLowerCase())
+}
+
+export function renderSpokenPaths(text: string): string {
+  return text.replace(SPOKEN_PATH, (match: string, word: string, offset: number) => {
+    if (NOT_A_SLUG.has(word.toLowerCase())) return match
+    if (ARTICLE_BEFORE.test(text.slice(0, offset))) return match
+    return `/${word.toLowerCase()}`
+  })
+}
+
+/** A written link, email, domain, handle or path, as a polish answer might contain one. */
+const LINK_TOKEN = new RegExp([
+  String.raw`https?:\/\/[^\s<>"')\]]+`,
+  String.raw`\bwww\.[^\s<>"')\]]+`,
+  String.raw`[\p{L}\p{N}._%+-]+@[\p{L}\p{N}-]+(?:\.[\p{L}\p{N}-]+)+`,
+  String.raw`\b[\p{L}\p{N}-]+(?:\.[\p{L}\p{N}-]+)*\.(?:${LINK_TLDS.join('|')})\b(?:\/[^\s<>"')\]]*)?`,
+  // A handle: "@sam", "@quilt_hq" (an email is matched whole above, first).
+  HANDLE.source,
+  // A path at the start of a token: "/pricing", "/build-and-price", "/docs/setup". Never
+  // "and/or" or "10/21" (a letter or digit right before the slash).
+  String.raw`(?<![\p{L}\p{N}\/])\/[\p{L}\p{N}_-]+(?:\/[\p{L}\p{N}_-]+)*`,
+].join('|'), 'giu')
+
+export function linkTokens(text: string): string[] {
+  return (text.match(LINK_TOKEN) ?? []).map(token => token.replace(/[.,;:!?]+$/, ''))
+}
+
+const compact = (text: string) => text.toLowerCase().replace(/[^\p{L}\p{N}]+/gu, '')
+const spoken = (text: string, re: RegExp) => re.test(text)
+/** An explicit request for paths: "as slugs", "as paths", "as a URL". Not any "path" ("the critical path"). */
+const ASKS_FOR_PATHS = /\bas\s+(?:an?\s+)?(?:slugs?|paths?|urls?)\b/u
+/** A dot spoken, or written between two letters ("docs.example"). "v6.83" or "3.5" is not one. */
+const SPOKEN_DOT = /\bdot\b|\p{L}\.\p{L}/u
+
+/**
+ * Why a polish answer must not be sent, or null.
+ * - 'invented_link': the answer holds a link, email, handle or path whose letters the speaker
+ *   never said (a word from `knownSpellings`, the dictionary's vocabulary, counts as said, so a
+ *   corrected spelling passes), or whose shape they never spoke: a path without "slash" (unless
+ *   they asked for slugs, paths or a URL), a domain without "dot", an email or handle without
+ *   "at". A scheme or "www" nobody said fails on its letters. A path made only of NOT_A_SLUG
+ *   words ("/twice", "/everywhere") is the character talked about, not a page.
+ * - 'lost_dictionary_link': the text going in held a link the dictionary wrote (a
+ *   correction-only form such as "/pricing") and the answer dropped it, in any case.
+ * Not handled: a number said as words and written as digits ("three sixty dot com" as
+ * "360.com") reads as invented; the answer is refused and the pre-polish text goes out.
+ */
+export function polishLinkProblem(
+  input: string,
+  output: string,
+  dictionaryLinks: readonly string[] = [],
+  knownSpellings: readonly string[] = [],
+): 'invented_link' | 'lost_dictionary_link' | null {
+  const inputFold = input.toLowerCase(), outputFold = output.toLowerCase()
+  for (const link of dictionaryLinks) {
+    const l = link.toLowerCase()
+    if (l && inputFold.includes(l) && !outputFold.includes(l)) return 'lost_dictionary_link'
+  }
+  const said = compact(input)
+  const known = new Set(knownSpellings.map(compact).filter(Boolean))
+  for (const token of linkTokens(output)) {
+    const lower = token.toLowerCase()
+    // Every letter run in the link must have been said somewhere (not necessarily in order).
+    const pieces = lower.split(/[^\p{L}\p{N}]+/u).filter(Boolean)
+    if (pieces.some(piece => !said.includes(piece) && !known.has(piece))) return 'invented_link'
+    // And its shape must have been spoken. A link already written in the input has its marks there.
+    if (lower.includes('@') && !spoken(inputFold, /@|\bat\b/)) return 'invented_link'
+    if (/\.[\p{L}]/u.test(lower.replace(/^https?:\/\//, '').split('@').pop() ?? '') && !spoken(inputFold, SPOKEN_DOT)) return 'invented_link'
+    if (lower.startsWith('/') && !spoken(inputFold, /\bslash\b|(?<![\p{L}\p{N}])\/[\p{L}\p{N}]/u) && !spoken(inputFold, ASKS_FOR_PATHS)) return 'invented_link'
+    // "/twice", "/everywhere": the speaker talked about the character, not a page (NOT_A_SLUG).
+    if (lower.startsWith('/') && !lower.includes('.') && pieces.every(piece => NOT_A_SLUG.has(piece))) return 'invented_link'
+  }
+  return null
+}

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

@@ -9,7 +9,9 @@
  * - a filler-like the deterministic pass leaves to the model ("like", "you know", "kind of"),
  *   or a sentence that opens on a tic ("So", "Well", "Okay")
  * - a filler sound still present (a meeting line, or one the pass kept)
- * - spoken formatting or punctuation ("new line", "bullet point", "comma", "question mark")
+ * - spoken formatting or punctuation ("new line", "bullet point", "comma", "question mark"), and
+ *   since 6.83.1 spoken links and formatting instructions ("slash", "dot com", "underscore",
+ *   "at sign", "all caps", "slugs")
  * - text that does not read as finished: no capital at the start or no closing punctuation
  * - more than MAX_WORDS words
  * Each check errs toward calling the model: a false "needed" costs a model call, a false
@@ -27,7 +29,7 @@ const REPEAT = /(?<![\p{L}\p{N}'])([\p{L}\p{N}']+)[\s,]+\1(?![\p{L}\p{N}'])/iu
 const FALSE_START = /(?<![\p{L}\p{N}'])([\p{L}']+)\s+[\p{L}']+(?:\s+[\p{L}']+)?,\s+\1(?![\p{L}\p{N}'])/iu
 const FILLER_LIKE = /\b(like|you know|kind of|kinda|sort of|sorta|basically|literally|i guess)\b|^["“(]?(so|well|okay|ok|alright|anyway)\b/i
 const FILLER = /(?<![\p{L}\p{N}'’-])(um+|uhm|uh+|erm?|ah+|hm+|mm+|mhm)(?![\p{L}\p{N}'’-])/iu
-const FORMATTING = /\b(new ?line|new paragraph|next line|bullet( point)?|numbered|number (one|two|three|1|2|3)|comma|period|full stop|question mark|exclamation (point|mark)|colon|semicolon|open (quote|paren)|close (quote|paren)|dash)\b/i
+const FORMATTING = /\b(new ?line|new paragraph|next line|bullet( point)?|numbered|number (one|two|three|1|2|3)|comma|period|full stop|question mark|exclamation (point|mark)|colon|semicolon|open (quote|paren)|close (quote|paren)|dash|slash|backslash|underscore|hyphen|at sign|dot (com|net|org|io|ai|co|dev|app)|all caps|slugs?)\b/i
 
 export function polishNeed(text: string): PolishNeed | null {
   const trimmed = text.trim()

package/server/lib/glossary-learn.ts

@@ -1,6 +1,9 @@
 // One-word dictionary learning (6.73.11). "Fix a word" in COS Control, and any
 // other surface, teaches ONE correction at a time: heard → written joins the
-// corrections map and `written` joins the vocabulary, in one write. Every learn
+// corrections map and `written` joins the vocabulary, in one write. Since 6.83.1 a
+// written form that is a link, email or path ("forward slash pricing" written
+// "/pricing") is kept as a correction ONLY: it never joins the vocabulary, so it
+// never reaches a decoder prompt. Every learn
 // is logged (bounded, newest first) so the person can see what COS learned, from
 // where, and undo exactly that one entry.
 //
@@ -42,11 +45,19 @@ export type UndoResult =
   | { ok: false; status: number; error: string }
 
 // Positive vocab is injected into the Whisper decoder prompt; URLs/emails/paths
-// there induce ".com"/handle hallucinations on quiet audio, so they are refused.
+// there induce ".com"/handle hallucinations on quiet audio, so they never join the
+// vocabulary. As a correction's written form they are fine (6.83.1): corrections are
+// applied to text after decoding and are not part of any decoder prompt.
+// 6.83.1: one top-level-domain list for this guard and the polish link check (dictation-format.ts).
+export const LINK_TLDS = ['com', 'net', 'org', 'io', 'ai', 'co', 'gov', 'edu', 'app', 'dev', 'us', 'uk'] as const
+const TLD = new RegExp(`\\.(?:${LINK_TLDS.join('|')})\\b`, 'i')
+/** "@sam" or "@quilt_hq": a handle seeds handle hallucinations in the decoder just as an email does. */
+export const HANDLE = /(?<![\p{L}\p{N}._%+-])@[\p{L}\p{N}_]{2,}/u
 export function looksLikeUrlEmailPath(s: string): boolean {
   return /(?:https?:\/\/|www\.)/i.test(s)
     || /@[\w.-]+\.\w/.test(s)
-    || /\.(?:com|net|org|io|ai|co|gov|edu|app|dev)\b/i.test(s)
+    || TLD.test(s)
+    || HANDLE.test(s)
     || /[/\\]/.test(s)
 }
 
@@ -78,26 +89,30 @@ export function learnCorrection(
     return { ok: false, status: 400, error: 'a correction cannot contain line breaks or control characters' }
   }
   if (heard === written) return { ok: false, status: 400, error: 'the written spelling is the same as what was heard' }
-  if (looksLikeUrlEmailPath(written)) {
-    return { ok: false, status: 400, error: 'the written spelling cannot be a URL, email or path; it would join the decoder prompt' }
+  // 6.83.1: a link, email or path is a correction only (see correctionOnly).
+  const correctionOnly = isCorrectionOnly(written)
+  if (correctionOnly && !/[\p{L}\p{N}]/u.test(written)) {
+    // "/" or "@" alone rewrites every "slash" or "at" in every transcript: no word to anchor it.
+    return { ok: false, status: 400, error: 'the written spelling needs a letter or number; a bare symbol would rewrite every sentence that says it' }
   }
 
   const existingKey = Object.keys(words.corrections).find(key => same(key, heard)) ?? null
   const correctionChanged = existingKey !== heard || words.corrections[heard] !== written
   const inVocabulary = words.vocabulary.some(term => same(term, written))
-  if (!correctionChanged && inVocabulary) return { ok: true, unchanged: true }
+  if (!correctionChanged && (inVocabulary || correctionOnly)) return { ok: true, unchanged: true }
 
   if (existingKey === null && Object.keys(words.corrections).length >= MAX_TERMS) {
     return { ok: false, status: 409, error: `the dictionary already holds ${MAX_TERMS} corrections; remove one first` }
   }
-  if (!inVocabulary && words.vocabulary.length >= MAX_TERMS) {
+  const addsVocabulary = !inVocabulary && !correctionOnly
+  if (addsVocabulary && words.vocabulary.length >= MAX_TERMS) {
     return { ok: false, status: 409, error: `the vocabulary already holds ${MAX_TERMS} terms; remove one first` }
   }
 
   const corrections = { ...words.corrections }
   if (existingKey !== null && existingKey !== heard) delete corrections[existingKey]
   corrections[heard] = written
-  const vocabulary = inVocabulary ? [...words.vocabulary] : [...words.vocabulary, written]
+  const vocabulary = addsVocabulary ? [...words.vocabulary, written] : [...words.vocabulary]
   const entry: CorrectionLogEntry = {
     id: stamp.id,
     heard,
@@ -106,11 +121,72 @@ export function learnCorrection(
     at: stamp.at,
     replacedKey: existingKey,
     previous: existingKey === null ? null : words.corrections[existingKey],
-    addedVocabulary: !inVocabulary,
+    addedVocabulary: addsVocabulary,
   }
   return { ok: true, unchanged: false, words: { vocabulary, corrections }, entry }
 }
 
+/**
+ * 6.83.1: a written form that is a link, email or path is kept in the corrections map
+ * and never added to the vocabulary (the decoder prompt). Same test as the vocabulary
+ * guard, so nothing the decoder refuses can reach it through a correction.
+ */
+export function isCorrectionOnly(written: string): boolean {
+  return looksLikeUrlEmailPath(written)
+}
+
+/** The one line a client can show after a correction-only learn. No em dashes, no arrows. */
+export const CORRECTION_ONLY_NOTE = 'Saved as a correction. Links, emails and paths are never added to the words that guide transcription, so COS rewrites what it hears instead.'
+
+/**
+ * The written forms of correction-only entries ("/pricing"). The polish link check
+ * (routes/prompt-drafts.ts) refuses an answer that drops one of them.
+ */
+export function correctionOnlyForms(corrections: Record<string, string>): string[] {
+  const out: string[] = []
+  for (const value of Object.values(corrections)) {
+    const v = value.trim()
+    if (v && isCorrectionOnly(v) && !out.includes(v)) out.push(v)
+  }
+  return out
+}
+
+/**
+ * The rolling transcript context Whisper is primed with already holds corrected text, so
+ * a correction-only form ("/pricing") would reach the decoder through it. Put the spoken
+ * form back ("forward slash pricing") before priming: the decoder hears words, never the
+ * link or path. Any case ("/Pricing" too). Longest forms first so "/build-and-price" is not
+ * split by "/build".
+ */
+export function decoderSafeContext(context: string, corrections: Record<string, string>): string {
+  const pairs = Object.entries(corrections)
+    .map(([heard, written]) => [heard.trim(), written.trim()] as const)
+    .filter(([heard, written]) => heard && written && isCorrectionOnly(written) && !isCorrectionOnly(heard))
+    .sort((a, b) => b[1].length - a[1].length)
+  let out = context
+  for (const [heard, written] of pairs) {
+    out = out.replace(new RegExp(written.replace(/[.*+?^${}()|[\]\\]/g, '\\$&'), 'gi'), () => heard)
+  }
+  return out
+}
+
+/**
+ * The decoder's priming window (6.83.1 QA W2): swap correction-only forms back to speech
+ * BEFORE taking the last `max` characters, so a dictionary link that straddles the cut can
+ * never leave its tail in the window. A first token the cut split that still reads as a
+ * link ("ample.com", "@example", "e/pricing", from a link the speaker said that is not in
+ * the dictionary) is dropped too; a split ordinary word stays, as before.
+ */
+export function decoderContextWindow(context: string | undefined, corrections: Record<string, string>, max = 250): string | undefined {
+  if (context === undefined) return undefined
+  const safe = decoderSafeContext(context, corrections)
+  if (safe.length <= max) return safe
+  const cut = safe.slice(-max)
+  const first = /^\S+/.exec(cut)?.[0] ?? ''
+  const split = first !== '' && /\S$/.test(safe.slice(0, safe.length - max))
+  return split && looksLikeUrlEmailPath(first) ? cut.slice(first.length).replace(/^\s+/, '') : cut
+}
+
 /** Newest first, bounded. */
 export function appendLog(log: CorrectionLogEntry[], entry: CorrectionLogEntry): CorrectionLogEntry[] {
   return [entry, ...log].slice(0, MAX_LOG)
@@ -189,7 +265,9 @@ export function addVocabulary(words: GlossaryWords, raw: unknown): EditResult {
   const term = validTerm(raw, 'term')
   if (!term.ok) return term
   if (looksLikeUrlEmailPath(term.value)) {
-    return { ok: false, status: 400, error: 'a vocabulary word cannot be a URL, email or path; it would join the decoder prompt' }
+    // A vocabulary word has no heard side: it only steers the decoder, which is exactly
+    // where a link, email or path does harm. Point at the correction that does work.
+    return { ok: false, status: 400, error: 'a link, email or path cannot be a vocabulary word because it would steer transcription. Add it as a correction instead: what you say, then how to write it' }
   }
   if (words.vocabulary.some(existing => same(existing, term.value))) return { ok: true, unchanged: true }
   if (words.vocabulary.length >= MAX_TERMS) {

package/server/lib/hallucination-filter.ts

@@ -12,6 +12,7 @@
 //     entirety (silence artifacts, caption training, foreign script, filler-only).
 
 import { getNegativeRules, getVocabulary, getOwnerName, getWhisperCorrections } from './profile.js'
+import { isCorrectionOnly } from './glossary-learn.js'
 
 // ── Whole-chunk silence hallucinations ─────────────────────────────────────
 const CAPTION_CREDIT_HALLUCINATION = /^\s*(?:closed\s+)?caption(?:ing|s)?\s+(?:is\s+)?provided\s+by\b/i
@@ -344,6 +345,10 @@ function getVocabEchoMatcher(): RegExp {
   // Include whisper_corrections key/value variants so the echo matches whatever
   // spelling whisper emits ("POS Nation" ↔ "POSNation", "Jewel 360" ↔ "Jewel360").
   for (const [key, value] of Object.entries(getWhisperCorrections())) {
+    // 6.83.1: a correction-only pair ("forward slash pricing" written "/pricing") is not in the
+    // vocabulary prompt, so it is not one of the seeded terms this detector exists for. Its heard
+    // phrase is how the person dictates a link; a chunk of just that phrase is kept as speech.
+    if (isCorrectionOnly(value)) continue
     raw.add(key)
     raw.add(value)
   }

package/server/lib/meeting-batch-transcribe.ts

@@ -24,7 +24,15 @@ import { MAC_CAPTURE_ID } from './mac-recording.js'
 import { MacParakeetUnavailableError } from './mac-recording-asr.js'
 import { transcribeParakeet, type ParakeetResult, type ParakeetRunOptions } from './parakeet.js'
 import { isDeletionProneEngine, resolveHypotheses, RESOLVER_VERSION, type Hypothesis } from './stt-resolver.js'
-import { getVocabulary } from './profile.js'
+import { getVocabulary, getWhisperCorrections } from './profile.js'
+import { decoderContextWindow } from './glossary-learn.js'
+
+/** 6.83.1: the decoder's priming window, with correction-only forms put back to speech before the cut. */
+function decoderWindow(previousText?: string): string | undefined {
+  let corrections: Record<string, string> = {}
+  try { corrections = getWhisperCorrections() } catch { /* a test double without it reads as none */ }
+  return decoderContextWindow(previousText, corrections)
+}
 import { captureSpeakerMode, policyLabel } from './meeting-speaker-policy.js'
 import { durableAtomicWriteFileSync } from './atomic-fs.js'
 import { isMetalBatchPreempted } from './whisper-metal-gate.js'
@@ -526,7 +534,7 @@ async function decodeWhisperOnce(
   audioDir: string,
 ): Promise<HighQualityTranscriptionResult> {
   try {
-    return await deps.whisper(input, previousText?.slice(-250), { priority: 'batch', timestamps })
+    return await deps.whisper(input, decoderWindow(previousText), { priority: 'batch', timestamps })
   } catch (error) {
     // A live meeting took the GPU mid-segment. The truncated Metal output
     // was already discarded upstream (BLOCKER contract) — it is never
@@ -539,7 +547,7 @@ async function decodeWhisperOnce(
       + 'retrying once on CPU',
     )
     refreshPendingLease(audioDir)
-    return deps.whisper(input, previousText?.slice(-250), { priority: 'batch', forceCpu: true, forceCpuReason: 'preempt_retry', timestamps })
+    return deps.whisper(input, decoderWindow(previousText), { priority: 'batch', forceCpu: true, forceCpuReason: 'preempt_retry', timestamps })
   }
 }
 
@@ -1043,7 +1051,7 @@ function queueProgressiveWork(sessionId: string, state: ProgressiveSessionState)
       const identity = currentCheckpointIdentity()
       const enhanced = await asrFrontEnd(combined, identity.frontEnd)
       if (controller.signal.aborted || state.closed) return
-      const decoded = await transcribeHighQuality(enhanced, pending.previousText?.slice(-250), {
+      const decoded = await transcribeHighQuality(enhanced, decoderWindow(pending.previousText), {
         priority: 'batch',
         forceCpu: true,
         forceCpuReason: 'progressive_checkpoint',

package/server/lib/profile.ts

@@ -5,6 +5,7 @@ import { existsSync, readFileSync, mkdirSync } from 'node:fs'
 import { homedir } from 'node:os'
 import { resolve, dirname } from 'node:path'
 import { atomicWriteFileSync } from './atomic-fs.js'
+import { looksLikeUrlEmailPath } from './glossary-learn.js'
 
 const APP_ROOT = resolve(import.meta.dirname, '../..')
 
@@ -136,7 +137,8 @@ export function getVocabulary(): string[] {
     if (typeof value !== 'string') return []
     const term = value.trim()
     const key = term.toLowerCase()
-    if (!term || PLACEHOLDER_VOCABULARY.has(key) || seen.has(key)) return []
+    // 6.83.1: a link, email, handle or path never steers the decoder, even hand-written here.
+    if (!term || PLACEHOLDER_VOCABULARY.has(key) || seen.has(key) || looksLikeUrlEmailPath(term)) return []
     seen.add(key)
     return [term]
   })

package/server/lib/query-job-coordinator.ts

@@ -37,6 +37,7 @@ import type { MaintenanceWorkLease } from './maintenance-lifecycle.js'
 import { applyTrailToolMode, type JobTrailDraft } from './job-trail.js'
 import { crashLoopParkedError, type BootResumeGate } from './boot-resume.js'
 import { restartNoticeEnabled } from './query-job-feature.js'
+import { noteJobProviderLimit } from './work-orchestrator/usage-events.js'
 
 const CLIENT_JOB_ID_RE = /^[0-9a-f]{8}-[0-9a-f]{4}-4[0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$/i
 
@@ -836,7 +837,10 @@ export class QueryJobCoordinator {
         this.finishActive(active)
         return false
       }
-      const result = await this.store.fail(active.jobId, normalizeQueryJobError(error))
+      const failure = normalizeQueryJobError(error)
+      // 6.83.0: a plan-lane provider limit marks that provider exhausted for the Work orchestrator (until its reset).
+      noteJobProviderLimit(snapshot.provider, failure.code, error instanceof Error ? error.message : String((error as any)?.message ?? ''), active.request.model, snapshot.lane)
+      const result = await this.store.fail(active.jobId, failure)
       const projected = isTerminalQueryJobStatus(result.job.status)
         ? await this.projectTerminal(result.job, active.request)
         : false

package/server/lib/unsaved-audio-quarantine.ts

@@ -43,8 +43,16 @@ export interface QuarantineManifest {
   reason: string
   chunkFiles: number
   bytes: number
+  /** 6.83.2: a shorter clock for this one capture (a Mac capture discarded with no sound). Never longer than the global one. */
+  retentionMs?: number
 }
 
+/** 6.83.2: how long a discarded no-sound Mac capture stays quarantined: long enough to undo a wrong discard by hand. */
+export const DISCARDED_RETENTION_MS = 24 * 60 * 60 * 1000
+
+/** The receipt a discard writes, so the capture is terminal (`no_speech`) and never recovered on its own. */
+export interface QuarantineReceipt { outcome: 'no_speech'; discarded: true; chunkFiles?: number; note: string }
+
 export interface UnsavedCapture {
   sessionId: string
   dirName: string
@@ -57,6 +65,12 @@ export interface UnsavedCapture {
   recovered: boolean
 }
 
+/** The clock that applies to one capture: its own when it set a shorter one, else the global retention. */
+export function effectiveRetentionMs(manifest: { retentionMs?: unknown } | null, retentionMs: number): number {
+  const own = manifest?.retentionMs
+  return typeof own === 'number' && Number.isFinite(own) && own > 0 ? Math.min(retentionMs, own) : retentionMs
+}
+
 export function unsavedAudioRoot(): string {
   return dataPath('unsaved-audio')
 }
@@ -99,6 +113,7 @@ export function quarantineSessionAudio(
   sourceDir: string,
   reason: string,
   root: string = unsavedAudioRoot(),
+  options: { retentionMs?: number; receipt?: QuarantineReceipt } = {},
 ): string | null {
   const sessionId = basename(sourceDir)
   try {
@@ -114,6 +129,7 @@ export function quarantineSessionAudio(
       reason,
       chunkFiles: countChunkWavs(target),
       bytes: dirBytes(target),
+      ...(options.retentionMs ? { retentionMs: options.retentionMs } : {}),
     }
     try {
       writeFileSync(resolve(target, QUARANTINE_MANIFEST), `${JSON.stringify(manifest)}\n`, {
@@ -121,6 +137,19 @@ export function quarantineSessionAudio(
         mode: 0o600,
       })
     } catch { /* manifest is observability; the audio move already succeeded */ }
+    if (options.receipt) {
+      // 6.83.2: a discarded capture is terminal. The receipt is what keeps the auto-recover sweep and the
+      // unsaved-captures count off it (listUnsavedCaptures reads it as recovered, readCaptureDisposition as no_speech).
+      try {
+        writeFileSync(resolve(target, RECOVERED_RECEIPT), `${JSON.stringify({
+          schemaVersion: 1,
+          recoveredAt: new Date().toISOString(),
+          chunkFiles: manifest.chunkFiles,
+          words: 0,
+          ...options.receipt,
+        })}\n`, { encoding: 'utf8', mode: 0o600 })
+      } catch { /* the audio is quarantined either way; without the receipt it is merely listed as recoverable */ }
+    }
     return target
   } catch {
     // Rename failed (cross-device, permissions, race). Leave the source alone —
@@ -220,6 +249,7 @@ export function listUnsavedCaptures(
     } catch { continue }
     const manifest = readManifest(dirPath)
     const atMs = quarantinedAtMs(dirPath, manifest)
+    const ownRetentionMs = effectiveRetentionMs(manifest, retentionMs)
     captures.push({
       sessionId: manifest?.sessionId ?? dir.replace(/\.\d+$/, ''),
       dirName: dir,
@@ -228,7 +258,7 @@ export function listUnsavedCaptures(
       chunkFiles: manifest?.chunkFiles ?? countChunkWavs(dirPath),
       bytes: manifest?.bytes ?? dirBytes(dirPath),
       reason: manifest?.reason ?? null,
-      expiresAt: atMs != null ? new Date(atMs + retentionMs).toISOString() : null,
+      expiresAt: atMs != null ? new Date(atMs + ownRetentionMs).toISOString() : null,
       recovered: existsSync(resolve(dirPath, RECOVERED_RECEIPT)),
     })
   }
@@ -248,9 +278,10 @@ export function purgeExpiredQuarantine(
     // sitting exactly at the retention boundary would otherwise lose its
     // audio mid-run, in the module whose thesis is "never delete evidence".
     if (isRecoveryActive(capture.dirName)) continue
-    const atMs = capture.quarantinedAt ? Date.parse(capture.quarantinedAt) : NaN
-    if (!Number.isFinite(atMs)) continue
-    if (Date.now() - atMs > retentionMs) {
+    // The capture's own expiry: a discarded no-sound capture sets a shorter clock (6.83.2).
+    const expiresMs = capture.expiresAt ? Date.parse(capture.expiresAt) : NaN
+    if (!Number.isFinite(expiresMs)) continue
+    if (Date.now() > expiresMs) {
       try {
         rmSync(resolve(root, capture.dirName), { recursive: true, force: true })
         purged.push(capture.dirName)
@@ -433,7 +464,7 @@ function dispositionOf(sessionId: string, dirPath: string, retentionMs: number):
     quarantineReason: manifest?.reason ?? null,
     savedFilename,
     recovering: isRecoveryActive(basename(dirPath)),
-    retainedUntil: atMs != null ? new Date(atMs + retentionMs).toISOString() : null,
+    retainedUntil: atMs != null ? new Date(atMs + effectiveRetentionMs(manifest, retentionMs)).toISOString() : null,
   }
 }
 

package/server/lib/whisper-local.ts

@@ -16,6 +16,7 @@ import crypto from 'node:crypto'
 import { batchTimestampsEnabled, parseNativeVadTimeline, remapBatchWords } from './whisper-batch-timing.js'
 import { readSttSettings, type FrontEndId } from './stt-settings.js'
 import { getVocabulary, getOwnerName, getWhisperCorrections } from './profile.js'
+import { decoderSafeContext } from './glossary-learn.js'
 import { stripBrandUrls } from './hallucination-filter.js'
 import {
   batchHqMetalEnabled,
@@ -1243,8 +1244,9 @@ export async function transcribeHighQuality(
   }
 }
 
-/** Build prompt with optional previous transcript context for continuity */
-function buildPrompt(context?: string, isQuiet?: boolean): string {
+/** Build prompt with optional previous transcript context for continuity.
+ *  Exported (6.83.1) only so tests can assert on the exact decoder prompt. */
+export function buildPrompt(context?: string, isQuiet?: boolean): string {
   // During quiet/silence audio, skip vocabulary prompt to reduce decoder bias
   if (isQuiet) return ''
   if (!context || context.length < 10) return getWhisperPrompt()
@@ -1259,6 +1261,9 @@ function buildPrompt(context?: string, isQuiet?: boolean): string {
   // prior chunk would otherwise feed back through this context and re-seed the
   // next decode. Strip brand URLs from the priming context (output unaffected).
   if (STRIP_BRAND_URLS) sanitized = stripBrandUrls(sanitized)
+  // 6.83.1: a correction-only form ("/pricing") came from the corrections pass, not the
+  // speaker's audio; the decoder is primed with the spoken form instead (glossary-learn.ts).
+  sanitized = decoderSafeContext(sanitized, getWhisperCorrections())
   // Previous transcript helps Whisper maintain proper noun consistency,
   // continue sentences across chunk boundaries, and reduce hallucinations
   return PROMPT_V2 ? `${getWhisperPrompt()} ${sanitized}` : `${getWhisperPrompt()}. ${sanitized}`
@@ -1379,14 +1384,34 @@ function buildCorrections(): Array<[RegExp, string]> {
 
   // Escape correction keys before interpolation. Names such as "A.C.M.E."
   // are literal vocabulary, never regular-expression programs.
-  for (const [pattern, replacement] of Object.entries(getWhisperCorrections())) {
-    const escaped = pattern.replace(/[.*+?^${}()|[\]\\]/g, '\\$&')
+  // 6.83.1: the words of a multi-word key may be split by a run of spaces or tabs, or by one
+  // hyphen ("forward-slash  pricing"); never by a line break or a spaced dash (" - ").
+  for (const [pattern, replacement] of correctionOrder(getWhisperCorrections())) {
+    const escaped = pattern.trim().split(/\s+/).map(part => part.replace(/[.*+?^${}()|[\]\\]/g, '\\$&')).join('(?:[ \\t]+|-)')
     corrections.push([new RegExp(`\\b${escaped}\\b`, 'gi'), replacement])
   }
 
   return corrections
 }
 
+/**
+ * The profile's order, except that a key goes ahead of any earlier key whose words it
+ * contains (6.83.1): "forward slash build and price" runs before "forward slash build", or
+ * the shorter key would cut the longer phrase short. Chains the person relies on
+ * ("Myles" then "Miles Ukoma") keep their order, since neither key contains the other.
+ */
+export function correctionOrder(corrections: Record<string, string>): Array<[string, string]> {
+  const norm = (key: string) => ` ${key.trim().toLowerCase().split(/[\s-]+/).join(' ')} `
+  const out: Array<[string, string]> = []
+  for (const entry of Object.entries(corrections)) {
+    const mine = norm(entry[0])
+    const at = out.findIndex(([key]) => mine !== norm(key) && mine.includes(norm(key)))
+    if (at < 0) out.push(entry)
+    else out.splice(at, 0, entry)
+  }
+  return out
+}
+
 let _corrections: Array<[RegExp, string]> | null = null
 function getCorrections(): Array<[RegExp, string]> {
   if (!_corrections) _corrections = buildCorrections()
@@ -1399,7 +1424,8 @@ function getCorrections(): Array<[RegExp, string]> {
 export function applyCorrections(text: string): string {
   let result = text
   for (const [pattern, replacement] of getCorrections()) {
-    result = result.replace(pattern, replacement)
+    // A function, so a written form holding "$&" or "$1" is inserted literally (6.83.1).
+    result = result.replace(pattern, () => replacement)
   }
   return result
 }