@tychenjiajun/pi-voice 0.7.0 → 0.8.0

package/src/settings-menu.ts

@@ -3,8 +3,10 @@ import type {
   ExtensionContext,
 } from "@earendil-works/pi-coding-agent";
 import { truncateToWidth } from "@earendil-works/pi-tui";
+import { downloadCatalogModel, pendingDownloads } from "./models.js";
 import { microphonePermission, type Permission } from "./audio.js";
-import { displayLanguage, getCatalogModel } from "./catalog.js";
+import { displayLanguage, getCatalogModel, LANGUAGE_DETECTION_MODEL } from "./catalog.js";
+import { autoLanguagePolicy } from "./language-detection-policy.js";
 import { chineseOutputSummary, isChineseLanguage } from "./chinese.js";
 import {
   chooseLanguages,
@@ -19,6 +21,7 @@ import {
 import { runModelSelection } from "./onboarding.js";
 import { chooseBackendType, promptRemoteBackend, warnMissingApiKey } from "./remote-asr.js";
 import {
+  settingsWithPreferredLanguages,
   writeSettings,
   type BackendSettings,
   type ChineseOutput,
@@ -96,6 +99,29 @@ function polishSummary(polishEnabled: boolean | undefined, model: PolishModelRef
   return model ? `${model.provider}/${model.id}` : "Pi's current model";
 }
 
+let detectorDownload: Promise<void> | undefined;
+
+/**
+ * Fetch the language detector in the background; until it lands, Auto detect
+ * transcribes as `fallback`.
+ */
+function downloadLanguageDetector(ctx: ExtensionContext, fallback: string): void {
+  if (detectorDownload) return;
+  ctx.ui.notify("Downloading language detector…", "info");
+  detectorDownload = downloadCatalogModel(LANGUAGE_DETECTION_MODEL)
+    .then(
+      () => ctx.ui.notify("Language detector downloaded. Auto detect is ready.", "info"),
+      (error: unknown) => ctx.ui.notify(
+        `Couldn't download the language detector (${error instanceof Error ? error.message : String(error)}). ` +
+        `Auto detect will use ${displayLanguage(fallback)} until it's downloaded. ` +
+        "Choose Auto detect again to retry the download.",
+        "error",
+      ),
+    )
+    .catch(() => undefined) // The session may be gone by the time it settles.
+    .finally(() => { detectorDownload = undefined; });
+}
+
 export function settingsHomeChoices(
   configured: TranscribeSettings,
   permission: Permission,
@@ -533,7 +559,7 @@ export async function showSettingsMenu(
       await saveUpdatedSettings(
         ctx,
         configured,
-        { ...configured, preferredLanguages: selection.languages },
+        settingsWithPreferredLanguages(configured, selection.languages),
         "Preferred languages saved",
       );
       continue;
@@ -550,10 +576,12 @@ export async function showSettingsMenu(
         backend: configured.backend,
         polishEnabled: configured.polishEnabled,
         polishModel: configured.polishModel,
+        voiceActivityDetection: configured.voiceActivityDetection,
+        longformChunking: configured.longformChunking,
         postActivation: "stay",
         onPreferredLanguagesChange: async (preferredLanguages) => {
           if (languagesEqual(preferredLanguages, configured.preferredLanguages)) return;
-          const next = { ...configured, preferredLanguages };
+          const next = settingsWithPreferredLanguages(configured, preferredLanguages);
           await writeSettings(next);
           Object.assign(configured, next);
           ctx.ui.notify("Preferred languages saved", "info");
@@ -575,15 +603,18 @@ export async function showSettingsMenu(
 
     if (action === "transcription-language") {
       const transcriptionLanguage = await chooseTranscriptionLanguage(ctx, configured);
-      if (
-        !transcriptionLanguage ||
-        transcriptionLanguage === configured.transcriptionLanguage
-      ) {
-        continue;
-      }
+      if (!transcriptionLanguage) continue;
       const model = configured.model
         ? getCatalogModel(configured.model.id)
         : undefined;
+      // Auto needs the detector on disk; choosing Auto again retries a failure.
+      if (model) {
+        const policy = autoLanguagePolicy(model, configured.preferredLanguages);
+        if (transcriptionLanguage === "auto" && policy.kind === "detect" && pendingDownloads(model, true).length) {
+          downloadLanguageDetector(ctx, policy.languages[0]!);
+        }
+      }
+      if (transcriptionLanguage === configured.transcriptionLanguage) continue;
       const summary = model
         ? transcriptionLanguageSummary(transcriptionLanguage, model)
         : transcriptionLanguage;

package/src/settings.ts

@@ -5,6 +5,7 @@ import {
   resolveModelLanguage,
   type CatalogModel,
 } from "./catalog.js";
+import { autoLanguagePolicy } from "./language-detection-policy.js";
 import { DEFAULT_SHORTCUT, normalizeShortcut } from "./shortcut-core.js";
 import { legacySettingsPath, settingsPath } from "./settings-path.js";
 
@@ -42,7 +43,7 @@ function defaultChineseOutput(): ChineseOutput {
   return "simplified";
 }
 
-/** "auto" asks a capable model to detect the language; otherwise this is a language code. */
+/** "auto" uses native detection or the external detector; otherwise a language code. */
 export type TranscriptionLanguage = string;
 
 export type TranscribeSettings = {
@@ -57,6 +58,10 @@ export type TranscribeSettings = {
   polishEnabled?: boolean;
   /** Optional post-processing model override; absent uses the agent's current model. */
   polishModel?: PolishModelRef;
+  /** Transcribe only the speech in a recording, not its silence and noise. */
+  voiceActivityDetection: boolean;
+  /** Hidden, settings.json only: false decodes long audio in one piece, without voice activity cuts. */
+  longformChunking: boolean;
   /**
    * The local catalog model. Present only in local mode (backend
    * `transcribe-cpp`); remote mode stores no local model.
@@ -112,7 +117,7 @@ function defaultTranscriptionLanguage(
   model: CatalogModel,
   preferredLanguages: readonly string[] = [],
 ): TranscriptionLanguage {
-  if (model.capabilities.languageDetection) return "auto";
+  if (autoLanguagePolicy(model, preferredLanguages).kind !== "unsupported") return "auto";
   for (const language of preferredLanguages) {
     const code = resolveModelLanguage(model, language);
     if (code) return code;
@@ -127,7 +132,9 @@ export function transcriptionLanguageForModel(
   preferredLanguages: readonly string[] = [],
 ): TranscriptionLanguage {
   if (typeof value === "string") {
-    if (value === "auto" && model.capabilities.languageDetection) return value;
+    if (value === "auto" && autoLanguagePolicy(model, preferredLanguages).kind !== "unsupported") {
+      return value;
+    }
     if (value !== "auto") {
       const code = resolveModelLanguage(model, value);
       if (code) return code;
@@ -220,6 +227,8 @@ function validateSettings(value: unknown): TranscribeSettings | undefined {
     microphone,
     polishEnabled: value.polishEnabled === true,
     ...(polishModel ? { polishModel } : {}),
+    voiceActivityDetection: value.voiceActivityDetection !== false,
+    longformChunking: value.longformChunking !== false,
     ...(backend.type === "transcribe-cpp"
       ? { model: { source: "catalog" as const, id: selected!.id, path: selected!.path } }
       : {}),
@@ -293,6 +302,8 @@ type ModelSettingsOptions = {
   polishEnabled?: boolean;
   /** Preserved across model re-selection; absent means the agent's current model. */
   polishModel?: PolishModelRef;
+  voiceActivityDetection?: boolean;
+  longformChunking?: boolean;
 };
 
 export function settingsForModel(
@@ -323,10 +334,13 @@ export function settingsForModel(
     microphone: { ...(options.microphone ?? DEFAULT_MICROPHONE) },
     polishEnabled: options.polishEnabled ?? false,
     ...(options.polishModel ? { polishModel: options.polishModel } : {}),
+    voiceActivityDetection: options.voiceActivityDetection ?? true,
+    longformChunking: options.longformChunking ?? true,
     model: { source: "catalog", id: modelId, path: modelPath },
   };
 }
 
+
 type RemoteSettingsOptions = Omit<ModelSettingsOptions, "backend"> & {
   backend: Extract<BackendSettings, { type: "openai-asr" }>;
 };
@@ -348,6 +362,8 @@ export function settingsRemoteOnly(options: RemoteSettingsOptions): TranscribeSe
     microphone: { ...(options.microphone ?? DEFAULT_MICROPHONE) },
     polishEnabled: options.polishEnabled ?? false,
     ...(options.polishModel ? { polishModel: options.polishModel } : {}),
+    voiceActivityDetection: options.voiceActivityDetection ?? true,
+    longformChunking: options.longformChunking ?? true,
   };
 }
 
@@ -356,3 +372,19 @@ export function transcriptionModelLabel(settings: TranscribeSettings): string {
   if (settings.model) return settings.model.id;
   return settings.backend.type === "openai-asr" ? settings.backend.model : "none";
 }
+
+/** Preference edits re-resolve the language, so Auto never outlives support for it. */
+export function settingsWithPreferredLanguages(
+  current: TranscribeSettings,
+  preferredLanguages: readonly string[],
+): TranscribeSettings {
+  // Remote settings carry no local model, so there is no per-model language to
+  // re-resolve; the endpoint detects the language itself.
+  if (!current.model) {
+    return {
+      ...current,
+      preferredLanguages: [...new Set(preferredLanguages.map(languageIdentity))],
+    };
+  }
+  return settingsForModel(current.model.id, current.model.path, { ...current, preferredLanguages });
+}

package/src/transcription-service.ts

@@ -1,4 +1,21 @@
+import { LANGUAGE_DETECTION_MODEL, displayLanguage, getCatalogModel } from "./catalog.js";
+import { isChineseLanguage } from "./chinese.js";
+import {
+  ChunkedDictationStream,
+  ChunkedTranscriber,
+  chunksTranscription,
+  MAX_CHUNK_SAMPLES,
+  type ChunkDecoder,
+} from "./chunking.js";
 import { Deferred } from "./deferred.js";
+import {
+  detectLanguage,
+  missingDetectorWarning,
+  settingsLanguagePolicy,
+  undetectablePreferences,
+  type AutoLanguagePolicy,
+} from "./language-detection-policy.js";
+import { describeError, log } from "./log.js";
 import type { TranscribeSettings } from "./settings.js";
 import type {
   DictationStream,
@@ -6,11 +23,24 @@ import type {
   TranscriptionOptions,
 } from "./transcription.js";
 
+/** A transcript, plus any language identification fallback or limitation. */
+export type Transcript = { text: string; warning?: string };
+
+/** Silero's probability for each 512-sample frame of a whole clip. */
+export type ClipScorer = (pcm: Float32Array, signal: AbortSignal) => Promise<readonly number[]>;
+
+/** Audio fed during recording, with its Silero frame probabilities when it has them. */
+type FedChunk = { pcm: Float32Array; probs?: readonly number[] };
+
+/** Decodes a take's audio in the language chosen from its start, once. */
+type TakeDecoder = { decode: ChunkDecoder; readonly warning: string | undefined };
+
 type TranscriptionJob = {
   settings: TranscribeSettings;
+  policy: AutoLanguagePolicy;
   pcm: Float32Array;
   signal?: AbortSignal;
-  resolve: (text: string) => void;
+  resolve: (transcript: Transcript) => void;
   reject: (error: unknown) => void;
   started: boolean;
   settled: boolean;
@@ -19,6 +49,7 @@ type TranscriptionJob = {
 
 type ReservationState = {
   settings: TranscribeSettings;
+  policy: AutoLanguagePolicy;
   accepting: boolean;
   submitted: boolean;
   cancelled: boolean;
@@ -27,12 +58,14 @@ type ReservationState = {
   ready: Deferred;
   /** Resolves when recording ends, whether by submit or cancel. */
   submission: Deferred;
-  result: Deferred<string>;
+  result: Deferred<Transcript>;
   fullPcm?: Float32Array;
   signal?: AbortSignal;
   removeAbortListener?: () => void;
-  chunks: Float32Array[];
+  chunks: FedChunk[];
   stream?: DictationStream;
+  /** The take's chunked stream, kept after reset until its decoding settles. */
+  chunked?: { stream: ChunkedDictationStream; decoder: TakeDecoder };
   drain?: Promise<void>;
   streamUnavailable: boolean;
   streamError?: unknown;
@@ -40,8 +73,8 @@ type ReservationState = {
 
 export type DictationReservation = {
   readonly ready: Promise<void>;
-  feed(chunk: Float32Array): void;
-  submit(pcm: Float32Array, signal?: AbortSignal): Promise<string>;
+  feed(chunk: Float32Array, probs?: readonly number[]): void;
+  submit(pcm: Float32Array, signal?: AbortSignal): Promise<Transcript>;
   cancel(): void;
 };
 
@@ -52,11 +85,12 @@ type ReusableBackend = Pick<
   startStream?: (
     options?: TranscriptionOptions,
   ) => Promise<DictationStream | undefined>;
+  identifyLanguage?: TranscribeCppBackend["identifyLanguage"];
 };
 
 type BackendFactory = (
   backendKey: string,
-  settings: TranscribeSettings,
+  settings?: TranscribeSettings,
 ) => ReusableBackend | Promise<ReusableBackend>;
 
 /** Local backends key on the model file; remote keys on endpoint identity. */
@@ -87,18 +121,28 @@ function cancellationError(state: ReservationState): Error {
 
 function transcriptionOptions(
   settings: TranscribeSettings,
+  language: string | undefined,
   signal?: AbortSignal,
 ): TranscriptionOptions {
   return {
     signal,
-    language:
-      settings.transcriptionLanguage === "auto"
-        ? undefined
-        : settings.transcriptionLanguage,
+    language,
     chineseOutput: settings.chineseOutput,
+    chineseEnabled: isChineseLanguage(settings.transcriptionLanguage) ||
+      settings.preferredLanguages.some(isChineseLanguage),
   };
 }
 
+function fixedLanguage(policy: AutoLanguagePolicy): string | undefined {
+  return policy.kind === "fixed" ? policy.language : undefined;
+}
+
+async function cachedDetectorPath(): Promise<string | undefined> {
+  // Keeps Hugging Face modules off the path of every other take.
+  const { findCachedCatalogModel } = await import("./models.js");
+  return findCachedCatalogModel(LANGUAGE_DETECTION_MODEL)?.path;
+}
+
 /** Owns the loaded model and schedules dictation ahead of queued file jobs. */
 export class TranscriptionService {
   private backend: ReusableBackend | undefined;
@@ -110,31 +154,42 @@ export class TranscriptionService {
   private loop: Promise<void> | undefined;
   private shuttingDown = false;
   private readonly shutdownController = new AbortController();
+  /** The language detector, loaded on demand like the transcription model. */
+  private detector: ReusableBackend | undefined;
+  private detectorLoading: Promise<ReusableBackend> | undefined;
+  /** A missing detector warns on the first take only, not every take. */
+  private missingDetectorWarned = false;
 
   constructor(
-    private readonly createBackend: BackendFactory = async (_key, settings) => {
-      if (settings.backend.type === "openai-asr") {
+    private readonly createBackend: BackendFactory = async (key, settings) => {
+      if (settings?.backend.type === "openai-asr") {
         const { OpenAIAsrBackend } = await import("./openai-asr.js");
         return new OpenAIAsrBackend(settings.backend);
       }
       const { TranscribeCppBackend } = await import("./transcription.js");
-      return new TranscribeCppBackend(requireLocalModel(settings).path);
+      // The key is the model file path for local backends, including the
+      // language detector (loaded without settings).
+      return new TranscribeCppBackend(key);
     },
+    /** Scores long clips for chunking; without it they decode in one piece. */
+    private readonly scoreClip?: ClipScorer,
   ) {}
 
   reserveDictation(settings: TranscribeSettings): DictationReservation {
     if (this.shuttingDown) throw new Error("Pi Voice is shutting down");
     if (this.reservation) throw new Error("A dictation reservation is already active");
 
+    const policy = settingsLanguagePolicy(settings);
     const state: ReservationState = {
       settings,
+      policy,
       accepting: true,
       submitted: false,
       cancelled: false,
       started: false,
       ready: new Deferred(),
       submission: new Deferred(),
-      result: new Deferred<string>(),
+      result: new Deferred<Transcript>(),
       chunks: [],
       streamUnavailable: false,
     };
@@ -147,14 +202,14 @@ export class TranscriptionService {
 
     return {
       ready: state.ready.promise,
-      feed: (chunk) => {
+      feed: (chunk, probs) => {
         if (
           !state.accepting ||
           state.streamUnavailable ||
           state.streamError !== undefined ||
           chunk.length === 0
         ) return;
-        state.chunks.push(chunk);
+        state.chunks.push({ pcm: chunk, probs });
         this.startDrain(state);
       },
       submit: (pcm, signal) => {
@@ -196,13 +251,14 @@ export class TranscriptionService {
     settings: TranscribeSettings,
     pcm: Float32Array,
     signal?: AbortSignal,
-  ): Promise<string> {
+  ): Promise<Transcript> {
     if (this.shuttingDown) return Promise.reject(new Error("Pi Voice is shutting down"));
     if (signal?.aborted) return Promise.reject(abortError(signal));
 
-    const result = new Promise<string>((resolve, reject) => {
+    const result = new Promise<Transcript>((resolve, reject) => {
       const job: TranscriptionJob = {
         settings,
+        policy: settingsLanguagePolicy(settings),
         pcm,
         signal,
         resolve,
@@ -283,7 +339,7 @@ export class TranscriptionService {
     ) {
       const chunk = state.chunks.shift()!;
       try {
-        await stream.feed(chunk);
+        await stream.feed(chunk.pcm, chunk.probs);
       } catch (error) {
         state.streamError = error;
         state.chunks.length = 0;
@@ -345,8 +401,7 @@ export class TranscriptionService {
         continue;
       }
 
-      // A dispose failure here would otherwise reject the loop promise unobserved.
-      await this.unloadModel().catch(() => undefined);
+      await this.unloadAll();
       return;
     }
   }
@@ -355,6 +410,8 @@ export class TranscriptionService {
     try {
       await this.runReservationWork(state);
     } finally {
+      // A reset chunked stream may still be decoding: keep the model until it stops.
+      await state.chunked?.stream.idle();
       state.removeAbortListener?.();
       this.reservationStates.delete(state);
     }
@@ -394,13 +451,20 @@ export class TranscriptionService {
       return;
     }
 
-    // If recording already ended while the model loaded (or while the stream
-    // opened), avoid replaying the complete clip through a newly opened stream
-    // and use the batch path.
-    if (!state.submitted && backend.startStream) {
+    if (chunksTranscription(state.settings)) {
+      // Only buffers until a chunk is due, so a take that already ended still uses it.
+      const abort = new AbortController();
+      const decoder = this.takeDecoder(backend, state.settings, state.policy, this.withShutdown(abort.signal));
+      const stream = new ChunkedDictationStream(decoder.decode, () => abort.abort(cancellationError(state)));
+      state.chunked = { stream, decoder };
+      state.stream = stream;
+    } else if (!state.submitted && !state.streamUnavailable && backend.startStream) {
+      // If recording already ended while the model loaded (or while the stream
+      // opened), avoid replaying the complete clip through a newly opened
+      // stream and use the batch path.
       try {
         const stream = await backend.startStream(
-          transcriptionOptions(state.settings),
+          transcriptionOptions(state.settings, fixedLanguage(state.policy)),
         );
         if (stream && state.submitted) {
           stream.reset();
@@ -425,6 +489,8 @@ export class TranscriptionService {
 
     state.ready.resolve();
     this.startDrain(state);
+    // Warm the detector while the user speaks; a failure resurfaces at detection.
+    if (state.policy.kind === "detect") await this.ensureDetector().catch(() => undefined);
     await state.submission.promise;
 
     if (!state.submitted) {
@@ -446,9 +512,10 @@ export class TranscriptionService {
       // streaming existed, instead of finalizing a stream that was never fed.
       if (stream && state.streamError === undefined && pcm.length > 0) {
         try {
-          const text = await stream.finalize();
+          const text = await stream.finalize(pcm);
           state.signal?.throwIfAborted();
-          state.result.resolve(text);
+          const warning = state.chunked?.stream === stream ? state.chunked.decoder.warning : undefined;
+          state.result.resolve(warning ? { text, warning } : { text });
           return;
         } catch (error) {
           if (state.signal?.aborted) throw abortError(state.signal);
@@ -461,16 +528,18 @@ export class TranscriptionService {
         }
       }
 
-      // Stream setup/feed/finalize failure: reset precedes the batch fallback.
+      // Stream setup/feed/finalize failure: reset precedes the batch fallback,
+      // and a live chunk still decoding must stop before the model is reused.
+      await state.chunked?.stream.idle();
       this.resetStream(state);
       state.chunks.length = 0;
-      const text = await this.transcribeBatch(
+      state.result.resolve(await this.transcribeBatch(
         backend,
         state.settings,
+        state.policy,
         pcm,
         this.withShutdown(state.signal),
-      );
-      state.result.resolve(text);
+      ));
     } catch (error) {
       this.resetStream(state);
       state.result.reject(
@@ -489,11 +558,87 @@ export class TranscriptionService {
   private async transcribeBatch(
     backend: ReusableBackend,
     settings: TranscribeSettings,
+    policy: AutoLanguagePolicy,
     pcm: Float32Array,
     signal: AbortSignal,
-  ): Promise<string> {
+  ): Promise<Transcript> {
     signal.throwIfAborted();
-    return backend.transcribe(pcm, transcriptionOptions(settings, signal));
+    const decoder = this.takeDecoder(backend, settings, policy, signal);
+    let text: string;
+    if (chunksTranscription(settings) && pcm.length > MAX_CHUNK_SAMPLES) {
+      const transcriber = new ChunkedTranscriber(decoder.decode);
+      transcriber.push(pcm, await this.scoreLongClip(pcm, signal));
+      text = await transcriber.finish();
+    } else {
+      text = await decoder.decode(pcm, pcm);
+    }
+    const warning = decoder.warning;
+    return warning ? { text, warning } : { text };
+  }
+
+  /** Scores for a clip too long for one chunk; undefined decodes it in one piece. */
+  private async scoreLongClip(pcm: Float32Array, signal: AbortSignal): Promise<readonly number[] | undefined> {
+    if (!this.scoreClip) {
+      log.warn("no voice activity detection; decoding the clip in one piece");
+      return undefined;
+    }
+    try {
+      return await this.scoreClip(pcm, signal);
+    } catch (error) {
+      signal.throwIfAborted();
+      log.warn(`voice activity detection failed, decoding the clip in one piece: ${describeError(error)}`);
+      return undefined;
+    }
+  }
+
+  /**
+   * A decoder for one take or file: the first chunk chooses the language from
+   * the start of the clip, and every chunk uses it.
+   */
+  private takeDecoder(
+    backend: ReusableBackend,
+    settings: TranscribeSettings,
+    policy: AutoLanguagePolicy,
+    signal: AbortSignal,
+  ): TakeDecoder {
+    let choice: Promise<{ language?: string; warning?: string }> | undefined;
+    let warning: string | undefined;
+    return {
+      decode: async (chunk, clip) => {
+        signal.throwIfAborted();
+        const chosen = await (choice ??= this.chooseLanguage(settings, policy, clip, signal));
+        warning = chosen.warning;
+        signal.throwIfAborted();
+        return backend.transcribe(chunk, transcriptionOptions(settings, chosen.language, signal));
+      },
+      get warning() { return warning; },
+    };
+  }
+
+  private async chooseLanguage(
+    settings: TranscribeSettings,
+    policy: AutoLanguagePolicy,
+    clip: Float32Array,
+    signal: AbortSignal,
+  ): Promise<{ language?: string; warning?: string }> {
+    if (policy.kind === "detect" && !this.detector && !(await cachedDetectorPath())) {
+      const language = policy.languages[0]!;
+      const warning = this.missingDetectorWarned ? undefined : missingDetectorWarning(language);
+      this.missingDetectorWarned = true;
+      return { language, warning };
+    }
+    if (policy.kind === "detect") {
+      return detectLanguage(policy, clip, async (head, allowed) =>
+        (await this.ensureDetector()).identifyLanguage!(head, allowed, signal));
+    }
+    if (policy.kind === "unsupported") {
+      // Settings normalization drops Auto first; this guards stale settings.
+      const model = settings.model ? getCatalogModel(settings.model.id) : undefined;
+      const skipped = model ? undetectablePreferences(model, settings.preferredLanguages) : [];
+      const which = skipped.length ? ` (${skipped.map(displayLanguage).join(", ")})` : "";
+      throw new Error(`Auto detect doesn't work with your current languages${which}. Choose a language in /voice-settings.`);
+    }
+    return { language: fixedLanguage(policy) };
   }
 
   private async runJob(job: TranscriptionJob): Promise<void> {
@@ -504,13 +649,26 @@ export class TranscriptionService {
     try {
       signal.throwIfAborted();
       const backend = await this.ensureBackend(job.settings);
-      const text = await this.transcribeBatch(backend, job.settings, job.pcm, signal);
-      this.settleJob(job, () => job.resolve(text));
+      const transcript = await this.transcribeBatch(backend, job.settings, job.policy, job.pcm, signal);
+      this.settleJob(job, () => job.resolve(transcript));
     } catch (error) {
       this.settleJob(job, () => job.reject(error));
     }
   }
 
+  /** Concurrent callers (prewarm, a live chunk) share one load. */
+  private ensureDetector(): Promise<ReusableBackend> {
+    return (this.detectorLoading ??= (async () => {
+      if (!this.detector) {
+        const path = await cachedDetectorPath();
+        if (!path) throw new Error("the language detector isn't downloaded");
+        this.detector = await this.createBackend(path);
+      }
+      await this.detector.prepare();
+      return this.detector;
+    })().finally(() => { this.detectorLoading = undefined; }));
+  }
+
   private async ensureBackend(settings: TranscribeSettings): Promise<ReusableBackend> {
     const key = backendKeyFor(settings);
     if (this.backend && this.backendKey === key) {
@@ -543,6 +701,16 @@ export class TranscriptionService {
     await backend.dispose();
   }
 
+  /** Never rejects: a dispose failure would otherwise go unobserved. */
+  private async unloadAll(): Promise<void> {
+    const detector = this.detector;
+    this.detector = undefined;
+    await Promise.all([
+      this.unloadModel().catch(() => undefined),
+      detector?.dispose().catch(() => undefined),
+    ]);
+  }
+
   async shutdown(): Promise<void> {
     if (!this.shuttingDown) {
       this.shuttingDown = true;
@@ -567,6 +735,6 @@ export class TranscriptionService {
 
     await this.loop?.catch(() => undefined);
     this.reservationStates.clear();
-    await this.unloadModel().catch(() => undefined);
+    await this.unloadAll();
   }
 }