diff --git a/src/components/ai-edition/NewEditorShell.tsx b/src/components/ai-edition/NewEditorShell.tsx
index 2a417df39..df679396d 100644
--- a/src/components/ai-edition/NewEditorShell.tsx
+++ b/src/components/ai-edition/NewEditorShell.tsx
@@ -223,6 +223,11 @@ export function NewEditorShell() {
 
 	const [seekTarget, setSeekTarget] = useState<SeekTarget | null>(null);
 	const [videoElement, setVideoElement] = useState<HTMLVideoElement | null>(null);
+	const voiceoverPausedRef = useRef(false);
+	const voiceoverSeekEpochRef = useRef(0);
+	const voiceoverActiveRef = useRef(false);
+	const voiceoverSessionRef = useRef(0);
+	const cancelPendingPlaybackRef = useRef<(() => void) | null>(null);
 	// v4 shell: three modes (Media / Edit / Rec), a collapsible agent (chat)
 	// column, and a floating facet inspector over the stage.
 	const [mode, setMode] = useState<EditorMode>("edit");
@@ -540,8 +545,12 @@ export function NewEditorShell() {
 		[setSourceDuration, enqueueTimelineWrite],
 	);
 
+	const canSeek = useCallback(() => !voiceoverPausedRef.current, []);
+	/** Seek the preview unless a paused take owns its current picture. */
 	const handleSeek = useCallback(
 		(timeSec: number, preservePlayback?: boolean) => {
+			// A paused take must resume against the same picture, not a scrubbed-to position.
+			if (!canSeek()) return;
 			setCurrentTime(timeSec);
 			setSeekTarget({
 				timeSec,
@@ -550,7 +559,7 @@ export function NewEditorShell() {
 				preservePlayback,
 			});
 		},
-		[setCurrentTime],
+		[setCurrentTime, canSeek],
 	);
 
 	const handleTimeChange = useCallback(
@@ -644,7 +653,10 @@ export function NewEditorShell() {
 		// here doesn't cause this effect to re-subscribe on every playhead tick.
 	}, [videoElement, setPlaying]);
 
+	/** Toggle ordinary playback; paused takes resume through the recording bar. */
 	const togglePlay = useCallback(() => {
+		// Resume the microphone and picture together from the voiceover bar.
+		if (voiceoverPausedRef.current) return;
 		if (!videoElement) return;
 		if (videoElement.paused) {
 			const playhead = useProjectStore.getState().currentTimeSec;
@@ -1057,7 +1069,11 @@ export function NewEditorShell() {
 	// where it is passed to the preview.
 	const [voiceoverRecording, setVoiceoverRecording] = useState(false);
 
+	/** Anchor a new take at the playhead and start preview playback at normal speed. */
 	const handleVoiceoverRecordingStart = useCallback(async () => {
+		voiceoverSessionRef.current++;
+		voiceoverActiveRef.current = true;
+		voiceoverPausedRef.current = false;
 		// Re-capture: the user may have scrubbed between opening the dialog and
 		// hitting Record, and playback starts from wherever the playhead is now.
 		const doc = useProjectStore.getState().document;
@@ -1073,11 +1089,45 @@ export function NewEditorShell() {
 		if (videoElement.paused) await videoElement.play();
 	}, [videoElement]);
 
+	/** End the take, invalidate pending playback and restore timeline audio. */
 	const handleVoiceoverRecordingStop = useCallback(() => {
+		voiceoverSessionRef.current++;
+		voiceoverActiveRef.current = false;
+		voiceoverPausedRef.current = false;
 		setVoiceoverRecording(false);
+		cancelPendingPlaybackRef.current?.();
 		videoElement?.pause();
 	}, [videoElement]);
 
+	/** Freeze the picture and invalidate queued scrubs without ending the take. */
+	const handleVoiceoverRecordingPause = useCallback(() => {
+		voiceoverPausedRef.current = true;
+		voiceoverSeekEpochRef.current++;
+		cancelPendingPlaybackRef.current?.();
+		videoElement?.pause();
+		// Keep voiceoverRecording true: the take still owns the unedited clock and mute.
+	}, [videoElement]);
+
+	/** Resume the picture before the microphone, unless Stop superseded this request. */
+	const handleVoiceoverRecordingResume = useCallback(async () => {
+		if (!voiceoverActiveRef.current) return;
+		if (!videoElement) throw new Error("The preview is not ready.");
+		const doc = useProjectStore.getState().document;
+		const end =
+			doc?.timeline.clips.reduce((max, clip) => Math.max(max, clip.timelineEndSec), 0) ?? 0;
+		if (end > 0 && useProjectStore.getState().currentTimeSec >= end - 0.001) return false;
+		const session = voiceoverSessionRef.current;
+		await videoElement.play();
+		if (session !== voiceoverSessionRef.current) {
+			// A pending play() must not restart the picture after Stop/Cancel.
+			if (!voiceoverActiveRef.current) videoElement.pause();
+			return;
+		}
+		voiceoverPausedRef.current = false;
+		return true;
+	}, [videoElement]);
+
+	/** Place saved audio at the original take anchor using active recording duration. */
 	const handleVoiceoverReady = useCallback(
 		async (assetId: string, durationSec: number) => {
 			setVoiceoverFlow(null);
@@ -1757,6 +1807,7 @@ export function NewEditorShell() {
 									onSeek={handleSeek}
 									onLoadedMetadata={handleLoadedMetadata}
 									onVideoElement={setVideoElement}
+									cancelPendingPlaybackRef={cancelPendingPlaybackRef}
 									playing={playing}
 								/>
 							</div>
@@ -1809,6 +1860,8 @@ export function NewEditorShell() {
 						onAnnotationRowCountChange={setAnnotationRowCount}
 						tl={tl}
 						setCurrentTime={handleSeek}
+						canSeek={canSeek}
+						seekEpochRef={voiceoverSeekEpochRef}
 						variant={mode === "media" ? "media" : "edit"}
 						onDropAsset={handleDropAsset}
 						videoSources={videoSources}
@@ -1881,7 +1934,7 @@ export function NewEditorShell() {
 				onClose={() => {
 					// Belt and braces: the recorder's own stop handler clears this, but a
 					// flow that ends any other way must not leave the timeline muted.
-					setVoiceoverRecording(false);
+					if (voiceoverActiveRef.current) handleVoiceoverRecordingStop();
 					setVoiceoverFlow(null);
 				}}
 				onComplete={(assetId, durationSec) => {
@@ -1889,6 +1942,8 @@ export function NewEditorShell() {
 				}}
 				onRecordingStart={handleVoiceoverRecordingStart}
 				onRecordingStop={handleVoiceoverRecordingStop}
+				onRecordingPause={handleVoiceoverRecordingPause}
+				onRecordingResume={handleVoiceoverRecordingResume}
 			/>
 		</div>
 	);
diff --git a/src/components/ai-edition/NewEditorShell.voiceover.test.tsx b/src/components/ai-edition/NewEditorShell.voiceover.test.tsx
index 8f43df0f3..f0ff89ce4 100644
--- a/src/components/ai-edition/NewEditorShell.voiceover.test.tsx
+++ b/src/components/ai-edition/NewEditorShell.voiceover.test.tsx
@@ -12,7 +12,8 @@ import { buildSceneDescription } from "@/native/sceneDescription";
 
 const mocks = vi.hoisted(() => ({
 	nativePlaybackSync: vi.fn(),
-	previewPlay: vi.fn(async () => undefined),
+	previewPlay: vi.fn(async (): Promise<void> => undefined),
+	previewPause: vi.fn(),
 }));
 
 vi.mock("@/contexts/ShortcutsContext", async () => {
@@ -53,7 +54,7 @@ vi.mock("./Preview", async () => {
 				const element = document.createElement("video");
 				Object.defineProperty(element, "paused", { configurable: true, value: true });
 				element.play = mocks.previewPlay;
-				element.pause = vi.fn();
+				element.pause = mocks.previewPause;
 				onVideoElement(element);
 				return () => onVideoElement(null);
 			}, [onVideoElement]);
@@ -66,21 +67,41 @@ vi.mock("./Preview", async () => {
 });
 
 vi.mock("./v4/V4Timeline", () => ({
-	V4Timeline: ({ onAddVoiceover }: { onAddVoiceover: () => void }) =>
-		createElement("button", { type: "button", onClick: onAddVoiceover }, "open-voiceover"),
+	V4Timeline: ({
+		onAddVoiceover,
+		setCurrentTime,
+		onTogglePlay,
+	}: {
+		onAddVoiceover: () => void;
+		setCurrentTime: (time: number) => void;
+		onTogglePlay: () => void;
+	}) =>
+		createElement(
+			"div",
+			null,
+			createElement("button", { type: "button", onClick: onAddVoiceover }, "open-voiceover"),
+			createElement("button", { type: "button", onClick: () => setCurrentTime(9) }, "seek-preview"),
+			createElement("button", { type: "button", onClick: onTogglePlay }, "toggle-preview"),
+		),
 }));
 
 vi.mock("./v4/AddAudioLayerDialog", () => ({
 	AddAudioLayerDialog: ({
 		open,
+		onClose,
 		onComplete,
 		onRecordingStart,
 		onRecordingStop,
+		onRecordingPause,
+		onRecordingResume,
 	}: {
 		open: boolean;
+		onClose: () => void;
 		onComplete: (assetId: string, durationSec: number) => void;
 		onRecordingStart: () => void | Promise<void>;
 		onRecordingStop: () => void;
+		onRecordingPause: () => void;
+		onRecordingResume: () => void | Promise<void>;
 	}) =>
 		open
 			? createElement(
@@ -88,6 +109,13 @@ vi.mock("./v4/AddAudioLayerDialog", () => ({
 					null,
 					createElement("button", { type: "button", onClick: onRecordingStart }, "start-recording"),
 					createElement("button", { type: "button", onClick: onRecordingStop }, "stop-recording"),
+					createElement("button", { type: "button", onClick: onClose }, "close-voiceover"),
+					createElement("button", { type: "button", onClick: onRecordingPause }, "pause-recording"),
+					createElement(
+						"button",
+						{ type: "button", onClick: onRecordingResume },
+						"resume-recording",
+					),
 					createElement(
 						"button",
 						{ type: "button", onClick: () => onComplete("voice", 4) },
@@ -155,52 +183,54 @@ function renderShell() {
 	);
 }
 
-describe("NewEditorShell voiceover placement", () => {
-	beforeEach(() => {
-		localStorage.clear();
-		vi.clearAllMocks();
-		(window as unknown as { electronAPI?: unknown }).electronAPI = {
-			onAiEditionChatEvent: () => () => undefined,
-			sendAiEditionChatPrompt: () => undefined,
-			setTitleBarOverlay: () => undefined,
-			setHasUnsavedChanges: () => undefined,
-			onRequestCloseConfirm: () => () => undefined,
-			onRequestSaveBeforeClose: () => () => undefined,
-			sendCloseConfirmResponse: () => undefined,
-			findRecordingCamera: () => Promise.resolve(null),
-			preparePreviewAudioTrack: () => Promise.resolve(null),
-			isAppPackaged: () => false,
-		};
-		Element.prototype.scrollTo = () => undefined;
-		(globalThis as unknown as { ResizeObserver?: unknown }).ResizeObserver = class {
-			observe = vi.fn();
-			unobserve = vi.fn();
-			disconnect = vi.fn();
-		};
-		const document = makeDocument();
-		const saveDocument = vi.fn(async (next: AxcutDocument) => {
-			useProjectStore.setState({
-				document: next,
-				revision: 2,
-				dirty: true,
-				lastSavedAt: new Date(),
-			});
-			return true;
-		});
+function prepareShell() {
+	localStorage.clear();
+	vi.clearAllMocks();
+	(window as unknown as { electronAPI?: unknown }).electronAPI = {
+		onAiEditionChatEvent: () => () => undefined,
+		sendAiEditionChatPrompt: () => undefined,
+		setTitleBarOverlay: () => undefined,
+		setHasUnsavedChanges: () => undefined,
+		onRequestCloseConfirm: () => () => undefined,
+		onRequestSaveBeforeClose: () => () => undefined,
+		sendCloseConfirmResponse: () => undefined,
+		findRecordingCamera: () => Promise.resolve(null),
+		preparePreviewAudioTrack: () => Promise.resolve(null),
+		isAppPackaged: () => false,
+	};
+	Element.prototype.scrollTo = () => undefined;
+	(globalThis as unknown as { ResizeObserver?: unknown }).ResizeObserver = class {
+		observe = vi.fn();
+		unobserve = vi.fn();
+		disconnect = vi.fn();
+	};
+	const document = makeDocument();
+	const saveDocument = vi.fn(async (next: AxcutDocument) => {
 		useProjectStore.setState({
-			projectId: document.project.id,
-			document,
-			revision: 1,
-			status: "ready",
-			error: null,
-			sourceDurationSec: 10,
-			currentTimeSec: 2,
-			playing: false,
-			dirty: false,
+			document: next,
+			revision: 2,
+			dirty: true,
 			lastSavedAt: new Date(),
-			saveDocument,
 		});
+		return true;
+	});
+	useProjectStore.setState({
+		projectId: document.project.id,
+		document,
+		revision: 1,
+		status: "ready",
+		error: null,
+		sourceDurationSec: 10,
+		currentTimeSec: 2,
+		playing: false,
+		dirty: false,
+		lastSavedAt: new Date(),
+		saveDocument,
 	});
+}
+
+describe("NewEditorShell voiceover placement", () => {
+	beforeEach(prepareShell);
 
 	afterEach(() => {
 		cleanup();
@@ -249,3 +279,98 @@ describe("NewEditorShell voiceover placement", () => {
 		]);
 	});
 });
+
+describe("paused voiceover preview", () => {
+	beforeEach(prepareShell);
+	afterEach(() => {
+		cleanup();
+		useProjectStore.getState().clear();
+	});
+
+	it.each([
+		false,
+		true,
+	])("only stops playback on closing an active take (active=%s)", async (active) => {
+		renderShell();
+		await act(async () => {
+			fireEvent.click(screen.getByText("toggle-preview"));
+		});
+		fireEvent.click(screen.getByText("open-voiceover"));
+		if (active) {
+			await act(async () => {
+				fireEvent.click(screen.getByText("start-recording"));
+			});
+		}
+		fireEvent.click(screen.getByText("close-voiceover"));
+		expect(mocks.previewPause).toHaveBeenCalledTimes(active ? 1 : 0);
+		expect(screen.queryByText("close-voiceover")).not.toBeInTheDocument();
+	});
+
+	it("freezes seeking and transport while paused, then keeps the original placement across resume", async () => {
+		renderShell();
+		fireEvent.click(screen.getByText("open-voiceover"));
+		await act(async () => {
+			fireEvent.click(screen.getByText("start-recording"));
+		});
+		act(() => {
+			useProjectStore.setState({ currentTimeSec: 4 });
+		});
+		fireEvent.click(screen.getByText("pause-recording"));
+		expect(mocks.previewPause).toHaveBeenCalledOnce();
+		expect(screen.getByTestId("preview-recording-mode")).toHaveAttribute("data-unedited", "true");
+		fireEvent.click(screen.getByText("seek-preview"));
+		fireEvent.click(screen.getByText("toggle-preview"));
+		expect(useProjectStore.getState().currentTimeSec).toBe(4);
+		expect(mocks.previewPlay).toHaveBeenCalledOnce();
+		await act(async () => {
+			fireEvent.click(screen.getByText("resume-recording"));
+		});
+		expect(mocks.previewPlay).toHaveBeenCalledTimes(2);
+		fireEvent.click(screen.getByText("stop-recording"));
+		fireEvent.click(screen.getByText("complete-recording"));
+		await waitFor(() => expect(useProjectStore.getState().document?.audioTracks).toHaveLength(1));
+		expect(useProjectStore.getState().document?.audioTracks[0]).toMatchObject({
+			startMs: 2000,
+			endMs: 6000,
+		});
+	});
+
+	it("re-pauses late playback if the take was stopped during an asynchronous resume", async () => {
+		renderShell();
+		fireEvent.click(screen.getByText("open-voiceover"));
+		await act(async () => {
+			fireEvent.click(screen.getByText("start-recording"));
+		});
+		fireEvent.click(screen.getByText("pause-recording"));
+		let finish!: () => void;
+		mocks.previewPlay.mockImplementationOnce(
+			() =>
+				new Promise<void>((resolve) => {
+					finish = resolve;
+				}),
+		);
+		fireEvent.click(screen.getByText("resume-recording"));
+		fireEvent.click(screen.getByText("stop-recording"));
+		await act(async () => {
+			finish();
+		});
+		expect(mocks.previewPause).toHaveBeenCalledTimes(3);
+		expect(screen.getByTestId("preview-recording-mode")).toHaveAttribute("data-unedited", "false");
+	});
+
+	it("does not restart preview when a paused take has reached the timeline end", async () => {
+		renderShell();
+		fireEvent.click(screen.getByText("open-voiceover"));
+		await act(async () => {
+			fireEvent.click(screen.getByText("start-recording"));
+		});
+		fireEvent.click(screen.getByText("pause-recording"));
+		act(() => {
+			useProjectStore.setState({ currentTimeSec: 10 });
+		});
+		await act(async () => {
+			fireEvent.click(screen.getByText("resume-recording"));
+		});
+		expect(mocks.previewPlay).toHaveBeenCalledTimes(1);
+	});
+});
diff --git a/src/components/ai-edition/Preview.tsx b/src/components/ai-edition/Preview.tsx
index 2d64b4428..01dbedf16 100644
--- a/src/components/ai-edition/Preview.tsx
+++ b/src/components/ai-edition/Preview.tsx
@@ -55,6 +55,7 @@ interface PreviewProps {
 	onSeek: (sec: number) => void;
 	onLoadedMetadata: (sec: number, assetId: string) => void;
 	onVideoElement: (el: HTMLVideoElement | null) => void;
+	cancelPendingPlaybackRef?: React.MutableRefObject<(() => void) | null>;
 	// ponytail: the transport bar (play/pause, prev/next, loop, scrub) moved
 	// into the timeline header (Bottombar), so playback state now lives in
 	// the parent shell — Preview only needs `playing` to report it on the
@@ -91,6 +92,7 @@ export function Preview({
 	onSeek,
 	onLoadedMetadata,
 	onVideoElement,
+	cancelPendingPlaybackRef,
 	playing,
 }: PreviewProps) {
 	const te = useScopedT("editor");
@@ -235,6 +237,7 @@ export function Preview({
 						onSeek={onSeek}
 						onLoadedMetadata={onLoadedMetadata}
 						onVideoElement={onVideoElement}
+						cancelPendingPlaybackRef={cancelPendingPlaybackRef}
 						currentTimeSec={currentTimeSec}
 						onVideoError={handleVideoError}
 						onVideoRecovered={handleVideoRecovered}
diff --git a/src/components/ai-edition/PreviewCanvas.tsx b/src/components/ai-edition/PreviewCanvas.tsx
index 24dca18be..e43e6c273 100644
--- a/src/components/ai-edition/PreviewCanvas.tsx
+++ b/src/components/ai-edition/PreviewCanvas.tsx
@@ -107,6 +107,7 @@ interface PreviewCanvasProps {
 	onSeek: (sec: number) => void;
 	onLoadedMetadata: (sec: number, assetId: string) => void;
 	onVideoElement: (el: HTMLVideoElement | null) => void;
+	cancelPendingPlaybackRef?: React.MutableRefObject<(() => void) | null>;
 	currentTimeSec: number;
 	/** Receives the id of the asset whose <video> gave up, plus the MediaError
 	 *  detail for the card. Transient failures are reloaded inside VirtualPreview
diff --git a/src/components/ai-edition/VirtualPreview.playback.test.tsx b/src/components/ai-edition/VirtualPreview.playback.test.tsx
index 517d0b9b6..465216e70 100644
--- a/src/components/ai-edition/VirtualPreview.playback.test.tsx
+++ b/src/components/ai-edition/VirtualPreview.playback.test.tsx
@@ -138,6 +138,41 @@ const reportedTimes = (onTimeChange: ReturnType<typeof vi.fn>) =>
 	onTimeChange.mock.calls.map((call) => call[0] as number);
 
 describe("VirtualPreview playback across a clip boundary", () => {
+	it("cancels queued playback on a source change but preserves its seek", () => {
+		const cancelRef = { current: null as (() => void) | null };
+		const sources = [
+			{ id: "a1", src: "file:///a1.mp4", label: "a1" },
+			{ id: "a2", src: "file:///a2.mp4", label: "a2" },
+		];
+		const clips = [clip("one", "a1", 0, 5, 0), clip("two", "a2", 0, 5, 5)];
+		const tree = (
+			seekTarget: { timeSec: number; requestId: number; preservePlayback?: boolean } | null,
+		) => (
+			<VirtualPreview
+				videoSources={sources}
+				clips={clips}
+				seekTarget={seekTarget}
+				cancelPendingPlaybackRef={cancelRef}
+			/>
+		);
+		const view = render(tree(null));
+		const first = view.container.querySelector("video") as HTMLVideoElement;
+		driveVideo(first);
+		act(() => fireEvent.loadedMetadata(first));
+		act(() => {
+			first.play();
+			view.rerender(tree({ timeSec: 8, requestId: 1, preservePlayback: true }));
+		});
+		const second = view.container.querySelector("video") as HTMLVideoElement;
+		const driven = driveVideo(second);
+		expect(cancelRef.current).not.toBeNull();
+		act(() => {
+			cancelRef.current?.();
+			fireEvent.loadedMetadata(second);
+		});
+		expect(second.play).not.toHaveBeenCalled();
+		expect(driven.currentTime).toBe(3);
+	});
 	// The reported bug: with two clips over ONE recording, playback stopped on reaching
 	// the second clip and the playhead landed at the end of the timeline.
 	it("crosses into the second clip of the same recording instead of stopping", () => {
diff --git a/src/components/ai-edition/VirtualPreview.tsx b/src/components/ai-edition/VirtualPreview.tsx
index 03b7530bc..3d7cc54db 100644
--- a/src/components/ai-edition/VirtualPreview.tsx
+++ b/src/components/ai-edition/VirtualPreview.tsx
@@ -468,6 +468,7 @@ interface VirtualPreviewProps {
 		videoHeight: number,
 	) => void;
 	onVideoElement?: (element: HTMLVideoElement | null) => void;
+	cancelPendingPlaybackRef?: React.MutableRefObject<(() => void) | null>;
 	videoStyle?: React.CSSProperties;
 	/** Called with the id of the asset that failed, not as a bare "the preview is
 	 *  broken" signal: only ONE source is mounted at a time (`activeSource`), so
@@ -507,6 +508,7 @@ export function VirtualPreview({
 	onTimeChange,
 	onLoadedMetadata,
 	onVideoElement,
+	cancelPendingPlaybackRef,
 	videoStyle,
 	onVideoError,
 	onVideoRecovered,
@@ -565,6 +567,15 @@ export function VirtualPreview({
 	// The seek that arrived while another was still running (see applySourceTime).
 	const pendingScrubTargetRef = useRef<number | null>(null);
 	const pendingSeekRef = useRef<{ sourceTimeSec: number; play: boolean } | null>(null);
+	useEffect(() => {
+		if (!cancelPendingPlaybackRef) return;
+		cancelPendingPlaybackRef.current = () => {
+			if (pendingSeekRef.current) pendingSeekRef.current.play = false;
+		};
+		return () => {
+			cancelPendingPlaybackRef.current = null;
+		};
+	}, [cancelPendingPlaybackRef]);
 	// When each AUTOMATIC reload happened. The budget is "reloads inside
 	// RELOAD_WINDOW_MS", so it expires by itself: a dead file burns it in
 	// seconds, while the occasional transient across a long editing session
diff --git a/src/components/ai-edition/v4/AddAudioLayerDialog.test.tsx b/src/components/ai-edition/v4/AddAudioLayerDialog.test.tsx
index 47277c782..db7fc61a3 100644
--- a/src/components/ai-edition/v4/AddAudioLayerDialog.test.tsx
+++ b/src/components/ai-edition/v4/AddAudioLayerDialog.test.tsx
@@ -1,6 +1,7 @@
 // @vitest-environment jsdom
 import "@testing-library/jest-dom";
-import { fireEvent, render, screen } from "@testing-library/react";
+import { Blob as NodeBlob } from "node:buffer";
+import { act, cleanup, fireEvent, render, screen } from "@testing-library/react";
 import { toast } from "sonner";
 import { afterEach, beforeEach, describe, expect, it, vi } from "vitest";
 import { AddAudioLayerDialog } from "./AddAudioLayerDialog";
@@ -26,7 +27,9 @@ vi.mock("@/lib/ai-edition/timeline/duration", () => ({
 /** A MediaRecorder stand-in that records whether it was ever stopped. */
 class FakeRecorder {
 	static instances: FakeRecorder[] = [];
-	state: "inactive" | "recording" = "inactive";
+	state: "inactive" | "recording" | "paused" = "inactive";
+	pauseCount = 0;
+	resumeCount = 0;
 	started = false;
 	stopped = false;
 	ondataavailable: ((e: { data: Blob }) => void) | null = null;
@@ -42,9 +45,18 @@ class FakeRecorder {
 		this.started = true;
 		this.state = "recording";
 	}
+	pause() {
+		this.state = "paused";
+		this.pauseCount++;
+	}
+	resume() {
+		this.state = "recording";
+		this.resumeCount++;
+	}
 	stop() {
 		this.stopped = true;
 		this.state = "inactive";
+		this.ondataavailable?.({ data: new Blob(["audio"]) });
 		this.onstop?.();
 	}
 }
@@ -57,6 +69,12 @@ beforeEach(() => {
 	addAudioAsset.mockReset();
 	vi.mocked(toast.error).mockClear();
 	vi.stubGlobal("MediaRecorder", FakeRecorder);
+	vi.stubGlobal("Blob", NodeBlob);
+	Object.defineProperty(window, "electronAPI", {
+		configurable: true,
+		value: { saveRecordedVoiceover: vi.fn(async () => ({ success: true, path: "/voice.webm" })) },
+	});
+	addAudioAsset.mockResolvedValue({ id: "voice" });
 	Object.defineProperty(navigator, "mediaDevices", {
 		configurable: true,
 		value: { getUserMedia: vi.fn(async () => ({ getTracks: () => [{ stop: stopTrack }] })) },
@@ -64,6 +82,9 @@ beforeEach(() => {
 });
 
 afterEach(() => {
+	cleanup();
+	vi.useRealTimers();
+	vi.restoreAllMocks();
 	vi.unstubAllGlobals();
 });
 
@@ -75,6 +96,8 @@ function renderDialog(over: Partial<Parameters<typeof AddAudioLayerDialog>[0]> =
 		onComplete: vi.fn(),
 		onRecordingStart: vi.fn(),
 		onRecordingStop: vi.fn(),
+		onRecordingPause: vi.fn(),
+		onRecordingResume: vi.fn(async () => undefined),
 		...over,
 	};
 	const view = render(<AddAudioLayerDialog {...props} />);
@@ -165,3 +188,168 @@ describe("AddAudioLayerDialog", () => {
 		expect(addAudioAsset).not.toHaveBeenCalled();
 	});
 });
+
+describe("voiceover pause and resume", () => {
+	let now = 0;
+	beforeEach(() => {
+		now = 0;
+		vi.spyOn(performance, "now").mockImplementation(() => now);
+		vi.useFakeTimers({ toFake: ["setInterval", "clearInterval"] });
+	});
+	async function start(over: Partial<Parameters<typeof AddAudioLayerDialog>[0]> = {}) {
+		const result = renderDialog(over);
+		await act(async () => {
+			fireEvent.click(screen.getByText("audio.record"));
+		});
+		return result;
+	}
+	function tick(at: number) {
+		now = at;
+		act(() => {
+			vi.advanceTimersByTime(200);
+		});
+	}
+
+	it("saves the paused take when the preview has reached the end", async () => {
+		const { props } = await start({ onRecordingResume: vi.fn(async () => false) });
+		tick(300);
+		fireEvent.click(screen.getByRole("button", { name: "audio.pause" }));
+		await act(async () => {
+			fireEvent.click(screen.getByRole("button", { name: "audio.resume" }));
+		});
+		expect(FakeRecorder.instances[0].stopped).toBe(true);
+		expect(FakeRecorder.instances[0].resumeCount).toBe(0);
+		expect(props.onComplete).toHaveBeenCalledWith("voice", 0.3);
+	});
+
+	it("freezes its clock across repeated pauses and saves one take with only active time", async () => {
+		const { props } = await start({ maxDurationSec: 6 });
+		tick(3000);
+		fireEvent.click(screen.getByRole("button", { name: "audio.pause" }));
+		expect(FakeRecorder.instances[0].state).toBe("paused");
+		expect(props.onRecordingPause).toHaveBeenCalledOnce();
+		tick(13000);
+		expect(screen.getByText("audio.paused 3.0s")).toBeInTheDocument();
+		expect(FakeRecorder.instances[0].stopped).toBe(false);
+		await act(async () => {
+			fireEvent.click(screen.getByRole("button", { name: "audio.resume" }));
+		});
+		tick(14000);
+		fireEvent.click(screen.getByRole("button", { name: "audio.pause" }));
+		tick(24000);
+		await act(async () => {
+			fireEvent.click(screen.getByRole("button", { name: "audio.resume" }));
+		});
+		tick(25000);
+		await act(async () => {
+			fireEvent.click(screen.getByText("audio.stop"));
+		});
+		expect(props.onComplete).toHaveBeenCalledWith("voice", 5);
+		expect(addAudioAsset).toHaveBeenCalledOnce();
+		expect(FakeRecorder.instances).toHaveLength(1);
+		expect(props.onRecordingStart).toHaveBeenCalledOnce();
+		expect(props.onRecordingResume).toHaveBeenCalledTimes(2);
+	});
+
+	it("stops and saves a paused take without including the wait", async () => {
+		const { props } = await start();
+		tick(2000);
+		fireEvent.click(screen.getByRole("button", { name: "audio.pause" }));
+		tick(22000);
+		await act(async () => {
+			fireEvent.click(screen.getByText("audio.stop"));
+		});
+		expect(props.onComplete).toHaveBeenCalledWith("voice", 2);
+		expect(stopTrack).toHaveBeenCalledOnce();
+	});
+
+	it.each([
+		"cancel",
+		"escape",
+		"unmount",
+	])("discards and releases a paused take on %s", async (how) => {
+		const { unmount, props } = await start();
+		fireEvent.click(screen.getByRole("button", { name: "audio.pause" }));
+		if (how === "unmount") unmount();
+		else if (how === "escape") fireEvent.keyDown(window, { key: "Escape" });
+		else fireEvent.click(screen.getByText("actions.cancel"));
+		expect(FakeRecorder.instances[0].stopped).toBe(true);
+		expect(stopTrack).toHaveBeenCalled();
+		expect(props.onRecordingStop).toHaveBeenCalled();
+		expect(addAudioAsset).not.toHaveBeenCalled();
+	});
+
+	it("leaves the recorder paused on preview resume failure, and permits retry", async () => {
+		const onRecordingResume = vi
+			.fn()
+			.mockRejectedValueOnce(new Error("play blocked"))
+			.mockResolvedValue(undefined);
+		const { props } = await start({ onRecordingResume });
+		tick(1000);
+		fireEvent.click(screen.getByRole("button", { name: "audio.pause" }));
+		await act(async () => {
+			fireEvent.click(screen.getByRole("button", { name: "audio.resume" }));
+		});
+		expect(FakeRecorder.instances[0].state).toBe("paused");
+		expect(toast.error).toHaveBeenCalledWith("audio.recordingUnavailable");
+		tick(11000);
+		await act(async () => {
+			fireEvent.click(screen.getByRole("button", { name: "audio.resume" }));
+		});
+		tick(12000);
+		await act(async () => {
+			fireEvent.click(screen.getByText("audio.stop"));
+		});
+		expect(props.onComplete).toHaveBeenCalledWith("voice", 2);
+	});
+
+	it("does not revive a take stopped while preview resume is pending", async () => {
+		let finishResume!: () => void;
+		const onRecordingResume = vi.fn(
+			() =>
+				new Promise<void>((resolve) => {
+					finishResume = resolve;
+				}),
+		);
+		const { props } = await start({ onRecordingResume });
+		tick(1000);
+		fireEvent.click(screen.getByRole("button", { name: "audio.pause" }));
+		fireEvent.click(screen.getByRole("button", { name: "audio.resume" }));
+		expect(screen.getByRole("button", { name: "audio.resume" })).toBeDisabled();
+		await act(async () => {
+			fireEvent.click(screen.getByText("audio.stop"));
+		});
+		await act(async () => {
+			finishResume();
+		});
+		expect(FakeRecorder.instances[0].resumeCount).toBe(0);
+		expect(props.onComplete).toHaveBeenCalledOnce();
+	});
+
+	it("allows pausing a new take after stopping a pending resume whose save fails", async () => {
+		let finishResume!: () => void;
+		const onRecordingResume = () =>
+			new Promise<void>((resolve) => {
+				finishResume = resolve;
+			});
+		await start({ onRecordingResume });
+		vi.mocked(window.electronAPI.saveRecordedVoiceover).mockRejectedValueOnce(
+			new Error("disk unavailable"),
+		);
+		fireEvent.click(screen.getByRole("button", { name: "audio.pause" }));
+		fireEvent.click(screen.getByRole("button", { name: "audio.resume" }));
+		await act(async () => {
+			fireEvent.click(screen.getByText("audio.stop"));
+		});
+		expect(toast.error).toHaveBeenCalledWith("audio.saveFailed", expect.anything());
+		await act(async () => {
+			fireEvent.click(screen.getByText("audio.record"));
+		});
+		expect(screen.getByRole("button", { name: "audio.pause" })).toBeEnabled();
+		await act(async () => {
+			finishResume();
+		});
+		fireEvent.click(screen.getByRole("button", { name: "audio.pause" }));
+		expect(FakeRecorder.instances[1].state).toBe("paused");
+	});
+});
diff --git a/src/components/ai-edition/v4/AddAudioLayerDialog.tsx b/src/components/ai-edition/v4/AddAudioLayerDialog.tsx
index 0ee457989..e2750e398 100644
--- a/src/components/ai-edition/v4/AddAudioLayerDialog.tsx
+++ b/src/components/ai-edition/v4/AddAudioLayerDialog.tsx
@@ -10,7 +10,7 @@
 // `onComplete` — placing the track on the timeline (span, anchor, inspector
 // selection) is the caller's job, exactly like the other add* flows.
 
-import { Mic, StopCircle, Upload } from "lucide-react";
+import { Mic, Pause, Play, StopCircle, Upload } from "lucide-react";
 import { useCallback, useEffect, useRef, useState } from "react";
 import { toast } from "sonner";
 import { toFileUrl } from "@/components/video-editor/projectPersistence";
@@ -49,6 +49,8 @@ export function AddAudioLayerDialog({
 	onComplete,
 	onRecordingStart,
 	onRecordingStop,
+	onRecordingPause,
+	onRecordingResume,
 }: {
 	open: boolean;
 	maxDurationSec: number;
@@ -56,16 +58,22 @@ export function AddAudioLayerDialog({
 	onComplete: (assetId: string, durationSec: number) => void;
 	onRecordingStart: () => void | Promise<void>;
 	onRecordingStop: () => void;
+	onRecordingPause: () => void;
+	onRecordingResume: () => void | boolean | Promise<void | boolean>;
 }) {
 	const t = useScopedT("timeline");
 	const tc = useScopedT("common");
 	const [busy, setBusy] = useState(false);
+	const [resuming, setResuming] = useState(false);
 	const [recording, setRecording] = useState(false);
+	const [paused, setPaused] = useState(false);
 	const [elapsedSec, setElapsedSec] = useState(0);
 	const recorderRef = useRef<MediaRecorder | null>(null);
 	const streamRef = useRef<MediaStream | null>(null);
 	const chunksRef = useRef<Blob[]>([]);
-	const startedAtRef = useRef(0);
+	const startedAtRef = useRef<number | null>(null);
+	const activeDurationMsRef = useRef(0);
+	const resumingRef = useRef(false);
 	const timerRef = useRef<ReturnType<typeof setInterval> | null>(null);
 	// Set when the user cancels (closes the dialog mid-take) — the stop handler
 	// then discards the blob instead of importing it as a layer.
@@ -73,13 +81,29 @@ export function AddAudioLayerDialog({
 	// Read by the Escape handler, which must not re-subscribe every time the
 	// elapsed-time state ticks.
 	const recordingRef = useRef(false);
+	/** Return accumulated active time plus the current segment, excluding pauses. */
+	const elapsed = useCallback(() => {
+		const liveMs = startedAtRef.current === null ? 0 : performance.now() - startedAtRef.current;
+		return (activeDurationMsRef.current + liveMs) / 1000;
+	}, []);
+	/** Commit the current segment once and freeze the effective recording clock. */
+	const freezeClock = useCallback(() => {
+		if (startedAtRef.current !== null) {
+			activeDurationMsRef.current += performance.now() - startedAtRef.current;
+			startedAtRef.current = null;
+		}
+		return activeDurationMsRef.current / 1000;
+	}, []);
 
 	// Reset whenever the dialog opens again — a cancelled recording must not
 	// leak its stream or timer into the next session.
 	useEffect(() => {
 		if (open) {
 			setBusy(false);
+			setResuming(false);
 			setRecording(false);
+			setPaused(false);
+			resumingRef.current = false;
 			recordingRef.current = false;
 			setElapsedSec(0);
 		}
@@ -106,7 +130,10 @@ export function AddAudioLayerDialog({
 		};
 	}, [open]);
 
+	/** Stop capture and release its stream; the recorder's stop handler owns saving. */
 	const stopRecording = useCallback(() => {
+		resumingRef.current = false;
+		setResuming(false);
 		if (timerRef.current) {
 			clearInterval(timerRef.current);
 			timerRef.current = null;
@@ -114,11 +141,53 @@ export function AddAudioLayerDialog({
 		const recorder = recorderRef.current;
 		// `recorder.onstop` (registered at start) owns the save path.
 		if (recorder && recorder.state !== "inactive") {
+			freezeClock();
 			recorder.stop();
 		}
 		for (const track of streamRef.current?.getTracks() ?? []) track.stop();
 		streamRef.current = null;
-	}, []);
+	}, [freezeClock]);
+
+	/** Pause the recorder and clock, then ask the shell to freeze the picture. */
+	const pauseRecording = useCallback(() => {
+		const recorder = recorderRef.current;
+		if (!recorder || recorder.state !== "recording" || resumingRef.current) return;
+		recorder.pause();
+		setElapsedSec(freezeClock());
+		setPaused(true);
+		onRecordingPause();
+	}, [freezeClock, onRecordingPause]);
+
+	/** Resume audio after playback is ready, retaining pause on failure or cancellation. */
+	const resumeRecording = useCallback(async () => {
+		const recorder = recorderRef.current;
+		if (!recorder || recorder.state !== "paused" || resumingRef.current) return;
+		resumingRef.current = true;
+		setResuming(true);
+		try {
+			// As on the first start, the picture must be playing before audio resumes.
+			const canResume = await onRecordingResume();
+			// Stop, cancel or teardown may have won while play() was pending.
+			if (recorderRef.current !== recorder || recorder.state !== "paused") return;
+			if (canResume === false) {
+				stopRecording();
+				return;
+			}
+			recorder.resume();
+			startedAtRef.current = performance.now();
+			setPaused(false);
+		} catch {
+			if (recorderRef.current === recorder && recorder.state === "paused") {
+				onRecordingPause();
+				toast.error(t("audio.recordingUnavailable"));
+			}
+		} finally {
+			if (recorderRef.current === recorder) {
+				resumingRef.current = false;
+				setResuming(false);
+			}
+		}
+	}, [onRecordingPause, onRecordingResume, stopRecording, t]);
 
 	const cancelRecording = useCallback(() => {
 		discardRef.current = true;
@@ -154,6 +223,7 @@ export function AddAudioLayerDialog({
 		[onComplete, t],
 	);
 
+	/** Acquire the microphone and create one recorder for the entire pauseable take. */
 	const startRecording = useCallback(async () => {
 		if (typeof navigator === "undefined" || !navigator.mediaDevices?.getUserMedia) {
 			toast.error(t("audio.recordingUnavailable"));
@@ -174,6 +244,7 @@ export function AddAudioLayerDialog({
 				? new MediaRecorder(stream, { mimeType })
 				: new MediaRecorder(stream);
 			recorderRef.current = recorder;
+			resumingRef.current = false;
 			chunksRef.current = [];
 			recorder.ondataavailable = (event) => {
 				if (event.data.size > 0) chunksRef.current.push(event.data);
@@ -182,10 +253,13 @@ export function AddAudioLayerDialog({
 				const blob = new Blob(chunksRef.current, {
 					type: recorder.mimeType || "audio/webm",
 				});
-				const duration = (performance.now() - startedAtRef.current) / 1000;
+				const duration = freezeClock();
 				const discarded = discardRef.current;
 				discardRef.current = false;
 				setRecording(false);
+				setPaused(false);
+				setResuming(false);
+				resumingRef.current = false;
 				recordingRef.current = false;
 				setElapsedSec(0);
 				onRecordingStop();
@@ -223,18 +297,20 @@ export function AddAudioLayerDialog({
 				return;
 			}
 			startedAtRef.current = performance.now();
+			activeDurationMsRef.current = 0;
 			discardRef.current = false;
 			recorder.start(250);
 			setRecording(true);
+			setPaused(false);
 			recordingRef.current = true;
 			setElapsedSec(0);
 			timerRef.current = setInterval(() => {
-				setElapsedSec((performance.now() - startedAtRef.current) / 1000);
+				setElapsedSec(elapsed());
 			}, 200);
 		} catch {
 			toast.error(t("audio.micDenied"));
 		}
-	}, [finishWithPath, onRecordingStart, onRecordingStop, t]);
+	}, [elapsed, freezeClock, finishWithPath, onRecordingStart, onRecordingStop, t]);
 
 	// Stop by itself at the end of the timeline so a layer can never outlive
 	// the video it was recorded over.
@@ -291,14 +367,25 @@ export function AddAudioLayerDialog({
 		<div className={styles.voiceoverBar} role="group" aria-label={t("audio.addVoiceover")}>
 			<span className={styles.voiceoverBarTitle}>
 				<strong>{t("audio.addVoiceover")}</strong>
-				<span>{recording ? t("audio.recordingHint") : t("audio.subtitle")}</span>
+				<span>
+					{recording ? t(paused ? "audio.pausedHint" : "audio.recordingHint") : t("audio.subtitle")}
+				</span>
 			</span>
 			{recording ? (
 				<>
 					<span className={styles.voiceoverBarLive} aria-live="polite">
-						<span className={`${styles.voiceoverBarDot} animate-pulse`} />
-						{t("audio.recording")} {elapsedSec.toFixed(1)}s
+						<span className={`${styles.voiceoverBarDot} ${paused ? "" : "animate-pulse"}`} />
+						{t(paused ? "audio.paused" : "audio.recording")} {elapsedSec.toFixed(1)}s
 					</span>
+					<button
+						type="button"
+						onClick={paused ? () => void resumeRecording() : pauseRecording}
+						disabled={busy || resuming}
+						className={styles.voiceoverBarBtn}
+					>
+						{paused ? <Play size={16} /> : <Pause size={16} />}
+						{t(paused ? "audio.resume" : "audio.pause")}
+					</button>
 					<button
 						type="button"
 						onClick={stopRecording}
diff --git a/src/components/ai-edition/v4/V4Timeline.geometry.test.tsx b/src/components/ai-edition/v4/V4Timeline.geometry.test.tsx
index 93a44e143..64bcd154c 100644
--- a/src/components/ai-edition/v4/V4Timeline.geometry.test.tsx
+++ b/src/components/ai-edition/v4/V4Timeline.geometry.test.tsx
@@ -112,6 +112,8 @@ function renderTimeline(
 	assets: Array<Record<string, unknown>> = [NO_CAMERA_ASSET],
 	onRender?: ProfilerOnRenderCallback,
 	overrides: Record<string, unknown> = {},
+	canSeek?: () => boolean,
+	seekEpochRef?: { current: number },
 ) {
 	const tl = {
 		clips,
@@ -159,6 +161,8 @@ function renderTimeline(
 				// stays typed as the real API rather than widened to `any` (AGENTS.md).
 				tl={tl as unknown as ReturnType<typeof useTimeline>}
 				setCurrentTime={setCurrentTime}
+				canSeek={canSeek}
+				seekEpochRef={seekEpochRef}
 				playing={false}
 				onTogglePlay={vi.fn()}
 				onEditClip={vi.fn()}
@@ -331,6 +335,67 @@ describe("timeline tracks", () => {
 });
 
 describe("V4Timeline scrubbing", () => {
+	it("discards a queued scrub after a pause and resume during the drag", () => {
+		const frames = new Map<number, FrameRequestCallback>();
+		let nextFrameId = 1;
+		vi.stubGlobal("requestAnimationFrame", (callback: FrameRequestCallback) => {
+			const frameId = nextFrameId++;
+			frames.set(frameId, callback);
+			return frameId;
+		});
+		vi.stubGlobal("cancelAnimationFrame", (frameId: number) => frames.delete(frameId));
+		const seekEpochRef = { current: 0 };
+		const { setCurrentTime } = renderTimeline(
+			undefined,
+			undefined,
+			undefined,
+			undefined,
+			{},
+			undefined,
+			seekEpochRef,
+		);
+		const ruler = document.querySelector<HTMLElement>("[class*=tlRulerRow]");
+		expect(ruler).not.toBeNull();
+		fireEvent.pointerDown(ruler as HTMLElement, { button: 0, clientX: 90 });
+		setCurrentTime.mockClear();
+		fireEvent.pointerMove(window, { clientX: 540 });
+		seekEpochRef.current++;
+		const [[frameId, frame]] = frames;
+		frames.delete(frameId);
+		act(() => frame(0));
+		fireEvent.pointerUp(window);
+		expect(setCurrentTime).not.toHaveBeenCalled();
+	});
+
+	it.each([
+		"tlRulerRow",
+		"tlTracks",
+	])("keeps the playhead fixed on %s while seeking is blocked", (targetClass) => {
+		let allowed = false;
+		const { setCurrentTime, tl } = renderTimeline(
+			undefined,
+			undefined,
+			undefined,
+			undefined,
+			{},
+			() => allowed,
+		);
+		const target = document.querySelector(`[class*=${targetClass}]`) as HTMLElement;
+		const playhead = document.querySelector<HTMLElement>("[class*=tlPlayhead][style]");
+		expect(playhead).not.toBeNull();
+		const before = playhead?.style.left;
+		fireEvent.pointerDown(target, { button: 0, clientX: 450 });
+		fireEvent.pointerMove(window, { clientX: 540 });
+		fireEvent.pointerUp(window);
+		expect(setCurrentTime).not.toHaveBeenCalled();
+		expect(tl.clearSelection).not.toHaveBeenCalled();
+		expect(playhead?.style.left).toBe(before);
+		allowed = true;
+		fireEvent.pointerDown(target, { button: 0, clientX: 450 });
+		fireEvent.pointerUp(window);
+		expect(setCurrentTime).toHaveBeenCalledWith(900);
+	});
+
 	it("publishes at most one React scrub-state update per animation frame", () => {
 		const frames = new Map<number, FrameRequestCallback>();
 		let nextFrameId = 1;
diff --git a/src/components/ai-edition/v4/V4Timeline.tsx b/src/components/ai-edition/v4/V4Timeline.tsx
index 79052a249..27bbdee51 100644
--- a/src/components/ai-edition/v4/V4Timeline.tsx
+++ b/src/components/ai-edition/v4/V4Timeline.tsx
@@ -21,6 +21,7 @@ import {
 	memo,
 	type KeyboardEvent as ReactKeyboardEvent,
 	type PointerEvent as ReactPointerEvent,
+	type RefObject,
 	useCallback,
 	useEffect,
 	useMemo,
@@ -643,6 +644,8 @@ function LayoutChangeMenu({ tl, onClose }: { tl: TimelineApi; onClose: () => voi
 export function V4Timeline({
 	tl,
 	setCurrentTime,
+	canSeek,
+	seekEpochRef,
 	variant = "edit",
 	onDropAsset,
 	videoSources = [],
@@ -654,6 +657,10 @@ export function V4Timeline({
 }: {
 	tl: TimelineApi;
 	setCurrentTime: (sec: number) => void;
+	/** Checked before local playhead updates as well as deferred seek writes. */
+	canSeek?: () => boolean;
+	/** Incremented whenever an in-flight scrub must be discarded. */
+	seekEpochRef?: RefObject<number>;
 	variant?: "edit" | "media";
 	onDropAsset?: (assetId: string) => Promise<void>;
 	videoSources?: VideoSource[];
@@ -885,13 +892,15 @@ export function V4Timeline({
 	const [scrubbingTimeSec, setScrubbingTimeSec] = useState<number | null>(null);
 	const rafSeekRef = useRef<number>(0);
 	const pendingSeekTimeRef = useRef<number | null>(null);
+	const pendingSeekEpochRef = useRef(0);
 
 	// ── interactions ────────────────────────────────────────────────
 	const playheadElRef = useRef<HTMLDivElement | null>(null);
 
-	// Seek timeline position from a clientX pointer position.
+	/** Move the local playhead and schedule a seek tied to the current seek epoch. */
 	const seekToClientX = useCallback(
 		(clientX: number, isImmediate = false) => {
+			if (canSeek?.() === false) return;
 			// Measure the canvas (the zoomed timeline frame): (clientX - left)/width
 			// is the fraction along the FULL timeline under the cursor, so it stays
 			// correct under zoom/pan and is unaffected by padding or the scrollbar.
@@ -907,6 +916,7 @@ export function V4Timeline({
 			}
 
 			pendingSeekTimeRef.current = targetTime;
+			pendingSeekEpochRef.current = seekEpochRef?.current ?? 0;
 
 			if (isImmediate) {
 				if (rafSeekRef.current !== 0) {
@@ -922,14 +932,18 @@ export function V4Timeline({
 			if (rafSeekRef.current === 0) {
 				rafSeekRef.current = requestAnimationFrame(() => {
 					rafSeekRef.current = 0;
-					if (pendingSeekTimeRef.current !== null) {
+					if (
+						pendingSeekTimeRef.current !== null &&
+						pendingSeekEpochRef.current === (seekEpochRef?.current ?? 0) &&
+						canSeek?.() !== false
+					) {
 						setScrubbingTimeSec(pendingSeekTimeRef.current);
 						setCurrentTime(pendingSeekTimeRef.current);
 					}
 				});
 			}
 		},
-		[setCurrentTime, total],
+		[setCurrentTime, total, canSeek, seekEpochRef],
 	);
 
 	// Mousedown anywhere on the empty timeline (ruler, lanes background, or
@@ -940,8 +954,10 @@ export function V4Timeline({
 	// anywhere else. Also clears any region selection, closing the
 	// selected-element settings pane (FloatingInspector) the way clicking
 	// away from a selected element is expected to.
+	/** Arm a scrub drag, dropping queued positions invalidated by a voiceover pause. */
 	const startScrub = useCallback(
 		(e: ReactPointerEvent) => {
+			if (canSeek?.() === false) return;
 			if (e.button !== 0) return;
 			// Media has no playhead rendered, so there is nothing to scrub. Guarded
 			// here rather than at the three call sites: seeking an invisible cursor
@@ -965,7 +981,12 @@ export function V4Timeline({
 					rafSeekRef.current = 0;
 				}
 				if (pendingSeekTimeRef.current !== null) {
-					setCurrentTime(pendingSeekTimeRef.current);
+					if (
+						pendingSeekEpochRef.current === (seekEpochRef?.current ?? 0) &&
+						canSeek?.() !== false
+					) {
+						setCurrentTime(pendingSeekTimeRef.current);
+					}
 					pendingSeekTimeRef.current = null;
 				}
 				setScrubbingTimeSec(null);
@@ -973,7 +994,7 @@ export function V4Timeline({
 			window.addEventListener("pointermove", move);
 			window.addEventListener("pointerup", up);
 		},
-		[seekToClientX, tl, setCurrentTime, showLanes],
+		[seekToClientX, tl, setCurrentTime, showLanes, canSeek, seekEpochRef],
 	);
 
 	const [activePillDrag, setActivePillDrag] = useState<{
diff --git a/src/i18n/locales/ar/timeline.json b/src/i18n/locales/ar/timeline.json
index 0094ae0b6..239e5c23c 100644
--- a/src/i18n/locales/ar/timeline.json
+++ b/src/i18n/locales/ar/timeline.json
@@ -107,6 +107,10 @@
 		"importFileHint": "أدرج موسيقى أو ملفًا صوتيًا",
 		"recording": "جارٍ التسجيل",
 		"recordingHint": "علّق صوتيًا مع الفيديو — يعمل أثناء التسجيل",
+		"pause": "إيقاف مؤقت",
+		"resume": "استئناف",
+		"paused": "متوقف مؤقتًا",
+		"pausedHint": "التسجيل والفيديو متوقفان مؤقتًا. اضغط على استئناف للمتابعة.",
 		"stop": "إيقاف",
 		"micDenied": "تم رفض الوصول إلى الميكروفون",
 		"recordingUnavailable": "التسجيل غير متاح هنا",
diff --git a/src/i18n/locales/cs/timeline.json b/src/i18n/locales/cs/timeline.json
index ff20ad4b8..c68dcbb5b 100644
--- a/src/i18n/locales/cs/timeline.json
+++ b/src/i18n/locales/cs/timeline.json
@@ -107,6 +107,10 @@
 		"importFileHint": "Přineste hudbu nebo zvukový soubor",
 		"recording": "Nahrávání",
 		"recordingHint": "Komentujte spolu s videem, které se přehrává při nahrávání",
+		"pause": "Pozastavit",
+		"resume": "Pokračovat",
+		"paused": "Pozastaveno",
+		"pausedHint": "Nahrávání i video jsou pozastavené. Pokračujte tlačítkem Pokračovat.",
 		"stop": "Zastavit",
 		"micDenied": "Přístup k mikrofonu byl odepřen",
 		"recordingUnavailable": "Nahrávání zde není dostupné",
diff --git a/src/i18n/locales/de/timeline.json b/src/i18n/locales/de/timeline.json
index 225fe0bed..10bdc04e5 100644
--- a/src/i18n/locales/de/timeline.json
+++ b/src/i18n/locales/de/timeline.json
@@ -107,6 +107,10 @@
 		"importFileHint": "Musik oder eine Audiodatei einbinden",
 		"recording": "Aufnahme läuft",
 		"recordingHint": "Sprich zum Video — es läuft, während du aufnimmst",
+		"pause": "Pause",
+		"resume": "Fortsetzen",
+		"paused": "Pausiert",
+		"pausedHint": "Aufnahme und Video sind pausiert. Mit „Fortsetzen“ geht es weiter.",
 		"stop": "Stopp",
 		"micDenied": "Zugriff auf das Mikrofon wurde verweigert",
 		"recordingUnavailable": "Aufnahme ist hier nicht verfügbar",
diff --git a/src/i18n/locales/en/timeline.json b/src/i18n/locales/en/timeline.json
index 3a3d6d477..c72b79b9d 100644
--- a/src/i18n/locales/en/timeline.json
+++ b/src/i18n/locales/en/timeline.json
@@ -107,6 +107,10 @@
 		"importFileHint": "Bring in music or an audio file",
 		"recording": "Recording",
 		"recordingHint": "Narrate along with the video — it plays while you record",
+		"pause": "Pause",
+		"resume": "Resume",
+		"paused": "Paused",
+		"pausedHint": "Recording and video are paused. Resume to continue.",
 		"stop": "Stop",
 		"micDenied": "Microphone access was denied",
 		"recordingUnavailable": "Recording is not available here",
diff --git a/src/i18n/locales/es/timeline.json b/src/i18n/locales/es/timeline.json
index 5d88e30be..b241b0d4f 100644
--- a/src/i18n/locales/es/timeline.json
+++ b/src/i18n/locales/es/timeline.json
@@ -107,6 +107,10 @@
 		"importFileHint": "Importa música o un archivo de audio",
 		"recording": "Grabando",
 		"recordingHint": "Narra junto al vídeo: se reproduce mientras grabas",
+		"pause": "Pausar",
+		"resume": "Reanudar",
+		"paused": "En pausa",
+		"pausedHint": "La grabación y el vídeo están en pausa. Pulsa Reanudar para continuar.",
 		"stop": "Detener",
 		"micDenied": "Se denegó el acceso al micrófono",
 		"recordingUnavailable": "La grabación no está disponible aquí",
diff --git a/src/i18n/locales/fr/timeline.json b/src/i18n/locales/fr/timeline.json
index f597f987a..6d310b45b 100644
--- a/src/i18n/locales/fr/timeline.json
+++ b/src/i18n/locales/fr/timeline.json
@@ -107,6 +107,10 @@
 		"importFileHint": "Importez une musique ou un fichier audio",
 		"recording": "Enregistrement",
 		"recordingHint": "Commentez en même temps que la vidéo — elle joue pendant l'enregistrement",
+		"pause": "Pause",
+		"resume": "Reprendre",
+		"paused": "En pause",
+		"pausedHint": "L’enregistrement et la vidéo sont en pause. Cliquez sur Reprendre pour continuer.",
 		"stop": "Arrêter",
 		"micDenied": "L'accès au micro a été refusé",
 		"recordingUnavailable": "L'enregistrement n'est pas disponible ici",
diff --git a/src/i18n/locales/it/timeline.json b/src/i18n/locales/it/timeline.json
index f5a20edef..9c78c4837 100644
--- a/src/i18n/locales/it/timeline.json
+++ b/src/i18n/locales/it/timeline.json
@@ -107,6 +107,10 @@
 		"importFileHint": "Importa musica o un file audio",
 		"recording": "Registrazione",
 		"recordingHint": "Racconta insieme al video: continua a riprodursi mentre registri",
+		"pause": "Pausa",
+		"resume": "Riprendi",
+		"paused": "In pausa",
+		"pausedHint": "La registrazione e il video sono in pausa. Premi Riprendi per continuare.",
 		"stop": "Ferma",
 		"micDenied": "Accesso al microfono negato",
 		"recordingUnavailable": "La registrazione non è disponibile qui",
diff --git a/src/i18n/locales/ja-JP/timeline.json b/src/i18n/locales/ja-JP/timeline.json
index 50586d334..f2baa49c8 100644
--- a/src/i18n/locales/ja-JP/timeline.json
+++ b/src/i18n/locales/ja-JP/timeline.json
@@ -107,6 +107,10 @@
 		"importFileHint": "音楽やオーディオファイルを読み込む",
 		"recording": "録音中",
 		"recordingHint": "動画に合わせて話してください — 録音中も再生されます",
+		"pause": "一時停止",
+		"resume": "再開",
+		"paused": "一時停止中",
+		"pausedHint": "録音と動画は一時停止中です。「再開」で続けられます。",
 		"stop": "停止",
 		"micDenied": "マイクへのアクセスが拒否されました",
 		"recordingUnavailable": "ここでは録音できません",
diff --git a/src/i18n/locales/ko-KR/timeline.json b/src/i18n/locales/ko-KR/timeline.json
index e6c142994..aec0c97c1 100644
--- a/src/i18n/locales/ko-KR/timeline.json
+++ b/src/i18n/locales/ko-KR/timeline.json
@@ -107,6 +107,10 @@
 		"importFileHint": "음악이나 오디오 파일 가져오기",
 		"recording": "녹음 중",
 		"recordingHint": "영상에 맞춰 말하세요 — 녹음하는 동안 재생됩니다",
+		"pause": "일시 정지",
+		"resume": "다시 시작",
+		"paused": "일시 정지됨",
+		"pausedHint": "녹음과 동영상이 일시 정지되었습니다. 다시 시작을 눌러 계속하세요.",
 		"stop": "중지",
 		"micDenied": "마이크 접근이 거부되었습니다",
 		"recordingUnavailable": "여기에서는 녹음할 수 없습니다",
diff --git a/src/i18n/locales/pt-BR/timeline.json b/src/i18n/locales/pt-BR/timeline.json
index 100b09639..002c0e64a 100644
--- a/src/i18n/locales/pt-BR/timeline.json
+++ b/src/i18n/locales/pt-BR/timeline.json
@@ -107,6 +107,10 @@
 		"importFileHint": "Importe música ou um arquivo de áudio",
 		"recording": "Gravando",
 		"recordingHint": "Narre junto com o vídeo — ele continua tocando enquanto você grava",
+		"pause": "Pausar",
+		"resume": "Retomar",
+		"paused": "Em pausa",
+		"pausedHint": "A gravação e o vídeo estão pausados. Clique em Retomar para continuar.",
 		"stop": "Parar",
 		"micDenied": "Acesso ao microfone negado",
 		"recordingUnavailable": "A gravação não está disponível aqui",
diff --git a/src/i18n/locales/ru/timeline.json b/src/i18n/locales/ru/timeline.json
index 8a18b1dbf..12d257100 100644
--- a/src/i18n/locales/ru/timeline.json
+++ b/src/i18n/locales/ru/timeline.json
@@ -107,6 +107,10 @@
 		"importFileHint": "Импортируйте музыку или аудиофайл",
 		"recording": "Запись",
 		"recordingHint": "Говорите под видео — оно продолжает играть во время записи",
+		"pause": "Пауза",
+		"resume": "Продолжить",
+		"paused": "Приостановлено",
+		"pausedHint": "Запись и видео приостановлены. Нажмите «Продолжить», чтобы продолжить запись.",
 		"stop": "Остановить",
 		"micDenied": "Доступ к микрофону запрещён",
 		"recordingUnavailable": "Запись здесь недоступна",
diff --git a/src/i18n/locales/tr/timeline.json b/src/i18n/locales/tr/timeline.json
index ba99653f8..de9a831ee 100644
--- a/src/i18n/locales/tr/timeline.json
+++ b/src/i18n/locales/tr/timeline.json
@@ -107,6 +107,10 @@
 		"importFileHint": "Müzik veya ses dosyası içe aktarın",
 		"recording": "Kaydediliyor",
 		"recordingHint": "Videoyla birlikte anlatın — kayıt sırasında oynamaya devam eder",
+		"pause": "Duraklat",
+		"resume": "Devam et",
+		"paused": "Duraklatıldı",
+		"pausedHint": "Kayıt ve video duraklatıldı. Sürdürmek için Devam et seçeneğine tıklayın.",
 		"stop": "Durdur",
 		"micDenied": "Mikrofon erişimi reddedildi",
 		"recordingUnavailable": "Burada kayıt kullanılamıyor",
diff --git a/src/i18n/locales/vi/timeline.json b/src/i18n/locales/vi/timeline.json
index ab7d3cf93..9b99061d0 100644
--- a/src/i18n/locales/vi/timeline.json
+++ b/src/i18n/locales/vi/timeline.json
@@ -107,6 +107,10 @@
 		"importFileHint": "Nhập nhạc hoặc tệp âm thanh",
 		"recording": "Đang ghi",
 		"recordingHint": "Thuyết minh cùng video — video vẫn phát trong khi bạn ghi âm",
+		"pause": "Tạm dừng",
+		"resume": "Tiếp tục",
+		"paused": "Đã tạm dừng",
+		"pausedHint": "Bản ghi âm và video đã tạm dừng. Nhấn Tiếp tục để ghi tiếp.",
 		"stop": "Dừng",
 		"micDenied": "Quyền truy cập micrô bị từ chối",
 		"recordingUnavailable": "Không thể ghi âm ở đây",
diff --git a/src/i18n/locales/zh-CN/timeline.json b/src/i18n/locales/zh-CN/timeline.json
index b9bde8859..874826c70 100644
--- a/src/i18n/locales/zh-CN/timeline.json
+++ b/src/i18n/locales/zh-CN/timeline.json
@@ -107,6 +107,10 @@
 		"importFileHint": "导入音乐或音频文件",
 		"recording": "正在录制",
 		"recordingHint": "跟着视频讲解 — 录制时视频会继续播放",
+		"pause": "暂停",
+		"resume": "继续",
+		"paused": "已暂停",
+		"pausedHint": "录音和视频已暂停，点击“继续”接着录制。",
 		"stop": "停止",
 		"micDenied": "麦克风访问被拒绝",
 		"recordingUnavailable": "此处无法录音",
diff --git a/src/i18n/locales/zh-TW/timeline.json b/src/i18n/locales/zh-TW/timeline.json
index 1d137a980..e390564eb 100644
--- a/src/i18n/locales/zh-TW/timeline.json
+++ b/src/i18n/locales/zh-TW/timeline.json
@@ -107,6 +107,10 @@
 		"importFileHint": "匯入音樂或音訊檔案",
 		"recording": "錄製中",
 		"recordingHint": "跟著影片講解 — 錄製時影片會繼續播放",
+		"pause": "暫停",
+		"resume": "繼續",
+		"paused": "已暫停",
+		"pausedHint": "錄音與影片已暫停，點擊「繼續」接著錄製。",
 		"stop": "停止",
 		"micDenied": "麥克風存取遭拒絕",
 		"recordingUnavailable": "此處無法錄音",
diff --git a/technical-documentation/testing/manual-e2e-checklist.md b/technical-documentation/testing/manual-e2e-checklist.md
index 26ab3d873..63bfe9b3a 100644
--- a/technical-documentation/testing/manual-e2e-checklist.md
+++ b/technical-documentation/testing/manual-e2e-checklist.md
@@ -1074,3 +1074,5 @@ These checks are the human slice: an agent cannot click Apple's picker (see abov
 | 2026-11-04 | `main` @ `290bd3a` + `fix/export-sparse-clip-start`, locally built compositor addon and app renderer (2.2.1) | macOS 27.0.1, arm64, Metal | **Partial — automated export regression; GUI not covered** | Synthetic one-update-per-second H.264 reproduces #1479 on installed 2.2.1 and in the new native test before the fix. Patched frame inspection holds green at 1.25 s and 1.983 s, then shows blue at 2.017 s; MP4 frame counts pass with/without camera and after a preceding clip. Patched app CLI exports the synthetic project and the affected private project with all original cuts unchanged; private media is not attached. Native unit suite: 492 passed; export timing: 15 passed, one existing bounded-tail test fails identically on unmodified main (container duration clips the requested tail before seeking). JS: 5192 passed, 5 skipped; both TypeScript checks and lint pass (existing warnings). **Skipped:** real OS GUI export, because computer-use initialization and app selection both timed out; capture, devices, preview interactions, signing/packaging, Windows and Linux were not exercised. This is not a release-candidate pass. |
 | 2026-10-21 | PR #1177, rebased on `main` @ `1e917109`, token presentation follow-up (dev build, Electron 41.2.1) | macOS 15.8, Apple Silicon | **Partial: Agent usage presentation** | Real Electron driven through OS computer-use, isolated `/tmp` profile and a local scripted OpenAI-compatible provider (no paid provider). A two-call turn showed muted `≥10.3k tokens` beside the activity indicator, then `12.3k tokens · 15s` beneath the reply. Input/output/cache details remained in the tooltip. During a second turn, creating Conversation 2 hid the running indicator/count there; returning to Conversation 1 restored the running count and then exactly one completed reply. Fully quit/relaunched Electron and reopened the editor: both completed summaries and their durations restored in Conversation 1, with old rewind controls absent. Sidecar inspection confirmed Conversation 2 remained empty. Skipped: capture/preview/export, native binaries, paid-provider billing, Windows/Linux and the rest of this checklist; chat-only change, not release-promotion QA. |
 | 2026-10-22 | PR #1177, maintainer presentation follow-up on `54ee4e15` (dev build, Electron 41.2.1) | macOS 15.8, Apple Silicon | **Partial: Agent usage presentation** | Real Electron driven through OS computer-use with an isolated `/tmp` profile and a local scripted Anthropic-compatible provider (synthetic counts, no paid provider). A two-call turn showed muted `≥10.3k tokens` beside the spinner, one expandable Thinking label while reasoning streamed, then `12.3k tokens · 45s` beneath the reply. Captured [running](https://raw.githubusercontent.com/auberginewly/openscreen-community/2cf6e8435c9214981243088aebc470380e6f8611/technical-documentation/testing/screenshots/pr-1177/running.png) and [completed](https://raw.githubusercontent.com/auberginewly/openscreen-community/2cf6e8435c9214981243088aebc470380e6f8611/technical-documentation/testing/screenshots/pr-1177/completed.png) screenshots. Component tests also cover partial totals with details confined to the tooltip, unavailable usage showing duration only, and unavailable usage without duration rendering nothing. Skipped: capture/preview/export, native binaries, paid-provider billing, restart/session switching (covered in the preceding pass), Windows/Linux and the rest of this checklist; chat presentation only. |
+| 2026-11-06 | `codex/voiceover-pause`, based on `main` @ `bc8d0a03`, Electron dev build with Node 22.22.1 | macOS 27.0, Apple Silicon | **Partial — voiceover pause/resume slice** | Real OS input through computer-use in an isolated user-data directory, a 60 s synthetic video and Chromium fake microphone. Recorded to 6.5 s, paused, verified Space did not advance the preview or timer, resumed from the same position, paused at 15.6 s, then stopped. Exactly one voiceover layer was saved at 0–15.6 s. The WebM decodes to 748,800 mono samples at 48 kHz (15.6 s), excluding time spent paused. **Not covered:** audible microphone content (the fake input was silent), physical devices, Windows/Linux, export, or the rest of this checklist. Unit tests additionally cover repeated pauses, cancel/Escape/unmount, resume failure and Stop racing with a pending resume. |
+| 2026-11-06 | `codex/voiceover-pause`, review fixes after `4acff70f`, Electron dev build | macOS 27.0, Apple Silicon | **Partial — paused timeline regression** | Computer-use input in the same isolated profile and synthetic-video/fake-microphone setup. Paused a take at 9.5 s, clicked the ruler: transport time stayed at 9.5 s. Cancelled the take and clicked the same ruler: seeking worked again. **Not covered:** native drag input (the computer-use drag API returned `noWindowsAvailable`); automated ruler/empty-lane pointer-drag tests passed. A separate regression test reproduces Stop during pending Resume with a failed save, then confirms the next take can pause. No physical microphone or full checklist pass. |