@gotcos/glasses-server 6.18.8 → 6.20.0

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

@@ -0,0 +1,314 @@
+// Quarantine for unsaved meeting audio.
+//
+// Until 6.19.0 the session-audio purge (boot sweep + 60s interval) DELETED any
+// session-audio directory that was not in the in-memory sessions map and did
+// not carry a fresh save-preserved marker. An offline meeting whose deferred
+// save never landed therefore lost its full-fidelity audio within a minute of
+// the server no longer tracking the session — two real meetings were destroyed
+// this way on 2026-08-01. The only surviving fragments were in ext-audio,
+// which is a speaker-enrollment store (unrecognized-speaker chunks, hard
+// capped), not meeting audio.
+//
+// The rule now: audio evidence is moved here, never deleted in place. A
+// quarantined capture is surfaced on /api/health (unsaved_captures) and can be
+// driven to a durable scribe via POST /api/meeting/orphans/:sessionId/recover.
+// Quarantine expires on a retention clock (default 72h) — long enough to
+// survive a weekend away from the Mac, bounded enough not to grow forever.
+
+import {
+  existsSync,
+  mkdirSync,
+  readdirSync,
+  readFileSync,
+  renameSync,
+  rmSync,
+  statSync,
+  writeFileSync,
+} from 'node:fs'
+import { basename, join, resolve } from 'node:path'
+import { dataPath } from './data-dir.js'
+
+export const QUARANTINE_MANIFEST = '_quarantine.json'
+export const RECOVERED_RECEIPT = '_recovered.json'
+const CHUNK_WAV_RE = /^chunk_\d{4}\.wav$/
+
+const DEFAULT_RETENTION_HOURS = 72
+const MIN_RETENTION_HOURS = 1
+const MAX_RETENTION_HOURS = 720
+
+export interface QuarantineManifest {
+  schemaVersion: 1
+  sessionId: string
+  quarantinedAt: string
+  reason: string
+  chunkFiles: number
+  bytes: number
+}
+
+export interface UnsavedCapture {
+  sessionId: string
+  dirName: string
+  quarantinedAt: string | null
+  ageHours: number | null
+  chunkFiles: number
+  bytes: number
+  reason: string | null
+  expiresAt: string | null
+  recovered: boolean
+}
+
+export function unsavedAudioRoot(): string {
+  return dataPath('unsaved-audio')
+}
+
+export function unsavedAudioRetentionMs(env: NodeJS.ProcessEnv = process.env): number {
+  // An EMPTY value means unset, not zero: Number('') === 0, which would clamp
+  // to the 1h minimum and silently collapse the 72h safety net — on the one
+  // knob whose failure mode is losing the audio this module exists to keep.
+  const rawText = (env.COS_UNSAVED_AUDIO_RETENTION_HOURS ?? '').trim()
+  if (rawText === '') return DEFAULT_RETENTION_HOURS * 60 * 60 * 1000
+  const raw = Number(rawText)
+  const hours = Number.isFinite(raw)
+    ? Math.min(MAX_RETENTION_HOURS, Math.max(MIN_RETENTION_HOURS, raw))
+    : DEFAULT_RETENTION_HOURS
+  return hours * 60 * 60 * 1000
+}
+
+export function countChunkWavs(dirPath: string): number {
+  try {
+    return readdirSync(dirPath).filter(name => CHUNK_WAV_RE.test(name)).length
+  } catch {
+    return 0
+  }
+}
+
+function dirBytes(dirPath: string): number {
+  let total = 0
+  try {
+    for (const name of readdirSync(dirPath)) {
+      try { total += statSync(join(dirPath, name)).size } catch { /* skip */ }
+    }
+  } catch { /* empty */ }
+  return total
+}
+
+/** Move one session-audio dir into quarantine instead of deleting it.
+ *  Returns the quarantine path, or null when the move could not be made
+ *  (in which case the SOURCE IS LEFT IN PLACE — never deleted on failure). */
+export function quarantineSessionAudio(
+  sourceDir: string,
+  reason: string,
+  root: string = unsavedAudioRoot(),
+): string | null {
+  const sessionId = basename(sourceDir)
+  try {
+    if (!existsSync(sourceDir)) return null
+    mkdirSync(root, { recursive: true, mode: 0o700 })
+    let target = resolve(root, sessionId)
+    if (existsSync(target)) target = resolve(root, `${sessionId}.${Date.now()}`)
+    renameSync(sourceDir, target)
+    const manifest: QuarantineManifest = {
+      schemaVersion: 1,
+      sessionId,
+      quarantinedAt: new Date().toISOString(),
+      reason,
+      chunkFiles: countChunkWavs(target),
+      bytes: dirBytes(target),
+    }
+    try {
+      writeFileSync(resolve(target, QUARANTINE_MANIFEST), `${JSON.stringify(manifest)}\n`, {
+        encoding: 'utf8',
+        mode: 0o600,
+      })
+    } catch { /* manifest is observability; the audio move already succeeded */ }
+    return target
+  } catch {
+    // Rename failed (cross-device, permissions, race). Leave the source alone —
+    // a skipped purge is recoverable, a deleted capture is not.
+    return null
+  }
+}
+
+export type OrphanSweepAction =
+  | { dir: string; action: 'kept_live' }
+  | { dir: string; action: 'kept_preserved' }
+  | { dir: string; action: 'quarantined'; target: string }
+  | { dir: string; action: 'quarantine_failed' }
+  | { dir: string; action: 'deleted_empty' }
+
+/** Shared sweep for the boot path and the 60s interval. A directory that
+ *  still holds chunk audio is quarantined; only chunk-less directories are
+ *  deleted. A failed quarantine move keeps the source in place. */
+export function sweepOrphanedSessionAudio(
+  sessionAudioRoot: string,
+  opts: {
+    isLive: (sessionId: string) => boolean
+    hasFreshPreservedMarker: (dirPath: string) => boolean
+    reason: string
+    quarantineRoot?: string
+  },
+): OrphanSweepAction[] {
+  const actions: OrphanSweepAction[] = []
+  let entries: string[] = []
+  try {
+    entries = readdirSync(sessionAudioRoot)
+  } catch {
+    return actions
+  }
+  for (const dir of entries) {
+    const dirPath = resolve(sessionAudioRoot, dir)
+    try {
+      if (!statSync(dirPath).isDirectory()) continue
+    } catch { continue }
+    if (opts.isLive(dir)) { actions.push({ dir, action: 'kept_live' }); continue }
+    if (opts.hasFreshPreservedMarker(dirPath)) { actions.push({ dir, action: 'kept_preserved' }); continue }
+    if (countChunkWavs(dirPath) > 0) {
+      const target = quarantineSessionAudio(dirPath, opts.reason, opts.quarantineRoot)
+      actions.push(target
+        ? { dir, action: 'quarantined', target }
+        : { dir, action: 'quarantine_failed' })
+      continue
+    }
+    try {
+      rmSync(dirPath, { recursive: true, force: true })
+      actions.push({ dir, action: 'deleted_empty' })
+    } catch { /* next sweep retries */ }
+  }
+  return actions
+}
+
+function readManifest(dirPath: string): QuarantineManifest | null {
+  try {
+    const raw = JSON.parse(readFileSync(resolve(dirPath, QUARANTINE_MANIFEST), 'utf8')) as QuarantineManifest
+    if (raw?.schemaVersion !== 1 || typeof raw.sessionId !== 'string') return null
+    return raw
+  } catch {
+    return null
+  }
+}
+
+function quarantinedAtMs(dirPath: string, manifest: QuarantineManifest | null): number | null {
+  if (manifest) {
+    const parsed = Date.parse(manifest.quarantinedAt)
+    if (Number.isFinite(parsed)) return parsed
+  }
+  try {
+    return statSync(dirPath).mtimeMs
+  } catch {
+    return null
+  }
+}
+
+/** Everything currently in quarantine, newest first. Recovered captures are
+ *  flagged (they linger until the retention clock clears them) so health can
+ *  exclude them from the actionable count. */
+export function listUnsavedCaptures(
+  root: string = unsavedAudioRoot(),
+  retentionMs: number = unsavedAudioRetentionMs(),
+): UnsavedCapture[] {
+  const captures: UnsavedCapture[] = []
+  let entries: string[] = []
+  try {
+    entries = readdirSync(root)
+  } catch {
+    return captures
+  }
+  for (const dir of entries) {
+    const dirPath = resolve(root, dir)
+    try {
+      if (!statSync(dirPath).isDirectory()) continue
+    } catch { continue }
+    const manifest = readManifest(dirPath)
+    const atMs = quarantinedAtMs(dirPath, manifest)
+    captures.push({
+      sessionId: manifest?.sessionId ?? dir.replace(/\.\d+$/, ''),
+      dirName: dir,
+      quarantinedAt: atMs != null ? new Date(atMs).toISOString() : null,
+      ageHours: atMs != null ? Math.round(((Date.now() - atMs) / 3_600_000) * 10) / 10 : null,
+      chunkFiles: manifest?.chunkFiles ?? countChunkWavs(dirPath),
+      bytes: manifest?.bytes ?? dirBytes(dirPath),
+      reason: manifest?.reason ?? null,
+      expiresAt: atMs != null ? new Date(atMs + retentionMs).toISOString() : null,
+      recovered: existsSync(resolve(dirPath, RECOVERED_RECEIPT)),
+    })
+  }
+  captures.sort((a, b) => (b.quarantinedAt ?? '').localeCompare(a.quarantinedAt ?? ''))
+  return captures
+}
+
+/** Retention: quarantined captures past the clock are removed. This is the
+ *  ONLY place quarantined audio is ever deleted. */
+export function purgeExpiredQuarantine(
+  root: string = unsavedAudioRoot(),
+  retentionMs: number = unsavedAudioRetentionMs(),
+): string[] {
+  const purged: string[] = []
+  for (const capture of listUnsavedCaptures(root, retentionMs)) {
+    // Never delete a directory a recovery is actively decoding — a capture
+    // 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) {
+      try {
+        rmSync(resolve(root, capture.dirName), { recursive: true, force: true })
+        purged.push(capture.dirName)
+      } catch { /* next sweep retries */ }
+    }
+  }
+  return purged
+}
+
+/** Resolve the quarantine dir for a sessionId (exact dir or timestamp-suffixed). */
+export function findQuarantineDir(
+  sessionId: string,
+  root: string = unsavedAudioRoot(),
+): string | null {
+  const exact = resolve(root, sessionId)
+  if (existsSync(exact)) return exact
+  try {
+    for (const dir of readdirSync(root)) {
+      if (dir === sessionId || dir.startsWith(`${sessionId}.`)) {
+        const dirPath = resolve(root, dir)
+        if (statSync(dirPath).isDirectory()) return dirPath
+      }
+    }
+  } catch { /* fall through */ }
+  return null
+}
+
+// ── Active recovery registry ─────────────────────────────────────────────
+// In-memory, single-process (matches the sessions map's own scope). Two
+// consumers: purgeExpiredQuarantine skips dirs being recovered (a capture at
+// the retention boundary must not be deleted mid-decode), and meeting_sync
+// renders an active row so COS Control warns BEFORE committing an Update
+// Server drain into a 20-90 minute recovery it cannot see.
+
+const activeRecoveries = new Map<string, { sessionId: string; dirPath: string; startedAt: number }>()
+
+export function registerActiveRecovery(sessionId: string, dirPath: string): void {
+  activeRecoveries.set(basename(dirPath), { sessionId, dirPath, startedAt: Date.now() })
+}
+
+export function clearActiveRecovery(dirPath: string): void {
+  activeRecoveries.delete(basename(dirPath))
+}
+
+export function listActiveRecoveries(): Array<{ sessionId: string; dirPath: string; startedAt: number }> {
+  return [...activeRecoveries.values()]
+}
+
+export function isRecoveryActive(dirName: string): boolean {
+  return activeRecoveries.has(dirName)
+}
+
+export function markRecovered(dirPath: string, savedFilename: string): void {
+  try {
+    writeFileSync(
+      resolve(dirPath, RECOVERED_RECEIPT),
+      `${JSON.stringify({ schemaVersion: 1, recoveredAt: new Date().toISOString(), savedFilename })}\n`,
+      { encoding: 'utf8', mode: 0o600 },
+    )
+  } catch { /* receipt is best-effort; findBySessionId remains the true guard */ }
+}

package/server/lib/whisper-local.ts

@@ -12,7 +12,7 @@ import { writeFileSync, unlinkSync, existsSync, readFileSync } from 'node:fs'
 import { basename, join } from 'node:path'
 import { homedir } from 'node:os'
 import crypto from 'node:crypto'
-import { getVocabulary, getOwnerName } from './profile.js'
+import { getVocabulary, getOwnerName, getWhisperCorrections } from './profile.js'
 import { stripBrandUrls } from './hallucination-filter.js'
 import {
   batchHqMetalEnabled,
@@ -1022,22 +1022,15 @@ async function transcribeViaCLI(audioBuffer: Buffer, context?: string, isQuiet?:
 // Post-processing correction dictionary — deterministic fixes for names Whisper garbles.
 // Prompt biasing is probabilistic; regex replacement is guaranteed.
 // User-specific corrections loaded from .cos-profile.json "whisper_corrections" field.
-import { loadProfileField } from './profile.js'
-
 function buildCorrections(): Array<[RegExp, string]> {
   const corrections: Array<[RegExp, string]> = []
 
-  // Load user-configured corrections from profile
-  // Format: { "whisper_corrections": { "Soundalike": "YourName", ... } }
-  try {
-    const raw = loadProfileField('whisper_corrections', '')
-    if (raw) {
-      const map = JSON.parse(raw) as Record<string, string>
-      for (const [pattern, replacement] of Object.entries(map)) {
-        corrections.push([new RegExp(`\\b${pattern}\\b`, 'gi'), replacement])
-      }
-    }
-  } catch { /* invalid JSON — skip */ }
+  // 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, '\\$&')
+    corrections.push([new RegExp(`\\b${escaped}\\b`, 'gi'), replacement])
+  }
 
   return corrections
 }

package/server/lib/whisper-preview.ts

@@ -0,0 +1,243 @@
+// Adaptive provisional transcription. This sidecar is deliberately isolated
+// from the authoritative large-v3-turbo server in whisper-local.ts:
+//   small.en  -> cosmetic prompt preview only
+//   turbo     -> committed live transcript (unchanged)
+//   large-v3  -> HQ save/polish (unchanged)
+
+import { spawn } from 'node:child_process'
+import type { ChildProcess } from 'node:child_process'
+import { existsSync } from 'node:fs'
+import { homedir } from 'node:os'
+import { join } from 'node:path'
+import { applyCorrections, getWhisperHealth, transcribeLocal } from './whisper-local.js'
+import { getOwnerName, getVocabulary } from './profile.js'
+
+export type WhisperPreviewRequest = 'auto' | 'small.en' | 'turbo' | 'off'
+export type WhisperPreviewModel = 'small.en' | 'large-v3-turbo' | null
+export type WhisperPreviewReason =
+  | 'disabled'
+  | 'small_model_missing'
+  | 'preview_binary_missing'
+  | 'preview_port_busy'
+  | 'preview_start_failed'
+  | 'preview_sidecar_unavailable'
+  | 'turbo_unavailable'
+  | null
+
+export interface WhisperPreviewCapability {
+  requested: WhisperPreviewRequest
+  effectiveModel: WhisperPreviewModel
+  ready: boolean
+  backend: 'whisper-preview-server' | 'whisper-server' | null
+  degraded: boolean
+  reason: WhisperPreviewReason
+  committedModel: 'large-v3-turbo'
+}
+
+const MODEL_DIR = join(process.env.HOME ?? homedir(), '.local/share/whisper-models')
+export const WHISPER_SMALL_EN_MODEL_PATH = join(MODEL_DIR, 'ggml-small.en.bin')
+const VAD_MODEL_PATH = join(MODEL_DIR, 'ggml-silero-v5.1.2.bin')
+const VAD_ENABLED = process.env.COS_WHISPER_VAD !== '0'
+const WHISPER_SERVER = ['/opt/homebrew/bin/whisper-server', '/usr/local/bin/whisper-server']
+  .find(existsSync) ?? '/opt/homebrew/bin/whisper-server'
+const PREVIEW_PORT = 8177
+const PREVIEW_URL = `http://127.0.0.1:${PREVIEW_PORT}`
+
+let previewProcess: ChildProcess | null = null
+let previewAvailable = false
+let previewStarting = false
+let previewFailure: WhisperPreviewReason = null
+let warnedInvalidChoice = false
+
+export function normalizeWhisperPreviewRequest(raw?: string): WhisperPreviewRequest {
+  const value = raw?.trim().toLowerCase()
+  // Backward compatibility is deliberate: simply updating the server keeps
+  // the old Turbo preview. Guided Setup opts the user into Small.en.
+  if (!value) return 'turbo'
+  if (value === 'auto' || value === 'adaptive') return 'auto'
+  if (value === 'small' || value === 'small.en' || value === 'ggml-small.en.bin') return 'small.en'
+  if (value === 'turbo' || value === 'large-v3-turbo' || value === 'ggml-large-v3-turbo.bin') return 'turbo'
+  if (value === 'off' || value === 'disabled' || value === '0') return 'off'
+  return 'auto'
+}
+
+function requestedPreviewModel(): WhisperPreviewRequest {
+  const raw = process.env.COS_WHISPER_PREVIEW_MODEL
+    ?? process.env.COS_WHISPER_REALTIME_MODEL // migration alias for early private installs
+  const normalized = normalizeWhisperPreviewRequest(raw)
+  if (raw && normalized === 'auto' && !['auto', 'adaptive'].includes(raw.trim().toLowerCase()) && !warnedInvalidChoice) {
+    warnedInvalidChoice = true
+    console.warn(`[whisper-preview] Unknown model "${raw}"; using adaptive selection.`)
+  }
+  return normalized
+}
+
+function selectedPreviewModel(requested = requestedPreviewModel()): WhisperPreviewModel {
+  if (requested === 'off') return null
+  if (requested === 'turbo') return 'large-v3-turbo'
+  if (requested === 'small.en') return existsSync(WHISPER_SMALL_EN_MODEL_PATH) ? 'small.en' : 'large-v3-turbo'
+  return existsSync(WHISPER_SMALL_EN_MODEL_PATH) ? 'small.en' : 'large-v3-turbo'
+}
+
+export function getWhisperPreviewCapability(): WhisperPreviewCapability {
+  const requested = requestedPreviewModel()
+  if (requested === 'off') {
+    return {
+      requested, effectiveModel: null, ready: false, backend: null,
+      degraded: false, reason: 'disabled', committedModel: 'large-v3-turbo',
+    }
+  }
+
+  const smallPresent = existsSync(WHISPER_SMALL_EN_MODEL_PATH)
+  const selected = selectedPreviewModel(requested)
+  const turboReady = getWhisperHealth().server
+  if (selected === 'small.en' && previewAvailable) {
+    return {
+      requested, effectiveModel: 'small.en', ready: true,
+      backend: 'whisper-preview-server', degraded: false, reason: null,
+      committedModel: 'large-v3-turbo',
+    }
+  }
+
+  const smallWasExpected = requested === 'small.en' || (requested === 'auto' && smallPresent)
+  const reason: WhisperPreviewReason = requested === 'small.en' && !smallPresent
+    ? 'small_model_missing'
+    : smallWasExpected
+      ? (previewFailure ?? (previewStarting ? null : 'preview_sidecar_unavailable'))
+      : turboReady ? null : 'turbo_unavailable'
+  return {
+    requested,
+    effectiveModel: turboReady ? 'large-v3-turbo' : selected,
+    ready: turboReady,
+    backend: turboReady ? 'whisper-server' : null,
+    degraded: smallWasExpected,
+    reason,
+    committedModel: 'large-v3-turbo',
+  }
+}
+
+async function endpointReady(path: '/health' | '/inference', init?: RequestInit, timeoutMs = 1_000): Promise<Response> {
+  return fetch(`${PREVIEW_URL}${path}`, { ...init, signal: AbortSignal.timeout(timeoutMs) })
+}
+
+/** Start the optional small.en preview worker. Failure is cosmetic: committed
+ * Turbo and every recovery/finalization path stay untouched. */
+export async function startWhisperPreviewServer(): Promise<void> {
+  const requested = requestedPreviewModel()
+  if (selectedPreviewModel(requested) !== 'small.en' || previewProcess || previewAvailable || previewStarting) return
+  if (!existsSync(WHISPER_SMALL_EN_MODEL_PATH)) {
+    previewFailure = 'small_model_missing'
+    return
+  }
+  if (!existsSync(WHISPER_SERVER)) {
+    previewFailure = 'preview_binary_missing'
+    return
+  }
+
+  previewStarting = true
+  previewFailure = null
+  try {
+    try {
+      const occupied = await endpointReady('/health')
+      if (occupied.ok) {
+        previewFailure = 'preview_port_busy'
+        return
+      }
+    } catch { /* clear port is expected */ }
+
+    const args = [
+      '-m', WHISPER_SMALL_EN_MODEL_PATH,
+      '-t', '16',
+      '-l', 'en',
+      '-fa',
+      '--no-speech-thold', '0.7',
+      '--host', '127.0.0.1',
+      '--port', String(PREVIEW_PORT),
+    ]
+    if (VAD_ENABLED && existsSync(VAD_MODEL_PATH)) {
+      args.push('--vad', '--vad-model', VAD_MODEL_PATH)
+    }
+    const child = spawn(WHISPER_SERVER, args, { stdio: 'ignore', detached: false })
+    previewProcess = child
+    child.once('close', code => {
+      if (previewProcess !== child) return
+      previewProcess = null
+      previewAvailable = false
+      previewFailure = code === 0 ? 'preview_sidecar_unavailable' : 'preview_start_failed'
+    })
+    child.once('error', () => {
+      previewAvailable = false
+      previewFailure = 'preview_start_failed'
+    })
+
+    const deadline = Date.now() + 45_000
+    while (Date.now() < deadline) {
+      if (child.exitCode !== null || child.signalCode !== null) break
+      try {
+        const response = await endpointReady('/health', undefined, 1_000)
+        if (response.ok) {
+          previewAvailable = true
+          previewFailure = null
+          console.log('[whisper-preview] small.en ready for provisional text; committed text remains Turbo')
+          return
+        }
+      } catch { /* model still loading */ }
+      await new Promise(resolve => setTimeout(resolve, 1_000))
+    }
+    try { child.kill('SIGKILL') } catch { /* already exited */ }
+    if (previewProcess === child) previewProcess = null
+    previewFailure = 'preview_start_failed'
+  } finally {
+    previewStarting = false
+  }
+}
+
+export function stopWhisperPreviewServer(): void {
+  const child = previewProcess
+  previewProcess = null
+  previewAvailable = false
+  previewStarting = false
+  if (child) {
+    try { child.kill('SIGTERM') } catch { /* already exited */ }
+  }
+}
+
+function previewPrompt(): string {
+  const vocabulary = getVocabulary()
+  return vocabulary.length > 0
+    ? [getOwnerName(), ...vocabulary].join(', ')
+    : `${getOwnerName()}. COS Glasses. Even G2.`
+}
+
+async function transcribeViaPreviewServer(audioBuffer: Buffer): Promise<string> {
+  const formData = new FormData()
+  formData.append('file', new Blob([new Uint8Array(audioBuffer)], { type: 'audio/wav' }), 'recording.wav')
+  formData.append('response_format', 'json')
+  formData.append('prompt', previewPrompt())
+  formData.append('suppress_non_speech', 'true')
+  const response = await endpointReady('/inference', { method: 'POST', body: formData }, 5_000)
+  if (!response.ok) throw new Error(`preview server ${response.status}`)
+  const result = await response.json() as { text?: unknown }
+  if (typeof result.text !== 'string') throw new Error('preview server returned invalid text')
+  return applyCorrections(result.text.trim())
+}
+
+/** Cosmetic preview only. A small-worker failure falls through to the existing
+ * non-circuit Turbo decode and can never write committed transcript state. */
+export async function transcribeWhisperPreview(audioBuffer: Buffer): Promise<{
+  text: string
+  model: 'small.en' | 'large-v3-turbo'
+  backend: 'whisper-preview-server' | 'whisper-server'
+}> {
+  if (previewAvailable) {
+    try {
+      return { text: await transcribeViaPreviewServer(audioBuffer), model: 'small.en', backend: 'whisper-preview-server' }
+    } catch (error) {
+      previewAvailable = false
+      previewFailure = 'preview_sidecar_unavailable'
+      console.warn(`[whisper-preview] small.en preview failed; falling back to Turbo: ${error instanceof Error ? error.message : error}`)
+    }
+  }
+  const result = await transcribeLocal(audioBuffer, undefined, undefined, { affectsCircuit: false })
+  return { text: result.text, model: 'large-v3-turbo', backend: 'whisper-server' }
+}

package/server/routes/glossary.ts

@@ -13,7 +13,7 @@ import { errMsg } from '../lib/utils.js'
 import {
   getVocabulary,
   getNegativeRules,
-  loadProfileField,
+  getWhisperCorrections,
   updateProfileFields,
 } from '../lib/profile.js'
 import { resetDecoderCaches } from '../lib/whisper-local.js'
@@ -36,16 +36,7 @@ function looksLikeUrlEmailPath(s: string): boolean {
 }
 
 function readCorrections(): Record<string, string> {
-  try {
-    const raw = loadProfileField('whisper_corrections', '')
-    if (!raw) return {}
-    const parsed = JSON.parse(raw)
-    return (parsed && typeof parsed === 'object' && !Array.isArray(parsed))
-      ? parsed as Record<string, string>
-      : {}
-  } catch {
-    return {}
-  }
+  return getWhisperCorrections()
 }
 
 function currentGlossary() {