Skip to content

Voice-to-text dictation app with local (Nvidia Parakeet/Whisper) and cloud models (BYOK). Privacy-first and available cross-platform.

92.6 KB
Raw Blame
const test = require("node:test");
const assert = require("node:assert/strict");
const { once } = require("node:events");
const { WebSocketServer } = require("ws");
const { OrukeetStreaming } = require("../../src/helpers/orukeetStreaming");
const { loadAudioManager } = require("./harness/audioManager");

async function loadManagerClass(t, mockModules) {
  const { AudioManager } = await loadAudioManager(t, {
    cachePrefix: "openwhispr-streaming-finalization-test-",
    settingsKey: "__streamingFinalizationSettings",
    settings: {
      useLocalWhisper: false,
      transcriptionMode: "providers",
      cloudTranscriptionMode: "byok",
      cloudTranscriptionProvider: "openai",
    },
    mockModules,
  });
  return AudioManager;
}

function createFinalizingManager(AudioManager) {
  const states = [];
  let providerStopCalls = 0;
  const manager = Object.assign(Object.create(AudioManager.prototype), {
    isRecording: true,
    isProcessing: false,
    isStreaming: true,
    streamingStartInProgress: false,
    _streamingStartSettlementWaiters: [],
    stopRequestedDuringStreamingStart: false,
    recordingStartTime: Date.now(),
    _streamingStopPromise: null,
    _streamingStopMode: null,
    _streamingCancellationGeneration: 0,
    _activeTranscriptionAbortController: null,
    _streamingSessionGeneration: 7,
    _activeStreamingSessionId: 7,
    _streamingMicSwapPromise: null,
    streamingFinalText: "",
    streamingPartialText: "",
    streamingTextBump: null,
    streamingTextDebounce: null,
    streamingCleanupFns: [],
    streamingProcessor: null,
    streamingSource: null,
    streamingAnalyser: null,
    streamingAudioContext: null,
    streamingStream: null,
    streamingFallbackRecorder: null,
    streamingFallbackChunks: [],
    _streamingFallbackSegments: [],
    pendingAssistantConversation: null,
    pendingSelectionEdit: null,
    micRecovery: { stop() {} },
    finishStreamingFallbackSegment: async () => null,
    mergeRecordedSegments: async () => null,
    getLargestRecordedSegment: () => null,
    awaitStreamingTextSettled: async () => {},
    getStreamingProvider: () => ({
      awaitsFinalTranscript: true,
      finalize() {},
      async stop() {
        providerStopCalls += 1;
        return { success: true };
      },
    }),
    getEffectiveSttLanguage: () => "auto",
    getStreamingProviderName: () => "openai",
    shouldUseStreaming: () => false,
    isRecordingAllowedByPolicy: () => true,
    onStateChange: (state) => states.push(state),
    onTranscriptionComplete() {},
  });
  return { manager, states, getProviderStopCalls: () => providerStopCalls };
}

test("streamed selection failures keep local error parameters and recovery details without publishing text", async (t) => {
  const AudioManager = await loadManagerClass(t, {
    "/config/prompts": "export const resolvePrompt = () => 'agent prompt';",
  });
  Object.assign(globalThis.__streamingFinalizationSettings, {
    useDictationAgent: true,
    dictationAgentMode: "local",
    dictationAgentModel: "local-model",
  });
  const { manager } = createFinalizingManager(AudioManager);
  const errors = [];
  const published = [];
  manager.streamingFinalText = "replace this";
  manager.voiceAgentRequested = true;
  manager.consumeScreenContext = async () => null;
  const fields = {
    code: "CONTEXT_TOO_LARGE",
    messageKey: "models.errors.contextTooLarge",
    messageParams: { model: "Qwen 3.5 2B", needed: 18000, max: 16384 },
    surface: "llm",
    settingsTarget: "dictationAgent",
    technicalDetails: { model: "local-model" },
  };
  manager.processAgentCommand = async () => {
    throw Object.assign(new Error("too long"), fields, { selectionEditFatal: true });
  };
  const saved = [];
  manager.saveFailedTranscription = async (...args) => {
    saved.push(args);
  };
  manager.onError = (error) => errors.push(error);
  manager.onTranscriptionComplete = (result) => published.push(result);
  assert.equal(await manager.stopStreamingRecording(), false);
  assert.equal(errors.length, 1);
  for (const [key, value] of Object.entries(fields)) assert.deepEqual(errors[0][key], value);
  assert.equal(errors[0].selectionEditFatal, true);
  assert.equal(errors[0].transcript, "replace this");
  assert.deepEqual(published, []);
  assert.equal(manager.pendingSelectionEdit, null);
  // The streamed transcript is kept in a failed history entry, as batch keeps it (#2676).
  assert.equal(saved.length, 1);
  assert.equal(saved[0][1], "CONTEXT_TOO_LARGE");
  assert.deepEqual(saved[0][3], { transcript: "replace this" });
});

test("streaming finalization is immediately processing and cannot start another session", async (t) => {
  const AudioManager = await loadManagerClass(t);
  const { manager, states, getProviderStopCalls } = createFinalizingManager(AudioManager);

  const firstStop = manager.stopStreamingRecording();

  assert.equal(manager.isProcessing, true);
  assert.equal(manager.getState().isFinalizingStreaming, true);
  assert.deepEqual(states[0], {
    isRecording: false,
    isProcessing: true,
    isStreaming: false,
  });

  assert.equal(await manager.startStreamingRecording(), false);
  const duplicateStop = manager.stopStreamingRecording();
  assert.deepEqual(await Promise.all([firstStop, duplicateStop]), [true, true]);

  assert.equal(getProviderStopCalls(), 1);
  assert.equal(manager.isProcessing, false);
  assert.equal(manager.getState().isFinalizingStreaming, false);
  assert.equal(states.filter((state) => state.isProcessing).length, 1);
  assert.deepEqual(states.at(-1), {
    isRecording: false,
    isProcessing: false,
    isStreaming: false,
  });
});

test("streaming silence publishes its empty outcome only after processing settles", async (t) => {
  const AudioManager = await loadManagerClass(t);
  const { manager } = createFinalizingManager(AudioManager);
  const order = [];
  manager.onStateChange = (state) => {
    order.push(state.isProcessing ? "processing" : "idle");
  };
  manager.onTranscriptionComplete = (result) => {
    order.push(result.text === "" ? "empty" : "transcript");
  };

  await manager.stopStreamingRecording();

  assert.deepEqual(order, ["processing", "idle", "empty"]);
});

test("streaming completion keeps the recording occurrence time", async (t) => {
  const AudioManager = await loadManagerClass(t);
  const { manager } = createFinalizingManager(AudioManager);
  globalThis.window.dispatchEvent = () => true;
  const recordingStartedAt = Date.parse("2026-09-02T14:00:00.000Z");
  let completion;
  manager.recordingStartTime = recordingStartedAt;
  manager.streamingFinalText = "same event";
  manager.finalizeChineseScript = async (text) => text;
  manager.onTranscriptionComplete = (result) => {
    completion = result;
  };

  await manager.stopStreamingRecording();

  assert.equal(completion.analyticsOccurredAt, new Date(recordingStartedAt).toISOString());
});

// Starts a stream on `providerName` under `startMode`, switches the saved mode to
// `stopMode` mid-recording, and stops with a streamed transcript.
async function streamAcrossModeSwitch(t, AudioManager, { providerName, startMode, stopMode }) {
  globalThis.__streamingFinalizationSettings = {
    ...globalThis.__streamingFinalizationSettings,
    cloudTranscriptionMode: startMode,
    isSignedIn: true,
    insightsSyncEnabled: true,
  };
  installCapture(t);
  const provider = startingOrukeetProvider({
    finalizeAcknowledged: false,
    awaitsFinalTranscript: false,
    finalize() {},
  });
  const { manager, completions } = createStartingManager(AudioManager, { providerName, provider });
  manager.finalizeChineseScript = async (text) => text;
  const usageCalls = [];
  globalThis.window.electronAPI.cloudStreamingUsage = async (...args) => {
    usageCalls.push(args);
    return { success: true };
  };
  const events = [];
  globalThis.window.dispatchEvent = (event) => events.push(event.type);

  assert.equal(await manager.startStreamingRecording(), true);
  globalThis.__streamingFinalizationSettings = {
    ...globalThis.__streamingFinalizationSettings,
    cloudTranscriptionMode: stopMode,
  };
  manager.streamingFinalText = "Words from this stream.";
  await manager.stopStreamingRecording();
  await new Promise(setImmediate);
  return { completion: completions[0], usageCalls, events };
}

test("a stream counts toward Cloud usage by the credentials it started on", async (t) => {
  const AudioManager = await loadManagerClass(t);

  await t.test("a Cloud stream switched to own keys mid-recording is still counted", async (t) => {
    const { usageCalls, events } = await streamAcrossModeSwitch(t, AudioManager, {
      providerName: "gemini",
      startMode: "openwhispr",
      stopMode: "byok",
    });
    assert.equal(usageCalls.length, 1);
    assert.equal(usageCalls[0][0], "Words from this stream.");
    assert.equal(usageCalls[0][2].sttProvider, "gemini");
    assert.equal(usageCalls[0][2].sendLogs, true);
    assert.deepEqual(events, ["usage-changed"]);
  });

  // #2558: a Free user's own Gemini key filled the Cloud word allowance.
  await t.test("an own-key stream switched to Cloud mid-recording is not counted", async (t) => {
    const { completion, usageCalls, events } = await streamAcrossModeSwitch(t, AudioManager, {
      providerName: "gemini",
      startMode: "byok",
      stopMode: "openwhispr",
    });
    assert.equal(completion.text, "Words from this stream.");
    // The opted-in insights sync pushes the local row under these.
    assert.ok(completion.clientTranscriptionId);
    assert.ok(completion.analyticsOccurredAt);
    assert.deepEqual(usageCalls, []);
    assert.deepEqual(events, []);
  });

  await t.test("tinfoil in Cloud mode streams on the user's key and is not counted", async (t) => {
    const { usageCalls, events } = await streamAcrossModeSwitch(t, AudioManager, {
      providerName: "tinfoil-realtime",
      startMode: "openwhispr",
      stopMode: "openwhispr",
    });
    assert.deepEqual(usageCalls, []);
    assert.deepEqual(events, []);
  });
});

test("only a provider that prefers its stop transcript pastes it over the streamed finals", async (t) => {
  const AudioManager = await loadManagerClass(t);
  globalThis.window.dispatchEvent = () => true;

  for (const [preferStopTranscript, expected] of [
    [true, "Turn one. Turn two is still open"],
    [false, "Turn one."],
  ]) {
    const { manager } = createFinalizingManager(AudioManager);
    let completion;
    manager.streamingFinalText = "Turn one.";
    manager.streamingPartialText = "Turn two is still open";
    manager.getStreamingProvider = () => ({
      awaitsFinalTranscript: true,
      preferStopTranscript,
      finalize() {},
      stop: async () => ({ success: true, text: "Turn one. Turn two is still open" }),
    });
    manager.finalizeChineseScript = async (text) => text;
    manager.onTranscriptionComplete = (result) => {
      completion = result;
    };

    await manager.stopStreamingRecording();

    assert.equal(completion.text, expected);
  }
});

test("cancelling an active streaming recording discards it without publishing text", async (t) => {
  const AudioManager = await loadManagerClass(t);
  const { manager, states, getProviderStopCalls } = createFinalizingManager(AudioManager);
  const completions = [];
  manager.streamingFinalText = "discard me";
  manager.cleanupPreview = async () => null;
  manager.onTranscriptionComplete = (result) => completions.push(result);

  assert.equal(await manager.cancelStreamingRecording(), true);

  assert.equal(getProviderStopCalls(), 1);
  assert.deepEqual(completions, []);
  assert.equal(manager._activeStreamingSessionId, null);
  assert.equal(manager.isRecording, false);
  assert.equal(manager.isProcessing, false);
  assert.equal(manager.isStreaming, false);
  assert.deepEqual(states.at(-1), {
    isRecording: false,
    isProcessing: false,
    isStreaming: false,
  });
});

test("streaming discard blocks restart until the provider disconnects", async (t) => {
  const AudioManager = await loadManagerClass(t);
  const { manager } = createFinalizingManager(AudioManager);
  let resolveProviderStop;
  let providerStopStarted = false;
  const providerStop = new Promise((resolve) => {
    resolveProviderStop = resolve;
  });
  manager.cleanupPreview = async () => null;
  manager.getStreamingProvider = () => ({
    stop: async () => {
      providerStopStarted = true;
      await providerStop;
      return { success: true };
    },
  });

  const cancel = manager.cancelStreamingRecording();
  while (!providerStopStarted) await new Promise((resolve) => setImmediate(resolve));

  assert.equal(manager.isProcessing, true);
  assert.equal(manager.getState().isFinalizingStreaming, true);
  assert.equal(await manager.startStreamingRecording(), false);

  resolveProviderStop();
  assert.equal(await cancel, true);
  assert.equal(manager.isProcessing, false);
  assert.equal(manager.getState().isFinalizingStreaming, false);
});

test("streaming discard waits for an in-progress provider start before disconnecting", async (t) => {
  const AudioManager = await loadManagerClass(t);
  const { manager } = createFinalizingManager(AudioManager);
  let providerStopCalls = 0;
  manager.streamingStartInProgress = true;
  manager.cleanupPreview = async () => null;
  manager.getStreamingProvider = () => ({
    stop: async () => {
      providerStopCalls += 1;
      return { success: true };
    },
  });

  const cancel = manager.cancelStreamingRecording();
  await new Promise((resolve) => setImmediate(resolve));
  assert.equal(providerStopCalls, 0);
  assert.equal(manager.isProcessing, true);

  manager._settleStreamingStart();
  assert.equal(await cancel, true);
  assert.equal(providerStopCalls, 1);
  assert.equal(manager.isProcessing, false);
});

test("cancelling while the streaming microphone opens never enters recording", async (t) => {
  const AudioManager = await loadManagerClass(t);
  const states = [];
  let resolveMicOpen;
  let micOpenStarted = false;
  const micOpen = new Promise((resolve) => {
    resolveMicOpen = resolve;
  });
  const previousAudioWorkletNode = globalThis.AudioWorkletNode;
  globalThis.AudioWorkletNode = class {
    constructor() {
      this.port = { postMessage() {} };
    }

    disconnect() {}
  };
  t.after(() => {
    if (previousAudioWorkletNode === undefined) delete globalThis.AudioWorkletNode;
    else globalThis.AudioWorkletNode = previousAudioWorkletNode;
  });

  const stream = {
    getAudioTracks: () => [{ getSettings: () => ({}) }],
    getTracks: () => [{ stop() {} }],
  };
  const source = { connect() {}, disconnect() {} };
  const provider = {
    onPartial: () => () => {},
    onFinal: () => () => {},
    onError: () => () => {},
    onSessionEnd: () => () => {},
    start: async () => ({ success: true }),
    stop: async () => ({ success: true }),
  };
  const manager = Object.assign(Object.create(AudioManager.prototype), {
    isRecording: false,
    isProcessing: false,
    isStreaming: false,
    streamingStartInProgress: false,
    _streamingStartSettlementWaiters: [],
    stopRequestedDuringStreamingStart: false,
    _streamingStopPromise: null,
    _streamingStopMode: null,
    _streamingCancellationGeneration: 0,
    _activeTranscriptionAbortController: null,
    _streamingSessionGeneration: 0,
    _activeStreamingSessionId: null,
    streamingCleanupFns: [],
    streamingFallbackRecorder: null,
    streamingFallbackChunks: [],
    _streamingFallbackSegments: [],
    streamingTextDebounce: null,
    preparedMicCapture: { take: async () => null },
    micRecovery: { stop() {} },
    isRecordingAllowedByPolicy: () => true,
    getAudioConstraints: async () => ({}),
    _acquireCaptureStream: async () => {
      micOpenStarted = true;
      return micOpen;
    },
    startStreamingFallbackRecorder() {},
    getOrCreateAudioContext: async () => ({
      createMediaStreamSource: () => source,
      createAnalyser: () => ({}),
      audioWorklet: { addModule: async () => {} },
    }),
    getWorkletBlobUrl: () => "",
    getStreamingProvider: () => provider,
    getStreamingProviderName: () => "openai",
    getEffectiveSttLanguage: () => "auto",
    getKeyterms: () => [],
    beginMicRecovery: async () => {},
    cleanupPreview: async () => null,
    _markCaptureStreamReleased() {},
    onStateChange: (state) => states.push(state),
  });

  const start = manager.startStreamingRecording();
  while (!micOpenStarted) await new Promise((resolve) => setImmediate(resolve));
  const cancel = manager.cancelStreamingRecording();
  resolveMicOpen(stream);

  assert.deepEqual(await Promise.all([start, cancel]), [false, true]);
  assert.equal(manager.isRecording, false);
  assert.equal(manager.isStreaming, false);
  assert.equal(manager.streamingStartInProgress, false);
  assert.equal(
    states.some((state) => state.isRecording),
    false,
    "a cancelled start must not publish a recording state"
  );
});

// A managed Orukeet recording that resolves its provider through the real
// sttConfig routing, with every provider channel recording what reached it.
async function startManagedOrukeetRecording(t, AudioManager) {
  useManagedOrukeetSettings();
  installCapture(t);
  const calls = [];
  const record = (name, result) => async () => {
    calls.push(name);
    return result;
  };
  const listen = () => () => {};
  let raiseStreamError;
  Object.assign(globalThis.window.electronAPI, {
    dictationRealtimeStart: async (options) => {
      calls.push(`${options.provider}:start:${options.model}`);
      return { success: true };
    },
    dictationRealtimeFinalize: record("realtime:finalize", {
      success: true,
      text: "Bonjour",
      language: "fr",
    }),
    dictationRealtimeStop: record("realtime:stop", { success: true }),
    onDictationRealtimePartial: listen,
    onDictationRealtimeFinal: listen,
    onDictationRealtimeError: (listener) => {
      raiseStreamError = listener;
      return () => {};
    },
    onDictationRealtimeSessionEnd: listen,
    deepgramStreamingFinalize: record("deepgram:finalize", { success: true }),
    deepgramStreamingStop: record("deepgram:stop", { success: true }),
    cloudStreamingUsage: async (_text, _durationSeconds, usage) => {
      calls.push(`usage:${usage.sttProvider}:${usage.sttDetectedLanguage}`);
      return { success: true };
    },
  });
  globalThis.window.dispatchEvent = () => true;

  const { manager, errors, completions } = createStartingManager(AudioManager, {});
  delete manager.getStreamingProvider;
  delete manager.getStreamingProviderName;
  manager.setSttConfig({ dictation: { mode: "streaming" }, streamingProvider: "orukeet" });
  // The hook's background TTL refresh lands while the mic opens and would now
  // route a new recording elsewhere.
  const openMic = manager._acquireCaptureStream;
  manager._acquireCaptureStream = async (constraints) => {
    manager.setSttConfig({ dictation: { mode: "streaming" }, streamingProvider: "deepgram" });
    return openMic(constraints);
  };

  assert.equal(await manager.startStreamingRecording(), true);
  assert.equal(manager.getStreamingProviderName(), "deepgram");

  return { manager, calls, completions, errors, raiseStreamError };
}

test("stop finalizes the Orukeet stream after an STT config refresh reroutes while the mic opens", async (t) => {
  const AudioManager = await loadManagerClass(t);
  const { manager, calls, completions } = await startManagedOrukeetRecording(t, AudioManager);

  assert.equal(await manager.stopStreamingRecording(), true);

  assert.deepEqual(calls, [
    "orukeet:start:orukeet-v0.1.0",
    "realtime:finalize",
    "realtime:stop",
    "usage:orukeet:fr",
  ]);
  assert.equal(completions.length, 1);
  assert.equal(completions[0].text, "Bonjour");
  assert.equal(completions[0].source, "orukeet-streaming");
  assert.equal(manager._activeStreamingProviderName, null);
});

test("cancel and cleanup disconnect the Orukeet stream after an STT config refresh reroutes while the mic opens", async (t) => {
  const AudioManager = await loadManagerClass(t);
  for (const teardown of ["cancelStreamingRecording", "cleanup"]) {
    await t.test(teardown, async (t) => {
      const { manager, calls, completions, errors, raiseStreamError } =
        await startManagedOrukeetRecording(t, AudioManager);
      manager.preparedMicCapture.cancel = () => {};
      manager.micStreamHold = { drop() {} };
      // The managed Orukeet session fails over, so the error never surfaces.
      raiseStreamError("Orukeet connection closed");

      await manager[teardown]();

      assert.deepEqual(calls, ["orukeet:start:orukeet-v0.1.0", "realtime:stop"]);
      assert.deepEqual(completions, []);
      assert.deepEqual(errors, []);
      assert.equal(manager._activeStreamingProviderName, null);
    });
  }
});

test("cancel overrides a normal streaming stop before it can publish text", async (t) => {
  const AudioManager = await loadManagerClass(t);
  const { manager } = createFinalizingManager(AudioManager);
  const completions = [];
  manager.streamingFinalText = "do not paste";
  manager.screenContextPromise = Promise.resolve({ data: "stale-screen" });
  manager.selectionCapturePromise = Promise.resolve({ text: "stale-selection" });
  manager.assistantSelectionContext = { text: "stale-assistant-selection" };
  manager.onTranscriptionComplete = (result) => completions.push(result);

  const stop = manager.stopStreamingRecording();
  const cancel = manager.cancelStreamingRecording();

  assert.equal(await stop, true);
  assert.equal(await cancel, true);
  assert.deepEqual(completions, []);
  assert.equal(manager.screenContextPromise, null);
  assert.equal(manager.selectionCapturePromise, null);
  assert.equal(manager.assistantSelectionContext, null);
  assert.equal(manager._streamingStopPromise, null);
  assert.equal(manager._streamingStopMode, null);
});

test("streaming cancellation aborts a BYOK fallback transcription request", async (t) => {
  const AudioManager = await loadManagerClass(t);
  const { manager } = createFinalizingManager(AudioManager);
  let abortCalls = 0;
  manager._activeTranscriptionAbortController = {
    abort() {
      abortCalls += 1;
    },
  };

  manager._requestStreamingCancellation();

  assert.equal(abortCalls, 1);
  assert.equal(manager._activeTranscriptionAbortController, null);
});

test("cancelling streaming processing stays busy until an awaited transform exits", async (t) => {
  const AudioManager = await loadManagerClass(t);
  const { manager } = createFinalizingManager(AudioManager);
  const completions = [];
  let resolveTransform;
  let transformStarted = false;
  const transform = new Promise((resolve) => {
    resolveTransform = resolve;
  });
  manager.streamingFinalText = "raw transcript";
  manager.finalizeChineseScript = async () => {
    transformStarted = true;
    return transform;
  };
  manager.onTranscriptionComplete = (result) => completions.push(result);

  const stop = manager.stopStreamingRecording();
  while (!transformStarted) await new Promise((resolve) => setImmediate(resolve));

  assert.equal(manager.cancelProcessing(), true);
  assert.equal(manager.isProcessing, true);
  assert.equal(manager.getState().isFinalizingStreaming, true);
  resolveTransform("transformed transcript");
  assert.equal(await stop, true);

  assert.deepEqual(completions, []);
  assert.equal(manager.isProcessing, false);
  assert.equal(manager.getState().isFinalizingStreaming, false);
});

test("an older streaming session cannot clean up the active session listeners", async (t) => {
  const AudioManager = await loadManagerClass(t);
  const manager = Object.assign(Object.create(AudioManager.prototype), {
    _activeStreamingSessionId: 12,
    streamingCleanupFns: [() => assert.fail("stale cleanup ran")],
    streamingFinalText: "current transcript",
    streamingPartialText: "current partial",
    streamingTextBump: null,
    streamingTextDebounce: null,
  });

  manager.cleanupStreamingListeners(11);

  assert.equal(manager.streamingCleanupFns.length, 1);
  assert.equal(manager.streamingFinalText, "current transcript");
  assert.equal(manager.streamingPartialText, "current partial");
});

test("Orukeet commits only after the worklet flush and skips settling sleeps", async (t) => {
  const AudioManager = await loadManagerClass(t);
  const { manager } = createFinalizingManager(AudioManager);
  const order = [];
  const delays = [];
  const originalTimeout = globalThis.setTimeout;
  t.mock.method(globalThis, "setTimeout", (callback, ms, ...args) => {
    delays.push(ms);
    return originalTimeout(callback, ms, ...args);
  });
  manager.streamingProcessor = {
    port: {
      postMessage(message) {
        assert.equal(message, "stop");
        queueMicrotask(() => {
          order.push("last-pcm");
          manager._streamingFlushResolve();
        });
      },
    },
    disconnect() {
      order.push("capture-stopped");
    },
  };
  manager.getStreamingProvider = () => ({
    finalizeAcknowledged: true,
    async finalize() {
      order.push("commit");
      return { success: true, text: "" };
    },
    async stop() {
      order.push("socket-stopped");
      return { success: true, text: "" };
    },
  });
  manager.awaitStreamingTextSettled = () => {
    throw new Error("Unexpected settling delay");
  };
  await manager.stopStreamingRecording();
  assert.deepEqual(order, ["last-pcm", "capture-stopped", "commit", "socket-stopped"]);
  assert.equal(delays.includes(120), false);
  assert.equal(delays.includes(300), false);
});

test("acknowledged streaming silence does not trigger another transcription", async (t) => {
  const AudioManager = await loadManagerClass(t);
  const { manager } = createFinalizingManager(AudioManager);
  manager.recordingStartTime = Date.now() - 5000;
  manager.streamingFallbackChunks = [new Blob([new Uint8Array(100)])];
  manager.finishStreamingFallbackSegment = async () => new Blob([new Uint8Array(100)]);
  manager.mergeRecordedSegments = async () => new Blob([new Uint8Array(100)]);
  let fallbackCalls = 0;
  manager.processWithOpenAIAPI = async () => {
    fallbackCalls += 1;
    return { text: "unexpected" };
  };
  manager.getStreamingProvider = () => ({
    finalizeAcknowledged: true,
    finalize: async () => ({ success: true, text: "" }),
    stop: async () => ({ success: true, text: "" }),
  });
  const completions = [];
  manager.onTranscriptionComplete = (result) => completions.push(result);
  assert.equal(await manager.stopStreamingRecording(), true);
  assert.equal(completions.length, 1);
  assert.equal(completions[0].text, "");
  assert.equal(fallbackCalls, 0);
});

test("a stream without a final falls back to batch for every provider, tagged only for Orukeet", async (t) => {
  const AudioManager = await loadManagerClass(t);
  globalThis.__streamingFinalizationSettings = {
    ...globalThis.__streamingFinalizationSettings,
    cloudTranscriptionMode: "openwhispr",
    isSignedIn: true,
  };
  const uploads = [];
  for (const providerName of ["orukeet", "openai-realtime", "deepgram"]) {
    const { manager } = createFinalizingManager(AudioManager);
    manager.recordingStartTime = Date.now() - 5000;
    manager.mergeRecordedSegments = async () => new Blob([new Uint8Array(100)]);
    manager.getStreamingProviderName = () => providerName;
    manager.processWithOpenWhisprCloud = async (_blob, metadata) => {
      uploads.push([providerName, metadata.streamingFallbackReason]);
      return { text: "" };
    };
    await manager.stopStreamingRecording();
  }

  assert.deepEqual(uploads, [
    ["orukeet", "stream_no_final"],
    ["openai-realtime", undefined],
    ["deepgram", undefined],
  ]);
});

test("a no-final stream whose Cloud upload finds no speech keeps the recording quietly", async (t) => {
  const AudioManager = await loadManagerClass(t);
  globalThis.__streamingFinalizationSettings = {
    ...globalThis.__streamingFinalizationSettings,
    cloudTranscriptionMode: "openwhispr",
    isSignedIn: true,
  };
  const { manager } = createFinalizingManager(AudioManager);
  manager.recordingStartTime = Date.now() - 5000;
  manager.mergeRecordedSegments = async () => new Blob([new Uint8Array(100)]);
  const saved = [];
  const errors = [];
  const completions = [];
  manager.saveFailedTranscription = (message, code) => saved.push({ message, code });
  manager.onError = (error) => errors.push(error);
  manager.onTranscriptionComplete = (result) => completions.push(result);
  manager.processWithOpenWhisprCloud = async () => {
    throw Object.assign(new Error("No speech detected in audio"), { code: "NO_SPEECH_DETECTED" });
  };

  await manager.stopStreamingRecording();

  assert.deepEqual(saved, [{ message: "No speech detected in audio", code: "NO_SPEECH_DETECTED" }]);
  assert.deepEqual(errors, []);
  assert.deepEqual(completions, [{ success: true, text: "" }]);
});

test("a no-final stream whose upload transcribed but failed its selection edit keeps the text", async (t) => {
  const AudioManager = await loadManagerClass(t);
  globalThis.__streamingFinalizationSettings = {
    ...globalThis.__streamingFinalizationSettings,
    cloudTranscriptionMode: "openwhispr",
    isSignedIn: true,
  };
  const { manager } = createFinalizingManager(AudioManager);
  manager.recordingStartTime = Date.now() - 5000;
  manager.mergeRecordedSegments = async () => new Blob([new Uint8Array(100)]);
  const saved = [];
  const errors = [];
  manager.saveFailedTranscription = (...args) => saved.push(args);
  manager.onError = (error) => errors.push(error);
  manager.processWithOpenWhisprCloud = async () => {
    const error = Object.assign(new Error("Selection edit failed"), {
      selectionEditFatal: true,
      code: "SELECTION_EDIT_CAPTURE_FAILED",
    });
    Object.defineProperty(error, "transcript", { value: "Fallback text" });
    throw error;
  };

  await manager.stopStreamingRecording();

  // Unlike a real transcription failure here, it is reported and kept as batch's is.
  assert.deepEqual(
    errors.map(({ code, transcript }) => [code, transcript]),
    [["SELECTION_EDIT_CAPTURE_FAILED", "Fallback text"]]
  );
  assert.deepEqual(
    saved.map((args) => [args[1], args[3].transcript]),
    [["SELECTION_EDIT_CAPTURE_FAILED", "Fallback text"]]
  );
});

test("Orukeet uses the acknowledged final even if the transcript event is delayed", async (t) => {
  const AudioManager = await loadManagerClass(t);
  const { manager } = createFinalizingManager(AudioManager);
  manager.getStreamingProviderName = () => "orukeet";
  manager.getStreamingProvider = () => ({
    finalizeAcknowledged: true,
    finalize: async () => ({ success: true, text: "Acknowledged final" }),
    stop: async () => ({ success: true, text: "" }),
  });
  const results = [];
  manager.onTranscriptionComplete = (result) => results.push(result);
  await manager.stopStreamingRecording();
  assert.equal(results[0].text, "Acknowledged final");
});

test("missing Orukeet capture flush never commits a partial recording", async (t) => {
  const AudioManager = await loadManagerClass(t);
  const { manager } = createFinalizingManager(AudioManager);
  const originalTimeout = globalThis.setTimeout;
  t.mock.method(globalThis, "setTimeout", (callback, ms, ...args) =>
    originalTimeout(callback, Math.min(ms, 10), ...args)
  );
  let stopped = false;
  manager.streamingProcessor = { port: { postMessage() {} }, disconnect() {} };
  manager.getStreamingProvider = () => ({
    finalizeAcknowledged: true,
    finalize: async () => assert.fail("incomplete PCM must not be committed"),
    stop: async () => {
      stopped = true;
      return { success: true, text: "" };
    },
  });
  await manager.stopStreamingRecording();
  assert.equal(stopped, true);
  assert.equal(manager.streamingProcessor, null);
});

function useManagedOrukeetSettings() {
  globalThis.__streamingFinalizationSettings = {
    ...globalThis.__streamingFinalizationSettings,
    cloudTranscriptionMode: "openwhispr",
    isSignedIn: true,
  };
}

// A capture pipeline whose fallback recorder holds "opening words" from the
// moment it starts, before any streaming session exists, and whose worklet
// answers "stop" with the flush sentinel like the real one.
function installCapture(t) {
  const previous = {
    AudioWorkletNode: globalThis.AudioWorkletNode,
    MediaRecorder: globalThis.MediaRecorder,
  };
  globalThis.AudioWorkletNode = class {
    constructor() {
      this.port = {
        postMessage: (message) => {
          if (message === "stop") queueMicrotask(() => this.port.onmessage?.({ data: "flushed" }));
        },
      };
    }

    connect() {}
    disconnect() {}
  };
  globalThis.MediaRecorder = class {
    constructor() {
      this.state = "inactive";
      this.mimeType = "audio/webm";
    }

    start() {
      this.state = "recording";
      this.ondataavailable({ data: new Blob(["opening words"]) });
    }

    stop() {
      this.state = "inactive";
      queueMicrotask(() => this.onstop?.());
    }
  };
  t.after(() => {
    for (const [name, value] of Object.entries(previous)) {
      if (value === undefined) delete globalThis[name];
      else globalThis[name] = value;
    }
  });
}

function createStartingManager(AudioManager, { providerName, provider }) {
  const errors = [];
  const uploads = [];
  const completions = [];
  const stream = { getAudioTracks: () => [], getTracks: () => [{ stop() {} }] };
  const source = { connect() {}, disconnect() {} };
  const manager = Object.assign(Object.create(AudioManager.prototype), {
    isRecording: false,
    isProcessing: false,
    isStreaming: false,
    streamingStartInProgress: false,
    _streamingStartSettlementWaiters: [],
    stopRequestedDuringStreamingStart: false,
    _streamingStopPromise: null,
    _streamingStopMode: null,
    _streamingCancellationGeneration: 0,
    _activeTranscriptionAbortController: null,
    _streamingSessionGeneration: 0,
    _activeStreamingSessionId: null,
    _streamingMicSwapPromise: null,
    streamingCleanupFns: [],
    streamingFallbackRecorder: null,
    streamingFallbackChunks: [],
    _streamingFallbackSegments: [],
    streamingTextDebounce: null,
    pendingAssistantConversation: null,
    pendingSelectionEdit: null,
    preparedMicCapture: { take: async () => null },
    micRecovery: { stop() {} },
    isRecordingAllowedByPolicy: () => true,
    getAudioConstraints: async () => ({}),
    _acquireCaptureStream: async () => stream,
    getOrCreateAudioContext: async () => ({
      createMediaStreamSource: () => source,
      createAnalyser: () => ({}),
      audioWorklet: { addModule: async () => {} },
    }),
    getWorkletBlobUrl: () => "",
    getStreamingProvider: () => provider,
    getStreamingProviderName: () => providerName,
    getEffectiveSttLanguage: () => "auto",
    getKeyterms: () => [],
    beginMicRecovery: async () => {},
    mergeRecordedSegments: async (segments) => segments[0] ?? null,
    getLargestRecordedSegment: () => null,
    awaitStreamingTextSettled: async () => {},
    shouldUseStreaming: () => false,
    _markCaptureStreamReleased() {},
    onStateChange() {},
    startRecording: async () => assert.fail("the microphone must not be reopened"),
    processWithOpenWhisprCloud: async (blob, metadata) => {
      uploads.push({ audio: await blob.text(), reason: metadata.streamingFallbackReason });
      return { text: "" };
    },
    onError: (error) => errors.push(error),
    onTranscriptionComplete: (result) => completions.push(result),
  });
  return { manager, errors, uploads, completions };
}

function startingOrukeetProvider(overrides = {}) {
  const sent = [];
  return {
    sent,
    onPartial: () => () => {},
    onFinal: () => () => {},
    onError: () => () => {},
    onSessionEnd: () => () => {},
    send: (pcm) => sent.push(pcm),
    start: async () => ({ success: true }),
    finalizeAcknowledged: true,
    // What main answers once the adapter is gone or failed.
    finalize: async () => ({ success: false, error: "No Orukeet recording is active" }),
    stop: async () => ({ success: true, text: "" }),
    ...overrides,
  };
}

// One 50 ms worklet chunk (800 PCM16 samples at 16 kHz).
const speechPcm = () => new Int16Array(800).fill(8000).buffer;
const silentPcm = () => new Int16Array(800).buffer;

function refusedStartProvider() {
  return startingOrukeetProvider({
    start: async () => ({ success: false, error: "Orukeet connection closed" }),
  });
}

test("a refused managed Orukeet start keeps its capture and uploads the opening words", async (t) => {
  const AudioManager = await loadManagerClass(t);
  useManagedOrukeetSettings();
  installCapture(t);
  const provider = startingOrukeetProvider({
    start: async () => ({ success: false, error: "Orukeet connection closed" }),
  });
  const { manager, errors, uploads } = createStartingManager(AudioManager, {
    providerName: "orukeet",
    provider,
  });

  assert.equal(await manager.startStreamingRecording(), true);
  assert.equal(manager.isRecording, true);
  manager.streamingProcessor.port.onmessage({ data: speechPcm() });
  assert.deepEqual(provider.sent, [], "a failed-over recording feeds no socket");

  // Stopped well under the 2 s floor a streamed recording needs to fall back.
  await manager.stopStreamingRecording();

  assert.deepEqual(uploads, [{ audio: "opening words", reason: "session_unavailable" }]);
  assert.deepEqual(errors, []);
});

test("a managed Orukeet stream refused mid-recording keeps recording and uploads it", async (t) => {
  const AudioManager = await loadManagerClass(t);
  useManagedOrukeetSettings();
  installCapture(t);
  let raise;
  const provider = startingOrukeetProvider({
    onError: (listener) => {
      raise = listener;
      return () => {};
    },
  });
  const { manager, errors, uploads } = createStartingManager(AudioManager, {
    providerName: "orukeet",
    provider,
  });

  assert.equal(await manager.startStreamingRecording(), true);
  raise("Account already has an active recording");

  assert.equal(manager.isStreaming, true, "the recording is not cut off");
  assert.equal(manager._streamingStopPromise, null);
  await manager.stopStreamingRecording();
  assert.deepEqual(uploads, [{ audio: "opening words", reason: "stream_no_final" }]);
  assert.deepEqual(errors, []);
});

test("a managed Orukeet error while stop awaits the final still uploads a short capture", async (t) => {
  const AudioManager = await loadManagerClass(t);
  useManagedOrukeetSettings();
  installCapture(t);
  let raise;
  const provider = startingOrukeetProvider({
    onError: (listener) => {
      raise = listener;
      return () => {};
    },
    // The refusal (commit capacity, a dropped socket or a final timeout)
    // lands a round trip after the commit, once stop has finished the
    // fallback recorder.
    finalize: async () => {
      while (manager.streamingFallbackRecorder) await new Promise(setImmediate);
      raise("Orukeet transcription failed: capacity");
      return { success: false, error: "Orukeet transcription failed: capacity" };
    },
  });
  const { manager, errors, uploads } = createStartingManager(AudioManager, {
    providerName: "orukeet",
    provider,
  });

  assert.equal(await manager.startStreamingRecording(), true);
  await manager.stopStreamingRecording();

  assert.deepEqual(uploads, [{ audio: "opening words", reason: "stream_no_final" }]);
  assert.deepEqual(errors, []);
});

test("a managed Orukeet drop without a fallback recorder surfaces and auto-stops", async (t) => {
  const AudioManager = await loadManagerClass(t);
  useManagedOrukeetSettings();
  installCapture(t);
  globalThis.MediaRecorder = class {
    constructor() {
      throw new Error("MediaRecorder unavailable");
    }
  };
  let raise;
  const provider = startingOrukeetProvider({
    onError: (listener) => {
      raise = listener;
      return () => {};
    },
  });
  const { manager, errors } = createStartingManager(AudioManager, {
    providerName: "orukeet",
    provider,
  });

  assert.equal(await manager.startStreamingRecording(), true);
  raise("Account already has an active recording");

  // Nothing holds the capture, so there is nothing to fail over to.
  assert.equal(errors[0]?.title, "Streaming Error");
  assert.ok(manager._streamingStopPromise, "the recording auto-stops");
  await manager._streamingStopPromise;
});

test("a refused managed Orukeet start without a fallback recorder records in batch instead", async (t) => {
  const AudioManager = await loadManagerClass(t);
  useManagedOrukeetSettings();
  installCapture(t);
  globalThis.MediaRecorder = class {
    constructor() {
      throw new Error("MediaRecorder unavailable");
    }
  };
  const { manager, uploads } = createStartingManager(AudioManager, {
    providerName: "orukeet",
    provider: refusedStartProvider(),
  });
  let batchStarts = 0;
  manager.startRecording = async () => {
    batchStarts += 1;
    return true;
  };
  manager.cleanupStreaming = async () => {};

  assert.equal(await manager.startStreamingRecording(), true);

  // Nothing captured the opening words, so only a fresh recording can.
  assert.equal(batchStarts, 1);
  assert.equal(manager._streamingFailoverReason, null);
  assert.deepEqual(uploads, []);
});

test("a stop pressed while a refused managed Orukeet start settles uploads once", async (t) => {
  const AudioManager = await loadManagerClass(t);
  useManagedOrukeetSettings();
  installCapture(t);
  let refuse;
  const provider = startingOrukeetProvider({
    start: () =>
      new Promise((resolve) => {
        refuse = () => resolve({ success: false, error: "Orukeet connection closed" });
      }),
  });
  const { manager, errors, uploads } = createStartingManager(AudioManager, {
    providerName: "orukeet",
    provider,
  });

  const starting = manager.startStreamingRecording();
  while (!refuse) await new Promise((resolve) => setImmediate(resolve));
  await manager.stopStreamingRecording();
  refuse();
  await starting;

  assert.equal(manager.isRecording, false, "the deferred stop ends the recording");
  assert.deepEqual(uploads, [{ audio: "opening words", reason: "session_unavailable" }]);
  assert.deepEqual(errors, []);
});

test("the recording after a failed-over one streams to its socket again", async (t) => {
  const AudioManager = await loadManagerClass(t);
  useManagedOrukeetSettings();
  installCapture(t);
  let starts = 0;
  const provider = startingOrukeetProvider({
    start: async () => {
      starts += 1;
      return starts === 1
        ? { success: false, error: "Orukeet connection closed" }
        : { success: true };
    },
  });
  const { manager } = createStartingManager(AudioManager, { providerName: "orukeet", provider });

  assert.equal(await manager.startStreamingRecording(), true);
  await manager.stopStreamingRecording();
  assert.equal(await manager.startStreamingRecording(), true);
  const pcm = speechPcm();
  manager.streamingProcessor.port.onmessage({ data: pcm });

  assert.deepEqual(provider.sent, [pcm]);
});

test("opening words streamed before a mid-recording drop still count as speech", async (t) => {
  const AudioManager = await loadManagerClass(t);
  useManagedOrukeetSettings();
  installCapture(t);
  let raise;
  const provider = startingOrukeetProvider({
    onError: (listener) => {
      raise = listener;
      return () => {};
    },
  });
  const { manager, uploads } = createStartingManager(AudioManager, {
    providerName: "orukeet",
    provider,
  });

  assert.equal(await manager.startStreamingRecording(), true);
  manager.streamingProcessor.port.onmessage({ data: speechPcm() });
  raise("Orukeet connection closed");
  manager.streamingProcessor.port.onmessage({ data: silentPcm() });
  await manager.stopStreamingRecording();

  assert.deepEqual(uploads, [{ audio: "opening words", reason: "stream_no_final" }]);
});

test("a capacity-refused managed commit closes and uploads the whole short capture once", async (t) => {
  const AudioManager = await loadManagerClass(t);
  useManagedOrukeetSettings();
  installCapture(t);
  const server = new WebSocketServer({ host: "127.0.0.1", port: 0 });
  await once(server, "listening");
  let commits = 0;
  server.on("connection", (socket) => {
    socket.send(
      JSON.stringify({
        type: "ready",
        channels: 1,
        sample_rate: 16000,
        encoding: "pcm_s16le",
        max_seconds: 600,
      })
    );
    socket.on("message", (data, binary) => {
      if (!binary && JSON.parse(data).type === "commit") {
        commits++;
        // A busy gateway keeps the PCM and socket until the client retries or closes.
        socket.send(JSON.stringify({ type: "error", code: "capacity", retry_after_ms: 100 }));
      }
    });
  });
  const adapter = new OrukeetStreaming({ timeoutMs: 500, retryCapacity: false });
  t.after(async () => {
    await adapter.disconnect();
    for (const socket of server.clients) socket.terminate();
    await new Promise((resolve) => server.close(resolve));
  });
  const provider = startingOrukeetProvider({
    start: async () => {
      await adapter.connect({
        baseUrl: `http://127.0.0.1:${server.address().port}`,
        apiKey: "test-key",
      });
      return { success: true };
    },
    send: (pcm) => adapter.sendAudio(pcm),
    onError: (listener) => {
      adapter.onError = (error) => listener(error.message);
      return () => {
        adapter.onError = null;
      };
    },
    finalize: async () => {
      try {
        return { success: true, ...(await adapter.finalize()) };
      } catch (error) {
        return { success: false, error: error.message };
      }
    },
    stop: async () => ({ success: true, ...(await adapter.disconnect()) }),
  });
  const { manager, errors, uploads } = createStartingManager(AudioManager, {
    providerName: "orukeet",
    provider,
  });
  const upload = manager.processWithOpenWhisprCloud;
  manager.processWithOpenWhisprCloud = async (...args) => {
    assert.equal(adapter.intentionalClose, true);
    assert.equal(adapter.retryTimer, undefined);
    assert.match(adapter.failure.message, /capacity/);
    return upload(...args);
  };

  await manager.startStreamingRecording();
  manager.streamingProcessor.port.onmessage({ data: speechPcm() });
  await Promise.all([manager.stopStreamingRecording(), manager.stopStreamingRecording()]);

  assert.equal(commits, 1);
  assert.deepEqual(uploads, [{ audio: "opening words", reason: "stream_no_final" }]);
  assert.deepEqual(errors, []);
});

test("other streaming providers still surface a dropped stream and auto-stop", async (t) => {
  const AudioManager = await loadManagerClass(t);
  useManagedOrukeetSettings();
  installCapture(t);
  let raise;
  const provider = startingOrukeetProvider({
    onError: (listener) => {
      raise = listener;
      return () => {};
    },
    finalizeAcknowledged: false,
  });
  const { manager, errors } = createStartingManager(AudioManager, {
    providerName: "openai-realtime",
    provider,
  });

  assert.equal(await manager.startStreamingRecording(), true);
  raise("Connection lost");

  assert.equal(errors[0].title, "Streaming Error");
  assert.ok(manager._streamingStopPromise, "the recording auto-stops");
  await manager._streamingStopPromise;
});

test("a failed-over upload error is reported and kept for retry, not shown as silence", async (t) => {
  const AudioManager = await loadManagerClass(t);
  useManagedOrukeetSettings();
  installCapture(t);
  const provider = startingOrukeetProvider({
    start: async () => ({ success: false, error: "Orukeet connection closed" }),
  });
  const { manager, errors, completions } = createStartingManager(AudioManager, {
    providerName: "orukeet",
    provider,
  });
  const saved = [];
  manager.saveFailedTranscription = async (message, code) => saved.push([message, code]);
  manager.processWithOpenWhisprCloud = async () => {
    const error = new Error("You're offline.");
    error.code = "OFFLINE";
    throw error;
  };

  await manager.startStreamingRecording();
  await manager.stopStreamingRecording();

  assert.equal(errors.length, 1);
  assert.equal(errors[0].code, "OFFLINE");
  assert.deepEqual(saved, [["You're offline.", "OFFLINE"]]);
  assert.deepEqual(completions, []);
});

test("cancelling a failed-over upload does not keep it as a failed transcription", async (t) => {
  const AudioManager = await loadManagerClass(t);
  useManagedOrukeetSettings();
  installCapture(t);
  const { manager, errors } = createStartingManager(AudioManager, {
    providerName: "orukeet",
    provider: refusedStartProvider(),
  });
  const saved = [];
  manager.saveFailedTranscription = async (message, code) => saved.push([message, code]);
  // Main answers an upload cancelled mid-flight with TRANSCRIPTION_CANCELLED.
  let cancelUpload;
  let uploadStarted;
  const uploading = new Promise((resolve) => {
    uploadStarted = resolve;
  });
  globalThis.window.electronAPI.cancelCloudTranscription = () => cancelUpload();
  manager.processWithOpenWhisprCloud = () =>
    new Promise((_resolve, reject) => {
      cancelUpload = () =>
        reject(Object.assign(new Error("Cancelled"), { code: "TRANSCRIPTION_CANCELLED" }));
      uploadStarted();
    });

  await manager.startStreamingRecording();
  const stopping = manager.stopStreamingRecording();
  await uploading;
  await manager.cancelStreamingRecording();
  await stopping;

  assert.deepEqual(saved, []);
  assert.deepEqual(errors, []);
});

test("a failed-over upload that echoes the dictionary reads as silence and keeps the audio", async (t) => {
  const AudioManager = await loadManagerClass(t);
  useManagedOrukeetSettings();
  installCapture(t);
  const { manager, errors, completions } = createStartingManager(AudioManager, {
    providerName: "orukeet",
    provider: refusedStartProvider(),
  });
  const saved = [];
  manager.saveFailedTranscription = async (message, code) => saved.push([message, code]);
  manager.processWithOpenWhisprCloud = async () => {
    throw Object.assign(new Error("No audio detected"), { code: "DICTIONARY_ECHO" });
  };

  await manager.startStreamingRecording();
  await manager.stopStreamingRecording();

  assert.deepEqual(saved, [["No audio detected", "DICTIONARY_ECHO"]]);
  assert.deepEqual(errors, []);
  assert.deepEqual(completions, [{ success: true, text: "" }]);
});

test("a start refused as disabled keeps its tag after the cached config is dropped", async (t) => {
  const AudioManager = await loadManagerClass(t);
  useManagedOrukeetSettings();
  installCapture(t);
  const { manager, uploads } = createStartingManager(AudioManager, {
    providerName: "orukeet",
    provider: startingOrukeetProvider({
      start: async () => ({ success: false, code: "FEATURE_NOT_ENABLED", error: "Disabled" }),
    }),
  });
  // Resolve the provider from the cached config, as the real manager does.
  delete manager.getStreamingProviderName;
  manager.sttConfig = { dictation: { mode: "streaming" }, streamingProvider: "orukeet" };

  await manager.startStreamingRecording();
  await manager.stopStreamingRecording();

  assert.deepEqual(uploads, [{ audio: "opening words", reason: "feature_disabled" }]);
});

test("signing out during a failed-over recording reports it and keeps the audio", async (t) => {
  const AudioManager = await loadManagerClass(t);
  useManagedOrukeetSettings();
  installCapture(t);
  const { manager, errors, uploads, completions } = createStartingManager(AudioManager, {
    providerName: "orukeet",
    provider: refusedStartProvider(),
  });
  const saved = [];
  manager.saveFailedTranscription = async (message, code) => saved.push(code);

  await manager.startStreamingRecording();
  globalThis.__streamingFinalizationSettings = {
    ...globalThis.__streamingFinalizationSettings,
    isSignedIn: false,
  };
  await manager.stopStreamingRecording();

  assert.deepEqual(uploads, []);
  assert.deepEqual(
    errors.map(({ code, messageKey }) => ({ code, messageKey })),
    [{ code: "AUTH_REQUIRED", messageKey: "hooks.audioRecording.errorDescriptions.sessionExpired" }]
  );
  assert.deepEqual(saved, ["AUTH_REQUIRED"]);
  assert.deepEqual(completions, []);
});

test("a failed-over upload that reaches the word limit carries it to the upgrade prompt", async (t) => {
  const AudioManager = await loadManagerClass(t);
  useManagedOrukeetSettings();
  installCapture(t);
  const { manager, completions } = createStartingManager(AudioManager, {
    providerName: "orukeet",
    provider: refusedStartProvider(),
  });
  globalThis.window.dispatchEvent = () => true;
  manager.processWithOpenWhisprCloud = async () => ({
    text: "Last words of the day.",
    source: "openwhispr",
    limitReached: true,
    wordsUsed: 2000,
    wordsRemaining: 0,
  });

  await manager.startStreamingRecording();
  await manager.stopStreamingRecording();

  assert.equal(completions.length, 1);
  const { text, limitReached, wordsUsed, wordsRemaining } = completions[0];
  assert.deepEqual(
    { text, limitReached, wordsUsed, wordsRemaining },
    { text: "Last words of the day.", limitReached: true, wordsUsed: 2000, wordsRemaining: 0 }
  );
});

test("a silent failed-over tap is not uploaded", async (t) => {
  const AudioManager = await loadManagerClass(t);
  useManagedOrukeetSettings();
  installCapture(t);
  const { manager, errors, uploads, completions } = createStartingManager(AudioManager, {
    providerName: "orukeet",
    provider: refusedStartProvider(),
  });

  await manager.startStreamingRecording();
  manager.streamingProcessor.port.onmessage({ data: silentPcm() });
  await manager.stopStreamingRecording();

  assert.deepEqual(uploads, []);
  assert.deepEqual(errors, []);
  assert.deepEqual(completions, [{ success: true, text: "" }]);
});

test("a failed-over selection edit that fails is reported as a selection edit failure", async (t) => {
  const AudioManager = await loadManagerClass(t);
  useManagedOrukeetSettings();
  installCapture(t);
  const { manager, errors } = createStartingManager(AudioManager, {
    providerName: "orukeet",
    provider: refusedStartProvider(),
  });
  manager.saveFailedTranscription = async () => {};
  manager.processWithOpenWhisprCloud = async () => {
    throw Object.assign(new Error("Selection edit could not safely read the selection: gone"), {
      code: "SELECTION_EDIT_CAPTURE_FAILED",
      messageKey: "hooks.audioRecording.selectionEditing.unavailable",
      selectionEditFatal: true,
    });
  };

  await manager.startStreamingRecording();
  await manager.stopStreamingRecording();

  assert.deepEqual(errors, [
    {
      title: "Selection Edit Failed",
      description: "Selection edit could not safely read the selection: gone",
      selectionEditFatal: true,
      code: "SELECTION_EDIT_CAPTURE_FAILED",
      messageKey: "hooks.audioRecording.selectionEditing.unavailable",
    },
  ]);
});

test("a managed Orukeet session fails over even if its route changes mid-recording", async (t) => {
  const AudioManager = await loadManagerClass(t);
  useManagedOrukeetSettings();
  installCapture(t);
  let raise;
  const { manager, errors } = createStartingManager(AudioManager, {
    providerName: "orukeet",
    provider: startingOrukeetProvider({
      onError: (listener) => {
        raise = listener;
        return () => {};
      },
    }),
  });

  assert.equal(await manager.startStreamingRecording(), true);
  // A background stt-config refresh rolled the account off the Orukeet route.
  manager.getStreamingProviderName = () => "deepgram";
  raise("Account already has an active recording");

  assert.deepEqual(errors, []);
  assert.equal(manager._streamingStopPromise, null, "the recording is not cut off");
  await manager.stopStreamingRecording();
});

const JA_FINAL = {
  success: true,
  text: "ashita no kaigi",
  model: "orukeet-v0.1.0",
  language: "ja",
  languageConfidence: 0.97,
  languageAudioSeconds: 6,
};

const JA_DETECTION = {
  sttDetectedLanguage: "ja",
  sttDetectedLanguageConfidence: 0.97,
  sttDetectedLanguageAudioSeconds: 6,
  sttDetectedLanguageStatus: "detected",
};

const detectionFields = (opts) =>
  Object.fromEntries(Object.entries(opts).filter(([key]) => key.startsWith("sttDetected")));

function orukeetProvider(final) {
  return {
    finalizeAcknowledged: true,
    finalize: async () => final,
    stop: async () => ({ success: true, text: "" }),
  };
}

// Stops a managed Cloud dictation whose provider acknowledged `final`, and
// records what reached Cloud: batch uploads, cleanup requests, streaming usage
// and the published result.
async function stopManagedDictation(
  AudioManager,
  { final, providerName = "orukeet", language = "auto", upload, settings = {}, overrides = {} }
) {
  globalThis.__streamingFinalizationSettings = {
    ...globalThis.__streamingFinalizationSettings,
    cloudTranscriptionMode: "openwhispr",
    isSignedIn: true,
    ...settings,
  };
  const { manager } = createFinalizingManager(AudioManager);
  manager._streamingMeteredByCloud =
    globalThis.__streamingFinalizationSettings.cloudTranscriptionMode === "openwhispr";
  manager.recordingStartTime = Date.now() - 8000;
  manager.mergeRecordedSegments = async () => new Blob([new Uint8Array(100)]);
  manager.getStreamingProvider = () => orukeetProvider(final);
  manager.getStreamingProviderName = () => providerName;
  manager.getEffectiveSttLanguage = () => language;
  Object.assign(manager, overrides);
  const uploads = [];
  if (upload) {
    manager.processWithOpenWhisprCloud = async (_blob, metadata) => {
      uploads.push(metadata);
      return upload(manager);
    };
  }
  const reasonCalls = [];
  globalThis.window.electronAPI.cloudReason = async (text, opts) => {
    reasonCalls.push([text, opts]);
    return { success: true, text: `${text}。` };
  };
  const usage = [];
  globalThis.window.electronAPI.cloudStreamingUsage = async (text, seconds, opts) => {
    usage.push({ ...opts, text, seconds });
    return { success: true };
  };
  globalThis.window.dispatchEvent = () => true;
  const published = [];
  manager.onTranscriptionComplete = (result) => published.push(result);
  const errors = [];
  manager.onError = (error) => errors.push(error);
  const stopResult = await manager.stopStreamingRecording();
  // Usage is reported in the background after the transcript is published.
  await new Promise(setImmediate);
  return { manager, uploads, reasonCalls, usage, published, errors, stopResult };
}

test("a confident unsupported estimate re-transcribes the kept recording through Cloud", async (t) => {
  const AudioManager = await loadManagerClass(t);
  const { uploads, usage, published } = await stopManagedDictation(AudioManager, {
    final: JA_FINAL,
    upload: async () => ({ text: "明日の会議", rawText: "明日の会議" }),
  });
  assert.equal(uploads.length, 1);
  assert.equal(uploads[0].streamingFallbackReason, "language_detected_unsupported");
  assert.deepEqual(uploads[0].detectedLanguageFields, JA_DETECTION);
  assert.equal(Object.hasOwn(uploads[0], "language"), false);
  assert.equal(published[0].text, "明日の会議");
  assert.equal(published[0].rawText, "明日の会議");
  // /api/transcribe metered the re-transcription; the stream is not metered too.
  assert.equal(usage.length, 0);
});

test("language re-transcription skips streaming cleanup", async (t) => {
  const AudioManager = await loadManagerClass(t, {
    "/stores/settingsStore": `
      export const getSettings = () => globalThis.__streamingFinalizationSettings;
      export const getEffectiveCleanupModel = () => null;
      export const selectResolvedLLMConfig = () => ({ model: null, provider: null });
      export const isCloudCleanupMode = () => true;
      export const isCloudDictationAgentMode = () => false;
      export const isCloudTranslationMode = () => false;
    `,
  });
  const originalNavigator = globalThis.navigator;
  Object.defineProperty(globalThis, "navigator", { value: { onLine: true }, configurable: true });
  t.after(() =>
    Object.defineProperty(globalThis, "navigator", {
      value: originalNavigator,
      configurable: true,
    })
  );
  const transcribeOpts = [];
  globalThis.window.electronAPI.cloudTranscribe = async (_audio, opts) => {
    transcribeOpts.push(opts);
    return { success: true, text: "明日の会議", sttProvider: "openai" };
  };
  const { reasonCalls, usage, published } = await stopManagedDictation(AudioManager, {
    final: JA_FINAL,
    settings: { useCleanupModel: true, cleanupCloudMode: "openwhispr", customPrompts: {} },
    overrides: {
      isDictionaryEcho: () => false,
      getWhisperPrompt: () => null,
      finalizeChineseScript: async (text) => text,
    },
  });
  // The real batch path ran: an "auto" upload that never declares the estimate.
  assert.equal(transcribeOpts.length, 1);
  assert.equal(Object.hasOwn(transcribeOpts[0], "language"), false);
  assert.equal(transcribeOpts[0].streamingFallbackReason, "language_detected_unsupported");
  assert.equal(transcribeOpts[0].sttDetectedLanguage, "ja");
  // One cleanup, on the Cloud transcript; Orukeet's text never reaches /api/reason.
  assert.deepEqual(
    reasonCalls.map(([text]) => text),
    ["明日の会議"]
  );
  assert.equal(reasonCalls[0][1].sttDetectedLanguage, "ja");
  assert.equal(published[0].text, "明日の会議。");
  assert.equal(usage.length, 0);
});

test("a low score, short window, supported or unknown estimate keeps the Orukeet text", async (t) => {
  const AudioManager = await loadManagerClass(t);
  for (const [final, expected] of [
    [
      { ...JA_FINAL, languageConfidence: 0.89 },
      { ...JA_DETECTION, sttDetectedLanguageConfidence: 0.89 },
    ],
    [
      { ...JA_FINAL, languageAudioSeconds: 2 },
      { ...JA_DETECTION, sttDetectedLanguageAudioSeconds: 2 },
    ],
    [
      { ...JA_FINAL, language: "de" },
      { ...JA_DETECTION, sttDetectedLanguage: "de" },
    ],
    [
      { ...JA_FINAL, language: null, languageConfidence: null },
      { sttDetectedLanguageStatus: "unknown" },
    ],
  ]) {
    const { uploads, usage, published } = await stopManagedDictation(AudioManager, {
      final,
      upload: async () => assert.fail("must not re-transcribe"),
    });
    assert.equal(uploads.length, 0);
    assert.equal(published[0].text, "ashita no kaigi");
    assert.equal(usage.length, 1);
    assert.deepEqual(detectionFields(usage[0]), expected);
  }
});

test("an explicit language setting never re-transcribes", async (t) => {
  const AudioManager = await loadManagerClass(t);
  const { uploads, usage, published } = await stopManagedDictation(AudioManager, {
    final: JA_FINAL,
    language: "en",
    upload: async () => assert.fail("must not re-transcribe"),
  });
  assert.equal(uploads.length, 0);
  assert.equal(published[0].text, "ashita no kaigi");
  assert.deepEqual(detectionFields(usage[0]), JA_DETECTION);
});

test("an older gateway sends no detection fields", async (t) => {
  const AudioManager = await loadManagerClass(t);
  const { uploads, usage, published } = await stopManagedDictation(AudioManager, {
    final: { success: true, text: "hello there" },
    upload: async () => assert.fail("must not re-transcribe"),
  });
  assert.equal(uploads.length, 0);
  assert.equal(published[0].text, "hello there");
  assert.deepEqual(detectionFields(usage[0]), {});
});

test("a failed re-transcription is reported and kept for retry, never pasting Orukeet's text", async (t) => {
  const AudioManager = await loadManagerClass(t);
  const saved = [];
  const { uploads, reasonCalls, usage, published, errors } = await stopManagedDictation(
    AudioManager,
    {
      final: JA_FINAL,
      upload: async () => {
        throw new Error("Cloud transcription failed");
      },
      overrides: { saveFailedTranscription: (...args) => saved.push(args) },
    }
  );
  assert.equal(uploads.length, 1);
  assert.deepEqual(
    errors.map(({ title, description }) => [title, description]),
    [["Transcription Error", "Transcription failed: Cloud transcription failed"]]
  );
  assert.deepEqual(
    saved.map(([message, code]) => [message, code]),
    [["Cloud transcription failed", null]]
  );
  assert.deepEqual(published, []);
  assert.deepEqual(reasonCalls, []);
  assert.deepEqual(usage, []);
});

test("a re-transcription that returns no text ends empty and keeps the recording", async (t) => {
  const AudioManager = await loadManagerClass(t);
  const saved = [];
  const { reasonCalls, usage, published, errors } = await stopManagedDictation(AudioManager, {
    final: JA_FINAL,
    upload: async () => ({ text: "" }),
    overrides: { saveFailedTranscription: (...args) => saved.push(args) },
  });
  assert.deepEqual(published, [{ success: true, text: "" }]);
  assert.deepEqual(
    saved.map(([, code]) => code),
    ["NO_SPEECH_DETECTED"]
  );
  assert.deepEqual(errors, []);
  assert.deepEqual(reasonCalls, []);
  assert.deepEqual(usage, []);
});

test("Cloud finding no speech ends the dictation empty and keeps the recording", async (t) => {
  const AudioManager = await loadManagerClass(t);
  const { dictionaryEchoError } = await import("../../src/utils/dictionaryEchoFilter.js");
  for (const error of [
    Object.assign(new Error("No speech detected in audio"), { code: "NO_SPEECH_DETECTED" }),
    dictionaryEchoError(),
  ]) {
    const saved = [];
    const { uploads, reasonCalls, usage, published } = await stopManagedDictation(AudioManager, {
      final: JA_FINAL,
      upload: async () => {
        throw error;
      },
      overrides: { saveFailedTranscription: (...args) => saved.push(args) },
    });
    assert.equal(uploads.length, 1, error.code);
    assert.deepEqual(published, [{ success: true, text: "" }], error.code);
    // Neither Orukeet's text nor a second metering (an echo was already metered).
    assert.deepEqual(reasonCalls, [], error.code);
    assert.deepEqual(usage, [], error.code);
    assert.deepEqual(
      saved.map(([, code]) => code),
      [error.code]
    );
  }
});

test("a re-transcription that reaches the word limit opens the upgrade prompt", async (t) => {
  const AudioManager = await loadManagerClass(t);
  const { published } = await stopManagedDictation(AudioManager, {
    final: JA_FINAL,
    upload: async () => ({
      text: "明日の会議",
      rawText: "明日の会議",
      source: "openwhispr",
      limitReached: true,
      wordsUsed: 2000,
      wordsRemaining: 0,
    }),
  });
  assert.equal(published[0].source, "openwhispr");
  assert.equal(published[0].limitReached, true);
  assert.equal(published[0].wordsUsed, 2000);
  assert.equal(published[0].wordsRemaining, 0);
});

test("only a signed-in OpenWhispr Cloud recording is re-transcribed", async (t) => {
  const AudioManager = await loadManagerClass(t);
  for (const settings of [{ cloudTranscriptionMode: "byok" }, { isSignedIn: false }]) {
    const { uploads, published } = await stopManagedDictation(AudioManager, {
      final: JA_FINAL,
      settings,
      upload: async () => assert.fail("must not upload to Cloud"),
    });
    assert.equal(uploads.length, 0, JSON.stringify(settings));
    assert.equal(published[0].text, "ashita no kaigi");
  }
});

test("kept Orukeet text carries the estimate into streaming cleanup and translation", async (t) => {
  const AudioManager = await loadManagerClass(t, {
    "/stores/settingsStore": `
      export const getSettings = () => globalThis.__streamingFinalizationSettings;
      export const getEffectiveCleanupModel = () => null;
      export const selectResolvedLLMConfig = () => ({ model: null, provider: null });
      export const isCloudCleanupMode = () => true;
      export const isCloudDictationAgentMode = () => false;
      export const isCloudTranslationMode = () => true;
    `,
    "/config/prompts": `
      export const resolvePrompt = () => "translation prompt";
      export const appendScreenContextSuffix = (prompt) => prompt;
    `,
    "/dictationAgentInference": `
      export const resolveDictationAgentInference = () => ({ reachable: false, config: {} });
      export const resolveDictationAgentVisionInference = () => ({ active: false, config: {} });
    `,
    "/dictationTranslationInference": `
      export const resolveDictationTranslationInference = () => ({
        reachable: true, model: "translation-model", config: { provider: "openwhispr" }
      });
    `,
  });
  for (const translationRequested of [false, true]) {
    const { uploads, reasonCalls, usage, published } = await stopManagedDictation(AudioManager, {
      final: { ...JA_FINAL, languageConfidence: 0.89 },
      upload: async () => assert.fail("must not re-transcribe"),
      settings: {
        useCleanupModel: true,
        cleanupCloudMode: "openwhispr",
        customPrompts: {},
        translationSourceLanguage: "en",
        translationTargetLanguage: "es",
      },
      overrides: {
        translationRequested,
        processWithReasoningModel: async () => "translated transcript",
        finalizeChineseScript: async (text) => text,
      },
    });
    const label = translationRequested ? "translation" : "cleanup";
    assert.equal(uploads.length, 0, label);
    assert.equal(
      published[0].text,
      translationRequested ? "translated transcript" : "ashita no kaigi。",
      label
    );
    // The cleanup call writes the combined log the backend's gate reads.
    assert.equal(reasonCalls.length, 1, label);
    assert.deepEqual(
      detectionFields(reasonCalls[0][1]),
      { ...JA_DETECTION, sttDetectedLanguageConfidence: 0.89 },
      label
    );
    assert.equal(usage[0].sendLogs, false, label);
  }
});

test("a non-Orukeet provider is untouched", async (t) => {
  const AudioManager = await loadManagerClass(t);
  const { uploads, usage, published } = await stopManagedDictation(AudioManager, {
    final: JA_FINAL,
    providerName: "deepgram",
    upload: async () => assert.fail("must not re-transcribe"),
  });
  assert.equal(uploads.length, 0);
  assert.equal(published[0].text, "ashita no kaigi");
  assert.deepEqual(detectionFields(usage[0]), {});
});

test("an empty Orukeet final with a confident unsupported estimate still re-transcribes", async (t) => {
  const AudioManager = await loadManagerClass(t);
  const { uploads, usage, published } = await stopManagedDictation(AudioManager, {
    final: { ...JA_FINAL, text: "" },
    upload: async () => ({ text: "明日の会議", rawText: "明日の会議" }),
  });
  assert.equal(uploads.length, 1);
  assert.equal(published[0].text, "明日の会議");
  assert.equal(usage.length, 0);
});

test("a language re-transcription whose selection edit fails keeps Cloud's transcript", async (t) => {
  const AudioManager = await loadManagerClass(t);
  const saved = [];
  const { published, errors } = await stopManagedDictation(AudioManager, {
    final: JA_FINAL,
    upload: async () => {
      const error = Object.assign(new Error("Selection edit failed"), {
        selectionEditFatal: true,
        code: "SELECTION_EDIT_REASONING_FAILED",
      });
      // What processWithOpenWhisprCloud attaches before rethrowing.
      Object.defineProperty(error, "transcript", { value: "明日の会議" });
      Object.defineProperty(error, "transcriptClientId", { value: "cloud-client-id" });
      throw error;
    },
    overrides: { saveFailedTranscription: (...args) => saved.push(args) },
  });
  assert.equal(errors[0].transcript, "明日の会議");
  assert.deepEqual(
    saved.map((args) => args[3]),
    [{ transcript: "明日の会議", clientTranscriptionId: "cloud-client-id" }]
  );
  assert.deepEqual(published, []);
});

test("a selection edit that fails during the language re-transcription surfaces its error", async (t) => {
  const AudioManager = await loadManagerClass(t);
  const selectionEditFailure = () =>
    Object.assign(new Error("Selection edit failed"), {
      selectionEditFatal: true,
      code: "SELECTION_EDIT_REASONING_FAILED",
    });
  const saved = [];
  const { reasonCalls, usage, published, errors } = await stopManagedDictation(AudioManager, {
    final: JA_FINAL,
    upload: async () => {
      throw selectionEditFailure();
    },
    overrides: { saveFailedTranscription: (...args) => saved.push(args) },
  });
  // As a failed batch selection edit ends: its own title, recording kept.
  assert.deepEqual(
    errors.map(({ title, description, code }) => [title, description, code]),
    [["Selection Edit Failed", "Selection edit failed", "SELECTION_EDIT_REASONING_FAILED"]]
  );
  assert.deepEqual(
    saved.map(([, code]) => code),
    ["SELECTION_EDIT_REASONING_FAILED"]
  );
  // Orukeet's discarded text is neither published nor edited with.
  assert.deepEqual(published, []);
  assert.deepEqual(reasonCalls, []);
  assert.deepEqual(usage, []);

  // A cancelled dictation ends quietly instead.
  const cancelled = await stopManagedDictation(AudioManager, {
    final: JA_FINAL,
    upload: async (manager) => {
      manager._requestStreamingCancellation();
      throw selectionEditFailure();
    },
  });
  assert.equal(cancelled.stopResult, true);
  assert.deepEqual(cancelled.errors, []);
  assert.deepEqual(cancelled.published, []);
});

test("language-score rollout modes reach the real finalization path without leaking content", async (t) => {
  globalThis.__orukeetRoutingLog = [];
  t.after(() => delete globalThis.__orukeetRoutingLog);
  const AudioManager = await loadManagerClass(t, {
    "/utils/logger": `export default { debug() {}, warn() {}, error() {}, logReasoning() {}, info(message, meta) { if (message === "Orukeet language routing comparison") globalThis.__orukeetRoutingLog.push(meta); } };`,
  });
  const sample = {
    ...JA_FINAL,
    text: "PRIVATE DICTATION",
    language: "hi",
    languageConfidence: 0.55,
    languageSupportedScore: 0.02,
  };
  for (const [mode, expected] of [
    ["shadow", false],
    ["supported-0.30", true],
    ["supported-0.10", true],
    ["off", false],
  ]) {
    globalThis.__orukeetRoutingLog.length = 0;
    const result = await stopManagedDictation(AudioManager, {
      final: sample,
      overrides: { sttConfig: { orukeetLanguageRouting: mode } },
      upload: async () => ({ text: "Cloud result", rawText: "Cloud result" }),
    });
    assert.equal(result.uploads.length, expected ? 1 : 0, mode);
    assert.equal(result.published[0].text, expected ? "Cloud result" : sample.text, mode);
    assert.equal(result.reasonCalls.length, 0, "no extra cleanup call");
    assert.equal(globalThis.__orukeetRoutingLog.length, mode === "off" ? 0 : 1);
    assert.doesNotMatch(
      JSON.stringify(globalThis.__orukeetRoutingLog),
      /PRIVATE DICTATION|Cloud result/
    );
    if (mode !== "off") {
      assert.equal(globalThis.__orukeetRoutingLog[0].fallbackAvailable, true);
      const telemetry = expected ? result.uploads[0] : result.usage[0];
      assert.deepEqual(telemetry.orukeetLanguageRouting, globalThis.__orukeetRoutingLog[0]);
      if (expected) assert.equal(telemetry.streamingFallbackReason, "language_supported_score_low");
    }
  }
});

test("language-score routing uses analyzed time and preserves explicit language, BYOK and unavailable metadata", async (t) => {
  const AudioManager = await loadManagerClass(t);
  const sample = {
    ...JA_FINAL,
    language: "hi",
    languageConfidence: 0.55,
    languageSupportedScore: 0.02,
  };
  for (const overrides of [
    { final: { ...sample, languageAudioSeconds: 3 } },
    { final: { ...sample, languageSupportedScore: undefined } },
    { language: "en" },
    { settings: { cloudTranscriptionMode: "byok" } },
    { providerName: "deepgram" },
  ]) {
    const r = await stopManagedDictation(AudioManager, {
      final: sample,
      overrides: { sttConfig: { orukeetLanguageRouting: "supported-0.30" } },
      upload: async () => ({ text: "Unexpected cloud", rawText: "Unexpected cloud" }),
      ...overrides,
    });
    assert.equal(r.uploads.length, 0, JSON.stringify(overrides));
    // An own-key stream reports no Cloud usage (#2558).
    if (overrides.settings?.cloudTranscriptionMode === "byok") assert.deepEqual(r.usage, []);
    if (overrides.providerName === "deepgram")
      assert.equal(r.usage[0].orukeetLanguageRouting, undefined);
  }
});

test("group-score fallback failure still discards the unsupported transcript", async (t) => {
  const AudioManager = await loadManagerClass(t);
  const r = await stopManagedDictation(AudioManager, {
    final: { ...JA_FINAL, languageConfidence: 0.4, languageSupportedScore: 0.01 },
    overrides: {
      sttConfig: { orukeetLanguageRouting: "supported-0.30" },
      saveFailedTranscription() {},
    },
    upload: async () => {
      throw Object.assign(new Error("Cloud unavailable"), { code: "NETWORK_ERROR" });
    },
  });
  assert.equal(r.uploads.length, 1);
  assert.equal(
    r.published.some((x) => x.text === JA_FINAL.text),
    false
  );
  assert.equal(r.errors.length, 1);
});

test("combined cleanup is reused once, while changed options or failed cleanup use the ordinary route", async (t) => {
  const AudioManager = await loadManagerClass(t, {
    "/stores/settingsStore": `
      export const getSettings = () => globalThis.__streamingFinalizationSettings;
      export const getEffectiveCleanupModel = () => null;
      export const selectResolvedLLMConfig = () => ({ model: null, provider: null });
      export const isCloudCleanupMode = () => true;
      export const isCloudDictationAgentMode = () => false;
      export const isCloudTranslationMode = () => false;
    `,
  });
  for (const [cleanupStatus, changed, calls, empty] of [
    ["complete", false, 0, false],
    ["complete", true, 1, false],
    ["fallback", false, 1, false],
    ["complete", false, 1, true],
  ]) {
    const options = { customDictionary: ["Orukeet"], language: "en" };
    const { reasonCalls, usage, published } = await stopManagedDictation(AudioManager, {
      final: {
        success: true,
        text: "please send invoice 128",
        cleanupStatus,
        cleanupText: empty ? "" : "Please send invoice 128.",
        asrFinalMs: 103,
        cleanup: {
          status: cleanupStatus,
          model: "gemma-4-12b",
          processingMs: 220,
          inputTokens: 40,
          outputTokens: 8,
        },
        cleanupOptions: options,
      },
      settings: { useCleanupModel: true, cleanupCloudMode: "openwhispr", customPrompts: {} },
      overrides: {
        _activePipelineOptions: changed ? { ...options, language: "fr" } : options,
        finalizeChineseScript: async (text) => text,
      },
    });
    assert.equal(reasonCalls.length, calls);
    assert.equal(published[0].rawText, "please send invoice 128");
    assert.equal(
      published[0].text,
      calls ? "please send invoice 128。" : "Please send invoice 128."
    );
    assert.equal(usage.length, 1);
    // Raw words are billed only when the combined cleanup is the pasted text.
    assert.equal(usage[0].text, calls ? published[0].text : "please send invoice 128");
    assert.equal(usage[0].sendLogs, calls === 0);
    assert.equal(usage[0].sttProcessingMs, 103);
    // A completed Gemma cleanup that wasn't used is never reported as this request's.
    const reported = cleanupStatus === "fallback" || calls === 0;
    assert.equal(usage[0].orukeetCleanup?.processingMs, reported ? 220 : undefined);
    if (calls)
      assert.equal(reasonCalls[0][1].orukeetCleanup?.status, reported ? "fallback" : undefined);
  }
});

test("combined cleanup that never finished pastes the raw text with a cleanup notice", async (t) => {
  const AudioManager = await loadManagerClass(t, {
    "/stores/settingsStore": `
      export const getSettings = () => globalThis.__streamingFinalizationSettings;
      export const getEffectiveCleanupModel = () => null;
      export const selectResolvedLLMConfig = () => ({ model: null, provider: null });
      export const isCloudCleanupMode = () => true;
      export const isCloudDictationAgentMode = () => false;
      export const isCloudTranslationMode = () => false;
    `,
  });
  const { reasonCalls, uploads, usage, published } = await stopManagedDictation(AudioManager, {
    final: {
      success: true,
      text: "please send invoice 128",
      cleanupError: "Orukeet final transcript timed out",
      asrFinalMs: 103,
      cleanup: { status: "fallback" },
    },
    upload: async () => assert.fail("The finished ASR text must not be transcribed again"),
    settings: { useCleanupModel: true, cleanupCloudMode: "openwhispr", customPrompts: {} },
  });
  assert.equal(reasonCalls.length, 0);
  assert.equal(uploads.length, 0);
  assert.equal(published[0].text, "please send invoice 128");
  assert.equal(published[0].cleanupFailure.messageKey, "app.toasts.cleanupFailed.title");
  assert.equal(usage[0].text, "please send invoice 128");
  assert.equal(usage[0].sendLogs, true);
  assert.deepEqual(usage[0].orukeetCleanup, { status: "fallback" });
});

test("combined text never replaces an unsupported-language fallback", async (t) => {
  const AudioManager = await loadManagerClass(t);
  const { uploads, published, reasonCalls } = await stopManagedDictation(AudioManager, {
    final: {
      ...JA_FINAL,
      cleanupStatus: "complete",
      cleanupText: "Wrong cleanup.",
      cleanupOptions: {},
      cleanup: { status: "complete", model: "gemma-4-12b" },
    },
    upload: async () => ({ text: "明日の会議", rawText: "明日の会議" }),
    overrides: { getPipelineCleanupOptions: () => ({}) },
  });
  assert.equal(uploads.length, 1);
  assert.equal(uploads[0].orukeetCleanup, undefined);
  assert.equal(reasonCalls.length, 0);
  assert.equal(published[0].text, "明日の会議");
});

test("ordinary Orukeet streams meter processed text and BYOK streams meter nothing", async (t) => {
  const AudioManager = await loadManagerClass(t, {
    "/stores/settingsStore": `
    export const getSettings = () => globalThis.__streamingFinalizationSettings;
    export const getEffectiveCleanupModel = () => null;
    export const selectResolvedLLMConfig = () => ({ model: null, provider: null });
    export const isCloudCleanupMode = () => true;
    export const isCloudDictationAgentMode = () => false;
    export const isCloudTranslationMode = () => false;
  `,
  });
  for (const cloudTranscriptionMode of ["openwhispr", "byok"]) {
    const result = await stopManagedDictation(AudioManager, {
      final: { success: true, text: "um please send invoice 128" },
      settings: {
        cloudTranscriptionMode,
        useCleanupModel: true,
        cleanupCloudMode: "openwhispr",
        customPrompts: { cleanup: "Keep text." },
      },
    });
    assert.equal(result.published[0].text, "um please send invoice 128。");
    if (cloudTranscriptionMode === "byok") {
      // An own-key stream reports no Cloud usage (#2558).
      assert.deepEqual(result.usage, []);
      continue;
    }
    assert.equal(result.usage[0].text, result.published[0].text);
    assert.equal(result.usage[0].sendLogs, false);
  }
});

test("recording config snapshot survives a rollback until the next recording", async (t) => {
  const AudioManager = await loadManagerClass(t);
  const result = await stopManagedDictation(AudioManager, {
    final: { ...JA_FINAL, languageConfidence: 0.55, languageSupportedScore: 0.02 },
    overrides: {
      _activeStreamingConfig: { orukeetLanguageRouting: "supported-0.30" },
      sttConfig: { orukeetLanguageRouting: "off", streamingProvider: "deepgram" },
    },
    upload: async () => ({ text: "Cloud result" }),
  });
  assert.equal(result.uploads.length, 1);
  assert.equal(result.uploads[0].orukeetLanguageRouting.mode, "supported-0.30");
  assert.equal(result.manager._activeStreamingConfig, null);
});

test("combined options are captured and passed through recording start", async (t) => {
  const AudioManager = await loadManagerClass(t);
  useManagedOrukeetSettings();
  installCapture(t);
  const options = { customDictionary: ["Orukeet"], language: "en" };
  let sent;
  const { manager } = createStartingManager(AudioManager, {
    providerName: "orukeet",
    provider: startingOrukeetProvider({
      start: async (value) => {
        sent = value;
        return { success: true };
      },
    }),
  });
  manager.getPipelineCleanupOptions = () => options;
  manager.sttConfig = { orukeetPipeline: "gemma12", orukeetLanguageRouting: "shadow" };
  await manager.startStreamingRecording();
  assert.deepEqual(sent.pipelineOptions, options);
  assert.equal(manager._activePipelineOptions, options);
  manager.setSttConfig({ streamingProvider: "deepgram" });
  assert.equal(manager._activeStreamingConfig.orukeetPipeline, "gemma12");
  await manager.cancelStreamingRecording();
});

// Cleanup routes on the store's whole cloud predicate, so the mock mirrors
// selectIsCloudCleanupMode: onboarding's local choice leaves cleanupCloudMode at
// its "openwhispr" default, and that field alone must never send text to Cloud.
const CLEANUP_ROUTING_STORE = `
  export const getSettings = () => globalThis.__streamingFinalizationSettings;
  export const isCloudCleanupMode = () => {
    const s = getSettings();
    return !!s.isSignedIn && s.cleanupMode === "openwhispr" && s.cleanupCloudMode === "openwhispr";
  };
  export const selectResolvedLLMConfig = (s) => ({
    model: s.cleanupModel,
    provider: s.cleanupMode === "openwhispr" ? "openwhispr" : "qwen",
    mode: s.cleanupMode,
  });
  export const getEffectiveCleanupModel = () =>
    isCloudCleanupMode() ? "" : selectResolvedLLMConfig(getSettings()).model;
  export const isCloudDictationAgentMode = () => false;
  export const isCloudTranslationMode = () => false;
`;

const LOCAL_CLEANUP_MODEL = "qwen3.5-4b-q4_k_m";

// `expected` is where cleanup runs: "cloud" (cloudReason), "model" (the scope's
// own model) or "raw" (no reachable cleanup, so the transcript is kept as is).
const CLEANUP_ROUTING_CASES = [
  {
    label: "local, cloud field left at default",
    cleanupMode: "local",
    cleanupCloudMode: "openwhispr",
    expected: "model",
  },
  {
    label: "local, cloud field byok",
    cleanupMode: "local",
    cleanupCloudMode: "byok",
    expected: "model",
  },
  {
    label: "local, model not downloaded",
    cleanupMode: "local",
    cleanupCloudMode: "openwhispr",
    cleanupModel: "",
    expected: "raw",
  },
  {
    label: "self-hosted, cloud field left at default",
    cleanupMode: "self-hosted",
    cleanupCloudMode: "openwhispr",
    expected: "model",
  },
  {
    label: "providers (BYOK)",
    cleanupMode: "providers",
    cleanupCloudMode: "byok",
    expected: "model",
  },
  {
    label: "providers, cloud field left at default",
    cleanupMode: "providers",
    cleanupCloudMode: "openwhispr",
    expected: "model",
  },
  {
    label: "OpenWhispr Cloud",
    cleanupMode: "openwhispr",
    cleanupCloudMode: "openwhispr",
    expected: "cloud",
  },
  {
    label: "OpenWhispr Cloud, signed out",
    cleanupMode: "openwhispr",
    cleanupCloudMode: "openwhispr",
    cleanupModel: "",
    isSignedIn: false,
    expected: "raw",
  },
];

const SIGNED_IN_CLEANUP_ROUTING_CASES = CLEANUP_ROUTING_CASES.filter(
  ({ isSignedIn }) => isSignedIn !== false
);

function cleanupRoutingSettings({
  cleanupMode,
  cleanupCloudMode,
  cleanupModel = LOCAL_CLEANUP_MODEL,
  isSignedIn = true,
}) {
  return {
    useCleanupModel: true,
    cleanupMode,
    cleanupCloudMode,
    cleanupModel,
    isSignedIn,
    customPrompts: {},
  };
}

function cleanedText(text, { expected }) {
  if (expected === "cloud") return `${text}。`;
  return expected === "model" ? `${text} (local)` : text;
}

const CLEANUP_TRANSLATION_MODULES = {
  "/stores/settingsStore": CLEANUP_ROUTING_STORE,
  "/config/prompts": `
    export const resolvePrompt = () => "translation prompt";
    export const appendScreenContextSuffix = (prompt) => prompt;
  `,
  "/dictationAgentInference": `
    export const resolveDictationAgentInference = () => ({ reachable: false, config: {} });
    export const resolveDictationAgentVisionInference = () => ({ active: false, config: {} });
  `,
  "/dictationTranslationInference": `
    export const resolveDictationTranslationInference = () => ({
      reachable: true, model: "translation-model", config: { provider: "qwen" }
    });
  `,
};

// Cloud carries the STT telemetry for its combined log; any other cleanup
// descriptor names the scope's model and sends nothing to Cloud.
function assertChainCleanup(cleanup, routing) {
  if (routing.expected === "cloud") {
    assert.equal(cleanup.mode, "cloudReason");
    return;
  }
  assert.equal(cleanup.mode, "model");
  assert.equal(cleanup.model, cleanupRoutingSettings(routing).cleanupModel);
  assert.equal(cleanup.meta, undefined);
}

function useOnlineNavigator(t) {
  const originalNavigator = globalThis.navigator;
  Object.defineProperty(globalThis, "navigator", { value: { onLine: true }, configurable: true });
  t.after(() =>
    Object.defineProperty(globalThis, "navigator", {
      value: originalNavigator,
      configurable: true,
    })
  );
}

function countingReasoningModel(localCalls) {
  return async (text, model) => {
    localCalls.push([text, model]);
    return `${text} (local)`;
  };
}

test("streaming cleanup goes to Cloud only when the cleanup scope is OpenWhispr Cloud", async (t) => {
  const AudioManager = await loadManagerClass(t, {
    "/stores/settingsStore": CLEANUP_ROUTING_STORE,
  });
  for (const routing of CLEANUP_ROUTING_CASES) {
    await t.test(routing.label, async () => {
      const localCalls = [];
      const { reasonCalls, usage, published } = await stopManagedDictation(AudioManager, {
        final: { success: true, text: "hello there", model: "orukeet-v0.1.0" },
        language: "en",
        upload: async () => assert.fail("must not re-transcribe"),
        settings: cleanupRoutingSettings(routing),
        overrides: {
          processWithReasoningModel: countingReasoningModel(localCalls),
          finalizeChineseScript: async (text) => text,
        },
      });
      assert.equal(reasonCalls.length, routing.expected === "cloud" ? 1 : 0);
      assert.deepEqual(
        localCalls.map(([, model]) => model),
        routing.expected === "model" ? [LOCAL_CLEANUP_MODEL] : []
      );
      assert.equal(published[0].text, cleanedText("hello there", routing));
      // Only a Cloud cleanup writes the combined log, so only it suppresses the STT one.
      assert.equal(usage.length, 1);
      assert.equal(usage[0].sendLogs, routing.expected !== "cloud");
    });
  }
});

test("streaming translation cleans up in Cloud only when the cleanup scope is OpenWhispr Cloud", async (t) => {
  const AudioManager = await loadManagerClass(t, CLEANUP_TRANSLATION_MODULES);
  for (const routing of CLEANUP_ROUTING_CASES) {
    await t.test(routing.label, async () => {
      const chainCleanups = [];
      await stopManagedDictation(AudioManager, {
        final: { success: true, text: "hello there", model: "orukeet-v0.1.0" },
        language: "en",
        upload: async () => assert.fail("must not re-transcribe"),
        settings: {
          ...cleanupRoutingSettings(routing),
          translationSourceLanguage: "en",
          translationTargetLanguage: "es",
        },
        overrides: {
          translationRequested: true,
          runTranslationChain: async ({ cleanup }) => {
            chainCleanups.push(cleanup);
            return { text: "hola" };
          },
          finalizeChineseScript: async (text) => text,
        },
      });
      assert.equal(chainCleanups.length, 1);
      assertChainCleanup(chainCleanups[0], routing);
    });
  }
});

test("batch Cloud cleanup goes to Cloud only when the cleanup scope is OpenWhispr Cloud", async (t) => {
  const AudioManager = await loadManagerClass(t, {
    "/stores/settingsStore": CLEANUP_ROUTING_STORE,
  });
  useOnlineNavigator(t);
  // Signed out never re-transcribes through Cloud, so it never reaches this path.
  for (const routing of SIGNED_IN_CLEANUP_ROUTING_CASES) {
    await t.test(routing.label, async () => {
      const transcribeOpts = [];
      globalThis.window.electronAPI.cloudTranscribe = async (_audio, opts) => {
        transcribeOpts.push(opts);
        return { success: true, text: "明日の会議", sttProvider: "openai" };
      };
      const localCalls = [];
      const { reasonCalls, published } = await stopManagedDictation(AudioManager, {
        final: JA_FINAL,
        settings: cleanupRoutingSettings(routing),
        overrides: {
          isDictionaryEcho: () => false,
          getWhisperPrompt: () => null,
          finalizeChineseScript: async (text) => text,
          processWithReasoningModel: countingReasoningModel(localCalls),
        },
      });
      assert.equal(transcribeOpts.length, 1);
      assert.equal(reasonCalls.length, routing.expected === "cloud" ? 1 : 0);
      assert.equal(localCalls.length, routing.expected === "model" ? 1 : 0);
      assert.equal(published[0].text, cleanedText("明日の会議", routing));
      // Only a Cloud cleanup writes the combined log, so only it suppresses the STT one.
      assert.equal(transcribeOpts[0].sendLogs, routing.expected === "cloud" ? "false" : undefined);
    });
  }
});

test("batch Cloud translation cleans up in Cloud only when the cleanup scope is OpenWhispr Cloud", async (t) => {
  const AudioManager = await loadManagerClass(t, CLEANUP_TRANSLATION_MODULES);
  useOnlineNavigator(t);
  for (const routing of SIGNED_IN_CLEANUP_ROUTING_CASES) {
    await t.test(routing.label, async () => {
      const transcribeOpts = [];
      globalThis.window.electronAPI.cloudTranscribe = async (_audio, opts) => {
        transcribeOpts.push(opts);
        return { success: true, text: "明日の会議", sttProvider: "openai" };
      };
      const chainCleanups = [];
      await stopManagedDictation(AudioManager, {
        final: JA_FINAL,
        settings: {
          ...cleanupRoutingSettings(routing),
          translationSourceLanguage: "ja",
          translationTargetLanguage: "en",
        },
        overrides: {
          translationRequested: true,
          isDictionaryEcho: () => false,
          getWhisperPrompt: () => null,
          runTranslationChain: async ({ cleanup }) => {
            chainCleanups.push(cleanup);
            return { text: "tomorrow's meeting" };
          },
          finalizeChineseScript: async (text) => text,
        },
      });
      assert.equal(transcribeOpts.length, 1);
      assert.equal(chainCleanups.length, 1);
      assertChainCleanup(chainCleanups[0], routing);
    });
  }
});