@gotcos/glasses-server 6.72.0 → 6.73.1

package/CHANGELOG.md

@@ -1,3 +1,25 @@
+## 6.73.1 — GPT tier selection correction
+
+- Resolve GPT Max/Frontier to the newest provider-described frontier model and GPT Balanced to the newest workhorse/balanced model. A newer workhorse version no longer displaces a frontier model: GPT-6-Astra serves Max, GPT-6.1-Sol serves Balanced in the current catalog.
+- Keep version-based selection when the provider does not describe both tiers; preserve saved tier preferences, explicit model overrides, discovery refresh, and last-known-good fallback.
+- Server catalog and execution share the corrected selection. Existing companion builds can receive the correction without an EHPK update. No transcription settings or experimental flags change.
+
+## [6.73.0] - 2026-10-13 - Prompts and dictation follow the speech-to-text settings
+
+Paired clients: none required. Every phone, including the public 618, already accepts the new dictation text (it never checks a model on dictation). COS Control and the phone can read the new `dictation` block in `GET /api/stt-settings` to replace "Dictation is unchanged" in their copy.
+
+- Dictation follows the settings (`docs/dictation-stt-contract.md`). The live provisional words (`/api/prompt-drafts/:id/peek`), the closed-chunk HUD text and the Fast mode final follow the Preview model. The final text with Fast mode off, and the speculative HQ warm, follow the HQ model. `/api/transcribe` (Quick VOICE, browser recordings) follows the same split. With the defaults (preview `turbo`, HQ `large-v3`) every dictation decode is the 6.72.0 Whisper decode, unchanged.
+- Fast mode now means "the fast engine you picked", the Preview model. On a standard Mac the Whisper choice is the Turbo live worker; on a Max-tier Mac it is the live Large-v3 worker, as before. A `large-v3` or `nemotron-560` Preview choice keeps dictation on Whisper and says why.
+- Parakeet Ultra runs for a prompt only when it is installed, warm, and the breaker is closed. When it is cold, failed, busy, or the audio is not 16 kHz WAV (the browser recorder posts WebM), the 6.72.0 Whisper engine decodes the same audio in the same request, so the user never sees a blank or an error because of Parakeet. The engine is chosen when each decode starts and never changes during it. A finalize takes one settings snapshot for all its chunks, and a chunk decoded under a different selection is decoded again instead of reused (cached records now carry `sttKey`; records from before 6.73.0 count as the 6.72.0 defaults).
+- Parakeet dictation runs on a new interactive lane: normal priority, never queued behind a meeting batch, at most two at once. The live preview uses the existing one-at-a-time preview lane. Dictation Parakeet failures count on the same breaker as the meeting preview; a busy lane does not. Choosing a Parakeet HQ model now also warms Parakeet (never while a recording is live).
+- Second opinion and resolver never run on dictation. The quiet gate never drops dictation audio: on clean spoken one-to-three-word commands the Silero rule (under 0.5 s of speech) would have dropped 18 of 30. The front end applies to Parakeet dictation decodes; Whisper dictation keeps raw audio as before (highpass changed the first word of Large-v3 HQ on 24 of 149 real prompt chunks).
+- Additive response fields: `engine` (`whisper`, `parakeet-ultra`, or `mixed` on a finalize) and `engineReason` on `/api/transcribe`, finalize and retry; `engine` on `prompt_transcript` events. `backend` reads `parakeet-ultra` for a Parakeet decode. `actualQuality` keeps its three values, so a Parakeet HQ prompt is HQ, not degraded.
+- `GET /api/stt-settings` adds `dictation` (`preview`, `fast`, `final`, each with `engine`, `follows`, `reason`, `reasonCode`; `frontEnd`, `quietGate: "none"`, `secondOpinion: "off"`, `note`) and `appliesTo.dictation`. Every 6.72.0 key keeps its value. The Parakeet preview option note now says dictation uses it on every phone.
+- `COS_DICTATION_FOLLOWS_STT=0` holds every dictation decode on its 6.72.0 Whisper engine.
+- Measured on this Mac (M3 Ultra, private engines on spare ports; full tables in the contract): on 152 real prompt chunks of 2 to 15 s, Parakeet Ultra decodes at p50 233 ms, p95 419 ms (plus the highpass front end, p50 58 ms), the live Large-v3 worker at 316 / 467 ms, the Turbo live worker at 195 / 241 ms, and whisper-cli Large-v3 HQ at 1,544 / 1,844 ms. On a synthetic set with known text, Parakeet Ultra matched 69% of name targets clean and 63% in G2 babble, against 98% and 86% for Large-v3 HQ; numbers with units and negations were level (negations 100% for every engine). Parakeet is clearly weaker on names for prompts.
+- No language model is called by any transcription path. No new downloads.
+- Tests: new suites for the dictation mapping, the Parakeet dictation runner, the plan in `transcribeAudioBuffer`, prompt-draft reuse across selections and the Parakeet live preview, the interactive lane and the HQ warm-up. Mutation gate: `node server/scripts/dictation-stt-mutation-gate.mjs` (repository only), green baseline first (100 tests in 8 files), each target matched exactly once: 22 of 22 killed, each by a named test.
+
 ## [6.72.0] - 2026-10-13 - Speech-to-text switcher, front-end fixes, Parakeet Ultra as an option
 
 Paired clients: COS Control 0.5.289 (Settings, Transcription) and COS Glasses 6.10.639 (Settings, Voice). Older clients show no switcher, but the new defaults below apply to their meetings too; change them with the routes or `<data>/stt-settings.json`.

package/README.md

@@ -148,7 +148,7 @@ range is the exact Tailscale/CGNAT allocation (`100.64.0.0/10`), not all of
   `COS_OPENAI_WHISPER_FALLBACK=1` opt-in and a configured key; a key alone never
   uploads audio.
 - HQ prompt dictation is requested by default; the phone's **Fast mode** switch
-  opts into turbo. Server 6.16.0 reports whether full local large-v3 actually
+  opts into the fast engine (the STT Preview model since 6.73.0). Server 6.16.0 reports whether full local large-v3 actually
   ran, and compatible companions alert once if an HQ request used Fast or
   Cloud instead of silently claiming HQ.
 - Local-first spoken reply playback through Kokoro on Apple silicon. The first
@@ -679,7 +679,11 @@ GET returns (abridged):
                "progress": {"state": "idle", "bytesDone": 0, "bytesTotal": 654356591, "error": null},
                "warm": {"preview": "cold"}, "preview": {"breaker": {"open": false, "retryAt": null, "misses": 0}, "counters": {}}, "note": "..."},
   "lastJob": {"at": "...", "meeting": "...", "outcome": "batch", "summary": {"windows": 12, "primaryFallbacks": 0, "timestampFallbacks": 0, "secondOpinionFailures": 0, "windowsLost": 0}},
-  "appliesTo": {"preview": "next live chunk", "hq": "next saved meeting"}
+  "dictation": {"preview": {"engine": "whisper", "follows": "preview", "reason": null, "reasonCode": null},
+                "fast": {"engine": "whisper", "follows": "preview", "reason": null, "reasonCode": null},
+                "final": {"engine": "whisper", "follows": "hq", "reason": null, "reasonCode": null},
+                "frontEnd": "raw", "quietGate": "none", "secondOpinion": "off", "note": "..."},
+  "appliesTo": {"preview": "next live chunk", "hq": "next saved meeting", "dictation": "next dictation chunk"}
 }
 ```
 
@@ -711,19 +715,52 @@ GET returns (abridged):
   never gets gap fill). See the evaluation for what each measured.
 - `COS_BATCH_HQ_TIMESTAMPS` still overrides HQ timestamps: `1` forces them on,
   `0` off. `COS_WHISPER_MEETING_PREVIEW=0` still turns the meeting preview off.
-- The `preview` setting drives only the meeting preview lane
-  (`POST /api/transcribe-stream/preview`). A client gets a non-Turbo preview
-  only if it lists that model in the `previewModels` query parameter
-  (comma-separated; COS Glasses 6.10.639 sends it); every other client gets
-  Whisper Turbo, so a phone that only accepts Turbo never sees another model.
-  Dictation's provisional words, prompt HQ and Fast mode are unchanged, and so
-  are playback audio filters. The Whisper previews keep raw audio; the Parakeet
-  preview hears the selected front end.
+- On the meeting preview lane (`POST /api/transcribe-stream/preview`) a client
+  gets a non-Turbo preview only if it lists that model in the `previewModels`
+  query parameter (comma-separated; COS Glasses 6.10.639 sends it); every other
+  client gets Whisper Turbo, so a phone that only accepts Turbo never sees
+  another model. Playback audio filters are unchanged. The Whisper previews keep
+  raw audio; the Parakeet preview hears the selected front end.
+- Since 6.73.0 the settings drive dictation too; see "Dictation" below.
 - The quiet gate decides the prompt and the front end of a live chunk. The
   silence-hallucination text drops (URL-only, repeated thank-you, a quiet
   vocabulary echo) stay on the pre-6.72 RMS test, because a chunk holding one
   short real name can be Silero-quiet.
 
+### Dictation (6.73.0)
+
+Prompts and dictation (Record Message, hold-to-talk, edit instructions, Quick
+VOICE) follow the same settings. Contract and measurements:
+`docs/dictation-stt-contract.md`.
+
+| Dictation decode | Follows | Whisper choice (default) | `parakeet` / `parakeet-ultra` |
+| --- | --- | --- | --- |
+| Live provisional words (`/api/prompt-drafts/:id/peek`) | Preview model | the 6.72.0 preview sidecar | Parakeet Ultra |
+| Closed-chunk HUD text and the Fast mode final | Preview model | the live worker (Turbo, or Large-v3 on a Max-tier Mac) | Parakeet Ultra |
+| Final text with Fast mode off, and the HQ warm | HQ model | whisper-cli Large-v3 | Parakeet Ultra |
+
+- Fast mode means "the fast engine you picked": the Preview model. With Fast
+  mode off the final text comes from the HQ model.
+- Parakeet runs for a prompt only when installed, warm, and with the breaker
+  closed. Otherwise, and when a Parakeet decode fails, is busy, or the audio is
+  not 16 kHz WAV (the browser recorder posts WebM), the 6.72.0 Whisper engine
+  decodes that audio and the response says why (`engineReason`). Selecting a
+  Parakeet HQ model also warms Parakeet. Dictation Parakeet failures count on
+  the same breaker as the meeting preview.
+- The engine is chosen when each decode starts. A finalize takes one snapshot
+  for all its chunks, and a chunk decoded under another selection is decoded
+  again rather than reused.
+- Second opinion and resolver never run on dictation. The quiet gate never
+  drops dictation audio. The front end applies to Parakeet dictation decodes;
+  Whisper dictation decodes keep raw audio, as before.
+- Responses gain `engine` (`whisper`, `parakeet-ultra`, or `mixed` on a
+  finalize) and `engineReason`; `prompt_transcript` events gain `engine`.
+  `actualQuality` keeps its values, so a Parakeet HQ prompt is not "degraded".
+  No phone needs a new request field: the phone never checks a model on
+  dictation text.
+- `COS_DICTATION_FOLLOWS_STT=0` holds every dictation decode on its 6.72.0
+  Whisper engine.
+
 ### Parakeet (FluidAudio CoreML, offline)
 
 `POST /api/stt-settings/parakeet/install` installs FluidAudio's `fluidaudiocli`
@@ -814,8 +851,9 @@ and empty workspace. Live preview and canonical meeting transcription are unchan
 ## HQ dictation
 
 Prompt dictation defaults to HQ. The phone owns the preference: **Fast mode
-OFF** requests HQ, and **Fast mode ON** requests turbo. The Mac performs all
-decoding; the phone does not run Whisper.
+OFF** requests HQ, and **Fast mode ON** requests the fast engine (the live
+worker, or Parakeet Ultra when it is the Preview model; see "Dictation (6.73.0)").
+The Mac performs all decoding; the phone does not run Whisper.
 
 For the recommended **Balanced** setup, run:
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@gotcos/glasses-server",
-  "version": "6.72.0",
+  "version": "6.73.1",
   "description": "COS Glasses: self-hosted AI heads-up-display server for Even G2 smart glasses, powered by Claude Code, Codex, Cursor Agent CLI, or local Ollama",
   "type": "module",
   "bin": {
@@ -53,6 +53,7 @@
     "!server/scripts/fact-check-mutation-gate.mjs",
     "!server/scripts/stale-session-mutation-gate.mjs",
     "!server/scripts/stt-mutation-gate.mjs",
+    "!server/scripts/dictation-stt-mutation-gate.mjs",
     "!server/scripts/pairing-mutation-gate.mjs",
     "!server/scripts/away-hold-mutation-gate.mjs",
     "!server/scripts/nemotron-mutation-gate.mjs",

package/server/lib/codex-model-catalog.ts

@@ -50,7 +50,7 @@ export interface CodexModelCatalog {
   source: CodexCatalogSource
   refreshedAt: string
   autoUpdates: true
-  selectionPolicy: 'newest-generation-top-two'
+  selectionPolicy: 'capability-tiers-then-newest-generation'
   options: CodexModelOption[]
   refreshError?: string
 }
@@ -93,13 +93,24 @@ function isCapabilityCandidate(model: CodexCatalogModel): boolean {
   return !/(?:fast and affordable|cost-efficient|small,? fast|ultra-fast)/i.test(model.description)
 }
 
-/** Select two full-size models from the newest visible GPT generation. */
+/** Prefer the provider's frontier/workhorse tiers; use generation order when
+ * the catalog does not describe both tiers. A newer workhorse (6.1 Sol) must
+ * not replace the frontier (6 Astra) merely because its version is higher.
+ */
 export function selectTopCodexModels(models: CodexCatalogModel[]): CodexCatalogModel[] {
   const visible = models.filter(model => !model.hidden && versionParts(model.id))
   if (visible.length === 0) return []
 
   const capable = visible.filter(isCapabilityCandidate)
   const pool = capable.length > 0 ? capable : visible
+  const byNewest = (candidates: CodexCatalogModel[]): CodexCatalogModel | undefined =>
+    candidates.slice().sort((a, b) => compareVersionsDesc(versionParts(a.id) ?? [], versionParts(b.id) ?? []))[0]
+  const frontier = byNewest(pool.filter(model => /\bfrontier\b/i.test(model.description)))
+  const balanced = byNewest(pool.filter(model =>
+    !/\bfrontier\b/i.test(model.description) && /\b(workhorse|balanced)\b/i.test(model.description),
+  ))
+  if (frontier && balanced) return [frontier, balanced]
+
   const versions = pool
     .map(model => versionParts(model.id))
     .filter((parts): parts is number[] => !!parts)
@@ -144,7 +155,7 @@ export function buildCodexModelCatalog(
     source,
     refreshedAt,
     autoUpdates: true,
-    selectionPolicy: 'newest-generation-top-two',
+    selectionPolicy: 'capability-tiers-then-newest-generation',
     options,
   }
 }
@@ -163,7 +174,7 @@ function cliDefaultCatalog(refreshError?: string): CodexModelCatalog {
     source: 'cli-default',
     refreshedAt: new Date().toISOString(),
     autoUpdates: true,
-    selectionPolicy: 'newest-generation-top-two',
+    selectionPolicy: 'capability-tiers-then-newest-generation',
     options: [
       { ...common, preference: CODEX_FRONTIER_MODEL, displayName: 'GPT Frontier (auto)' },
       { ...common, preference: CODEX_BALANCED_MODEL, displayName: 'GPT Balanced (auto)', isDefault: false },

package/server/lib/dictation-stt.ts

@@ -0,0 +1,117 @@
+// Dictation speech-to-text (6.73.0): prompts and dictation follow the STT
+// settings. The contract and the evidence behind every rule here:
+// docs/dictation-stt-contract.md.
+//
+//   live preview (peek) and Fast mode  -> the Preview model
+//   final text (Fast mode off)         -> the HQ model
+//
+// Only the Parakeet branch is new. Every Whisper path is the 6.72.0 code,
+// unchanged, and it is also the fallback: a Parakeet decode that is cold,
+// failed, busy or behind an open breaker leaves the request on Whisper with a
+// reason code, so the user never sees a blank or an error because of it.
+// The engine is chosen once when a decode starts and never changes during it.
+// Second opinion and resolver never run here. No LLM is ever called.
+
+import { transcribeParakeet, ParakeetError } from './parakeet.js'
+import { asrFrontEnd } from './stt-live.js'
+import {
+  currentSttCapabilities, ensurePreviewWarm, noteParakeetDictationHit, noteParakeetDictationMiss,
+  PARAKEET_PREVIEW_TIMEOUT_MS, PREVIEW_PARAKEET_MODEL,
+} from './stt-runtime.js'
+import {
+  dictationPlan, readSttSettings, type DictationPlan, type DictationSlot, type FrontEndId,
+} from './stt-settings.js'
+
+/** The plan for a dictation decode starting now. A Parakeet selection that is
+ *  not warm yet starts a warm-up (never awaited) and decodes this one on Whisper. */
+export function currentDictationPlan(slot: DictationSlot): DictationPlan {
+  let plan: DictationPlan
+  try {
+    const settings = readSttSettings()
+    plan = dictationPlan(slot, settings, currentSttCapabilities())
+    if (plan.reason === 'parakeet_warming' || plan.reason === 'parakeet_warm_failed') ensurePreviewWarm()
+  } catch (error) {
+    console.warn(`[stt] dictation settings unreadable, using Whisper: ${error instanceof Error ? error.message : error}`)
+    plan = { slot, engine: 'whisper', reason: null, frontEnd: 'highpass', key: slot === 'final' ? 'final:large-v3' : `${slot}:turbo` }
+  }
+  return plan
+}
+
+/** Parakeet reads 16 kHz mono PCM16 WAV. The browser recorder posts WebM, which stays on Whisper. */
+export function isPcm16kMonoWav(audio: Buffer): boolean {
+  if (audio.length < 44 || audio.toString('ascii', 0, 4) !== 'RIFF' || audio.toString('ascii', 8, 12) !== 'WAVE') return false
+  let offset = 12
+  while (offset + 8 <= audio.length) {
+    const id = audio.toString('ascii', offset, offset + 4)
+    const size = audio.readUInt32LE(offset + 4)
+    const body = offset + 8
+    if (id === 'fmt ') {
+      return body + 16 <= audio.length
+        && audio.readUInt16LE(body) === 1 && audio.readUInt16LE(body + 2) === 1
+        && audio.readUInt32LE(body + 4) === 16_000 && audio.readUInt16LE(body + 14) === 16
+    }
+    offset = body + size + (size % 2)
+  }
+  return false
+}
+
+/** A warm Parakeet decodes 6 s in about 0.3 s. The budget is generous so a busy
+ *  Neural Engine is not a miss, and bounded so a hang falls to Whisper quickly. */
+export function parakeetDictationTimeoutMs(audio: Buffer): number {
+  const seconds = Math.max(0, (audio.length - 44) / 32_000)
+  return Math.min(15_000, Math.round(2_000 + 150 * seconds))
+}
+
+export type DictationLane = 'preview' | 'interactive'
+
+export interface DictationParakeetDeps {
+  parakeet: (audio: Buffer, lane: DictationLane, timeoutMs: number) => Promise<{ text: string }>
+  frontEnd: (audio: Buffer, frontEnd: FrontEndId) => Promise<Buffer>
+  hit: () => void
+  miss: () => void
+}
+
+export const defaultDictationParakeetDeps: DictationParakeetDeps = {
+  parakeet: (audio, lane, timeoutMs) => transcribeParakeet(audio, { model: PREVIEW_PARAKEET_MODEL, lane, timeoutMs }),
+  frontEnd: (audio, fe) => asrFrontEnd(audio, fe),
+  hit: () => noteParakeetDictationHit(),
+  miss: () => noteParakeetDictationMiss(),
+}
+
+export type DictationParakeetOutcome =
+  | { ok: true; text: string }
+  | { ok: false; reason: 'parakeet_busy' | 'parakeet_failed' | 'audio_not_pcm_wav' }
+
+/** Applies the front end only on the Parakeet branch (see the contract). */
+export const DICTATION_PARAKEET_FRONT_END = true
+
+/**
+ * One Parakeet decode for a dictation request. Never throws: any failure is an
+ * outcome the caller turns into its 6.72.0 Whisper decode of the same audio.
+ * Raw text only; the caller runs the same corrections and filters as Whisper text.
+ */
+export async function runParakeetDictation(
+  audio: Buffer,
+  plan: DictationPlan,
+  lane: DictationLane,
+  deps: DictationParakeetDeps = defaultDictationParakeetDeps,
+): Promise<DictationParakeetOutcome> {
+  if (plan.engine !== 'parakeet-ultra') return { ok: false, reason: 'parakeet_failed' }
+  if (!isPcm16kMonoWav(audio)) return { ok: false, reason: 'audio_not_pcm_wav' }
+  const timeoutMs = lane === 'preview' ? PARAKEET_PREVIEW_TIMEOUT_MS : parakeetDictationTimeoutMs(audio)
+  let input = audio
+  if (DICTATION_PARAKEET_FRONT_END) {
+    // A front-end failure is not a Parakeet miss: decode the raw audio instead.
+    try { input = await deps.frontEnd(audio, plan.frontEnd) } catch { input = audio }
+  }
+  try {
+    const result = await deps.parakeet(input, lane, timeoutMs)
+    deps.hit()
+    return { ok: true, text: result.text }
+  } catch (error) {
+    const busy = error instanceof ParakeetError ? error.reason === 'busy' : (error as { reason?: string })?.reason === 'busy'
+    if (!busy) deps.miss()
+    console.warn(`[stt] Parakeet dictation ${plan.slot} ${busy ? 'busy' : 'missed'}; Whisper decodes it: ${error instanceof Error ? error.message : error}`)
+    return { ok: false, reason: busy ? 'parakeet_busy' : 'parakeet_failed' }
+  }
+}

package/server/lib/parakeet.ts

@@ -383,8 +383,10 @@ type SpawnLike = (command: string, args: string[], options: SpawnOptions) => Chi
 
 export interface ParakeetRunOptions {
   model: ParakeetModelId
-  /** preview: one at a time, a busy lane is a miss. batch: queued, lower CPU priority. */
-  lane: 'preview' | 'batch' | 'warmup'
+  /** preview: one at a time, a busy lane is a miss. batch: queued, lower CPU priority.
+   *  interactive (6.73.0, dictation final and Fast mode): normal priority, never queued
+   *  behind a meeting batch, at most INTERACTIVE_LANE_MAX at once; beyond that it is busy. */
+  lane: 'preview' | 'batch' | 'warmup' | 'interactive'
   timeoutMs: number
   signal?: AbortSignal
   spawnImpl?: SpawnLike
@@ -510,6 +512,9 @@ export function padShortWav(wav: Buffer, minSec = MIN_PARAKEET_AUDIO_SEC): Buffe
 
 let previewBusy = false
 let batchTail: Promise<unknown> = Promise.resolve()
+/** A prompt's Fast warm and HQ warm can overlap for one chunk; a third waits for Whisper. */
+export const INTERACTIVE_LANE_MAX = 2
+let interactiveRunning = 0
 
 export function transcribeParakeet(wav: Buffer, options: ParakeetRunOptions): Promise<ParakeetResult> {
   if (options.lane === 'preview') {
@@ -517,6 +522,11 @@ export function transcribeParakeet(wav: Buffer, options: ParakeetRunOptions): Pr
     previewBusy = true
     return runParakeet(wav, options).finally(() => { previewBusy = false })
   }
+  if (options.lane === 'interactive') {
+    if (interactiveRunning >= INTERACTIVE_LANE_MAX) return Promise.reject(new ParakeetError('busy', 'the interactive lane is full'))
+    interactiveRunning++
+    return runParakeet(wav, options).finally(() => { interactiveRunning-- })
+  }
   if (options.lane === 'batch') {
     const job = batchTail.then(() => runParakeet(wav, options))
     batchTail = job.catch(() => undefined)
@@ -581,7 +591,7 @@ function runParakeetChecked(wav: Buffer, options: ParakeetRunOptions): Promise<P
     options.signal?.addEventListener('abort', onAbort, { once: true })
     liveChildren.add(child)
     child.once('close', () => liveChildren.delete(child))
-    if (child.pid && options.lane !== 'preview') {
+    if (child.pid && options.lane !== 'preview' && options.lane !== 'interactive') {
       try { setPriority(child.pid, 10) } catch { /* runs at normal priority */ }
     }
     let stderr = ''
@@ -659,7 +669,7 @@ export function warmParakeet(model: ParakeetModelId, spawnImpl?: SpawnLike): Pro
 }
 
 export function __resetParakeetForTests(): void {
-  warm.clear(); warming.clear(); previewBusy = false; batchTail = Promise.resolve(); installing = null
+  warm.clear(); warming.clear(); previewBusy = false; interactiveRunning = 0; batchTail = Promise.resolve(); installing = null
   progress = { state: 'idle', bytesDone: 0, bytesTotal: TOTAL_BYTES, error: null }
   installedCache = null
 }

package/server/lib/prompt-draft-store.ts

@@ -22,6 +22,11 @@ export interface PromptDraftTranscriptRecord {
   degraded: boolean
   degradationReason?: string
   acceptedDegraded?: boolean
+  /** 6.73.0: the setting this decode followed ("fast:parakeet", "final:large-v3").
+   *  Absent on older records, which were all made under the 6.72.0 defaults. */
+  sttKey?: string
+  engine?: 'whisper' | 'parakeet-ultra'
+  engineReason?: string
 }
 
 /** Higher wins. Fast warm must never replace an HQ/cloud decode for the same audio. */

package/server/lib/stt-runtime.ts

@@ -59,6 +59,11 @@ function notePreviewMiss(now = Date.now()): void {
 }
 function notePreviewHit(): void { breaker = { misses: 0, openUntil: 0, backoffMs: PREVIEW_BREAKER_BASE_MS } }
 
+/** 6.73.0: dictation Parakeet decodes share the preview breaker, so a Parakeet that keeps
+ *  failing stops being tried for prompts and meetings alike. A busy lane is not a miss. */
+export function noteParakeetDictationMiss(now = Date.now()): void { notePreviewMiss(now) }
+export function noteParakeetDictationHit(): void { notePreviewHit() }
+
 export function __resetPreviewForTests(): void {
   for (const k of Object.keys(previewStats) as Array<keyof typeof previewStats>) previewStats[k] = 0
   breaker = { misses: 0, openUntil: 0, backoffMs: PREVIEW_BREAKER_BASE_MS }
@@ -80,6 +85,7 @@ export function currentSttCapabilities(): SttCapabilities {
     parakeetPreviewWarmFailed: installed && warm === 'failed',
     parakeetPreviewBreakerOpen: installed && previewBreakerState().open,
     previewDisabledByEnv: process.env.COS_WHISPER_MEETING_PREVIEW === '0',
+    dictationDisabledByEnv: process.env.COS_DICTATION_FOLLOWS_STT === '0',
   }
 }
 
@@ -132,7 +138,9 @@ export const WARM_RETRY_MS = 120_000
  */
 export function ensurePreviewWarm(now = Date.now()): 'started' | 'skipped' | 'deferred' {
   const settings = readSttSettings()
-  if (settings.preview !== 'parakeet' || !parakeetInstalled().installed) return 'skipped'
+  // 6.73.0: a Parakeet HQ model also warms, because dictation final text uses it only warm.
+  const wanted = settings.preview === 'parakeet' || settings.hq === 'parakeet-ultra'
+  if (!wanted || !parakeetInstalled().installed) return 'skipped'
   const w = parakeetWarmState(PREVIEW_PARAKEET_MODEL)
   if (w.state === 'warm' || w.state === 'warming') return 'skipped'
   if (w.state === 'failed' && now - w.at < WARM_RETRY_MS) return 'skipped'
@@ -144,7 +152,7 @@ export function ensurePreviewWarm(now = Date.now()): 'started' | 'skipped' | 'de
 }
 
 let warmTimer: ReturnType<typeof setInterval> | null = null
-/** Server start: one try now, then every minute (a no-op unless Parakeet preview is selected and cold). */
+/** Server start: one try now, then every minute (a no-op unless a Parakeet preview or HQ model is selected and cold). */
 export function startPreviewWarmLoop(): void {
   ensurePreviewWarm()
   if (warmTimer) return

package/server/lib/stt-settings.ts

@@ -130,6 +130,8 @@ export interface SttCapabilities {
   /** Repeated preview misses opened the preview breaker: Turbo until it closes. */
   parakeetPreviewBreakerOpen?: boolean
   previewDisabledByEnv: boolean
+  /** 6.73.0: COS_DICTATION_FOLLOWS_STT=0 keeps every dictation decode on its 6.72.0 Whisper engine. */
+  dictationDisabledByEnv?: boolean
 }
 
 export interface SttOption {
@@ -153,7 +155,7 @@ export function previewOptions(c: SttCapabilities): SttOption[] {
     : c.parakeetPreviewBreakerOpen
       ? 'Parakeet missed several previews in a row; Whisper Turbo previews for a few minutes, then Parakeet is tried again.'
       : c.parakeetPreviewWarm
-        ? 'Parakeet Ultra on the Neural Engine, about 0.3 s per chunk. Experimental: compare it live yourself. Needs COS Glasses 6.10.639; older phones keep Whisper Turbo.'
+        ? 'Parakeet Ultra on the Neural Engine, about 0.3 s per chunk. Experimental: compare it live yourself. Meeting previews need COS Glasses 6.10.639 (older phones keep Whisper Turbo there). Dictation previews and Fast mode use it on every phone.'
         : c.parakeetPreviewWarmFailed
           ? 'Parakeet could not start; Whisper Turbo previews. It is tried again every 2 minutes.'
           : c.parakeetPreviewWarming
@@ -306,6 +308,92 @@ export function effectiveStt(settings: SttSettings, c: SttCapabilities): Effecti
   }
 }
 
+// ── Dictation (6.73.0) ────────────────────────────────────────────────────────
+//
+// Prompting and dictation follow the same choices (docs/dictation-stt-contract.md):
+// the live preview and Fast mode follow the Preview model, the final text follows
+// the HQ model. Second opinion and resolver never run on dictation.
+
+export type DictationSlot = 'preview' | 'fast' | 'final'
+export type DictationEngine = 'whisper' | 'parakeet-ultra'
+
+export interface DictationPlan {
+  slot: DictationSlot
+  engine: DictationEngine
+  /** Why the selection could not run, as a REASON_TEXT code; null when it runs as chosen. */
+  reason: string | null
+  /** What a Parakeet decode hears. Whisper dictation always decodes raw audio. */
+  frontEnd: FrontEndId
+  /** The decode path this follows: "preview:" or "fast:" plus turbo or parakeet, or
+   *  "final:" plus large-v3 or parakeet-ultra. A cached decode is reused only under the same key. */
+  key: string
+}
+
+/** Which slot a decode is in: Fast mode follows the Preview model, otherwise the HQ model. */
+export function dictationSlotForMode(mode: 'hq' | 'fast'): DictationSlot {
+  return mode === 'fast' ? 'fast' : 'final'
+}
+
+/** The 6.72.0 key every pre-6.73 cached decode was made under. */
+export function legacyDictationKey(mode: 'hq' | 'fast'): string {
+  return mode === 'fast' ? `fast:${DEFAULT_STT_SETTINGS.preview}` : `final:${DEFAULT_STT_SETTINGS.hq}`
+}
+
+/** Pure: what a dictation decode in this slot will use, given the settings and this Mac. */
+export function dictationPlan(slot: DictationSlot, settings: SttSettings, c: SttCapabilities): DictationPlan {
+  if (c.dictationDisabledByEnv) {
+    return { slot, engine: 'whisper', reason: 'dictation_disabled_by_env', frontEnd: settings.frontEnd, key: slot === 'final' ? 'final:large-v3' : `${slot}:turbo` }
+  }
+  const wantsParakeet = slot === 'final' ? settings.hq === 'parakeet-ultra' : settings.preview === 'parakeet'
+  // The key names the dictation decode path, not the raw id: every Whisper choice in a
+  // slot is the same 6.72.0 decode for a prompt, so switching among them re-decodes nothing.
+  const key = slot === 'final' ? (wantsParakeet ? 'final:parakeet-ultra' : 'final:large-v3') : `${slot}:${wantsParakeet ? 'parakeet' : 'turbo'}`
+  const base = { slot, frontEnd: settings.frontEnd, key }
+  if (!wantsParakeet) {
+    // large-v3 and nemotron-560 previews are not offered; dictation keeps its Whisper engine.
+    const reason = slot !== 'final' && settings.preview === 'large-v3' ? 'large_v3_preview_not_offered'
+      : slot !== 'final' && settings.preview === 'nemotron-560' ? 'nemotron_not_wired' : null
+    return { ...base, engine: 'whisper', reason }
+  }
+  const reason = !c.parakeetInstalled ? 'parakeet_not_installed'
+    : c.parakeetPreviewBreakerOpen ? 'parakeet_breaker_open'
+      : c.parakeetPreviewWarm ? null
+        : c.parakeetPreviewWarmFailed ? 'parakeet_warm_failed'
+          : 'parakeet_warming'
+  return { ...base, engine: reason ? 'whisper' : 'parakeet-ultra', reason }
+}
+
+export const DICTATION_REASON_TEXT: Record<string, string> = {
+  parakeet_busy: 'Parakeet was busy with another decode; Whisper decoded this one.',
+  parakeet_failed: 'Parakeet failed on this audio; Whisper decoded it instead.',
+  audio_not_pcm_wav: 'This audio is not 16 kHz WAV, which Parakeet needs; Whisper decoded it.',
+  dictation_disabled_by_env: 'Dictation is held on Whisper on this server (COS_DICTATION_FOLLOWS_STT=0).',
+}
+
+function dictationSlotView(plan: DictationPlan, follows: 'preview' | 'hq') {
+  const code = plan.reason
+  return { engine: plan.engine, follows, reason: code ? (REASON_TEXT[code] ?? DICTATION_REASON_TEXT[code] ?? code) : null, reasonCode: code }
+}
+
+export function dictationView(settings: SttSettings, c: SttCapabilities) {
+  const preview = dictationPlan('preview', settings, c)
+  const fast = dictationPlan('fast', settings, c)
+  const final = dictationPlan('final', settings, c)
+  const anyParakeet = settings.preview === 'parakeet' || settings.hq === 'parakeet-ultra'
+  const name = (p: DictationPlan) => p.engine === 'parakeet-ultra' ? 'Parakeet Ultra' : 'Whisper'
+  const note = `Dictation follows these settings: the live preview and Fast mode use the Preview model (now ${name(preview)}), the final text uses the HQ model (now ${name(final)}). `
+    + 'Dictation never runs the second opinion or the resolver, and the quiet gate never drops a spoken prompt.'
+  return {
+    preview: dictationSlotView(preview, 'preview'),
+    fast: dictationSlotView(fast, 'preview'),
+    final: dictationSlotView(final, 'hq'),
+    frontEnd: anyParakeet ? settings.frontEnd : 'raw' as const,
+    quietGate: 'none' as const,
+    secondOpinion: 'off' as const,
+    note,
+  }
+}
+
 export interface ParakeetStatus {
   installed: boolean
   installable: boolean
@@ -337,6 +425,7 @@ export function settingsView(settings: SttSettings, c: SttCapabilities, parakeet
     quietGate: { selected: settings.quietGate, options: QUIET_GATE_OPTIONS },
     parakeet,
     lastJob,
-    appliesTo: { preview: 'next live chunk', hq: 'next saved meeting' },
+    dictation: dictationView(settings, c),
+    appliesTo: { preview: 'next live chunk', hq: 'next saved meeting', dictation: 'next dictation chunk' },
   }
 }

package/server/lib/transcribe-audio.ts

@@ -22,6 +22,8 @@ import {
 } from './hallucination-filter.js'
 import { getOpenAIKey, tryGetOpenAIKey } from './openai-key.js'
 import { getTranscriptionPolicySnapshot, isOpenAIWhisperFallbackReady } from './transcription-policy.js'
+import { currentDictationPlan, runParakeetDictation, type DictationParakeetOutcome } from './dictation-stt.js'
+import { dictationSlotForMode, type DictationEngine, type DictationPlan, type DictationSlot } from './stt-settings.js'
 
 export { OpenAIWhisperBudgetExhaustedError, estimateAudioSeconds }
 
@@ -39,6 +41,22 @@ export interface TranscribeAudioResult {
   degradationReason?: string
   elapsedMs: number
   audioBytes: number
+  /** 6.73.0: the engine that decoded this audio. */
+  engine: DictationEngine
+  /** Why the selected engine did not run (a reason code), when it did not. */
+  engineReason?: string
+  /** The setting this decode followed (see DictationPlan.key). */
+  dictationKey: string
+}
+
+/** Injected by tests; production reads the settings and runs Parakeet. */
+export interface DictationSttDeps {
+  plan: (slot: DictationSlot) => DictationPlan
+  parakeet: (audio: Buffer, plan: DictationPlan) => Promise<DictationParakeetOutcome>
+}
+export const defaultDictationSttDeps: DictationSttDeps = {
+  plan: slot => currentDictationPlan(slot),
+  parakeet: (audio, plan) => runParakeetDictation(audio, plan, 'interactive'),
 }
 
 export type TranscriptionBackendPolicy = 'automatic' | 'local-only'
@@ -147,6 +165,9 @@ export async function transcribeAudioBuffer(
     policy?: TranscriptionBackendPolicy
     /** When false, turbo/server failures do not move the shared meeting circuit breaker. */
     affectsCircuit?: boolean
+    /** A plan snapshot taken by the caller (prompt finalize takes one for every chunk). */
+    dictationPlan?: DictationPlan
+    sttDeps?: DictationSttDeps
   } = {},
 ): Promise<TranscribeAudioResult> {
   const requestedMode = opts.mode ?? 'hq'
@@ -160,14 +181,39 @@ export async function transcribeAudioBuffer(
     console.log(`[transcribe] mode downgrade: hq → fast (audio ${audioSeconds.toFixed(1)}s > cap ${HQ_MAX_SECONDS}s)`)
   }
 
-  let text: string
+  let text!: string
   let words: WhisperWord[] | undefined
-  let backend: string
-  let actualQuality: 'hq' | 'fast' | 'cloud'
+  let backend!: string
+  let actualQuality!: 'hq' | 'fast' | 'cloud'
   let degradationReason: string | undefined = effectiveMode !== requestedMode ? 'audio_too_long' : undefined
   const tStart = performance.now()
 
-  if (effectiveMode === 'hq') {
+  // 6.73.0: Fast mode follows the Preview model, otherwise the HQ model. One plan
+  // per decode; a long clip downgraded to Fast is planned for the Fast slot.
+  const sttDeps = opts.sttDeps ?? defaultDictationSttDeps
+  const slot = dictationSlotForMode(effectiveMode)
+  const plan = opts.dictationPlan && opts.dictationPlan.slot === slot ? opts.dictationPlan : sttDeps.plan(slot)
+  let engine: DictationEngine = 'whisper'
+  let engineReason: string | null = plan.reason
+  let decoded = false
+  if (plan.engine === 'parakeet-ultra') {
+    const outcome = await sttDeps.parakeet(audioBuffer, plan)
+    if (outcome.ok) {
+      text = outcome.text
+      backend = 'parakeet-ultra'
+      actualQuality = effectiveMode
+      engine = 'parakeet-ultra'
+      engineReason = null
+      decoded = true
+    } else {
+      engineReason = outcome.reason
+    }
+  }
+
+  if (decoded) {
+    // Parakeet ran: nothing below. Its word clocks are not passed to the prompt tail
+    // guard, whose confidence rule is calibrated on Whisper token probabilities.
+  } else if (effectiveMode === 'hq') {
     try {
       // A0 (2026-07-30): ffmpeg enhance light (highpass=f=80) was measured dropping
       // leading speech on compose ("device just for your awareness"). Meeting batch
@@ -286,5 +332,8 @@ export async function transcribeAudioBuffer(
     ...(degradationReason ? { degradationReason } : {}),
     elapsedMs,
     audioBytes: audioBuffer.length,
+    engine,
+    ...(engineReason ? { engineReason } : {}),
+    dictationKey: plan.key,
   }
 }

package/server/routes/prompt-drafts.ts

@@ -40,6 +40,8 @@ import { applyCorrections } from '../lib/whisper-local.js'
 import { applyFuzzyCorrections } from '../lib/fuzzy-correct.js'
 import { getAllSpeakerNames } from '../lib/speaker-embeddings.js'
 import { transcribeWhisperPreview } from '../lib/whisper-preview.js'
+import { currentDictationPlan, runParakeetDictation } from '../lib/dictation-stt.js'
+import { dictationSlotForMode, legacyDictationKey, type DictationPlan } from '../lib/stt-settings.js'
 import { autoCleanDictation, AUTOCLEAN_MAX_CHARS } from '../lib/dictation-clean.js'
 import { getVocabulary } from '../lib/profile.js'
 import { createBreaker } from '../lib/claude-circuit.js'
@@ -240,14 +242,25 @@ async function sendDraftError(res: Response, draftId: string, err: any): Promise
   res.status(err.status ?? 500).json({ error: err.message })
 }
 
-function modeQualityKey(draftId: string, chunkIndex: number, mode: 'hq' | 'fast', hash: string): string {
-  return `${draftId}:${chunkIndex}:${mode}:${hash}`
+// 6.73.0: the setting key is part of every decode key, so a decode made under
+// one STT selection is never shared with or reused for another.
+function modeQualityKey(draftId: string, chunkIndex: number, mode: 'hq' | 'fast', hash: string, sttKey: string): string {
+  return `${draftId}:${chunkIndex}:${mode}:${hash}:${sttKey}`
 }
 
-async function transcribeChunk(draftId: string, chunkIndex: number, audio: Buffer, mode: 'hq' | 'fast', purpose: 'warm' | 'final'): Promise<string> {
+/** The setting key a stored record was made under (pre-6.73 records: the 6.72.0 defaults). */
+export function recordSttKey(record: PromptDraftTranscriptRecord): string {
+  return record.sttKey ?? legacyDictationKey(record.requestedMode)
+}
+
+function planFor(mode: 'hq' | 'fast'): DictationPlan {
+  return currentDictationPlan(dictationSlotForMode(mode))
+}
+
+async function transcribeChunk(draftId: string, chunkIndex: number, audio: Buffer, mode: 'hq' | 'fast', purpose: 'warm' | 'final', plan: DictationPlan = planFor(mode)): Promise<string> {
   const hash = audioHash(audio)
-  const purposeKey = `${draftId}:${chunkIndex}:${purpose}:${mode}:${hash}`
-  const sharedKey = modeQualityKey(draftId, chunkIndex, mode, hash)
+  const purposeKey = `${draftId}:${chunkIndex}:${purpose}:${mode}:${hash}:${plan.key}`
+  const sharedKey = modeQualityKey(draftId, chunkIndex, mode, hash, plan.key)
 
   // HQ warm and HQ finalize must share one decode (plan step 8a).
   const existingShared = modeQualityJobs.get(sharedKey)
@@ -276,6 +289,9 @@ async function transcribeChunk(draftId: string, chunkIndex: number, audio: Buffe
           backend: warmMatches ? warm!.backend : 'shared-inflight',
           degraded: warmMatches ? warm!.degraded : false,
           ...(warmMatches && warm!.degradationReason ? { degradationReason: warm!.degradationReason } : {}),
+          sttKey: plan.key,
+          ...(warmMatches && warm!.engine ? { engine: warm!.engine } : {}),
+          ...(warmMatches && warm!.engineReason ? { engineReason: warm!.engineReason } : {}),
         }
         if (
           !cachedFinal
@@ -298,7 +314,7 @@ async function transcribeChunk(draftId: string, chunkIndex: number, audio: Buffe
     try {
       // Speculative warm is always local-only. Finalize may use automatic cloud fallback.
       const policy = purpose === 'warm' ? 'local-only' as const : 'automatic' as const
-      const result = await transcribeAudioBuffer(audio, { mode, policy })
+      const result = await transcribeAudioBuffer(audio, { mode, policy, dictationPlan: plan })
       if (!isCurrentChunk(draftId, chunkIndex, audio)) return ''
       // 6.45.4 — the sentence Whisper invents after the speaker stops. Never trims
       // audio; drops a trailing sentence only on the junk lexicon or on silence
@@ -313,9 +329,11 @@ async function transcribeChunk(draftId: string, chunkIndex: number, audio: Buffe
         text, hash, requestedMode: result.requestedMode, actualQuality: result.actualQuality,
         backend: result.backend, degraded: result.degraded,
         ...(result.degradationReason ? { degradationReason: result.degradationReason } : {}),
+        sttKey: result.dictationKey, engine: result.engine,
+        ...(result.engineReason ? { engineReason: result.engineReason } : {}),
       }
       await markPromptDraftChunkTranscript(draftId, chunkIndex, record, purpose)
-      console.log(`[prompt-draft] chunk ${draftId}/${chunkIndex}: ${result.elapsedMs.toFixed(1)}ms | ${result.backend} | ${purpose}/${mode} | ${text.length} chars`)
+      console.log(`[prompt-draft] chunk ${draftId}/${chunkIndex}: ${result.elapsedMs.toFixed(1)}ms | ${result.backend}${result.engineReason ? ` (${result.engineReason})` : ''} | ${purpose}/${mode} | ${text.length} chars`)
       return text
     } catch (err) {
       if (err instanceof NoSpeechDetectedError) {
@@ -324,7 +342,7 @@ async function transcribeChunk(draftId: string, chunkIndex: number, audio: Buffe
         // recognized failure shape instead of persisting either the artifact
         // or an empty gap. Other no-speech results retain existing behavior.
         if (mode === 'hq' && isCaptionCreditHallucination(err.rawText)) {
-          const fastJob = modeQualityJobs.get(modeQualityKey(draftId, chunkIndex, 'fast', hash))
+          const fastJob = [...modeQualityJobs.entries()].find(([key]) => key.startsWith(`${draftId}:${chunkIndex}:fast:${hash}:`))?.[1]
           if (fastJob) {
             try { await fastJob } catch { /* normal no-speech path below */ }
           }
@@ -342,6 +360,7 @@ async function transcribeChunk(draftId: string, chunkIndex: number, audio: Buffe
                 requestedMode: 'hq',
                 degraded: true,
                 degradationReason: 'hq_caption_credit_hallucination',
+                sttKey: plan.key,
               }, 'final')
             }
             console.warn(`[prompt-draft] dropped HQ caption-credit hallucination ${draftId}/${chunkIndex}; retained Fast text`)
@@ -349,7 +368,7 @@ async function transcribeChunk(draftId: string, chunkIndex: number, audio: Buffe
           }
         }
         await markPromptDraftChunkTranscript(draftId, chunkIndex, {
-          text: '', hash, requestedMode: mode, actualQuality: mode, backend: 'no-speech', degraded: false,
+          text: '', hash, requestedMode: mode, actualQuality: mode, backend: 'no-speech', degraded: false, sttKey: plan.key,
         }, purpose)
         return ''
       }
@@ -364,12 +383,15 @@ async function transcribeChunk(draftId: string, chunkIndex: number, audio: Buffe
   return job
 }
 
-function isReusableTranscript(
+export function isReusableTranscript(
   cached: PromptDraftTranscriptRecord | undefined,
   hash: string,
   mode: 'hq' | 'fast',
+  sttKey: string,
 ): boolean {
   if (!cached || cached.hash !== hash || cached.requestedMode !== mode) return false
+  // 6.73.0: a decode made under a different STT selection is decoded again.
+  if (recordSttKey(cached) !== sttKey) return false
   if (cached.backend.startsWith('legacy')) return false
   if (mode === 'fast') return cached.actualQuality === 'fast' || cached.actualQuality === 'cloud'
   // mode === 'hq'
@@ -385,12 +407,14 @@ async function finalizeDraft(draftId: string, mode: 'hq' | 'fast', autoClean: Au
   if (!meta) throw Object.assign(new Error('draft not found'), { status: 404 })
   const texts: string[] = []
   const transcriptRecords: PromptDraftTranscriptRecord[] = []
+  // One STT snapshot for the whole finalize: a settings change mid-finalize never mixes selections.
+  const plan = planFor(mode)
   for (const chunk of readPromptDraftChunks(draftId)) {
     try {
       const hash = audioHash(chunk.audioBuffer)
       // Await in-flight HQ warm before deciding cache miss (plan step 8b belt).
       if (mode === 'hq') {
-        const inflight = modeQualityJobs.get(modeQualityKey(draftId, chunk.chunkIndex, 'hq', hash))
+        const inflight = modeQualityJobs.get(modeQualityKey(draftId, chunk.chunkIndex, 'hq', hash, plan.key))
         if (inflight) {
           try { await inflight } catch { /* finalize may retry with automatic below */ }
         }
@@ -401,8 +425,8 @@ async function finalizeDraft(draftId: string, mode: 'hq' | 'fast', autoClean: Au
       // When Settings HQ is available, never treat a degraded turbo warm as final
       // — that left finished chats on Fast text while REVIEW looked "HQ ready".
       // Legacy records stay excluded (reconstructed provenance).
-      const reusable = isReusableTranscript(cached, hash, mode)
-      const raw = reusable ? cached!.text : await transcribeChunk(draftId, chunk.chunkIndex, chunk.audioBuffer, mode, 'final')
+      const reusable = isReusableTranscript(cached, hash, mode, plan.key)
+      const raw = reusable ? cached!.text : await transcribeChunk(draftId, chunk.chunkIndex, chunk.audioBuffer, mode, 'final', plan)
       const text = sanitizeTranscript(draftId, raw, !reusable)
       if (text.trim()) {
         texts.push(text.trim())
@@ -433,6 +457,8 @@ async function finalizeDraft(draftId: string, mode: 'hq' | 'fast', autoClean: Au
   const degraded = mode === 'hq' && (actualQuality !== 'hq' || transcriptRecords.some(record => record.degraded))
   const backends = [...new Set(transcriptRecords.map(record => record.backend))]
   const degradationReason = transcriptRecords.find(record => record.degradationReason)?.degradationReason
+  const engines = [...new Set(transcriptRecords.map(record => record.engine ?? 'whisper'))]
+  const engineReason = transcriptRecords.find(record => record.engineReason)?.engineReason
   return {
     draftId,
     text: finalText,
@@ -445,6 +471,9 @@ async function finalizeDraft(draftId: string, mode: 'hq' | 'fast', autoClean: Au
     degraded,
     backend: backends.length === 1 ? backends[0] : 'mixed',
     ...(degradationReason ? { degradationReason } : {}),
+    // 6.73.0, additive.
+    engine: engines.length === 1 ? engines[0] : engines.length === 0 ? plan.engine : 'mixed',
+    ...(engineReason ? { engineReason } : {}),
   }
 }
 
@@ -513,15 +542,24 @@ promptDraftsRouter.post('/prompt-drafts/:draftId/peek', async (req, res) => {
     peekTail = peekTail.then(async () => {
       lease.setPhase('active')
       try {
-        const result = await transcribeWhisperPreview(audio)
+        // 6.73.0: the live preview follows the Preview model. Parakeet runs on the
+        // shared one-at-a-time preview lane; any miss is the 6.72.0 Whisper peek.
+        const plan = currentDictationPlan('preview')
+        let raw: string | null = null
+        let engine: 'whisper' | 'parakeet-ultra' = 'whisper'
+        if (plan.engine === 'parakeet-ultra') {
+          const outcome = await runParakeetDictation(audio, plan, 'preview')
+          if (outcome.ok) { raw = applyCorrections(outcome.text); engine = 'parakeet-ultra' }
+        }
+        if (raw === null) raw = (await transcribeWhisperPreview(audio)).text
         // 6.45.4: the same whole-sentence filler rule as the commit path, so an
         // invented closing line never paints on the lens only to vanish later.
-        const text = sanitizeTranscript(draftId, guardPromptTail({ text: result.text, speech: SPEECH_UNKNOWN }).text, false)
+        const text = sanitizeTranscript(draftId, guardPromptTail({ text: raw, speech: SPEECH_UNKNOWN }).text, false)
         if (!text) return
         if (!loadPromptDraftMeta(draftId)) return
         emitDisplay({
           type: 'prompt_transcript',
-          data: { draftId, chunkIndex, text, provisional: true, peekGen },
+          data: { draftId, chunkIndex, text, provisional: true, peekGen, engine },
         })
       } catch (err: any) {
         if (!(err instanceof NoSpeechDetectedError)) {
@@ -575,9 +613,10 @@ promptDraftsRouter.post('/prompt-drafts/:draftId/chunks', async (req, res) => {
       // transcript only after rechecking that this exact audio still owns the
       // chunk index; a retry/replacement must never paint stale words.
       if (!isCurrentChunk(req.params.draftId, chunkIndex, audio)) return
+      const warm = loadPromptDraftMeta(req.params.draftId)?.warmTranscripts?.[String(chunkIndex)]
       emitDisplay({
         type: 'prompt_transcript',
-        data: { draftId: req.params.draftId, chunkIndex, text },
+        data: { draftId: req.params.draftId, chunkIndex, text, ...(warm?.requestedMode === 'fast' && warm.engine ? { engine: warm.engine } : {}) },
       })
     }).catch(err => {
       console.warn(`[prompt-draft] warm transcription failed ${req.params.draftId}/${chunkIndex}: ${err.message}`)

package/server/routes/transcribe.ts

@@ -1,4 +1,5 @@
-// POST /api/transcribe — Whisper transcription endpoint (message-query / one-shot path).
+// POST /api/transcribe: one-shot transcription (message-query path). 6.73.0: the engine
+// follows the STT settings (docs/dictation-stt-contract.md); Whisper is the fallback.
 //
 // The actual Whisper + cleanup pipeline lives in server/lib/transcribe-audio.ts so
 // prompt-draft recovery and the legacy one-shot path share exactly the same behavior.
@@ -43,7 +44,7 @@ transcribeRouter.post('/transcribe', async (req, res) => {
     }
 
     const result = await transcribeAudioBuffer(audioBuffer, { mode: resolveMode(req) })
-    console.log(`[perf] /transcribe: ${result.elapsedMs.toFixed(1)}ms | mode=${result.mode} | ${result.backend} | ${result.audioBytes}b | ${result.text.length} chars`)
+    console.log(`[perf] /transcribe: ${result.elapsedMs.toFixed(1)}ms | mode=${result.mode} | ${result.backend}${result.engineReason ? ` (${result.engineReason})` : ''} | ${result.audioBytes}b | ${result.text.length} chars`)
     res.json({
       text: result.text,
       backend: result.backend,
@@ -52,6 +53,9 @@ transcribeRouter.post('/transcribe', async (req, res) => {
       actualQuality: result.actualQuality,
       degraded: result.degraded,
       ...(result.degradationReason ? { degradationReason: result.degradationReason } : {}),
+      // 6.73.0, additive: which engine decoded it and, when the selection could not run, why.
+      engine: result.engine,
+      ...(result.engineReason ? { engineReason: result.engineReason } : {}),
     })
   } catch (err: any) {
     if (err instanceof MaintenanceLifecycleError) {