From 36e079d7417f9a13eb6d71a9a7da6a54aee86ca5 Mon Sep 17 00:00:00 2001
From: Tadas Petra <60107328+tadaspetra@users.noreply.github.com>
Date: Thu, 2 Jul 2026 09:07:06 -0500
Subject: [PATCH] Replace realtime Scribe streaming with post-recording batch
 transcription

The realtime WebSocket session died during long silences (idle/session
limits), killing the transcript for the rest of the take. Transcription is
now a batch pass over the finalized recording, ordered so footage durability
never depends on the network:

- Stop flow saves the recovery checkpoint before any transcription call;
  failure or timeout falls back to full-duration sections with a visible
  warning instead of blocking or losing the take.
- New main-process transcription-service extracts audio from the finalized
  file via ffmpeg stream copy and calls batch Scribe (scribe_v2, word
  timestamps); the API key never reaches the renderer.
- Word timestamps map into recording time via per-file recorder start
  offsets instead of the old wall-clock estimate.
- Record is blocked while the previous take is still post-processing so
  overlapping take flows cannot race on the shared recovery checkpoint.
- Removed the WebSocket/AudioWorklet/PCM pipeline, live segment editing UI,
  scribe token IPC, and scribe-status module (net -215 lines).

Tests: segment builder + timeout helper (15), transcription service temp-file
cleanup and failure paths (10), IPC handler validation (3); media-cleanup and
register-handlers suites updated. pnpm run check passes.

Co-Authored-By: Claude Fable 5 <noreply@anthropic.com>
---
 .env.example                                  |   2 +-
 AGENTS.md                                     |   2 +-
 docs/production/feature-inventory.md          |  19 +-
 docs/production/runbook.md                    |   2 +-
 docs/production/target-architecture.md        |   4 +-
 src/audio-processor.ts                        |  15 -
 src/main.ts                                   |   4 +-
 src/main/ipc/register-handlers.ts             |  23 +-
 src/main/services/scribe-service.ts           |  10 +-
 src/main/services/transcription-service.ts    | 150 ++++++
 src/preload.ts                                |   2 +-
 src/renderer/app.ts                           | 467 +++++-------------
 src/renderer/features/media-cleanup.ts        |  25 -
 .../features/transcript/batch-transcript.ts   | 100 ++++
 .../features/transcript/scribe-status.ts      | 119 -----
 src/shared/electron-api.ts                    |  17 +-
 tests/unit/batch-transcript.test.ts           | 143 ++++++
 tests/unit/media-cleanup.test.ts              |  37 --
 tests/unit/register-handlers.test.ts          |  58 ++-
 tests/unit/scribe-status.test.ts              |  68 ---
 tests/unit/transcription-service.test.ts      | 205 ++++++++
 tsconfig.build.json                           |   1 -
 22 files changed, 827 insertions(+), 646 deletions(-)
 delete mode 100644 src/audio-processor.ts
 create mode 100644 src/main/services/transcription-service.ts
 create mode 100644 src/renderer/features/transcript/batch-transcript.ts
 delete mode 100644 src/renderer/features/transcript/scribe-status.ts
 create mode 100644 tests/unit/batch-transcript.test.ts
 delete mode 100644 tests/unit/scribe-status.test.ts
 create mode 100644 tests/unit/transcription-service.test.ts

diff --git a/.env.example b/.env.example
index 0b20037..a8df4b3 100644
--- a/.env.example
+++ b/.env.example
@@ -1,2 +1,2 @@
-# Required for realtime transcript token generation.
+# Required for post-recording batch transcription (main process only).
 ELEVENLABS_API_KEY=
diff --git a/AGENTS.md b/AGENTS.md
index 8029222..6bf03df 100644
--- a/AGENTS.md
+++ b/AGENTS.md
@@ -241,7 +241,7 @@ Default to:
 - Very long timelines with dense camera-overlay keyframes can produce extremely nested ffmpeg filter expressions that exceed parser limits and fail render; the overlay graph needs to stay bounded for long sessions.
 - Heavy H.264 screen exports (high resolution, high quality, dense UI detail) can stress QuickTime playback more than NLEs; explicit yuv420p and a compatible profile/level—and avoiding unnecessary output resolution—improves default macOS playback.
 - `@electron/packager` dependency pruning can miss transitive packages under `pnpm`’s symlinked `node_modules` layout (fresh CI installs surface this); the packaging smoke harness avoids relying on that prune path.
-- The Scribe live-transcription `AudioWorklet` (`audio-processor`) must load as a plain browser worklet script; compiling it with the main-process TypeScript target (e.g. CommonJS/NodeNext) breaks loading (`exports` undefined) and silently disables transcription-driven features.
+- Transcription is a batch pass over the finalized recording (main-process `transcription-service` extracts audio via ffmpeg stream copy, then calls ElevenLabs batch Scribe with word timestamps); it must never run before the finalized files and the recovery checkpoint are on disk, and its failure/timeout must fall back to full-duration sections instead of blocking or losing the take. The realtime Scribe WebSocket/AudioWorklet pipeline was removed because long silences and session limits killed the live socket mid-recording; take flows are serialized (`stopRecordingInFlight` guards Record) so overlapping post-processing cannot race on the shared recovery checkpoint.
 - `src/renderer/styles/main.css` is Tailwind build output (`build:styles`, minified); full `check` rebuilds styles via nested steps, so tracking a non-matching formatted copy causes perpetual diffs—prefer generating locally and not treating it as hand-edited source.
 - Recording durability depends on streaming `MediaRecorder` chunks directly to disk via IPC temp `.part` files (renamed on finalize) instead of buffering in the renderer; screen and camera are independent recorder pipelines, so stop/save/finalize must tolerate one failing without blocking the other, and recovery normalization must require the screen file but tolerate a missing camera file so a partial failure does not discard an otherwise-recoverable take. Partial WebM files report `duration=Infinity`; resolve real duration by seeking a probe `<video>` element to `1e101` so the browser computes duration from the seekable range, and tolerate unreadable probes without wedging the whole recovery flow.
 - Premiere Pro FCP7 xmeml `Crop` must be emitted as `<effecttype>filter</effecttype>` + `<effectcategory>Matte</effectcategory>`; mis-classifying it as a motion effect makes Premiere silently drop the effect, leaving the camera uncropped and PiP placement drifting off the intended corner. Crop runs before the fixed Motion effect in Premiere's pipeline, which shapes how authored PiP geometry translates into Motion center/scale + Crop percentages.
diff --git a/docs/production/feature-inventory.md b/docs/production/feature-inventory.md
index 75c9d39..94cbfb9 100644
--- a/docs/production/feature-inventory.md
+++ b/docs/production/feature-inventory.md
@@ -78,23 +78,16 @@ Acceptance criteria:
 
 ## C. Transcript And Trim
 
-### C1. Realtime transcript
+### C1. Batch transcript
 
-- During recording, app sends PCM chunks to Scribe realtime websocket and displays partial + committed text.
+- After recording stops and the take's files are finalized and checkpointed for recovery, the app batch-transcribes the finalized mic audio (audio-only file, or audio extracted from the camera file via ffmpeg stream copy) with ElevenLabs Scribe in the main process, then groups word timestamps into speech segments.
 
 Acceptance criteria:
 
-- Committed transcript segments store `start/end/text`.
-- Non-speech annotations (e.g. bracketed cues) are stripped from user-visible transcript and segment content.
-
-### C2. Segment editing
-
-- User can select transcript segments and toggle deletion with keyboard shortcuts.
-
-Acceptance criteria:
-
-- Deleted segments are excluded from trim input.
-- Badge reflects active vs removed count.
+- No transcription network call happens before the finalized files and the recovery take are on disk; a transcription failure or timeout never loses or blocks the recording (falls back to full-duration sections with a visible warning).
+- Speech segments store `start/end/text`, with word timestamps mapped into recording time using the per-file recorder start offsets.
+- Non-speech annotations (e.g. bracketed cues) are stripped from segment content.
+- Recordings without mic audio skip transcription entirely (no network call).
 
 ### C3. Section computation
 
diff --git a/docs/production/runbook.md b/docs/production/runbook.md
index f3a8a3d..22ab737 100644
--- a/docs/production/runbook.md
+++ b/docs/production/runbook.md
@@ -3,7 +3,7 @@
 ## Environment
 
 - Copy `.env.example` to `.env`.
-- Set `ELEVENLABS_API_KEY` for realtime transcription token generation.
+- Set `ELEVENLABS_API_KEY` for post-recording batch transcription (used only in the main process; never exposed to the renderer).
 
 ## Local Verification
 
diff --git a/docs/production/target-architecture.md b/docs/production/target-architecture.md
index 3bf9923..a60929c 100644
--- a/docs/production/target-architecture.md
+++ b/docs/production/target-architecture.md
@@ -22,6 +22,7 @@ src/
       render-service.js
       sections-service.js
       scribe-service.js
+      transcription-service.js
       media-service.js
     infra/
       file-system.js
@@ -33,6 +34,7 @@ src/
     features/
       transcript/
         transcript-utils.js
+        batch-transcript.js
       timeline/
         section-utils.js
         keyframe-utils.js
@@ -59,7 +61,7 @@ flowchart LR
   mainIpc --> recoveryService["services/recovery-service.js"]
   mainIpc --> renderService["services/render-service.js"]
   mainIpc --> sectionsService["services/sections-service.js"]
-  mainIpc --> scribeService["services/scribe-service.js"]
+  mainIpc --> transcriptionService["services/transcription-service.js"]
   projectService --> sharedDomain["shared/domain/*.js"]
   recoveryService --> sharedDomain
   renderService --> sharedDomain
diff --git a/src/audio-processor.ts b/src/audio-processor.ts
deleted file mode 100644
index f3e27a9..0000000
--- a/src/audio-processor.ts
+++ /dev/null
@@ -1,15 +0,0 @@
-class AudioCaptureProcessor extends AudioWorkletProcessor {
-  process(inputs: Float32Array[][]): boolean {
-    const input = inputs[0]?.[0];
-    if (!input) return true;
-
-    const pcm = new Int16Array(input.length);
-    for (let index = 0; index < input.length; index += 1) {
-      pcm[index] = Math.max(-32768, Math.min(32767, Math.round(input[index] * 32767)));
-    }
-    this.port.postMessage({ pcm: pcm.buffer }, [pcm.buffer]);
-    return true;
-  }
-}
-
-registerProcessor('audio-capture', AudioCaptureProcessor);
diff --git a/src/main.ts b/src/main.ts
index e1976df..c5665b3 100644
--- a/src/main.ts
+++ b/src/main.ts
@@ -23,7 +23,7 @@ import { renderComposite } from './main/services/render-service';
 import { exportPremiereProject } from './main/services/premiere-export-service';
 import { computeSections } from './main/services/sections-service';
 import { generatePreview } from './main/services/preview-render-service';
-import { getScribeToken } from './main/services/scribe-service';
+import { transcribeRecordingFile } from './main/services/transcription-service';
 import * as proxyService from './main/services/proxy-service';
 import * as recordingService from './main/services/recording-service';
 
@@ -49,7 +49,7 @@ registerIpcHandlers({
   exportPremiereProject,
   computeSections,
   generatePreview,
-  getScribeToken,
+  transcribeRecordingFile,
   proxyService,
   recordingService,
   setPendingDisplayMediaSource
diff --git a/src/main/ipc/register-handlers.ts b/src/main/ipc/register-handlers.ts
index 960c0bb..bf08cbd 100644
--- a/src/main/ipc/register-handlers.ts
+++ b/src/main/ipc/register-handlers.ts
@@ -19,6 +19,7 @@ import type { renderComposite } from '../services/render-service';
 import type { exportPremiereProject } from '../services/premiere-export-service';
 import type { computeSections } from '../services/sections-service';
 import type { generatePreview } from '../services/preview-render-service';
+import type { transcribeRecordingFile } from '../services/transcription-service';
 import type * as proxyServiceModule from '../services/proxy-service';
 import type * as recordingServiceModule from '../services/recording-service';
 
@@ -28,6 +29,9 @@ type RenderComposite = typeof renderComposite;
 type ExportPremiereProject = typeof exportPremiereProject;
 type ComputeSections = typeof computeSections;
 type GeneratePreview = typeof generatePreview;
+type TranscribeRecordingFile = (
+  opts: Parameters<typeof transcribeRecordingFile>[0]
+) => ReturnType<typeof transcribeRecordingFile>;
 type ProxyService = typeof proxyServiceModule;
 type RecordingService = typeof recordingServiceModule;
 
@@ -51,7 +55,7 @@ export function registerIpcHandlers({
   exportPremiereProject,
   computeSections,
   generatePreview,
-  getScribeToken,
+  transcribeRecordingFile,
   proxyService,
   recordingService,
   setPendingDisplayMediaSource
@@ -69,7 +73,7 @@ export function registerIpcHandlers({
   exportPremiereProject: ExportPremiereProject;
   computeSections: ComputeSections;
   generatePreview: GeneratePreview;
-  getScribeToken: () => Promise<string>;
+  transcribeRecordingFile: TranscribeRecordingFile;
   proxyService: ProxyService;
   recordingService: RecordingService;
   setPendingDisplayMediaSource: (sourceId: string | null) => void;
@@ -331,11 +335,20 @@ export function registerIpcHandlers({
     return filePaths[0];
   });
 
-  ipcMain.handle('get-scribe-token', async () => {
+  ipcMain.handle('transcription:transcribe', async (_event, opts: unknown) => {
+    const payload = (opts || {}) as { sourcePath?: unknown; languageCode?: unknown };
+    if (typeof payload.sourcePath !== 'string' || !payload.sourcePath.trim()) {
+      throw new Error('transcription:transcribe requires a sourcePath');
+    }
     try {
-      return await getScribeToken();
+      return await transcribeRecordingFile({
+        sourcePath: payload.sourcePath,
+        ...(typeof payload.languageCode === 'string' && payload.languageCode
+          ? { languageCode: payload.languageCode }
+          : {})
+      });
     } catch (error) {
-      console.error('Failed to get Scribe token:', error);
+      console.error('Batch transcription failed:', error);
       throw error;
     }
   });
diff --git a/src/main/services/scribe-service.ts b/src/main/services/scribe-service.ts
index e5a0c41..e9b613b 100644
--- a/src/main/services/scribe-service.ts
+++ b/src/main/services/scribe-service.ts
@@ -6,12 +6,4 @@ function getRequiredEnv(name: string): string {
   return value;
 }
 
-async function getScribeToken(): Promise<string> {
-  const apiKey = getRequiredEnv('ELEVENLABS_API_KEY');
-  const { ElevenLabsClient } = await import('@elevenlabs/elevenlabs-js');
-  const client = new ElevenLabsClient({ apiKey });
-  const response = await client.tokens.singleUse.create('realtime_scribe');
-  return response.token;
-}
-
-export { getRequiredEnv, getScribeToken };
+export { getRequiredEnv };
diff --git a/src/main/services/transcription-service.ts b/src/main/services/transcription-service.ts
new file mode 100644
index 0000000..41fe402
--- /dev/null
+++ b/src/main/services/transcription-service.ts
@@ -0,0 +1,150 @@
+import crypto from 'crypto';
+import fs from 'fs';
+import os from 'os';
+import path from 'path';
+
+import ffmpegStatic from 'ffmpeg-static';
+
+import { runFfmpeg } from './ffmpeg-runner';
+import { getRequiredEnv } from './scribe-service';
+
+export interface TranscriptionWord {
+  text: string;
+  start?: number;
+  end?: number;
+  type?: string;
+}
+
+export interface TranscribeRecordingResult {
+  words: TranscriptionWord[];
+  languageCode?: string;
+}
+
+export interface TranscribeRecordingOptions {
+  /** Finalized recording file that carries the mic audio (audio-only or camera webm). */
+  sourcePath: string;
+  languageCode?: string;
+}
+
+export interface TranscriptionDeps {
+  runFfmpegImpl?: typeof runFfmpeg;
+  ffmpegPath?: string;
+  /**
+   * Performs the batch speech-to-text request. Defaults to the ElevenLabs SDK;
+   * injectable so tests never touch the network.
+   */
+  convertImpl?: (request: {
+    modelId: string;
+    file: { path: string };
+    timestampsGranularity: string;
+    tagAudioEvents: boolean;
+    diarize: boolean;
+    languageCode?: string;
+  }) => Promise<unknown>;
+}
+
+async function defaultConvertImpl(request: {
+  modelId: string;
+  file: { path: string };
+  timestampsGranularity: string;
+  tagAudioEvents: boolean;
+  diarize: boolean;
+  languageCode?: string;
+}): Promise<unknown> {
+  const apiKey = getRequiredEnv('ELEVENLABS_API_KEY');
+  const { ElevenLabsClient } = await import('@elevenlabs/elevenlabs-js');
+  const client = new ElevenLabsClient({ apiKey });
+  return client.speechToText.convert(request as never);
+}
+
+function normalizeWords(rawWords: unknown): TranscriptionWord[] {
+  if (!Array.isArray(rawWords)) return [];
+  const words: TranscriptionWord[] = [];
+  for (const raw of rawWords) {
+    if (!raw || typeof raw !== 'object') continue;
+    const candidate = raw as { text?: unknown; start?: unknown; end?: unknown; type?: unknown };
+    if (typeof candidate.text !== 'string') continue;
+    const word: TranscriptionWord = { text: candidate.text };
+    if (typeof candidate.start === 'number' && Number.isFinite(candidate.start)) {
+      word.start = candidate.start;
+    }
+    if (typeof candidate.end === 'number' && Number.isFinite(candidate.end)) {
+      word.end = candidate.end;
+    }
+    if (typeof candidate.type === 'string') {
+      word.type = candidate.type;
+    }
+    words.push(word);
+  }
+  return words;
+}
+
+/**
+ * Transcribes a finalized recording file with batch Scribe.
+ *
+ * The source recording is never modified: audio is stream-copied (no
+ * re-encode) into a temp file with ffmpeg first, both to drop video payload
+ * from the upload and to rewrite the container headers MediaRecorder leaves
+ * incomplete (partial WebM metadata). The temp file is always removed, and
+ * every failure surfaces as a rejection for the caller to handle — this
+ * service must never affect the durability of the recording itself.
+ */
+export async function transcribeRecordingFile(
+  { sourcePath, languageCode = 'eng' }: TranscribeRecordingOptions,
+  deps: TranscriptionDeps = {}
+): Promise<TranscribeRecordingResult> {
+  const runFfmpegImpl = deps.runFfmpegImpl || runFfmpeg;
+  const convertImpl = deps.convertImpl || defaultConvertImpl;
+
+  // Fail fast before doing any work when the key is absent, so the renderer
+  // gets a clear, actionable error instead of a late SDK failure.
+  getRequiredEnv('ELEVENLABS_API_KEY');
+
+  if (typeof sourcePath !== 'string' || !sourcePath.trim()) {
+    throw new Error('Transcription source path is required');
+  }
+  let stats: fs.Stats;
+  try {
+    stats = fs.statSync(sourcePath);
+  } catch {
+    throw new Error(`Transcription source not found: ${sourcePath}`);
+  }
+  if (!stats.isFile() || stats.size === 0) {
+    throw new Error(`Transcription source is empty: ${sourcePath}`);
+  }
+
+  const tempAudioPath = path.join(
+    os.tmpdir(),
+    `loop-transcribe-${crypto.randomBytes(6).toString('hex')}.webm`
+  );
+
+  try {
+    await runFfmpegImpl({
+      ffmpegPath: deps.ffmpegPath ?? ffmpegStatic ?? undefined,
+      args: ['-hide_banner', '-nostdin', '-i', sourcePath, '-vn', '-c:a', 'copy', '-y', tempAudioPath]
+    });
+
+    const response = (await convertImpl({
+      modelId: 'scribe_v2',
+      file: { path: tempAudioPath },
+      timestampsGranularity: 'word',
+      tagAudioEvents: false,
+      diarize: false,
+      languageCode
+    })) as { words?: unknown; languageCode?: unknown } | null;
+
+    const result: TranscribeRecordingResult = {
+      words: normalizeWords(response?.words)
+    };
+    if (typeof response?.languageCode === 'string') {
+      result.languageCode = response.languageCode;
+    }
+    return result;
+  } finally {
+    try {
+      fs.rmSync(tempAudioPath, { force: true });
+    } catch {
+      // Best-effort temp cleanup; never mask the primary error.
+    }
+  }
+}
diff --git a/src/preload.ts b/src/preload.ts
index a85cced..d799060 100644
--- a/src/preload.ts
+++ b/src/preload.ts
@@ -56,7 +56,7 @@ const electronApi: ElectronApi = {
   importFile: (sourcePath, projectFolder) =>
     ipcRenderer.invoke('import-file', sourcePath, projectFolder),
   pickImageFile: () => ipcRenderer.invoke('pick-image-file'),
-  getScribeToken: () => ipcRenderer.invoke('get-scribe-token'),
+  transcribeRecording: (opts) => ipcRenderer.invoke('transcription:transcribe', opts),
   generateProxy: (opts) => ipcRenderer.invoke('proxy:generate', opts),
   onProxyProgress: (listener) => {
     if (typeof listener !== 'function') return () => {};
diff --git a/src/renderer/app.ts b/src/renderer/app.ts
index 945e286..f735825 100644
--- a/src/renderer/app.ts
+++ b/src/renderer/app.ts
@@ -1,13 +1,9 @@
 // @ts-nocheck
+import { normalizeTranscriptText } from './features/transcript/transcript-utils';
 import {
-  normalizeTranscriptText,
-  stripNonSpeechAnnotations,
-  extractSpokenWordTokens
-} from './features/transcript/transcript-utils';
-import {
-  getScribeStatusFromCloseEvent,
-  getScribeStatusFromMessage
-} from './features/transcript/scribe-status';
+  buildSegmentsFromWords,
+  getTranscriptionTimeoutMs
+} from './features/transcript/batch-transcript';
 import {
   roundMs,
   buildRemappedSectionsFromSegments,
@@ -195,13 +191,7 @@ let saveDebounceTimer = null;
 let persistQueue = Promise.resolve();
 let mediaInitialized = false;
 let mediaIdleTimer = null;
-let scribeWs = null;
-let scribeWorkletNode = null;
 let speechSegments = [];
-let audioChunkBuffer = [];
-let audioSendInterval = null;
-let scribeLastFailureReason = null;
-let scribeManualClose = false;
 let micSourceNode = null;
 const MEDIA_IDLE_TIMEOUT_MS = 30000;
 
@@ -239,10 +229,6 @@ function resetMediaRefsAfterCleanup() {
   meterRAF = null;
   drawRAF = null;
   lastCompositeDrawAt = 0;
-  scribeWs = null;
-  scribeWorkletNode = null;
-  audioChunkBuffer = [];
-  audioSendInterval = null;
   micSourceNode = null;
   mediaInitialized = false;
   screenVideo.srcObject = null;
@@ -257,11 +243,8 @@ function cleanupRendererMediaResources() {
     audioStream,
     recorders,
     screenRecInterval,
-    audioSendInterval,
     timerInterval,
     audioContext,
-    scribeWorkletNode,
-    scribeWs,
     drawRAF,
     meterRAF,
     cancelEditorDrawLoop,
@@ -416,9 +399,6 @@ if (typeof window.electronAPI.onProxyProgress === 'function') {
     }
   });
 }
-let scribeAudioOffset = 0; // seconds between recording start and first audio sent to Scribe
-let workletRegistered = null; // tracks which AudioContext has the worklet registered
-
 const CANVAS_W = 1920;
 const CANVAS_H = 1080;
 const PIP_FRACTION = 0.22;
@@ -2634,7 +2614,6 @@ function stopAudioMeter() {
   meterRAF = null;
   micSourceNode = null;
   if (audioContext) {
-    if (workletRegistered === audioContext) workletRegistered = null;
     audioContext.close();
     audioContext = null;
   }
@@ -2920,18 +2899,6 @@ function computeRecorderStartOffsetsMs(recorderList) {
   };
 }
 
-function mergeInt16Arrays(arrays) {
-  let totalLength = 0;
-  for (const arr of arrays) totalLength += arr.length;
-  const merged = new Int16Array(totalLength);
-  let offset = 0;
-  for (const arr of arrays) {
-    merged.set(arr, offset);
-    offset += arr.length;
-  }
-  return merged;
-}
-
 function setTranscriptStatus(text, tone = 'neutral') {
   if (!transcriptStatus) return;
 
@@ -2949,18 +2916,6 @@ function setTranscriptStatus(text, tone = 'neutral') {
   transcriptStatus.textContent = hasText ? text : '';
 }
 
-function applyScribeStatus(status) {
-  if (!status) return;
-
-  if (status.failureReason) {
-    scribeLastFailureReason = status.failureReason;
-  } else if (status.tone === 'success') {
-    scribeLastFailureReason = null;
-  }
-
-  setTranscriptStatus(status.text, status.tone);
-}
-
 /**
  * Surface a recording notice on the existing transcript status line. The
  * status line lives inside the transcript panel (hidden outside recording),
@@ -2994,6 +2949,14 @@ function handleRecorderFailure(kind, suffix) {
 
 async function startRecording() {
   if (!activeProjectPath) return;
+  // The previous take's stop flow now includes batch transcription, so it can
+  // still be running when Record is pressed again. Overlapping take flows
+  // would race on the shared recovery checkpoint (.pending-recording.json)
+  // and the Stop guard, so refuse to start until the previous take settles.
+  if (stopRecordingInFlight) {
+    showRecordingNotice('Still processing the previous take — try again in a moment.', 'warning');
+    return;
+  }
   recorders = [];
   speechSegments = [];
   // Fresh take: forget any activity windows captured before Record was
@@ -3001,13 +2964,6 @@ async function startRecording() {
   systemAudioActivitySegments = [];
   systemAudioActivityOpen = null;
   systemAudioLastActiveSec = 0;
-  audioChunkBuffer = [];
-  scribeLastFailureReason = null;
-  scribeManualClose = false;
-  // Reset scribe audio timestamp offset and worklet registration per take so
-  // timestamps are never carried over from a previous recording session.
-  scribeAudioOffset = 0;
-  workletRegistered = null;
 
   // The takeId is generated once for this recording session and shared by
   // both recorders, so the on-disk temp files can be matched back to the
@@ -3145,183 +3101,19 @@ async function startRecording() {
   startTime = Date.now();
   timerInterval = setInterval(updateTimer, 200);
 
-  // Show transcript panel and clear previous content
+  // Show transcript panel with a passive note: transcription now runs as a
+  // batch pass over the finalized recording after Stop, so nothing streams
+  // while recording and a long pause can never kill the transcript.
   transcriptPanel.classList.remove('hidden');
   transcriptContent.innerHTML = '';
   segmentBadge.textContent = '0 segments';
-  setTranscriptStatus('Transcription connecting...', 'neutral');
-
-  // Set up Scribe via direct WebSocket
-  if (audioContext && audioStream && micSourceNode) {
-    try {
-      const token = await window.electronAPI.getScribeToken();
-      const sampleRate = audioContext.sampleRate;
-
-      // Map sample rate to ElevenLabs audio_format parameter
-      const formatMap = {
-        8000: 'pcm_8000',
-        16000: 'pcm_16000',
-        22050: 'pcm_22050',
-        24000: 'pcm_24000',
-        44100: 'pcm_44100',
-        48000: 'pcm_48000'
-      };
-      const audioFormat = formatMap[sampleRate] || 'pcm_16000';
-
-      const wsUrl =
-        `wss://api.elevenlabs.io/v1/speech-to-text/realtime` +
-        `?model_id=scribe_v2_realtime` +
-        `&token=${token}` +
-        `&audio_format=${audioFormat}` +
-        `&commit_strategy=vad` +
-        `&include_timestamps=true` +
-        `&vad_silence_threshold_secs=1.5` +
-        `&vad_threshold=0.8` +
-        `&min_speech_duration_ms=200` +
-        `&language_code=eng`;
-
-      scribeWs = new WebSocket(wsUrl);
-
-      scribeWs.onopen = () => {
-        setTranscriptStatus('Transcription connecting...', 'neutral');
-      };
-
-      scribeWs.onmessage = (event) => {
-        let msg;
-        try {
-          msg = JSON.parse(event.data);
-        } catch (error) {
-          console.warn('Failed to parse Scribe message:', error);
-          return;
-        }
-
-        applyScribeStatus(getScribeStatusFromMessage(msg));
-
-        if (msg.message_type === 'partial_transcript') {
-          updatePartialTranscript(msg.text || '');
-        } else if (msg.message_type === 'committed_transcript_with_timestamps') {
-          commitTranscript(msg);
-        }
-      };
-
-      scribeWs.onerror = (err) => {
-        console.error('Scribe WebSocket error:', err);
-        if (!scribeManualClose) {
-          setTranscriptStatus('Transcription connection error', 'error');
-        }
-      };
-
-      scribeWs.onclose = (event) => {
-        console.warn('Scribe WebSocket closed:', {
-          code: event.code,
-          reason: event.reason,
-          wasClean: event.wasClean,
-          lastFailureReason: scribeLastFailureReason,
-          manualClose: scribeManualClose
-        });
-        if (!scribeManualClose) {
-          applyScribeStatus(getScribeStatusFromCloseEvent(event, scribeLastFailureReason));
-        }
-      };
-
-      // Set up AudioWorklet for PCM capture (only register module once per AudioContext)
-      if (workletRegistered !== audioContext) {
-        await audioContext.audioWorklet.addModule(
-          new URL('./audio-processor.js', window.location.href).toString()
-        );
-        workletRegistered = audioContext;
-      }
-      scribeWorkletNode = new AudioWorkletNode(audioContext, 'audio-capture');
-      micSourceNode.connect(scribeWorkletNode);
-
-      scribeWorkletNode.port.onmessage = (e) => {
-        if (e.data.pcm) {
-          audioChunkBuffer.push(new Int16Array(e.data.pcm));
-        }
-      };
-
-      // Record the offset: time between recording start and first audio send
-      scribeAudioOffset = (Date.now() - startTime) / 1000;
-
-      // Send accumulated audio every ~100ms
-      audioSendInterval = setInterval(() => {
-        if (audioChunkBuffer.length === 0 || !scribeWs || scribeWs.readyState !== WebSocket.OPEN)
-          return;
-        const merged = mergeInt16Arrays(audioChunkBuffer);
-        audioChunkBuffer = [];
-        const bytes = new Uint8Array(merged.buffer);
-        const CHUNK = 8192;
-        let binary = '';
-        for (let i = 0; i < bytes.length; i += CHUNK) {
-          binary += String.fromCharCode.apply(null, bytes.subarray(i, i + CHUNK));
-        }
-        const base64 = btoa(binary);
-        scribeWs.send(
-          JSON.stringify({
-            message_type: 'input_audio_chunk',
-            audio_base_64: base64,
-            sample_rate: sampleRate,
-            commit: false
-          })
-        );
-      }, 100);
-    } catch (err) {
-      console.warn('Scribe setup failed:', err);
-      const reason = err instanceof Error ? err.message : 'setup failed';
-      setTranscriptStatus(`Transcription unavailable: ${reason}`, 'error');
-    }
+  if (audioStream) {
+    setTranscriptStatus('Transcript will be generated when recording stops', 'neutral');
   } else {
-    setTranscriptStatus('Transcription unavailable: microphone not ready', 'warning');
+    setTranscriptStatus('Transcription unavailable: no microphone selected', 'warning');
   }
 }
 
-function updatePartialTranscript(text) {
-  let partial = document.getElementById('partialText');
-  if (!partial) {
-    partial = document.createElement('div');
-    partial.id = 'partialText';
-    partial.className = 'text-neutral-600 italic';
-    transcriptContent.prepend(partial);
-  }
-  partial.textContent = stripNonSpeechAnnotations(text);
-  transcriptContent.scrollTop = 0;
-}
-
-function commitTranscript(data) {
-  // Remove partial display
-  const partial = document.getElementById('partialText');
-  if (partial) partial.remove();
-
-  const spokenWords = extractSpokenWordTokens(data.words);
-  if (spokenWords.length === 0) return;
-
-  // Build clean text from spoken words only, excluding non-speech annotations.
-  const cleanText = stripNonSpeechAnnotations(spokenWords.map((w) => w.text).join(' '));
-  if (!cleanText) return;
-
-  // Shift timestamps by the offset between recording start and first audio sent
-  speechSegments.push({
-    start: spokenWords[0].start + scribeAudioOffset,
-    end: spokenWords[spokenWords.length - 1].end + scribeAudioOffset,
-    text: cleanText
-  });
-
-  // Add committed text
-  const div = document.createElement('div');
-  div.className =
-    'mb-2 text-neutral-300 cursor-pointer rounded-md px-1.5 py-0.5 -mx-1 hover:bg-neutral-800/60 transition-colors';
-  div.dataset.segmentIndex = speechSegments.length - 1;
-  div.textContent = cleanText;
-  div.addEventListener('click', () => {
-    const idx = parseInt(div.dataset.segmentIndex, 10);
-    selectSegment(selectedSegmentIndex === idx ? -1 : idx);
-  });
-  transcriptContent.prepend(div);
-  transcriptContent.scrollTop = 0;
-
-  updateSegmentBadge();
-}
-
 /**
  * Probe a media file's duration using a throwaway <video> element. Partial
  * WebM files produced by a crashed MediaRecorder typically report
@@ -4015,37 +3807,6 @@ async function stopRecordingImpl() {
   for (const cleanup of trackEndedCleanups) cleanup();
   trackEndedCleanups = [];
 
-  // Stop audio send interval
-  if (audioSendInterval) {
-    clearInterval(audioSendInterval);
-    audioSendInterval = null;
-  }
-
-  // Disconnect worklet (must sever micSourceNode→worklet input, not just worklet outputs)
-  if (scribeWorkletNode) {
-    scribeWorkletNode.port.onmessage = null;
-    if (micSourceNode) micSourceNode.disconnect(scribeWorkletNode);
-    scribeWorkletNode.disconnect();
-    scribeWorkletNode = null;
-  }
-
-  // Send final commit and close WebSocket.
-  // Detach onmessage first so late-arriving transcripts cannot mutate
-  // speechSegments after we snapshot them for section computation.
-  const hadScribe = !!scribeWs;
-  scribeManualClose = true;
-  if (scribeWs) {
-    scribeWs.onmessage = null;
-    if (scribeWs.readyState === WebSocket.OPEN) {
-      scribeWs.send(JSON.stringify({ message_type: 'commit' }));
-      await new Promise((r) => setTimeout(r, 1000));
-      scribeWs.close();
-    }
-  }
-  scribeWs = null;
-  scribeLastFailureReason = null;
-  audioChunkBuffer = [];
-
   if (screenRecInterval) {
     clearInterval(screenRecInterval);
     screenRecInterval = null;
@@ -4104,9 +3865,9 @@ async function stopRecordingImpl() {
   if (keepSilencesToggle) keepSilencesToggle.disabled = false;
   timerEl.textContent = '00:00';
 
-  // Hide transcript panel
-  transcriptPanel.classList.add('hidden');
-  setTranscriptStatus('', 'neutral');
+  // The transcript panel stays visible for now: the batch transcription pass
+  // below reports its progress on the transcript status line. It is hidden
+  // once the take enters the editor (or on the failure branches).
 
   // Enter editor if we have at least a screen recording
   if (results.screen?.path) {
@@ -4138,17 +3899,19 @@ async function stopRecordingImpl() {
     pendingRecordingAudioSource = null;
     const audioPath = audioSource === 'external' ? audioOnlyPath : null;
 
-    // Compute sections from speech segments (instant, no FFmpeg). If any
-    // system audio activity was detected during the take, flush any still-
-    // open window and merge those "keep" regions alongside speech so the
-    // section builder never trims across audible system sound (e.g. music,
-    // screen narration, tutorial demos) just because the mic was quiet.
+    // Flush any still-open system-audio activity window so those "keep"
+    // regions can be merged alongside speech and the section builder never
+    // trims across audible system sound (music, screen narration, demos)
+    // just because the mic was quiet.
     closeSystemAudioActivityWindow();
     const autoCutSilences = keepSilencesToggle?.checked !== true;
-    const activeSegments = [
-      ...speechSegments.filter((s) => !s.deleted),
-      ...systemAudioActivitySegments
-    ];
+    let transcriptNotice = false;
+
+    // Durable checkpoint BEFORE any transcription work: the finalized files
+    // plus this recovery take are everything needed to restore the full
+    // recording if the app dies (or transcription fails) from here on. The
+    // sections at this point deliberately keep the whole recording.
+    let activeSegments = [...systemAudioActivitySegments];
     let sectionsForTimeline = buildRecordingSectionsForTimeline({
       recordedDuration,
       activeSegments,
@@ -4166,6 +3929,86 @@ async function stopRecordingImpl() {
       sections: sectionsForTimeline,
       trimSegments: activeSegments
     });
+
+    // Batch-transcribe the finalized recording. The mic audio lives either in
+    // the dedicated audio-only file or muxed into the camera file; word
+    // timestamps come back relative to that file, so the per-file recorder
+    // start offset maps them into recording time exactly.
+    let transcriptionSourcePath = null;
+    let transcriptionOffsetSec = 0;
+    if (audioSource === 'external' && audioOnlyPath) {
+      transcriptionSourcePath = audioOnlyPath;
+      transcriptionOffsetSec = recorderStartOffsetsMs.audio / 1000;
+    } else if (audioSource === 'camera' && cameraPath) {
+      transcriptionSourcePath = cameraPath;
+      transcriptionOffsetSec = recorderStartOffsetsMs.camera / 1000;
+    }
+
+    if (transcriptionSourcePath) {
+      setTranscriptStatus('Transcribing recording...', 'neutral');
+      try {
+        const timeoutMs = getTranscriptionTimeoutMs(recordedDuration);
+        const result = await Promise.race([
+          window.electronAPI.transcribeRecording({ sourcePath: transcriptionSourcePath }),
+          new Promise((_, reject) => {
+            setTimeout(
+              () =>
+                reject(
+                  new Error(`transcription timed out after ${Math.round(timeoutMs / 1000)}s`)
+                ),
+              timeoutMs
+            );
+          })
+        ]);
+        if (!matchesActiveProjectSession(projectSession)) return;
+        speechSegments = buildSegmentsFromWords(result?.words || [], {
+          offsetSec: transcriptionOffsetSec
+        });
+        updateSegmentBadge();
+        if (speechSegments.length > 0) {
+          setTranscriptStatus('', 'neutral');
+        } else {
+          console.warn('No speech detected, using full recording');
+          setTranscriptStatus('No speech detected — keeping the full recording', 'warning');
+          transcriptNotice = true;
+        }
+      } catch (err) {
+        if (!matchesActiveProjectSession(projectSession)) return;
+        // The take is already durable (files + recovery checkpoint), so a
+        // transcription failure only costs the auto-cut: keep the full
+        // recording and surface the reason instead of failing silently.
+        console.error('Batch transcription failed, keeping full recording:', err);
+        const reason = err instanceof Error ? err.message : String(err);
+        setTranscriptStatus(`Transcription failed: ${reason} — full recording kept`, 'warning');
+        transcriptNotice = true;
+      }
+    }
+
+    if (speechSegments.length > 0) {
+      activeSegments = [
+        ...speechSegments.filter((s) => !s.deleted),
+        ...systemAudioActivitySegments
+      ];
+      sectionsForTimeline = buildRecordingSectionsForTimeline({
+        recordedDuration,
+        activeSegments,
+        autoCutSilences
+      });
+      // Refresh the recovery checkpoint with the transcript-aware sections so
+      // a crash between here and project persistence recovers the same cut.
+      await saveRecoveryTake({
+        id: takeId,
+        createdAt: takeCreatedAt,
+        screenPath,
+        cameraPath,
+        audioPath,
+        audioSource,
+        hasSystemAudio,
+        recordedDuration,
+        sections: sectionsForTimeline,
+        trimSegments: activeSegments
+      });
+    }
     if (autoCutSilences && activeSegments.length > 0) {
       try {
         const computed = await window.electronAPI.computeSections({
@@ -4186,8 +4029,6 @@ async function stopRecordingImpl() {
           autoCutSilences
         });
       }
-    } else if (autoCutSilences && hadScribe) {
-      console.warn('No speech detected, using full recording');
     }
 
     // Set takeId on all sections
@@ -4214,6 +4055,13 @@ async function stopRecordingImpl() {
       });
     }
 
+    // Transcription is settled; drop the panel unless it carries a warning
+    // the user should still see next time the recording view is shown.
+    if (!transcriptNotice) {
+      transcriptPanel.classList.add('hidden');
+      setTranscriptStatus('', 'neutral');
+    }
+
     let appendResult;
     try {
       appendResult = appendTakeToTimeline({
@@ -4287,6 +4135,8 @@ async function stopRecordingImpl() {
       }
     }
   } else if (finalizeErrors.length > 0) {
+    transcriptPanel.classList.add('hidden');
+    setTranscriptStatus('', 'neutral');
     console.error('Recording finalize failed:', finalizeErrors);
     // Best-effort: drop any remaining temp files so the project folder stays
     // clean. The user will have already seen this error surfaced in the
@@ -4302,6 +4152,8 @@ async function stopRecordingImpl() {
     pendingRecordingAudioSource = null;
     showProjectHomeMessage(finalizeErrors.join(' '));
   } else {
+    transcriptPanel.classList.add('hidden');
+    setTranscriptStatus('', 'neutral');
     pendingRecordingTakeId = null;
     pendingRecordingAudioSource = null;
   }
@@ -5757,33 +5609,6 @@ editorExportPremiereBtn.addEventListener('click', async () => {
   await exportPremiere();
 });
 
-// ===== Segment selection =====
-
-transcriptContent.addEventListener('click', (e) => {
-  if (!e.target.closest('[data-segment-index]')) selectSegment(-1);
-});
-
-let selectedSegmentIndex = -1;
-const recordingUndoStack = [];
-
-function selectSegment(index) {
-  // Deselect previous
-  if (selectedSegmentIndex >= 0) {
-    const prev = transcriptContent.querySelector(`[data-segment-index="${selectedSegmentIndex}"]`);
-    if (prev) prev.style.outline = '';
-  }
-  selectedSegmentIndex = index;
-  if (index >= 0) {
-    const el = transcriptContent.querySelector(`[data-segment-index="${index}"]`);
-    if (el) el.style.outline = '2px solid rgba(255, 255, 255, 0.3)';
-  }
-}
-
-function applySegmentDeletedStyle(el, deleted) {
-  el.style.textDecoration = deleted ? 'line-through' : '';
-  el.style.opacity = deleted ? '0.4' : '';
-}
-
 // ===== Keyboard shortcuts =====
 
 function updateSegmentBadge() {
@@ -5798,52 +5623,6 @@ function updateSegmentBadge() {
 }
 
 document.addEventListener('keydown', (e) => {
-  // Backspace during recording: toggle delete on selected segment, or remove last non-deleted
-  if (recording && e.code === 'Backspace') {
-    e.preventDefault();
-    if (selectedSegmentIndex >= 0 && selectedSegmentIndex < speechSegments.length) {
-      // Toggle delete on selected segment
-      const seg = speechSegments[selectedSegmentIndex];
-      recordingUndoStack.push({ segmentIndex: selectedSegmentIndex, wasDeleted: seg.deleted });
-      seg.deleted = !seg.deleted;
-      const el = transcriptContent.querySelector(`[data-segment-index="${selectedSegmentIndex}"]`);
-      if (el) applySegmentDeletedStyle(el, seg.deleted);
-      updateSegmentBadge();
-    } else {
-      // No selection: delete last non-deleted segment
-      for (let i = speechSegments.length - 1; i >= 0; i--) {
-        if (!speechSegments[i].deleted) {
-          recordingUndoStack.push({ segmentIndex: i, wasDeleted: false });
-          speechSegments[i].deleted = true;
-          const el = transcriptContent.querySelector(`[data-segment-index="${i}"]`);
-          if (el) applySegmentDeletedStyle(el, true);
-          updateSegmentBadge();
-          break;
-        }
-      }
-    }
-    return;
-  }
-
-  // Ctrl+Z during recording: undo last delete/undelete action
-  if (recording && e.code === 'KeyZ' && (e.metaKey || e.ctrlKey) && !e.shiftKey) {
-    e.preventDefault();
-    const action = recordingUndoStack.pop();
-    if (action) {
-      speechSegments[action.segmentIndex].deleted = action.wasDeleted;
-      const el = transcriptContent.querySelector(`[data-segment-index="${action.segmentIndex}"]`);
-      if (el) applySegmentDeletedStyle(el, action.wasDeleted);
-      updateSegmentBadge();
-    }
-    return;
-  }
-
-  // Escape during recording: deselect segment
-  if (recording && e.code === 'Escape') {
-    selectSegment(-1);
-    return;
-  }
-
   if (!editorState || editorState.rendering || activeWorkspaceView !== 'timeline') return;
   // Don't capture if focus is in an input
   if (e.target.tagName === 'SELECT' || e.target.tagName === 'INPUT') return;
diff --git a/src/renderer/features/media-cleanup.ts b/src/renderer/features/media-cleanup.ts
index 7c4b766..f6338da 100644
--- a/src/renderer/features/media-cleanup.ts
+++ b/src/renderer/features/media-cleanup.ts
@@ -5,11 +5,8 @@ export interface MediaRefs {
   audioStream?: MediaStream | null;
   recorders?: MediaRecorder[];
   screenRecInterval?: ReturnType<typeof setInterval> | null;
-  audioSendInterval?: ReturnType<typeof setInterval> | null;
   timerInterval?: ReturnType<typeof setInterval> | null;
   audioContext?: AudioContext | null;
-  scribeWorkletNode?: AudioWorkletNode | null;
-  scribeWs?: WebSocket | null;
   drawRAF?: number | null;
   meterRAF?: number | null;
   cancelEditorDrawLoop?: (() => void) | null;
@@ -37,10 +34,6 @@ export function cleanupAllMedia(refs: MediaRefs | null | undefined): void {
     clearInterval(refs.screenRecInterval);
     refs.screenRecInterval = null;
   }
-  if (refs.audioSendInterval) {
-    clearInterval(refs.audioSendInterval);
-    refs.audioSendInterval = null;
-  }
   if (refs.timerInterval) {
     clearInterval(refs.timerInterval);
     refs.timerInterval = null;
@@ -57,24 +50,6 @@ export function cleanupAllMedia(refs: MediaRefs | null | undefined): void {
     refs.recorders = [];
   }
 
-  if (refs.scribeWorkletNode) {
-    try {
-      refs.scribeWorkletNode.disconnect();
-    } catch {
-      // Already disconnected.
-    }
-    refs.scribeWorkletNode = null;
-  }
-
-  if (refs.scribeWs) {
-    try {
-      refs.scribeWs.close();
-    } catch {
-      // Already closed.
-    }
-    refs.scribeWs = null;
-  }
-
   if (typeof refs.stopAudioMeter === 'function') {
     try {
       refs.stopAudioMeter();
diff --git a/src/renderer/features/transcript/batch-transcript.ts b/src/renderer/features/transcript/batch-transcript.ts
new file mode 100644
index 0000000..c94f716
--- /dev/null
+++ b/src/renderer/features/transcript/batch-transcript.ts
@@ -0,0 +1,100 @@
+/**
+ * Helpers for building timeline speech segments from a batch (whole-file)
+ * transcription result. Replaces the segment stream that the realtime Scribe
+ * WebSocket used to emit: instead of VAD-committed chunks arriving live, the
+ * full word list arrives once after recording stops and is grouped into
+ * segments here.
+ */
+
+import {
+  extractSpokenWordTokens,
+  stripNonSpeechAnnotations,
+  type TranscriptToken
+} from './transcript-utils';
+
+export interface SpeechSegment {
+  start: number;
+  end: number;
+  text: string;
+}
+
+/**
+ * Silence gap (seconds) between words that starts a new segment. Matches the
+ * vad_silence_threshold_secs the realtime session used, so auto-cut sections
+ * built from batch segments land on the same boundaries users are used to.
+ */
+export const BATCH_SEGMENT_MAX_GAP_SEC = 1.5;
+
+export const TRANSCRIPTION_TIMEOUT_MIN_MS = 120_000;
+export const TRANSCRIPTION_TIMEOUT_MAX_MS = 600_000;
+
+/**
+ * Groups batch transcription words into speech segments.
+ *
+ * @param words Word tokens from the batch speech-to-text response, with
+ *   timestamps relative to the transcribed audio file.
+ * @param offsetSec Seconds between recording start and the audio file's first
+ *   sample (the per-file recorder start offset), so segment times land in
+ *   recording time.
+ * @param maxGapSec Silence between consecutive words that splits segments.
+ */
+export function buildSegmentsFromWords(
+  words: TranscriptToken[],
+  {
+    offsetSec = 0,
+    maxGapSec = BATCH_SEGMENT_MAX_GAP_SEC
+  }: { offsetSec?: number; maxGapSec?: number } = {}
+): SpeechSegment[] {
+  const spoken = extractSpokenWordTokens(Array.isArray(words) ? words : []).filter(
+    (token) =>
+      typeof token.start === 'number' &&
+      Number.isFinite(token.start) &&
+      typeof token.end === 'number' &&
+      Number.isFinite(token.end)
+  );
+  if (spoken.length === 0) return [];
+
+  const groups: TranscriptToken[][] = [];
+  let current: TranscriptToken[] = [];
+  let previousEnd: number | null = null;
+
+  for (const token of spoken) {
+    if (previousEnd !== null && (token.start as number) - previousEnd > maxGapSec) {
+      groups.push(current);
+      current = [];
+    }
+    current.push(token);
+    previousEnd = token.end as number;
+  }
+  if (current.length > 0) groups.push(current);
+
+  const segments: SpeechSegment[] = [];
+  for (const group of groups) {
+    const text = stripNonSpeechAnnotations(group.map((token) => token.text || '').join(' '));
+    if (!text) continue;
+    segments.push({
+      start: Math.max(0, (group[0].start as number) + offsetSec),
+      end: Math.max(0, (group[group.length - 1].end as number) + offsetSec),
+      text
+    });
+  }
+  return segments;
+}
+
+/**
+ * Upper bound on how long the renderer waits for a batch transcription before
+ * falling back to full-duration sections. Scales with recording length
+ * (batch STT is much faster than realtime, but long takes still need room),
+ * clamped so a hung request can never wedge the stop flow indefinitely.
+ */
+export function getTranscriptionTimeoutMs(durationSec: number): number {
+  const safeDuration =
+    typeof durationSec === 'number' && Number.isFinite(durationSec) && durationSec > 0
+      ? durationSec
+      : 0;
+  const scaled = safeDuration * 1000;
+  return Math.min(
+    TRANSCRIPTION_TIMEOUT_MAX_MS,
+    Math.max(TRANSCRIPTION_TIMEOUT_MIN_MS, scaled)
+  );
+}
diff --git a/src/renderer/features/transcript/scribe-status.ts b/src/renderer/features/transcript/scribe-status.ts
deleted file mode 100644
index 62bd1c9..0000000
--- a/src/renderer/features/transcript/scribe-status.ts
+++ /dev/null
@@ -1,119 +0,0 @@
-export type TranscriptStatusTone = 'neutral' | 'success' | 'warning' | 'error';
-
-export interface TranscriptStatus {
-  text: string;
-  tone: TranscriptStatusTone;
-  failureReason?: string;
-}
-
-interface ScribeMessageLike {
-  message_type?: string;
-  error?: string;
-}
-
-interface ScribeCloseLike {
-  code?: number;
-  reason?: string;
-}
-
-const SCRIBE_ERROR_TYPES = new Set([
-  'auth_error',
-  'quota_exceeded',
-  'transcriber_error',
-  'input_error',
-  'error',
-  'commit_throttled',
-  'unaccepted_terms',
-  'rate_limited',
-  'queue_overflow',
-  'resource_exhausted',
-  'session_time_limit_exceeded',
-  'chunk_size_exceeded',
-  'insufficient_audio_activity'
-]);
-
-function normalizeReason(value: unknown): string {
-  return typeof value === 'string' ? value.trim() : '';
-}
-
-export function getScribeFailureReason(
-  message: ScribeMessageLike | null | undefined
-): string | null {
-  const messageType = normalizeReason(message?.message_type);
-  const error = normalizeReason(message?.error);
-
-  if (messageType === 'error') {
-    return error || 'error';
-  }
-
-  if (SCRIBE_ERROR_TYPES.has(messageType)) {
-    return error && error !== messageType ? `${messageType}: ${error}` : messageType;
-  }
-
-  if (!messageType && error) {
-    return error;
-  }
-
-  return null;
-}
-
-export function getScribeStatusFromMessage(
-  message: ScribeMessageLike | null | undefined
-): TranscriptStatus | null {
-  const messageType = normalizeReason(message?.message_type);
-
-  if (messageType === 'session_started') {
-    return {
-      text: 'Transcription connected',
-      tone: 'success'
-    };
-  }
-
-  const failureReason = getScribeFailureReason(message);
-  if (failureReason) {
-    return {
-      text: `Transcription error: ${failureReason}`,
-      tone: 'error',
-      failureReason
-    };
-  }
-
-  return null;
-}
-
-export function getScribeStatusFromCloseEvent(
-  event: ScribeCloseLike | null | undefined,
-  lastFailureReason?: string | null
-): TranscriptStatus {
-  const previousReason = normalizeReason(lastFailureReason);
-  if (previousReason) {
-    return {
-      text: `Transcription disconnected: ${previousReason}`,
-      tone: 'warning',
-      failureReason: previousReason
-    };
-  }
-
-  const closeReason = normalizeReason(event?.reason);
-  if (closeReason) {
-    return {
-      text: `Transcription disconnected: ${closeReason}`,
-      tone: 'warning',
-      failureReason: closeReason
-    };
-  }
-
-  const closeCode = Number.isFinite(event?.code) ? Number(event?.code) : null;
-  if (closeCode !== null) {
-    return {
-      text: `Transcription disconnected (code ${closeCode})`,
-      tone: 'warning',
-      failureReason: `code ${closeCode}`
-    };
-  }
-
-  return {
-    text: 'Transcription disconnected',
-    tone: 'warning'
-  };
-}
diff --git a/src/shared/electron-api.ts b/src/shared/electron-api.ts
index 1cfa51a..1488fe6 100644
--- a/src/shared/electron-api.ts
+++ b/src/shared/electron-api.ts
@@ -73,6 +73,18 @@ export interface RecordingCancelResult {
   cancelled: boolean;
 }
 
+export interface TranscribedWord {
+  text: string;
+  start?: number;
+  end?: number;
+  type?: string;
+}
+
+export interface TranscribeRecordingResult {
+  words: TranscribedWord[];
+  languageCode?: string;
+}
+
 export interface OrphanRecordingCandidate {
   takeId: string;
   createdAt: string;
@@ -160,7 +172,10 @@ export interface ElectronApi {
   onExportPremiereProgress: (listener: (payload: RenderProgressUpdate) => void) => () => void;
   importFile: (sourcePath: string, projectFolder: string) => Promise<string>;
   pickImageFile: () => Promise<string | null>;
-  getScribeToken: () => Promise<string>;
+  transcribeRecording: (opts: {
+    sourcePath: string;
+    languageCode?: string;
+  }) => Promise<TranscribeRecordingResult>;
   generateProxy: (opts: GenerateProxyOpts) => Promise<string | null>;
   onProxyProgress: (listener: (payload: ProxyProgressUpdate) => void) => () => void;
   getPathForFile: (file: File) => string;
diff --git a/tests/unit/batch-transcript.test.ts b/tests/unit/batch-transcript.test.ts
new file mode 100644
index 0000000..848e162
--- /dev/null
+++ b/tests/unit/batch-transcript.test.ts
@@ -0,0 +1,143 @@
+import { describe, expect, test } from 'vitest';
+
+import {
+  BATCH_SEGMENT_MAX_GAP_SEC,
+  buildSegmentsFromWords,
+  getTranscriptionTimeoutMs,
+  TRANSCRIPTION_TIMEOUT_MAX_MS,
+  TRANSCRIPTION_TIMEOUT_MIN_MS
+} from '../../src/renderer/features/transcript/batch-transcript';
+
+describe('renderer/features/transcript/batch-transcript', () => {
+  describe('buildSegmentsFromWords', () => {
+    test('groups consecutive words into one segment', () => {
+      const words = [
+        { text: 'Hello', start: 0.2, end: 0.6, type: 'word' },
+        { text: 'there', start: 0.7, end: 1.0, type: 'word' },
+        { text: 'friend', start: 1.1, end: 1.5, type: 'word' }
+      ];
+      expect(buildSegmentsFromWords(words)).toEqual([
+        { start: 0.2, end: 1.5, text: 'Hello there friend' }
+      ]);
+    });
+
+    test('splits segments when the gap between words exceeds the max gap', () => {
+      const words = [
+        { text: 'First', start: 0, end: 0.5, type: 'word' },
+        { text: 'part', start: 0.6, end: 1.0, type: 'word' },
+        // 2.5s silence — new segment
+        { text: 'Second', start: 3.5, end: 4.0, type: 'word' },
+        { text: 'part', start: 4.1, end: 4.4, type: 'word' }
+      ];
+      expect(buildSegmentsFromWords(words, { maxGapSec: 1.5 })).toEqual([
+        { start: 0, end: 1.0, text: 'First part' },
+        { start: 3.5, end: 4.4, text: 'Second part' }
+      ]);
+    });
+
+    test('a gap exactly at the threshold does not split', () => {
+      const words = [
+        { text: 'a', start: 0, end: 0.5, type: 'word' },
+        { text: 'b', start: 2.0, end: 2.4, type: 'word' }
+      ];
+      expect(buildSegmentsFromWords(words, { maxGapSec: 1.5 })).toHaveLength(1);
+    });
+
+    test('applies the recording-time offset to every segment', () => {
+      const words = [
+        { text: 'Offset', start: 1.0, end: 1.4, type: 'word' },
+        { text: 'test', start: 4.0, end: 4.5, type: 'word' }
+      ];
+      const segments = buildSegmentsFromWords(words, { offsetSec: 0.25, maxGapSec: 1.5 });
+      expect(segments).toEqual([
+        { start: 1.25, end: 1.65, text: 'Offset' },
+        { start: 4.25, end: 4.75, text: 'test' }
+      ]);
+    });
+
+    test('ignores spacing and audio_event tokens for text and boundaries', () => {
+      const words = [
+        { text: 'Real', start: 0.1, end: 0.4, type: 'word' },
+        { text: ' ', start: 0.4, end: 0.5, type: 'spacing' },
+        { text: '(laughs)', start: 0.5, end: 1.2, type: 'audio_event' },
+        { text: 'words', start: 1.3, end: 1.7, type: 'word' }
+      ];
+      expect(buildSegmentsFromWords(words)).toEqual([
+        { start: 0.1, end: 1.7, text: 'Real words' }
+      ]);
+    });
+
+    test('strips bracketed non-speech annotations from segment text', () => {
+      const words = [
+        { text: '[music]', start: 0, end: 0.4, type: 'word' },
+        { text: 'speech', start: 0.5, end: 1.0, type: 'word' }
+      ];
+      const segments = buildSegmentsFromWords(words);
+      expect(segments).toHaveLength(1);
+      expect(segments[0].text).toBe('speech');
+    });
+
+    test('skips words with missing or non-finite timestamps', () => {
+      const words = [
+        { text: 'good', start: 0, end: 0.5, type: 'word' },
+        { text: 'bad', type: 'word' },
+        { text: 'worse', start: Number.NaN, end: 1.0, type: 'word' },
+        { text: 'fine', start: 0.8, end: 1.2, type: 'word' }
+      ];
+      expect(buildSegmentsFromWords(words)).toEqual([
+        { start: 0, end: 1.2, text: 'good fine' }
+      ]);
+    });
+
+    test('drops segments whose text is empty after annotation stripping', () => {
+      const words = [
+        { text: '[silence]', start: 0, end: 0.5, type: 'word' },
+        // far gap → its own segment, which strips to empty text
+        { text: 'kept', start: 10, end: 10.5, type: 'word' }
+      ];
+      expect(buildSegmentsFromWords(words, { maxGapSec: 1.5 })).toEqual([
+        { start: 10, end: 10.5, text: 'kept' }
+      ]);
+    });
+
+    test('returns an empty array for empty or malformed input', () => {
+      expect(buildSegmentsFromWords([])).toEqual([]);
+      expect(buildSegmentsFromWords(null as never)).toEqual([]);
+      expect(buildSegmentsFromWords(undefined as never)).toEqual([]);
+    });
+
+    test('never produces negative timestamps when the offset is negative', () => {
+      const words = [{ text: 'clamped', start: 0.1, end: 0.5, type: 'word' }];
+      const segments = buildSegmentsFromWords(words, { offsetSec: -1 });
+      expect(segments[0].start).toBe(0);
+      expect(segments[0].end).toBe(0);
+    });
+
+    test('default max gap matches the legacy realtime VAD silence threshold', () => {
+      expect(BATCH_SEGMENT_MAX_GAP_SEC).toBe(1.5);
+    });
+  });
+
+  describe('getTranscriptionTimeoutMs', () => {
+    test('short recordings get the minimum timeout', () => {
+      expect(getTranscriptionTimeoutMs(10)).toBe(TRANSCRIPTION_TIMEOUT_MIN_MS);
+    });
+
+    test('long recordings scale the timeout with duration', () => {
+      const fortyMinutes = 40 * 60;
+      const timeout = getTranscriptionTimeoutMs(fortyMinutes);
+      expect(timeout).toBeGreaterThan(TRANSCRIPTION_TIMEOUT_MIN_MS);
+      expect(timeout).toBeLessThanOrEqual(TRANSCRIPTION_TIMEOUT_MAX_MS);
+    });
+
+    test('timeout is capped at the maximum', () => {
+      expect(getTranscriptionTimeoutMs(100 * 60 * 60)).toBe(TRANSCRIPTION_TIMEOUT_MAX_MS);
+    });
+
+    test('malformed durations fall back to the minimum timeout', () => {
+      expect(getTranscriptionTimeoutMs(Number.NaN)).toBe(TRANSCRIPTION_TIMEOUT_MIN_MS);
+      expect(getTranscriptionTimeoutMs(-5)).toBe(TRANSCRIPTION_TIMEOUT_MIN_MS);
+      expect(getTranscriptionTimeoutMs(undefined as never)).toBe(TRANSCRIPTION_TIMEOUT_MIN_MS);
+    });
+  });
+});
diff --git a/tests/unit/media-cleanup.test.ts b/tests/unit/media-cleanup.test.ts
index 2da4e0a..92a5cad 100644
--- a/tests/unit/media-cleanup.test.ts
+++ b/tests/unit/media-cleanup.test.ts
@@ -19,22 +19,12 @@ function makeFakeAudioContext() {
   return { close: vi.fn() };
 }
 
-function makeFakeWorkletNode() {
-  return { disconnect: vi.fn() };
-}
-
-function makeFakeWebSocket() {
-  return { close: vi.fn() };
-}
-
 type FakeMediaRefs = MediaRefs & {
   screenStream: ReturnType<typeof makeFakeStream> | null;
   cameraStream: ReturnType<typeof makeFakeStream> | null;
   audioStream: ReturnType<typeof makeFakeStream> | null;
   recorders: ReturnType<typeof makeFakeRecorder>[];
   audioContext: ReturnType<typeof makeFakeAudioContext> | null;
-  scribeWorkletNode: ReturnType<typeof makeFakeWorkletNode> | null;
-  scribeWs: ReturnType<typeof makeFakeWebSocket> | null;
   cancelEditorDrawLoop: ReturnType<typeof vi.fn> | null;
   stopAudioMeter: ReturnType<typeof vi.fn> | null;
 };
@@ -47,11 +37,8 @@ function makeFullRefs(): FakeMediaRefs {
     audioStream: makeFakeStream(1),
     recorders: [makeFakeRecorder('recording'), makeFakeRecorder('recording')],
     screenRecInterval: setInterval(() => {}, 100000),
-    audioSendInterval: setInterval(() => {}, 100000),
     timerInterval: setInterval(() => {}, 100000),
     audioContext: makeFakeAudioContext(),
-    scribeWorkletNode: makeFakeWorkletNode(),
-    scribeWs: makeFakeWebSocket(),
     drawRAF: 1,
     meterRAF: 2,
     cancelEditorDrawLoop: vi.fn(),
@@ -109,11 +96,8 @@ describe('cleanupAllMedia', () => {
       audioStream: null,
       recorders: [] as ReturnType<typeof makeFakeRecorder>[],
       screenRecInterval: null,
-      audioSendInterval: null,
       timerInterval: null,
       audioContext: null,
-      scribeWorkletNode: null,
-      scribeWs: null,
       drawRAF: null,
       meterRAF: null,
       cancelEditorDrawLoop: null,
@@ -173,30 +157,9 @@ describe('cleanupAllMedia', () => {
     cleanupAllMedia(refs);
 
     expect(refs.screenRecInterval).toBeNull();
-    expect(refs.audioSendInterval).toBeNull();
     expect(refs.timerInterval).toBeNull();
   });
 
-  test('disconnects scribe worklet node', () => {
-    const refs = makeFullRefs();
-    const node = refs.scribeWorkletNode!;
-
-    cleanupAllMedia(refs);
-
-    expect(node.disconnect).toHaveBeenCalledOnce();
-    expect(refs.scribeWorkletNode).toBeNull();
-  });
-
-  test('closes scribe websocket', () => {
-    const refs = makeFullRefs();
-    const socket = refs.scribeWs!;
-
-    cleanupAllMedia(refs);
-
-    expect(socket.close).toHaveBeenCalledOnce();
-    expect(refs.scribeWs).toBeNull();
-  });
-
   test('calls stopAudioMeter and closes the audio context', () => {
     const refs = makeFullRefs();
     const audioContext = refs.audioContext!;
diff --git a/tests/unit/register-handlers.test.ts b/tests/unit/register-handlers.test.ts
index a3cae6c..f5d005b 100644
--- a/tests/unit/register-handlers.test.ts
+++ b/tests/unit/register-handlers.test.ts
@@ -81,6 +81,12 @@ function registerWithHandlers(
   );
   const proxyService = createProxyServiceStub();
   const recordingService = createRecordingServiceStub();
+  const transcribeRecordingFile = vi.fn(
+    async (): Promise<{
+      words: Array<{ text: string; start?: number; end?: number; type?: string }>;
+      languageCode?: string;
+    }> => ({ words: [], languageCode: 'eng' })
+  );
   const exportPremiereProject = vi.fn(
     async (_opts: unknown, deps: { onProgress?: (u: unknown) => void; signal?: AbortSignal }) => {
       deps.onProgress?.({ phase: 'transcoding', percent: 0.5 });
@@ -105,7 +111,7 @@ function registerWithHandlers(
     renderComposite,
     exportPremiereProject,
     computeSections: vi.fn(),
-    getScribeToken: vi.fn(),
+    transcribeRecordingFile,
     proxyService,
     recordingService,
     setPendingDisplayMediaSource: vi.fn()
@@ -118,11 +124,59 @@ function registerWithHandlers(
     renderComposite,
     exportPremiereProject,
     proxyService,
-    recordingService
+    recordingService,
+    transcribeRecordingFile
   };
 }
 
 describe('main/ipc/register-handlers', () => {
+  test('transcription:transcribe delegates to the transcription service', async () => {
+    const { handlers, transcribeRecordingFile } = registerWithHandlers();
+    transcribeRecordingFile.mockResolvedValueOnce({
+      words: [{ text: 'hi', start: 0, end: 0.3, type: 'word' }],
+      languageCode: 'eng'
+    });
+
+    const result = await handlers.get('transcription:transcribe')!(
+      {},
+      { sourcePath: '/tmp/recording-take-audio.webm' }
+    );
+
+    expect(transcribeRecordingFile).toHaveBeenCalledWith({
+      sourcePath: '/tmp/recording-take-audio.webm'
+    });
+    expect(result).toEqual({
+      words: [{ text: 'hi', start: 0, end: 0.3, type: 'word' }],
+      languageCode: 'eng'
+    });
+  });
+
+  test('transcription:transcribe rejects payloads without a sourcePath', async () => {
+    const { handlers, transcribeRecordingFile } = registerWithHandlers();
+
+    await expect(handlers.get('transcription:transcribe')!({}, {})).rejects.toThrow(
+      /sourcePath/
+    );
+    await expect(handlers.get('transcription:transcribe')!({}, null)).rejects.toThrow(
+      /sourcePath/
+    );
+    expect(transcribeRecordingFile).not.toHaveBeenCalled();
+  });
+
+  test('transcription:transcribe forwards an explicit languageCode', async () => {
+    const { handlers, transcribeRecordingFile } = registerWithHandlers();
+
+    await handlers.get('transcription:transcribe')!(
+      {},
+      { sourcePath: '/tmp/a.webm', languageCode: 'spa' }
+    );
+
+    expect(transcribeRecordingFile).toHaveBeenCalledWith({
+      sourcePath: '/tmp/a.webm',
+      languageCode: 'spa'
+    });
+  });
+
   test('request-media-access returns granted on non-mac platforms', async () => {
     const { handlers } = registerWithHandlers();
 
diff --git a/tests/unit/scribe-status.test.ts b/tests/unit/scribe-status.test.ts
deleted file mode 100644
index 7f87e74..0000000
--- a/tests/unit/scribe-status.test.ts
+++ /dev/null
@@ -1,68 +0,0 @@
-import { describe, expect, test } from 'vitest';
-
-import {
-  getScribeFailureReason,
-  getScribeStatusFromCloseEvent,
-  getScribeStatusFromMessage
-} from '../../src/renderer/features/transcript/scribe-status';
-
-describe('scribe-status', () => {
-  test('reports when the transcription session connects', () => {
-    expect(getScribeStatusFromMessage({ message_type: 'session_started' })).toEqual({
-      text: 'Transcription connected',
-      tone: 'success'
-    });
-  });
-
-  test('preserves exact server error types', () => {
-    expect(getScribeStatusFromMessage({ message_type: 'insufficient_audio_activity' })).toEqual({
-      text: 'Transcription error: insufficient_audio_activity',
-      tone: 'error',
-      failureReason: 'insufficient_audio_activity'
-    });
-  });
-
-  test('combines explicit error details with the server error type', () => {
-    expect(
-      getScribeFailureReason({
-        message_type: 'session_time_limit_exceeded',
-        error: 'Maximum session time has been reached'
-      })
-    ).toBe('session_time_limit_exceeded: Maximum session time has been reached');
-  });
-
-  test('uses generic error payloads as the failure reason', () => {
-    expect(
-      getScribeStatusFromMessage({
-        message_type: 'error',
-        error: 'quota_exceeded'
-      })
-    ).toEqual({
-      text: 'Transcription error: quota_exceeded',
-      tone: 'error',
-      failureReason: 'quota_exceeded'
-    });
-  });
-
-  test('prefers the last known server failure when the socket closes', () => {
-    expect(getScribeStatusFromCloseEvent({ code: 1006 }, 'insufficient_audio_activity')).toEqual({
-      text: 'Transcription disconnected: insufficient_audio_activity',
-      tone: 'warning',
-      failureReason: 'insufficient_audio_activity'
-    });
-  });
-
-  test('falls back to the websocket close reason and code', () => {
-    expect(getScribeStatusFromCloseEvent({ code: 4000, reason: 'network_changed' })).toEqual({
-      text: 'Transcription disconnected: network_changed',
-      tone: 'warning',
-      failureReason: 'network_changed'
-    });
-
-    expect(getScribeStatusFromCloseEvent({ code: 1006 })).toEqual({
-      text: 'Transcription disconnected (code 1006)',
-      tone: 'warning',
-      failureReason: 'code 1006'
-    });
-  });
-});
diff --git a/tests/unit/transcription-service.test.ts b/tests/unit/transcription-service.test.ts
new file mode 100644
index 0000000..94536a7
--- /dev/null
+++ b/tests/unit/transcription-service.test.ts
@@ -0,0 +1,205 @@
+import fs from 'fs';
+import os from 'os';
+import path from 'path';
+
+import { afterEach, beforeEach, describe, expect, test, vi } from 'vitest';
+
+import {
+  transcribeRecordingFile,
+  type TranscriptionDeps
+} from '../../src/main/services/transcription-service';
+
+const OLD_ENV = process.env.ELEVENLABS_API_KEY;
+
+function makeTempSource(): string {
+  const dir = fs.mkdtempSync(path.join(os.tmpdir(), 'loop-transcribe-test-'));
+  const sourcePath = path.join(dir, 'recording-take-1-camera.webm');
+  fs.writeFileSync(sourcePath, Buffer.from('fake-webm-bytes'));
+  return sourcePath;
+}
+
+function makeDeps(overrides: Partial<TranscriptionDeps> = {}): {
+  deps: TranscriptionDeps;
+  extractedPaths: string[];
+  convertCalls: Array<Record<string, unknown>>;
+} {
+  const extractedPaths: string[] = [];
+  const calls: Array<Record<string, unknown>> = [];
+
+  const deps: TranscriptionDeps = {
+    runFfmpegImpl: vi.fn(async (opts: { args?: string[] } = {}) => {
+      // The output path is the last ffmpeg argument; write a fake extracted file
+      const args = opts.args;
+      const outPath = args?.[args.length - 1];
+      if (typeof outPath === 'string') {
+        fs.writeFileSync(outPath, Buffer.from('fake-extracted-audio'));
+        extractedPaths.push(outPath);
+      }
+      return { stderr: '' };
+    }) as TranscriptionDeps['runFfmpegImpl'],
+    convertImpl: vi.fn(async (request: Record<string, unknown>) => {
+      calls.push(request);
+      return {
+        languageCode: 'eng',
+        languageProbability: 0.99,
+        text: 'hello world',
+        words: [
+          { text: 'hello', start: 0.1, end: 0.4, type: 'word', logprob: -0.01 },
+          { text: ' ', start: 0.4, end: 0.5, type: 'spacing', logprob: 0 },
+          { text: 'world', start: 0.5, end: 0.9, type: 'word', logprob: -0.02 }
+        ]
+      };
+    }),
+    ...overrides
+  };
+  return { deps, extractedPaths, convertCalls: calls };
+}
+
+describe('main/services/transcription-service', () => {
+  beforeEach(() => {
+    process.env.ELEVENLABS_API_KEY = 'test-key';
+  });
+
+  afterEach(() => {
+    if (OLD_ENV === undefined) {
+      delete process.env.ELEVENLABS_API_KEY;
+    } else {
+      process.env.ELEVENLABS_API_KEY = OLD_ENV;
+    }
+    vi.restoreAllMocks();
+  });
+
+  test('extracts audio with ffmpeg then transcribes the extracted file', async () => {
+    const sourcePath = makeTempSource();
+    const { deps, extractedPaths, convertCalls } = makeDeps();
+
+    const result = await transcribeRecordingFile({ sourcePath }, deps);
+
+    // ffmpeg was invoked with -vn (drop video) and stream-copied audio
+    expect(deps.runFfmpegImpl).toHaveBeenCalledTimes(1);
+    const ffmpegArgs = (deps.runFfmpegImpl as ReturnType<typeof vi.fn>).mock.calls[0][0].args;
+    expect(ffmpegArgs).toContain('-vn');
+    expect(ffmpegArgs).toContain(sourcePath);
+
+    // The transcription request used the extracted audio file, not the source
+    expect(convertCalls).toHaveLength(1);
+    const uploaded = convertCalls[0].file as { path?: string };
+    expect(uploaded?.path).toBe(extractedPaths[0]);
+    expect(convertCalls[0].modelId).toBe('scribe_v2');
+
+    // Words are normalized to plain serializable objects
+    expect(result.words).toEqual([
+      { text: 'hello', start: 0.1, end: 0.4, type: 'word' },
+      { text: ' ', start: 0.4, end: 0.5, type: 'spacing' },
+      { text: 'world', start: 0.5, end: 0.9, type: 'word' }
+    ]);
+    expect(result.languageCode).toBe('eng');
+  });
+
+  test('cleans up the extracted temp file on success', async () => {
+    const sourcePath = makeTempSource();
+    const { deps, extractedPaths } = makeDeps();
+
+    await transcribeRecordingFile({ sourcePath }, deps);
+
+    expect(extractedPaths).toHaveLength(1);
+    expect(fs.existsSync(extractedPaths[0])).toBe(false);
+  });
+
+  test('cleans up the extracted temp file when transcription fails', async () => {
+    const sourcePath = makeTempSource();
+    const { deps, extractedPaths } = makeDeps({
+      convertImpl: vi.fn(async () => {
+        throw new Error('quota exceeded');
+      })
+    });
+
+    await expect(transcribeRecordingFile({ sourcePath }, deps)).rejects.toThrow(
+      /quota exceeded/
+    );
+    expect(extractedPaths).toHaveLength(1);
+    expect(fs.existsSync(extractedPaths[0])).toBe(false);
+  });
+
+  test('propagates ffmpeg extraction failures', async () => {
+    const sourcePath = makeTempSource();
+    const { deps } = makeDeps({
+      runFfmpegImpl: vi.fn(async () => {
+        throw new Error('ffmpeg exploded');
+      })
+    });
+
+    await expect(transcribeRecordingFile({ sourcePath }, deps)).rejects.toThrow(
+      /ffmpeg exploded/
+    );
+    expect(deps.convertImpl).not.toHaveBeenCalled();
+  });
+
+  test('rejects when the source file does not exist', async () => {
+    const { deps } = makeDeps();
+    await expect(
+      transcribeRecordingFile({ sourcePath: '/nonexistent/take.webm' }, deps)
+    ).rejects.toThrow(/not found|no such file|does not exist/i);
+    expect(deps.runFfmpegImpl).not.toHaveBeenCalled();
+    expect(deps.convertImpl).not.toHaveBeenCalled();
+  });
+
+  test('rejects when the source file is empty', async () => {
+    const dir = fs.mkdtempSync(path.join(os.tmpdir(), 'loop-transcribe-test-'));
+    const sourcePath = path.join(dir, 'empty.webm');
+    fs.writeFileSync(sourcePath, Buffer.alloc(0));
+    const { deps } = makeDeps();
+
+    await expect(transcribeRecordingFile({ sourcePath }, deps)).rejects.toThrow(/empty/i);
+    expect(deps.convertImpl).not.toHaveBeenCalled();
+  });
+
+  test('rejects early when ELEVENLABS_API_KEY is missing', async () => {
+    delete process.env.ELEVENLABS_API_KEY;
+    const sourcePath = makeTempSource();
+    const { deps } = makeDeps({ convertImpl: undefined });
+
+    await expect(transcribeRecordingFile({ sourcePath }, deps)).rejects.toThrow(
+      /ELEVENLABS_API_KEY/
+    );
+    expect(deps.runFfmpegImpl).not.toHaveBeenCalled();
+  });
+
+  test('passes the resolved ffmpeg binary path to the runner', async () => {
+    const sourcePath = makeTempSource();
+    const { deps } = makeDeps({ ffmpegPath: '/custom/ffmpeg' });
+
+    await transcribeRecordingFile({ sourcePath }, deps);
+
+    const call = (deps.runFfmpegImpl as ReturnType<typeof vi.fn>).mock.calls[0][0];
+    expect(call.ffmpegPath).toBe('/custom/ffmpeg');
+  });
+
+  test('tolerates responses with missing words array', async () => {
+    const sourcePath = makeTempSource();
+    const { deps } = makeDeps({
+      convertImpl: vi.fn(async () => ({ text: '', languageCode: 'eng' }))
+    });
+
+    const result = await transcribeRecordingFile({ sourcePath }, deps);
+    expect(result.words).toEqual([]);
+  });
+
+  test('drops malformed word entries instead of failing', async () => {
+    const sourcePath = makeTempSource();
+    const { deps } = makeDeps({
+      convertImpl: vi.fn(async () => ({
+        text: 'ok',
+        words: [
+          { text: 'ok', start: 0, end: 0.3, type: 'word' },
+          null,
+          'garbage',
+          { start: 1, end: 2 }
+        ]
+      }))
+    });
+
+    const result = await transcribeRecordingFile({ sourcePath }, deps);
+    expect(result.words).toEqual([{ text: 'ok', start: 0, end: 0.3, type: 'word' }]);
+  });
+});
diff --git a/tsconfig.build.json b/tsconfig.build.json
index 8f8036d..4b15755 100644
--- a/tsconfig.build.json
+++ b/tsconfig.build.json
@@ -9,7 +9,6 @@
     "rootDir": "src"
   },
   "include": [
-    "src/audio-processor.ts",
     "src/**/*.d.ts",
     "src/main.ts",
     "src/preload.ts",