@gotcos/glasses-server 6.71.14 → 6.73.0

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-live.ts

@@ -0,0 +1,60 @@
+// The live chunk's quiet gate and ASR front end (6.72.0). Kept apart from the
+// decoders so the live route imports only audio code.
+
+import { enhanceAudio } from './audio-enhance.js'
+import { isSileroAvailable, measureSpeechSeconds } from './vad-silero.js'
+import type { FrontEndId, QuietGateId } from './stt-settings.js'
+
+/** Under this many seconds of Silero speech a chunk is quiet (bake-off canary 5). */
+export const QUIET_SPEECH_SEC = 0.5
+export const QUIET_RMS = 150
+
+export interface QuietDecision {
+  isQuiet: boolean
+  rms: number
+  /** Silero speech seconds; null when the gate fell back to RMS. */
+  speechSec: number | null
+  gate: 'silero' | 'rms' | 'rms_fallback'
+}
+
+export function chunkRms(wav: Buffer): number {
+  const pcm = wav.subarray(44)
+  const n = Math.floor(pcm.length / 2)
+  let sumSq = 0
+  for (let i = 0; i < n; i++) { const s = pcm.readInt16LE(i * 2); sumSq += s * s }
+  return Math.sqrt(sumSq / Math.max(1, n))
+}
+
+/**
+ * Quiet means "do not prompt, do not enhance, drop silence echoes". RMS 150
+ * fired on 1% of G2 chunks while Silero found no speech in 9.3%, so 6.72.0
+ * gates on Silero speech seconds (the in-process sherpa Silero, about 17 ms a
+ * 6 s chunk). Silero unavailable or the clip too short: the old RMS gate.
+ */
+export function decideQuiet(wav: Buffer, gate: QuietGateId, vad: { available: () => boolean; speechSeconds: (wav: Buffer) => number | null } = { available: () => isSileroAvailable(), speechSeconds: w => measureSpeechSeconds(w) }): QuietDecision {
+  const rms = chunkRms(wav)
+  if (gate === 'silero' && vad.available()) {
+    const speechSec = vad.speechSeconds(wav)
+    if (speechSec !== null && Number.isFinite(speechSec)) {
+      return { isQuiet: speechSec < QUIET_SPEECH_SEC, rms, speechSec, gate: 'silero' }
+    }
+    return { isQuiet: rms < QUIET_RMS, rms, speechSec: null, gate: 'rms_fallback' }
+  }
+  return { isQuiet: rms < QUIET_RMS, rms, speechSec: null, gate: 'rms' }
+}
+
+/**
+ * Whether the silence-hallucination TEXT drops (URL-only, repeated thank-you,
+ * quiet vocabulary echo) may fire. They stay on the pre-6.72 RMS test: the
+ * Silero gate also calls a chunk holding one short real name quiet, and those
+ * drops would delete it.
+ */
+export function silenceDropsAllowed(decision: QuietDecision): boolean {
+  return decision.rms < QUIET_RMS
+}
+
+/** ASR input for a live chunk or an HQ window. Playback audio is never touched here. */
+export function asrFrontEnd(audio: Buffer, frontEnd: FrontEndId): Promise<Buffer> {
+  return frontEnd === 'full' ? enhanceAudio(audio) : enhanceAudio(audio, { profile: 'light' })
+}
+

package/server/lib/stt-resolver.ts

@@ -0,0 +1,327 @@
+// Second-opinion resolver for meeting HQ (6.72.0). Algorithmic only: no model
+// call, no network, no LLM. Transcription must never call `claude -p`.
+//
+// Two decoders hear the same window. Their words are aligned by edit distance
+// over normalized words (an optional time-skew limit exists but is off: it
+// measured worse), and every place they disagree is recorded. The resolver
+// then applies two measured rules, and nothing else:
+//
+//   1. Gap fill. Large-v3 is deletion-prone on G2 audio (bake-off silver
+//      deletions 6.1% for the fixed Large-v3, 6.6% on the shipped path, against
+//      2.1% for Parakeet Ultra). Where the primary is a Whisper engine and the
+//      second opinion heard words the primary has nothing for, those words are
+//      taken, but only inside a span the primary's own VAD marked as speech and
+//      only when the second opinion's mean word confidence is at least 0.5.
+//   2. Vocabulary rescue. Where the second opinion's side of a short
+//      disagreement (at most 4 words, and the primary's side at most 2 longer)
+//      holds a profile vocabulary term the primary's side does not, the second
+//      opinion's words are taken.
+//
+// Everything else stays as the primary heard it. No region whose two sides
+// differ in a negation, a number or a unit is ever changed, whatever its length
+// (the 2026-10-13 diagnostic saw "born lacking" become "born having" and
+// "18 months" become "18 minutes"); it is listed as a protected disagreement.
+
+export interface HypWord {
+  word: string
+  start: number
+  end: number
+  probability?: number
+}
+
+export interface Hypothesis {
+  engine: string
+  text: string
+  /** Spoken words (not sub-word tokens), seconds from the start of the window. */
+  words?: HypWord[]
+}
+
+export type DisagreementKind = 'substitution' | 'primary_only' | 'second_only'
+export type ResolutionReason = 'gap_fill' | 'vocabulary' | 'protected' | 'not_speech' | 'low_confidence' | 'too_wide' | null
+
+export interface Disagreement {
+  kind: DisagreementKind
+  primary: string
+  second: string
+  start: number | null
+  end: number | null
+  taken: 'primary' | 'second'
+  reason: ResolutionReason
+}
+
+export interface ResolveOptions {
+  vocabulary: readonly string[]
+  /** Gap fill only for a deletion-prone primary (the Whisper engines). */
+  primaryDeletionProne: boolean
+  /** Where the primary's own VAD heard speech, seconds on the window clock.
+   *  Gap fill needs it: a run outside every span is background the primary's VAD
+   *  rejected, and is not taken. Absent: no gap fill at all. */
+  speechSpans?: ReadonlyArray<readonly [number, number]> | null
+  /** Mean word confidence a gap-fill run needs (second opinion's own scores). */
+  minGapConfidence?: number
+  /** false: report disagreements, change nothing. */
+  apply: boolean
+  /** When set, two words more than this far apart in time never align. Off by
+   *  default: on the production-path silver decode every limit tried (2, 3, 5,
+   *  10 s) made the resolver worse than plain text alignment, because Large-v3's
+   *  remapped token clocks have a heavy tail (median skew 0.23 s, p90 1.0 s). */
+  maxSkewSec?: number | null
+}
+
+export interface ResolveResult {
+  text: string
+  words: HypWord[]
+  /** True when the resolver's words carry clocks for every word. */
+  timed: boolean
+  disagreements: Disagreement[]
+  wordsFromSecond: number
+  applied: boolean
+  skipped?: 'too_long'
+}
+
+export const RESOLVER_VERSION = 'stt-resolver-v1'
+/** Alignment is quadratic; a 30 s window is about 100 words a side. */
+export const MAX_ALIGNMENT_CELLS = 2_000_000
+export const DEFAULT_MAX_SKEW_SEC: number | null = null
+/** Agreed words each side of a region that a vocabulary match may span. */
+export const CONTEXT_WORDS = 3
+/** A vocabulary rescue replaces at most this many second-opinion words... */
+export const MAX_VOCAB_REGION_WORDS = 4
+/** ...and at most this many more primary words than it inserts. */
+export const MAX_VOCAB_REGION_SLACK = 2
+export const DEFAULT_MIN_GAP_CONFIDENCE = 0.5
+/** Share of a gap-fill run's words whose midpoint must lie in a speech span. */
+export const MIN_SPEECH_SHARE = 0.5
+
+const NEGATIONS = new Set([
+  'not', 'no', 'never', 'none', 'nor', 'nothing', 'nobody', 'neither', 'without', 'cannot',
+  'dont', 'doesnt', 'didnt', 'isnt', 'arent', 'wasnt', 'werent', 'wont', 'wouldnt', 'cant',
+  'couldnt', 'shouldnt', 'havent', 'hasnt', 'hadnt', 'aint', 'lacking', 'lack', 'lacks',
+])
+// Unambiguous units and number words only. "am", "one", "second" and "first"
+// are everyday words far more often than quantities, and protecting them would
+// block most real gap fills.
+const UNITS = new Set([
+  'seconds', 'minute', 'minutes', 'hour', 'hours', 'day', 'days', 'week', 'weeks',
+  'month', 'months', 'year', 'years', 'percent', 'dollar', 'dollars', 'cents',
+  'thousand', 'million', 'billion',
+])
+const NUMBER_WORDS = new Set([
+  'zero', 'two', 'three', 'four', 'five', 'six', 'seven', 'eight', 'nine', 'ten',
+  'eleven', 'twelve', 'thirteen', 'fourteen', 'fifteen', 'sixteen', 'seventeen', 'eighteen',
+  'nineteen', 'twenty', 'thirty', 'forty', 'fifty', 'sixty', 'seventy', 'eighty', 'ninety',
+  'hundred', 'half', 'quarter', 'twice',
+])
+
+
+/** Lowercase letters and digits only. "Don't," and "dont" are the same word. */
+export function wordKey(word: string): string {
+  return word.normalize('NFKD').replace(/\p{M}+/gu, '').toLowerCase().replace(/[^\p{L}\p{N}]+/gu, '')
+}
+
+export function isProtectedKey(key: string): boolean {
+  return NEGATIONS.has(key) || UNITS.has(key) || NUMBER_WORDS.has(key) || /\d/.test(key)
+}
+
+interface Token { display: string; key: string; start: number | null; end: number | null; probability?: number }
+
+function tokens(h: Hypothesis): Token[] {
+  const timedWords = Array.isArray(h.words) && h.words.length > 0 ? h.words : null
+  const source = timedWords
+    ? timedWords.map(w => ({
+        display: String(w.word ?? '').trim(),
+        start: Number.isFinite(w.start) ? w.start : null,
+        end: Number.isFinite(w.end) ? w.end : null,
+        probability: w.probability,
+      }))
+    : String(h.text ?? '').split(/\s+/).map(display => ({ display, start: null, end: null, probability: undefined }))
+  return source
+    .filter(t => t.display.length > 0)
+    .map(t => ({ ...t, key: wordKey(t.display) }))
+    .filter(t => t.key.length > 0)
+}
+
+function vocabSequences(vocabulary: readonly string[]): string[][] {
+  const out: string[][] = []
+  const seen = new Set<string>()
+  for (const term of vocabulary) {
+    const seq = String(term).split(/\s+/).map(wordKey).filter(Boolean)
+    if (!seq.length) continue
+    const id = seq.join(' ')
+    if (seen.has(id)) continue
+    seen.add(id)
+    out.push(seq)
+    // "ThriftCart" is also heard as "thrift cart": both spellings count.
+    const joined = seq.join('')
+    if (seq.length > 1 && !seen.has(joined)) { seen.add(joined); out.push([joined]) }
+  }
+  return out
+}
+
+function termsIn(keys: string[], sequences: string[][]): Set<string> {
+  const found = new Set<string>()
+  for (const seq of sequences) {
+    for (let i = 0; i + seq.length <= keys.length; i++) {
+      let hit = true
+      for (let k = 0; k < seq.length; k++) if (keys[i + k] !== seq[k]) { hit = false; break }
+      if (hit) { found.add(seq.join('')); break }
+    }
+  }
+  return found
+}
+
+function mid(t: Token): number | null {
+  if (t.start === null) return null
+  return t.end === null ? t.start : (t.start + t.end) / 2
+}
+
+type Op = { kind: '=' | 's' | 'p' | 'q'; i: number | null; j: number | null }
+
+/** Edit-distance alignment. Two words far apart in time cannot pair. */
+function align(a: Token[], b: Token[], maxSkew: number | null): Op[] {
+  const n = a.length, m = b.length
+  const INF = 1e9
+  const D = new Float64Array((n + 1) * (m + 1))
+  const W = m + 1
+  for (let i = 0; i <= n; i++) D[i * W] = i
+  for (let j = 0; j <= m; j++) D[j] = j
+  const pairCost = (i: number, j: number): number => {
+    const ta = a[i], tb = b[j]
+    const ma = mid(ta), mb = mid(tb)
+    if (maxSkew !== null && ma !== null && mb !== null && Math.abs(ma - mb) > maxSkew) return INF
+    return ta.key === tb.key ? 0 : 1
+  }
+  for (let i = 1; i <= n; i++) {
+    for (let j = 1; j <= m; j++) {
+      const diag = D[(i - 1) * W + j - 1] + pairCost(i - 1, j - 1)
+      const up = D[(i - 1) * W + j] + 1
+      const left = D[i * W + j - 1] + 1
+      D[i * W + j] = Math.min(diag, up, left)
+    }
+  }
+  const ops: Op[] = []
+  let i = n, j = m
+  while (i > 0 || j > 0) {
+    if (i > 0 && j > 0) {
+      const c = pairCost(i - 1, j - 1)
+      if (c < INF && D[i * W + j] === D[(i - 1) * W + j - 1] + c) {
+        ops.push({ kind: c === 0 ? '=' : 's', i: i - 1, j: j - 1 }); i--; j--; continue
+      }
+    }
+    if (i > 0 && D[i * W + j] === D[(i - 1) * W + j] + 1) { ops.push({ kind: 'p', i: i - 1, j: null }); i--; continue }
+    ops.push({ kind: 'q', i: null, j: j - 1 }); j--
+  }
+  return ops.reverse()
+}
+
+function span(ts: Token[]): { start: number | null; end: number | null } {
+  const starts = ts.map(t => t.start).filter((x): x is number => x !== null)
+  const ends = ts.map(t => t.end ?? t.start).filter((x): x is number => x !== null)
+  return { start: starts.length ? Math.min(...starts) : null, end: ends.length ? Math.max(...ends) : null }
+}
+
+function sameProtected(p: Token[], q: Token[]): boolean {
+  const pk = p.map(t => t.key).filter(isProtectedKey).join(' ')
+  const qk = q.map(t => t.key).filter(isProtectedKey).join(' ')
+  return pk === qk
+}
+
+/** A second-opinion-only run is taken only where the primary's VAD heard
+ *  speech and the second opinion was confident. */
+function gapVerdict(q: Token[], options: ResolveOptions): ResolutionReason {
+  const spans = options.speechSpans
+  if (!spans || !spans.length) return 'not_speech'
+  const timed = q.filter(t => t.start !== null)
+  if (!timed.length) return 'not_speech'
+  const inside = timed.filter(t => { const m = mid(t)!; return spans.some(([a, b]) => m >= a && m <= b) }).length
+  if (inside / timed.length < MIN_SPEECH_SHARE) return 'not_speech'
+  const scored = q.filter(t => typeof t.probability === 'number' && Number.isFinite(t.probability))
+  const floor = options.minGapConfidence ?? DEFAULT_MIN_GAP_CONFIDENCE
+  if (scored.length && scored.reduce((n, t) => n + (t.probability as number), 0) / scored.length < floor) return 'low_confidence'
+  return 'gap_fill'
+}
+
+export function resolveHypotheses(primary: Hypothesis, second: Hypothesis, options: ResolveOptions): ResolveResult {
+  const P = tokens(primary), Q = tokens(second)
+  const toWords = (ts: Token[]): HypWord[] => ts.map(t => ({
+    word: t.display,
+    start: t.start ?? 0,
+    end: Math.max(t.start ?? 0, t.end ?? t.start ?? 0),
+    ...(t.probability !== undefined ? { probability: t.probability } : {}),
+  }))
+  const primaryOnly = (): ResolveResult => ({
+    text: P.map(t => t.display).join(' '),
+    words: toWords(P),
+    timed: P.length > 0 && P.every(t => t.start !== null),
+    disagreements: [],
+    wordsFromSecond: 0,
+    applied: false,
+  })
+  if ((P.length + 1) * (Q.length + 1) > MAX_ALIGNMENT_CELLS) return { ...primaryOnly(), skipped: 'too_long' }
+
+  const sequences = vocabSequences(options.vocabulary)
+  const ops = align(P, Q, options.maxSkewSec ?? DEFAULT_MAX_SKEW_SEC)
+  const out: Token[] = []
+  const disagreements: Disagreement[] = []
+  let wordsFromSecond = 0
+  let k = 0
+  while (k < ops.length) {
+    if (ops[k].kind === '=') { out.push(P[ops[k].i!]); k++; continue }
+    const p: Token[] = [], q: Token[] = []
+    const regionStart = k
+    while (k < ops.length && ops[k].kind !== '=') {
+      if (ops[k].i !== null) p.push(P[ops[k].i!])
+      if (ops[k].j !== null) q.push(Q[ops[k].j!])
+      k++
+    }
+    // Agreed words on both sides, so a term split across the edge of the
+    // region ("drift cart" vs "thrift cart") is still seen whole.
+    const before: string[] = [], after: string[] = []
+    for (let b = regionStart - 1; b >= 0 && before.length < CONTEXT_WORDS && ops[b].kind === '='; b--) before.unshift(P[ops[b].i!].key)
+    for (let a = k; a < ops.length && after.length < CONTEXT_WORDS && ops[a].kind === '='; a++) after.push(P[ops[a].i!].key)
+    const kind: DisagreementKind = !p.length ? 'second_only' : !q.length ? 'primary_only' : 'substitution'
+    let take: 'primary' | 'second' = 'primary'
+    let reason: ResolutionReason = null
+    if (q.length) {
+      const withContext = (side: Token[]) => [...before, ...side.map(t => t.key), ...after]
+      const primaryTerms = termsIn(withContext(p), sequences)
+      const newTerms = [...termsIn(withContext(q), sequences)].filter(t => !primaryTerms.has(t))
+      const wantGap = kind === 'second_only' && options.primaryDeletionProne
+      const wantVocab = newTerms.length > 0
+      if (wantGap || wantVocab) {
+        if (!sameProtected(p, q)) reason = 'protected'
+        else if (wantVocab && (q.length > MAX_VOCAB_REGION_WORDS || p.length > q.length + MAX_VOCAB_REGION_SLACK)) {
+          // A term inside a long disagreement is not a reason to swap the whole region.
+          reason = wantGap ? gapVerdict(q, options) : 'too_wide'
+          if (reason === 'gap_fill') take = 'second'
+        } else if (wantVocab) { take = 'second'; reason = 'vocabulary' }
+        else { reason = gapVerdict(q, options); if (reason === 'gap_fill') take = 'second' }
+      }
+    }
+    const where = span([...p, ...q])
+    disagreements.push({
+      kind,
+      primary: p.map(t => t.display).join(' '),
+      second: q.map(t => t.display).join(' '),
+      start: where.start,
+      end: where.end,
+      taken: options.apply ? take : 'primary',
+      reason,
+    })
+    if (options.apply && take === 'second') { out.push(...q); wordsFromSecond += q.length }
+    else out.push(...p)
+  }
+  return {
+    text: out.map(t => t.display).join(' '),
+    words: toWords(out),
+    timed: out.length > 0 && out.every(t => t.start !== null),
+    disagreements,
+    wordsFromSecond,
+    applied: options.apply,
+  }
+}
+
+/** Whisper's deletion-prone profile is the reason gap fill exists. */
+export function isDeletionProneEngine(engine: string): boolean {
+  return engine === 'large-v3' || engine === 'large-v3-legacy'
+}

package/server/lib/stt-runtime.ts

@@ -0,0 +1,233 @@
+// Where the STT settings meet the decoders (6.72.0): what this Mac can run,
+// the live quiet gate and ASR front end, and the meeting preview dispatch.
+
+import { existsSync } from 'node:fs'
+import {
+  applyCorrections,
+  getHighQualityTranscriptionCapability,
+  getWhisperCommitCapability,
+  WHISPER_TURBO_MODEL_PATH,
+} from './whisper-local.js'
+import { transcribeWhisperMeetingPreview } from './whisper-preview.js'
+import { asrFrontEnd } from './stt-live.js'
+import {
+  getInstallProgress, parakeetInstalled, parakeetInstallRunning, parakeetWarmState, pinnedCliKnown,
+  PARAKEET_VERSION_LABEL, transcribeParakeet, warmParakeet, type ParakeetModelId,
+} from './parakeet.js'
+import {
+  effectiveStt, readSttSettings, type EffectiveStt, type FrontEndId, type ParakeetStatus,
+  type SttCapabilities,
+} from './stt-settings.js'
+
+/** The live preview's Parakeet model. Ultra over v2 on the live-lane evidence
+ *  (docs/stt-672-evaluation.md): lower WER, and v2 put text on 3 of 40 clean
+ *  non-speech units where Ultra put none. */
+export const PREVIEW_PARAKEET_MODEL: ParakeetModelId = 'parakeet-ultra'
+/** The phone gives a preview 1.8 s end to end. Parakeet gets this long... */
+export const PARAKEET_PREVIEW_TIMEOUT_MS = 900
+/** ...and a miss falls back to Turbo only while this much of the budget is left unused. */
+export const PREVIEW_TURBO_FALLBACK_BEFORE_MS = 900
+/** Consecutive Parakeet preview misses (not busy lanes) that open the breaker. */
+export const PREVIEW_BREAKER_MISSES = 3
+export const PREVIEW_BREAKER_BASE_MS = 60_000
+export const PREVIEW_BREAKER_MAX_MS = 10 * 60_000
+
+// ── Recording probe (registered by the server; avoids an import cycle) ───────
+let recordingLiveProbe: () => boolean = () => false
+export function setRecordingLiveProbe(probe: () => boolean): void { recordingLiveProbe = probe }
+function recordingLive(): boolean { try { return recordingLiveProbe() } catch { return true } }
+
+// ── Preview breaker and counters ─────────────────────────────────────────────
+const previewStats = { parakeet: 0, parakeetMisses: 0, turboFallbacks: 0, turbo: 0, nonTurboWithheld: 0, empty: 0 }
+let breaker = { misses: 0, openUntil: 0, backoffMs: PREVIEW_BREAKER_BASE_MS }
+
+export function previewBreakerState(now = Date.now()): { open: boolean; retryAt: string | null; misses: number } {
+  const open = now < breaker.openUntil
+  return { open, retryAt: open ? new Date(breaker.openUntil).toISOString() : null, misses: breaker.misses }
+}
+export function previewCounters(): typeof previewStats { return { ...previewStats } }
+
+function notePreviewMiss(now = Date.now()): void {
+  previewStats.parakeetMisses++
+  breaker.misses++
+  if (breaker.misses >= PREVIEW_BREAKER_MISSES) {
+    breaker.openUntil = now + breaker.backoffMs
+    console.warn(`[stt] Parakeet preview missed ${breaker.misses} in a row; Turbo previews for ${Math.round(breaker.backoffMs / 1000)} s`)
+    breaker.backoffMs = Math.min(breaker.backoffMs * 2, PREVIEW_BREAKER_MAX_MS)
+    breaker.misses = 0
+  }
+}
+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 }
+  recordingLiveProbe = () => false
+}
+
+export function currentSttCapabilities(): SttCapabilities {
+  const commit = getWhisperCommitCapability()
+  const hq = getHighQualityTranscriptionCapability()
+  const installed = parakeetInstalled().installed
+  const warm = parakeetWarmState(PREVIEW_PARAKEET_MODEL).state
+  return {
+    turboModel: existsSync(WHISPER_TURBO_MODEL_PATH),
+    liveLargeV3: commit.effectiveModel === 'large-v3',
+    hqLargeV3: hq.hqAvailable && hq.model === 'large-v3',
+    parakeetInstalled: installed,
+    parakeetPreviewWarm: installed && warm === 'warm',
+    parakeetPreviewWarming: installed && warm === 'warming',
+    parakeetPreviewWarmFailed: installed && warm === 'failed',
+    parakeetPreviewBreakerOpen: installed && previewBreakerState().open,
+    previewDisabledByEnv: process.env.COS_WHISPER_MEETING_PREVIEW === '0',
+    dictationDisabledByEnv: process.env.COS_DICTATION_FOLLOWS_STT === '0',
+  }
+}
+
+export function currentEffectiveStt(): EffectiveStt {
+  return effectiveStt(readSttSettings(), currentSttCapabilities())
+}
+
+export function parakeetStatus(live: boolean): ParakeetStatus {
+  const installed = parakeetInstalled()
+  const progress = getInstallProgress()
+  const running = parakeetInstallRunning()
+  const sandbox = existsSync('/usr/bin/sandbox-exec')
+  const appleSilicon = process.platform === 'darwin' && process.arch === 'arm64'
+  // A button that can never succeed is never offered: the pinned CLI must be on this Mac.
+  const cli = appleSilicon ? pinnedCliKnown() : false
+  const installable = !installed.installed && !running && sandbox && appleSilicon && cli === true
+  const warm = parakeetWarmState(PREVIEW_PARAKEET_MODEL)
+  const note = installed.installed
+    ? 'Installed. Runs offline on the Neural Engine.'
+    : running
+      ? 'Installing.'
+      : !sandbox || !appleSilicon
+        ? 'Parakeet needs an Apple silicon Mac.'
+        : cli === false
+          ? 'Parakeet needs FluidAudio fluidaudiocli 0.17.4 at ~/.cos-glasses/bin (the speaker-separation tool); this Mac does not have that build.'
+          : cli === null
+            ? 'Checking this Mac for the FluidAudio CLI.'
+            : live
+              ? 'Install after the live recording is saved.'
+              : 'About 654 MB. Installs the pinned model and checks every file.'
+  return {
+    installed: installed.installed,
+    installable,
+    version: PARAKEET_VERSION_LABEL,
+    bytes: installed.installed ? installed.bytes : progress.bytesDone,
+    progress: { ...progress, state: installed.installed && !running ? 'installed' : progress.state },
+    warm: { preview: warm.state, ...(warm.error ? { error: warm.error } : {}), ...(warm.at ? { at: new Date(warm.at).toISOString() } : {}) },
+    preview: { breaker: previewBreakerState(), counters: previewCounters() },
+    note,
+  }
+}
+
+/** A failed warm-up is retried at most this often, never per chunk. */
+export const WARM_RETRY_MS = 120_000
+
+/**
+ * Start warming the preview model when it is selected; never awaited by a
+ * chunk. Deferred while a recording is live (the first CoreML compile is 12 to
+ * 25 s of Neural Engine work next to the live diarizer); a timer retries.
+ */
+export function ensurePreviewWarm(now = Date.now()): 'started' | 'skipped' | 'deferred' {
+  const settings = readSttSettings()
+  // 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'
+  if (recordingLive()) return 'deferred'
+  void warmParakeet(PREVIEW_PARAKEET_MODEL).then(ok => {
+    console.log(`[stt] Parakeet preview ${ok ? 'warm' : 'not warm'}: ${JSON.stringify(parakeetWarmState(PREVIEW_PARAKEET_MODEL))}`)
+  })
+  return 'started'
+}
+
+let warmTimer: ReturnType<typeof setInterval> | null = null
+/** 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
+  warmTimer = setInterval(() => { try { ensurePreviewWarm() } catch { /* next tick */ } }, 60_000)
+  warmTimer.unref?.()
+}
+export function stopPreviewWarmLoop(): void { if (warmTimer) clearInterval(warmTimer); warmTimer = null }
+
+// ── Meeting preview ──────────────────────────────────────────────────────────
+
+export interface PreviewResult {
+  text: string
+  model: string
+  backend: string
+}
+
+export interface PreviewDeps {
+  effective: () => EffectiveStt
+  turbo: (audio: Buffer) => Promise<{ text: string; model: string; backend: string } | null>
+  parakeet: (audio: Buffer) => Promise<{ text: string } | null>
+  frontEnd: (audio: Buffer, frontEnd: FrontEndId) => Promise<Buffer>
+  now?: () => number
+}
+
+export const defaultPreviewDeps: PreviewDeps = {
+  effective: () => currentEffectiveStt(),
+  turbo: audio => transcribeWhisperMeetingPreview(audio),
+  parakeet: async audio => {
+    const result = await transcribeParakeet(audio, { model: PREVIEW_PARAKEET_MODEL, lane: 'preview', timeoutMs: PARAKEET_PREVIEW_TIMEOUT_MS })
+    return { text: applyCorrections(result.text) }
+  },
+  frontEnd: (audio, fe) => asrFrontEnd(audio, fe),
+}
+
+/**
+ * Cosmetic preview for the still-open phrase. Never durable, never attributed.
+ *
+ * `acceptedModels` is what the client says it accepts (`previewModels`). A
+ * client that lists nothing (every phone before 6.10.639) gets Whisper Turbo
+ * whatever the setting, so a preview it would reject is never sent. A
+ * Parakeet miss falls back to Turbo only while the phone's 1.8 s budget allows
+ * (PREVIEW_TURBO_FALLBACK_BEFORE_MS); otherwise it is a quiet miss (204).
+ * The Parakeet preview hears the selected ASR front end (highpass by default);
+ * the Whisper previews keep raw audio, as before 6.72 (highpass measured
+ * slightly worse for Turbo).
+ */
+export async function transcribeMeetingPreview(audio: Buffer, acceptedModels: readonly string[] = [], deps: PreviewDeps = defaultPreviewDeps): Promise<PreviewResult | null> {
+  const now = deps.now ?? (() => performance.now())
+  const started = now()
+  let eff: EffectiveStt | null = null
+  try { eff = deps.effective() } catch (error) {
+    console.warn(`[stt] preview settings unreadable, using Turbo: ${error instanceof Error ? error.message : error}`)
+  }
+  const turbo = async () => {
+    previewStats.turbo++
+    const t = await deps.turbo(audio)
+    return t ? { text: t.text, model: t.model, backend: t.backend } : null
+  }
+  if (!eff) return turbo()
+  if (eff.settings.preview === 'parakeet' && eff.preview.engine !== 'parakeet') ensurePreviewWarm()
+  if (eff.preview.engine === 'parakeet') {
+    if (!acceptedModels.includes(PREVIEW_PARAKEET_MODEL)) {
+      previewStats.nonTurboWithheld++
+      return turbo()
+    }
+    try {
+      const r = await deps.parakeet(await deps.frontEnd(audio, eff.frontEnd))
+      if (r) { notePreviewHit(); previewStats.parakeet++; return { text: r.text, model: PREVIEW_PARAKEET_MODEL, backend: 'fluidaudio-coreml' } }
+    } catch (error) {
+      const busy = (error as { reason?: string })?.reason === 'busy'
+      if (!busy) notePreviewMiss()
+      console.warn(`[stt] Parakeet preview missed${busy ? ' (busy)' : ''}: ${error instanceof Error ? error.message : error}`)
+    }
+    if (now() - started >= PREVIEW_TURBO_FALLBACK_BEFORE_MS) { previewStats.empty++; return null }
+    previewStats.turboFallbacks++
+  }
+  return turbo()
+}