diff --git a/src/components/ai-edition/NewEditorShell.togglePlay.test.tsx b/src/components/ai-edition/NewEditorShell.togglePlay.test.tsx
new file mode 100644
index 000000000..3fa5fcb73
--- /dev/null
+++ b/src/components/ai-edition/NewEditorShell.togglePlay.test.tsx
@@ -0,0 +1,222 @@
+// @vitest-environment jsdom
+import "@testing-library/jest-dom";
+import { act, cleanup, fireEvent, render } from "@testing-library/react";
+import { createElement, useEffect } from "react";
+import { afterEach, beforeEach, describe, expect, it, vi } from "vitest";
+
+const mocks = vi.hoisted(() => ({
+	previewPlay: vi.fn(() => Promise.resolve()),
+	previewPause: vi.fn(),
+	latestSeekTarget: null as {
+		timeSec: number;
+		isSource?: boolean;
+		requestId: number;
+		preservePlayback?: boolean;
+	} | null,
+}));
+
+vi.mock("@/contexts/ShortcutsContext", async () => {
+	const { DEFAULT_SHORTCUTS } = await import("@/lib/shortcuts");
+	return {
+		useShortcuts: () => ({
+			shortcuts: DEFAULT_SHORTCUTS,
+			isMac: false,
+			isConfigOpen: false,
+			openConfig: vi.fn(),
+			closeConfig: vi.fn(),
+			setShortcuts: vi.fn(),
+			persistShortcuts: () => Promise.resolve(true),
+		}),
+	};
+});
+
+vi.mock("@/contexts/I18nContext", () => ({
+	useI18n: () => ({
+		locale: "en",
+		setLocale: vi.fn(),
+	}),
+	useScopedT: () => (key: string) => key,
+}));
+
+vi.mock("./Preview", () => ({
+	Preview: ({
+		seekTarget,
+		onVideoElement,
+	}: {
+		seekTarget: {
+			timeSec: number;
+			isSource?: boolean;
+			requestId: number;
+			preservePlayback?: boolean;
+		} | null;
+		onVideoElement: (element: HTMLVideoElement | null) => void;
+	}) => {
+		mocks.latestSeekTarget = seekTarget;
+		useEffect(() => {
+			const element = document.createElement("video");
+			let paused = true;
+			Object.defineProperty(element, "paused", {
+				configurable: true,
+				get: () => paused,
+			});
+			element.play = vi.fn(() => {
+				paused = false;
+				element.dispatchEvent(new Event("play"));
+				return mocks.previewPlay();
+			});
+			element.pause = vi.fn(() => {
+				paused = true;
+				element.dispatchEvent(new Event("pause"));
+				mocks.previewPause();
+			});
+			onVideoElement(element);
+			return () => onVideoElement(null);
+		}, [onVideoElement]);
+		return createElement("div", {
+			"data-testid": "preview-mock",
+			"data-seek-target": JSON.stringify(seekTarget),
+		});
+	},
+}));
+
+import { TooltipProvider } from "@/components/ui/tooltip";
+import { EditorDialogsProvider } from "@/contexts/EditorDialogsContext";
+import type { AxcutAsset, AxcutClip, AxcutDocument } from "@/lib/ai-edition/schema";
+import { createEmptyDocument } from "@/lib/ai-edition/schema";
+import { useProjectStore } from "@/lib/ai-edition/store/projectStore";
+import { NewEditorShell } from "./NewEditorShell";
+
+function makeCrossAssetDocument(): AxcutDocument {
+	const doc = createEmptyDocument({ projectId: "p1", title: "Cross-Asset Replay" });
+	const asset1: AxcutAsset = {
+		id: "a1",
+		kind: "video",
+		label: "a1",
+		originalPath: "/a1.mp4",
+		durationSec: 5,
+		cameraTrack: null,
+	};
+	const asset2: AxcutAsset = {
+		id: "a2",
+		kind: "video",
+		label: "a2",
+		originalPath: "/a2.mp4",
+		durationSec: 5,
+		cameraTrack: null,
+	};
+	const clip1: AxcutClip = {
+		id: "c1",
+		assetId: "a1",
+		sourceStartSec: 0,
+		sourceEndSec: 5,
+		timelineStartSec: 0,
+		timelineEndSec: 5,
+		wordRefs: [],
+		origin: "user",
+		reason: "",
+	};
+	const clip2: AxcutClip = {
+		id: "c2",
+		assetId: "a2",
+		sourceStartSec: 0,
+		sourceEndSec: 5,
+		timelineStartSec: 5,
+		timelineEndSec: 10,
+		wordRefs: [],
+		origin: "user",
+		reason: "",
+	};
+	doc.assets = [asset1, asset2];
+	doc.timeline.clips = [clip1, clip2];
+	return doc;
+}
+
+function renderShell() {
+	return render(
+		<TooltipProvider>
+			<EditorDialogsProvider>
+				<NewEditorShell />
+			</EditorDialogsProvider>
+		</TooltipProvider>,
+	);
+}
+
+describe("NewEditorShell togglePlay cross-asset replay", () => {
+	beforeEach(() => {
+		localStorage.clear();
+		mocks.previewPlay.mockClear();
+		mocks.previewPause.mockClear();
+		mocks.latestSeekTarget = null;
+		(window as unknown as { electronAPI?: unknown }).electronAPI = {
+			onAiEditionChatEvent: () => () => {},
+			setTitleBarOverlay: () => {},
+			setHasUnsavedChanges: () => {},
+			onRequestCloseConfirm: () => () => {},
+			onRequestSaveBeforeClose: () => () => {},
+			sendCloseConfirmResponse: () => {},
+			findRecordingCamera: () => Promise.resolve(null),
+			preparePreviewAudioTrack: () => Promise.resolve({ success: false, path: null }),
+			readBinaryFile: () => Promise.resolve(new Uint8Array(0)),
+			isAppPackaged: () => false,
+		};
+		Element.prototype.scrollTo = () => {};
+		(globalThis as unknown as { ResizeObserver?: unknown }).ResizeObserver = class {
+			observe() {}
+			unobserve() {}
+			disconnect() {}
+		};
+	});
+
+	afterEach(() => {
+		cleanup();
+		(window as unknown as { electronAPI?: unknown }).electronAPI = undefined;
+	});
+
+	it("preserves playback intent when replaying across assets through togglePlay", async () => {
+		const doc = makeCrossAssetDocument();
+		useProjectStore.setState({
+			document: doc,
+			projectId: "p1",
+			currentTimeSec: 10, // at the end of the timeline
+			playing: false,
+		});
+
+		renderShell();
+
+		// Trigger replay via Space shortcut (togglePlay)
+		await act(async () => {
+			fireEvent.keyDown(document.body, { key: " ", code: "Space" });
+		});
+
+		// 1. togglePlay must have initiated a seek to 0 carrying preservePlayback: true
+		expect(mocks.latestSeekTarget).toMatchObject({
+			timeSec: 0,
+			preservePlayback: true,
+		});
+
+		// 2. togglePlay must have called play() to start playback
+		expect(mocks.previewPlay).toHaveBeenCalledTimes(1);
+		expect(useProjectStore.getState().currentTimeSec).toBe(0);
+	});
+
+	it("does not rewind to 0 when pressing play from an intermediate position after cross-asset seek", async () => {
+		const doc = makeCrossAssetDocument();
+		useProjectStore.setState({
+			document: doc,
+			projectId: "p1",
+			currentTimeSec: 4, // in clip1 (0-5s), timeline ends at 10s
+			playing: false,
+		});
+
+		renderShell();
+
+		await act(async () => {
+			fireEvent.keyDown(document.body, { key: " ", code: "Space" });
+		});
+
+		// Must NOT seek to 0
+		expect(mocks.latestSeekTarget).toBeNull();
+		expect(mocks.previewPlay).toHaveBeenCalledTimes(1);
+		expect(useProjectStore.getState().currentTimeSec).toBe(4);
+	});
+});
diff --git a/src/components/ai-edition/NewEditorShell.tsx b/src/components/ai-edition/NewEditorShell.tsx
index d87a215ea..b3340ce85 100644
--- a/src/components/ai-edition/NewEditorShell.tsx
+++ b/src/components/ai-edition/NewEditorShell.tsx
@@ -49,6 +49,10 @@ import {
 	trimAppliesToClip,
 	ventilateTimelineSpanToTrims,
 } from "@/lib/ai-edition/timeline/trim-mapping";
+import {
+	locateVirtualPosition,
+	totalVirtualDuration,
+} from "@/lib/ai-edition/timeline/virtual-preview";
 import { firstTimelineBusyView } from "@/lib/ai-edition/transcription/status";
 import { matchesShortcut } from "@/lib/shortcuts";
 import { nativeBridgeClient } from "@/native";
@@ -81,6 +85,7 @@ interface SeekTarget {
 	timeSec: number;
 	isSource?: boolean;
 	requestId: number;
+	preservePlayback?: boolean;
 }
 
 /**
@@ -536,9 +541,14 @@ export function NewEditorShell() {
 	);
 
 	const handleSeek = useCallback(
-		(timeSec: number) => {
+		(timeSec: number, preservePlayback?: boolean) => {
 			setCurrentTime(timeSec);
-			setSeekTarget({ timeSec, isSource: false, requestId: ++seekSeqRef.current });
+			setSeekTarget({
+				timeSec,
+				isSource: false,
+				requestId: ++seekSeqRef.current,
+				preservePlayback,
+			});
 		},
 		[setCurrentTime],
 	);
@@ -602,8 +612,8 @@ export function NewEditorShell() {
 	useEffect(() => {
 		const el = videoElement;
 		if (!el) return;
-		const onPlay = () => setPlaying(true);
-		const onPause = () => setPlaying(false);
+		const onPlay = () => setPlaying(!el.paused);
+		const onPause = () => setPlaying(!el.paused);
 		// BUG corrigé : ce listener écoutait le même événement DOM natif 'ended' que le
 		// onEnded interne de VirtualPreview.tsx, sans la moindre logique multi-clip — il
 		// mettait TOUJOURS `playing` à false, y compris quand VirtualPreview venait
@@ -614,9 +624,12 @@ export function NewEditorShell() {
 		// suivant ?" que VirtualPreview — seul point de
 		// vérité pour "y a-t-il encore de la timeline à jouer".
 		const onEnded = () => {
+			if (!el.paused) return;
 			const playhead = useProjectStore.getState().currentTimeSec;
+			const duration = totalVirtualDuration(clipsForEndedRef.current);
+			const isAtEnd = duration > 0 && playhead >= duration - 0.1;
 			const hasNextClip = clipsForEndedRef.current.some((c) => c.timelineStartSec > playhead + 0.1);
-			if (!hasNextClip) setPlaying(false);
+			if (isAtEnd && !hasNextClip) setPlaying(false);
 		};
 		el.addEventListener("play", onPlay);
 		el.addEventListener("pause", onPause);
@@ -634,6 +647,27 @@ export function NewEditorShell() {
 	const togglePlay = useCallback(() => {
 		if (!videoElement) return;
 		if (videoElement.paused) {
+			const playhead = useProjectStore.getState().currentTimeSec;
+			const duration = totalVirtualDuration(clipsForEndedRef.current);
+			const endPos = locateVirtualPosition(clipsForEndedRef.current, duration);
+			const currentPos = locateVirtualPosition(clipsForEndedRef.current, playhead);
+			const hasNextClip = clipsForEndedRef.current.some((c) => c.timelineStartSec > playhead + 0.1);
+			const isAtEnd =
+				duration > 0 &&
+				playhead >= duration - 0.05 &&
+				!hasNextClip &&
+				currentPos?.clip.id === endPos?.clip.id;
+			if (isAtEnd) {
+				handleSeek(0, true);
+				const startPos = locateVirtualPosition(clipsForEndedRef.current, 0);
+				if (startPos && startPos.clip.assetId === endPos?.clip.assetId) {
+					try {
+						videoElement.currentTime = startPos.sourceTimeSec;
+					} catch {
+						// media metadata not ready yet
+					}
+				}
+			}
 			// Same catch as VirtualPreview's: `play()` rejects on the autoplay policy
 			// or when a new load interrupts it, and the store's `playing` flag is
 			// driven by the element's own play/pause listeners above — so a rejection
@@ -644,7 +678,7 @@ export function NewEditorShell() {
 		} else {
 			videoElement.pause();
 		}
-	}, [videoElement]);
+	}, [videoElement, handleSeek]);
 
 	// "Transcribe now" from the transcript pane. The run itself belongs to the
 	// transcription store (it owns the queue, the toasts and the failure
diff --git a/src/components/ai-edition/Preview.tsx b/src/components/ai-edition/Preview.tsx
index c809a329b..2d64b4428 100644
--- a/src/components/ai-edition/Preview.tsx
+++ b/src/components/ai-edition/Preview.tsx
@@ -50,7 +50,7 @@ interface PreviewProps {
 	onAnnotationChange?: (id: string, patch: Partial<AxcutAnnotationRegion>) => void;
 	onAnnotationBlurDataChange?: (id: string, blurData: BlurData) => void;
 	onAnnotationCommit?: () => void;
-	seekTarget: { timeSec: number; requestId: number } | null;
+	seekTarget: { timeSec: number; requestId: number; preservePlayback?: boolean } | null;
 	onTimeChange: (sec: number) => void;
 	onSeek: (sec: number) => void;
 	onLoadedMetadata: (sec: number, assetId: string) => void;
diff --git a/src/components/ai-edition/PreviewCanvas.tsx b/src/components/ai-edition/PreviewCanvas.tsx
index 557593f4c..5ba8f0007 100644
--- a/src/components/ai-edition/PreviewCanvas.tsx
+++ b/src/components/ai-edition/PreviewCanvas.tsx
@@ -100,7 +100,7 @@ interface PreviewCanvasProps {
 	onAnnotationChange?: (id: string, patch: Partial<AxcutAnnotationRegion>) => void;
 	onAnnotationBlurDataChange?: (id: string, blurData: BlurData) => void;
 	onAnnotationCommit?: () => void;
-	seekTarget: { timeSec: number; requestId: number } | null;
+	seekTarget: { timeSec: number; requestId: number; preservePlayback?: boolean } | null;
 	onTimeChange: (sec: number) => void;
 	onSeek: (sec: number) => void;
 	onLoadedMetadata: (sec: number, assetId: string) => void;
diff --git a/src/components/ai-edition/VirtualPreview.playback.test.tsx b/src/components/ai-edition/VirtualPreview.playback.test.tsx
index becfb077a..517d0b9b6 100644
--- a/src/components/ai-edition/VirtualPreview.playback.test.tsx
+++ b/src/components/ai-edition/VirtualPreview.playback.test.tsx
@@ -93,6 +93,9 @@ function driveVideo(element: HTMLVideoElement) {
 		play: () => {
 			paused = false;
 		},
+		pause: () => {
+			paused = true;
+		},
 		seekTo: (next: number) => {
 			currentTime = next;
 		},
@@ -757,3 +760,534 @@ describe("VirtualPreview primary audio keeps to the picture", () => {
 		expect(world.audioEl.playbackRate).toBe(1);
 	});
 });
+
+describe("VirtualPreview replay", () => {
+	it.each([10, 4])("restarts with one play event after a %s-second clip ends", (end) => {
+		const { video, element, onTimeChange } = mount([clip("clip_1", "a1", 2, end, 0)]);
+		video.play();
+		video.seekTo(end - 0.04);
+		tick();
+		tick();
+		expect(element.paused).toBe(true);
+
+		act(() => {
+			video.play();
+			fireEvent.play(element);
+		});
+		tick();
+		expect(video.currentTime).toBe(2);
+		expect(element.paused).toBe(false);
+		expect(reportedTimes(onTimeChange).at(-1)).toBe(0);
+	});
+
+	it("restarts after the browser's ended event", () => {
+		const { video, element, onTimeChange } = mount([clip("clip_1", "a1", 0, 10, 0)]);
+		video.seekTo(10);
+		act(() => fireEvent.ended(element));
+		expect(reportedTimes(onTimeChange).at(-1)).toBe(10);
+		act(() => {
+			video.play();
+			fireEvent.play(element);
+		});
+		tick();
+		expect(video.currentTime).toBe(0);
+		expect(element.paused).toBe(false);
+	});
+
+	it("does not pause or cancel playback while a replay seek is in flight", () => {
+		const { video, element, onTimeChange } = mount([clip("clip_1", "a1", 2, 4, 0)]);
+		video.play();
+		video.seekTo(3.96);
+		tick();
+		tick();
+		expect(element.paused).toBe(true);
+		const initialPauseCalls = video.pauseCalls.length;
+
+		let seeking = true;
+		Object.defineProperty(element, "seeking", { configurable: true, get: () => seeking });
+
+		act(() => {
+			video.play();
+			fireEvent.play(element);
+		});
+		// While seek is in flight across ticks, boundary check must not pause:
+		tick();
+		expect(element.paused).toBe(false);
+		expect(video.pauseCalls.length).toBe(initialPauseCalls);
+
+		// Demuxer finishes seeking to target:
+		seeking = false;
+		act(() => fireEvent.seeked(element));
+		tick();
+		expect(element.paused).toBe(false);
+		expect(video.pauseCalls.length).toBe(initialPauseCalls);
+		expect(video.currentTime).toBe(2);
+		expect(reportedTimes(onTimeChange).at(-1)).toBe(0);
+	});
+
+	it("restarts playback across assets when the last clip uses a different asset than the first", () => {
+		const sources: VideoSource[] = [
+			{ id: "a1", src: "file:///tmp/a1.mp4", label: "a1" },
+			{ id: "a2", src: "file:///tmp/a2.mp4", label: "a2" },
+		];
+		const clips = [clip("clip_1", "a1", 0, 5, 0), clip("clip_2", "a2", 0, 5, 5)];
+		let currentSeekTarget: {
+			timeSec: number;
+			requestId: number;
+			preservePlayback?: boolean;
+		} | null = null;
+		const onTimeChange = vi.fn();
+
+		const view = render(
+			<VirtualPreview
+				videoSources={sources}
+				clips={clips}
+				seekTarget={currentSeekTarget}
+				onTimeChange={onTimeChange}
+			/>,
+		);
+
+		// Mount first asset (a1)
+		const videoEl1 = view.container.querySelector("video");
+		if (!videoEl1) throw new Error("no initial <video>");
+		driveVideo(videoEl1);
+		act(() => {
+			fireEvent.loadedMetadata(videoEl1);
+		});
+
+		// Seek to the second clip on asset a2 (e.g. 8s virtual time)
+		act(() => {
+			currentSeekTarget = { timeSec: 8, requestId: 1 };
+			view.rerender(
+				<VirtualPreview
+					videoSources={sources}
+					clips={clips}
+					seekTarget={currentSeekTarget}
+					onTimeChange={onTimeChange}
+				/>,
+			);
+		});
+
+		// Now second asset (a2) mounts
+		const videoEl2 = view.container.querySelector("video");
+		if (!videoEl2) throw new Error("no second <video>");
+		const video2 = driveVideo(videoEl2);
+		act(() => {
+			fireEvent.loadedMetadata(videoEl2);
+		});
+		video2.play();
+		// Play to end of clip_2 / timeline (10s)
+		video2.seekTo(5);
+		video2.pause();
+		act(() => {
+			fireEvent.ended(videoEl2);
+		});
+		expect(videoEl2.paused).toBe(true);
+
+		// Shell triggers replay: handleSeek(0, true) + play()
+		act(() => {
+			currentSeekTarget = { timeSec: 0, requestId: 2, preservePlayback: true };
+			view.rerender(
+				<VirtualPreview
+					videoSources={sources}
+					clips={clips}
+					seekTarget={currentSeekTarget}
+					onTimeChange={onTimeChange}
+				/>,
+			);
+			video2.play();
+			fireEvent.play(videoEl2);
+		});
+
+		// Replay triggers switch back to a1
+		const replayVideoEl1 = view.container.querySelector("video");
+		if (!replayVideoEl1) throw new Error("no replay <video>");
+		const replayVideo1 = driveVideo(replayVideoEl1);
+
+		// Metadata loads for a1
+		act(() => {
+			fireEvent.loadedMetadata(replayVideoEl1);
+		});
+
+		// Replay must have automatically resumed playback on the first asset
+		expect(replayVideo1.currentTime).toBe(0);
+		expect(replayVideoEl1.paused).toBe(false);
+	});
+
+	it("resumes playback at 14s after seeking from B to A while paused", () => {
+		const sources: VideoSource[] = [
+			{ id: "a1", src: "file:///tmp/a1.mp4", label: "a1" },
+			{ id: "a2", src: "file:///tmp/a2.mp4", label: "a2" },
+		];
+		const clips = [clip("clip_1", "a1", 0, 15, 0), clip("clip_2", "a2", 0, 15, 15)];
+		let currentSeekTarget: {
+			timeSec: number;
+			requestId: number;
+			preservePlayback?: boolean;
+		} | null = null;
+		const onTimeChange = vi.fn();
+
+		const view = render(
+			<VirtualPreview
+				videoSources={sources}
+				clips={clips}
+				seekTarget={currentSeekTarget}
+				onTimeChange={onTimeChange}
+			/>,
+		);
+
+		const videoEl1 = view.container.querySelector("video");
+		if (!videoEl1) throw new Error("no initial <video>");
+		driveVideo(videoEl1);
+		act(() => {
+			fireEvent.loadedMetadata(videoEl1);
+		});
+
+		// Seek to clip_2 on asset a2 at 20s
+		act(() => {
+			currentSeekTarget = { timeSec: 20, requestId: 1 };
+			view.rerender(
+				<VirtualPreview
+					videoSources={sources}
+					clips={clips}
+					seekTarget={currentSeekTarget}
+					onTimeChange={onTimeChange}
+				/>,
+			);
+		});
+
+		const videoEl2 = view.container.querySelector("video");
+		if (!videoEl2) throw new Error("no second <video>");
+		const video2 = driveVideo(videoEl2);
+		act(() => {
+			fireEvent.loadedMetadata(videoEl2);
+		});
+		video2.seekTo(5);
+		video2.pause();
+
+		// Paused in B. Click timeline at 14s (clip A)
+		act(() => {
+			currentSeekTarget = { timeSec: 14, requestId: 2 };
+			view.rerender(
+				<VirtualPreview
+					videoSources={sources}
+					clips={clips}
+					seekTarget={currentSeekTarget}
+					onTimeChange={onTimeChange}
+				/>,
+			);
+		});
+
+		// rAF tick while loading
+		tick();
+
+		const videoElA = view.container.querySelector("video");
+		if (!videoElA) throw new Error("no video for A");
+		const videoA = driveVideo(videoElA);
+
+		tick();
+
+		act(() => {
+			fireEvent.loadedMetadata(videoElA);
+		});
+
+		tick();
+
+		// User waits 2s, presses Play
+		act(() => {
+			videoA.play();
+			fireEvent.play(videoElA);
+		});
+
+		tick();
+
+		expect(videoA.currentTime).toBe(14);
+		expect(reportedTimes(onTimeChange).at(-1)).toBe(14);
+	});
+
+	it("resumes playback at 14s after cross-source seek during playback", () => {
+		const sources: VideoSource[] = [
+			{ id: "a1", src: "file:///tmp/a1.mp4", label: "a1" },
+			{ id: "a2", src: "file:///tmp/a2.mp4", label: "a2" },
+		];
+		const clips = [clip("clip_1", "a1", 0, 15, 0), clip("clip_2", "a2", 0, 15, 15)];
+		let currentSeekTarget: {
+			timeSec: number;
+			requestId: number;
+			preservePlayback?: boolean;
+		} | null = null;
+		const onTimeChange = vi.fn();
+
+		const view = render(
+			<VirtualPreview
+				videoSources={sources}
+				clips={clips}
+				seekTarget={currentSeekTarget}
+				onTimeChange={onTimeChange}
+			/>,
+		);
+
+		const videoEl1 = view.container.querySelector("video");
+		if (!videoEl1) throw new Error("no initial <video>");
+		driveVideo(videoEl1);
+		act(() => {
+			fireEvent.loadedMetadata(videoEl1);
+		});
+
+		// Start playing in clip_2 on asset a2 at 20s
+		act(() => {
+			currentSeekTarget = { timeSec: 20, requestId: 1, preservePlayback: true };
+			view.rerender(
+				<VirtualPreview
+					videoSources={sources}
+					clips={clips}
+					seekTarget={currentSeekTarget}
+					onTimeChange={onTimeChange}
+				/>,
+			);
+		});
+
+		const videoEl2 = view.container.querySelector("video");
+		if (!videoEl2) throw new Error("no second <video>");
+		const video2 = driveVideo(videoEl2);
+		act(() => {
+			fireEvent.loadedMetadata(videoEl2);
+		});
+		video2.seekTo(5);
+		video2.play();
+
+		// WHILE PLAYING in B at 20s (source time 5):
+		// Click timeline at 14s (clip A)
+		act(() => {
+			currentSeekTarget = { timeSec: 14, requestId: 2, preservePlayback: true };
+			view.rerender(
+				<VirtualPreview
+					videoSources={sources}
+					clips={clips}
+					seekTarget={currentSeekTarget}
+					onTimeChange={onTimeChange}
+				/>,
+			);
+		});
+
+		// rAF loop ticks
+		tick();
+
+		const videoElA = view.container.querySelector("video");
+		if (!videoElA) throw new Error("no video for A");
+		const videoA = driveVideo(videoElA);
+
+		tick();
+
+		act(() => {
+			fireEvent.loadedMetadata(videoElA);
+		});
+
+		tick();
+
+		expect(videoA.currentTime).toBe(14);
+		expect(reportedTimes(onTimeChange).at(-1)).toBe(14);
+	});
+
+	it("does not let stale loadState in tick closure block clip boundary checks or timeline end", () => {
+		const sources: VideoSource[] = [
+			{ id: "a1", src: "file:///tmp/a1.mp4", label: "a1" },
+			{ id: "a2", src: "file:///tmp/a2.mp4", label: "a2" },
+		];
+		const clips = [clip("clip_1", "a1", 0, 15, 0), clip("clip_2", "a2", 0, 15, 15)];
+		let currentSeekTarget: {
+			timeSec: number;
+			requestId: number;
+			preservePlayback?: boolean;
+		} | null = null;
+		const onTimeChange = vi.fn();
+
+		const view = render(
+			<VirtualPreview
+				videoSources={sources}
+				clips={clips}
+				seekTarget={currentSeekTarget}
+				onTimeChange={onTimeChange}
+			/>,
+		);
+
+		const videoEl1 = view.container.querySelector("video");
+		if (!videoEl1) throw new Error("no initial <video>");
+		driveVideo(videoEl1);
+		act(() => {
+			fireEvent.loadedMetadata(videoEl1);
+		});
+
+		// Seek to clip_2 on asset a2 at 28.5s
+		act(() => {
+			currentSeekTarget = { timeSec: 28.5, requestId: 1, preservePlayback: true };
+			view.rerender(
+				<VirtualPreview
+					videoSources={sources}
+					clips={clips}
+					seekTarget={currentSeekTarget}
+					onTimeChange={onTimeChange}
+				/>,
+			);
+		});
+
+		tick();
+
+		const videoEl2 = view.container.querySelector("video");
+		if (!videoEl2) throw new Error("no second <video>");
+		const video2 = driveVideo(videoEl2);
+		act(() => {
+			fireEvent.loadedMetadata(videoEl2);
+		});
+		video2.play();
+
+		// Advance video2 to 15.0s (30s virtual time, timeline end)
+		video2.seekTo(15);
+		tick();
+
+		// If tick was blocked by stale loadState === "loading", video2 would not be paused
+		// and virtual time would not reach 30s.
+		expect(video2.pauseCalls.length).toBeGreaterThan(0);
+		expect(reportedTimes(onTimeChange).at(-1)).toBe(30);
+	});
+
+	it("advances across source boundary when playing from clip A into clip B without being blocked by stale loadState", () => {
+		const sources: VideoSource[] = [
+			{ id: "a1", src: "file:///tmp/a1.mp4", label: "a1" },
+			{ id: "a2", src: "file:///tmp/a2.mp4", label: "a2" },
+		];
+		const clips = [clip("clip_1", "a1", 0, 15, 0), clip("clip_2", "a2", 0, 15, 15)];
+		let currentSeekTarget: {
+			timeSec: number;
+			requestId: number;
+			preservePlayback?: boolean;
+		} | null = null;
+		const onTimeChange = vi.fn();
+
+		const view = render(
+			<VirtualPreview
+				videoSources={sources}
+				clips={clips}
+				seekTarget={currentSeekTarget}
+				onTimeChange={onTimeChange}
+			/>,
+		);
+
+		const videoEl1 = view.container.querySelector("video");
+		if (!videoEl1) throw new Error("no initial <video>");
+		const video1 = driveVideo(videoEl1);
+		act(() => {
+			fireEvent.loadedMetadata(videoEl1);
+		});
+
+		// Start playing in clip_1 at 14s
+		act(() => {
+			currentSeekTarget = { timeSec: 14, requestId: 1, preservePlayback: true };
+			view.rerender(
+				<VirtualPreview
+					videoSources={sources}
+					clips={clips}
+					seekTarget={currentSeekTarget}
+					onTimeChange={onTimeChange}
+				/>,
+			);
+		});
+
+		video1.seekTo(14);
+		video1.play();
+		tick();
+
+		// Play to clip_1's boundary at 15s
+		video1.seekTo(15);
+		tick();
+
+		// Now asset switch happens into clip_2 (a2).
+		const videoEl2 = view.container.querySelector("video");
+		if (!videoEl2) throw new Error("no second <video>");
+		const video2 = driveVideo(videoEl2);
+		act(() => {
+			fireEvent.loadedMetadata(videoEl2);
+		});
+		video2.play();
+
+		// Play in clip_2 at source time 1s (virtual time 16s)
+		video2.seekTo(1);
+		tick();
+
+		// Tick should process and report virtual time 16s (not blocked by stale loadState)
+		expect(reportedTimes(onTimeChange).at(-1)).toBe(16);
+	});
+
+	it("advances to next clip when onWaiting is fired before onEnded at clip boundary", () => {
+		const sources: VideoSource[] = [
+			{ id: "a1", src: "file:///tmp/a1.mp4", label: "a1" },
+			{ id: "a2", src: "file:///tmp/a2.mp4", label: "a2" },
+		];
+		const clips = [clip("clip_1", "a1", 0, 15, 0), clip("clip_2", "a2", 0, 15, 15)];
+		let currentSeekTarget: {
+			timeSec: number;
+			requestId: number;
+			preservePlayback?: boolean;
+		} | null = null;
+		const onTimeChange = vi.fn();
+
+		const view = render(
+			<VirtualPreview
+				videoSources={sources}
+				clips={clips}
+				seekTarget={currentSeekTarget}
+				onTimeChange={onTimeChange}
+			/>,
+		);
+
+		const videoEl1 = view.container.querySelector("video");
+		if (!videoEl1) throw new Error("no initial <video>");
+		const video1 = driveVideo(videoEl1);
+		act(() => {
+			fireEvent.loadedMetadata(videoEl1);
+		});
+
+		// Start playing near the end of clip_1
+		act(() => {
+			currentSeekTarget = { timeSec: 14.9, requestId: 1, preservePlayback: true };
+			view.rerender(
+				<VirtualPreview
+					videoSources={sources}
+					clips={clips}
+					seekTarget={currentSeekTarget}
+					onTimeChange={onTimeChange}
+				/>,
+			);
+		});
+
+		video1.seekTo(14.9);
+		video1.play();
+		tick();
+
+		// Browser buffers at EOF: fires waiting (loadState -> loading)
+		act(() => {
+			fireEvent.waiting(videoEl1);
+		});
+
+		// Browser pauses and fires ended at EOF
+		act(() => {
+			video1.pause();
+			fireEvent.ended(videoEl1);
+		});
+
+		tick();
+
+		// Asset switch happens into clip_2 (a2)
+		const videoEl2 = view.container.querySelector("video");
+		if (!videoEl2) throw new Error("no second <video>");
+		const video2 = driveVideo(videoEl2);
+		act(() => {
+			fireEvent.loadedMetadata(videoEl2);
+		});
+		video2.play();
+		video2.seekTo(1);
+		tick();
+
+		expect(reportedTimes(onTimeChange).at(-1)).toBe(16);
+	});
+});
diff --git a/src/components/ai-edition/VirtualPreview.tsx b/src/components/ai-edition/VirtualPreview.tsx
index 3481e2368..03b7530bc 100644
--- a/src/components/ai-edition/VirtualPreview.tsx
+++ b/src/components/ai-edition/VirtualPreview.tsx
@@ -454,7 +454,12 @@ interface VirtualPreviewProps {
 	trimRanges?: AxcutTrimRange[];
 	/** Play the raw timeline continuously while capturing a voiceover. */
 	playUneditedTimeline?: boolean;
-	seekTarget?: { timeSec: number; isSource?: boolean; requestId: number } | null;
+	seekTarget?: {
+		timeSec: number;
+		isSource?: boolean;
+		requestId: number;
+		preservePlayback?: boolean;
+	} | null;
 	onTimeChange?: (timeSec: number) => void;
 	onLoadedMetadata?: (
 		durationSec: number,
@@ -587,6 +592,12 @@ export function VirtualPreview({
 	const activeClipIdRef = useRef<string | null>(null);
 	const [virtualTimeSec, setVirtualTimeSec] = useState(0);
 	const [loadState, setLoadState] = useState<"idle" | "loading" | "ready" | "error">("idle");
+	const loadStateRef = useRef(loadState);
+	loadStateRef.current = loadState;
+	const updateLoadState = useCallback((nextState: "idle" | "loading" | "ready" | "error") => {
+		loadStateRef.current = nextState;
+		setLoadState(nextState);
+	}, []);
 	const [sourceIndex, setSourceIndex] = useState(0);
 
 	const virtualDurationSec = useMemo(() => totalVirtualDuration(clips), [clips]);
@@ -1171,10 +1182,32 @@ export function VirtualPreview({
 			// position rather than jumping. Note this cannot ride on `v.paused`,
 			// the gate the rest of the tick uses — an `error` does not fire
 			// `pause`, so a failure mid-playback leaves `paused` false.
-			if (recoveringRef.current) {
+			// Same for in-flight pending seeks or loads: the element's currentTime is
+			// stale or 0 and must not trigger clip boundary or trim fallbacks.
+			if (
+				recoveringRef.current ||
+				v.seeking ||
+				pendingSeekRef.current !== null ||
+				loadStateRef.current === "loading"
+			) {
 				return;
 			}
 			const activeSourceId = videoSourcesRef.current[sourceIndexRef.current]?.id;
+			if (isProgrammaticSeekRef.current) {
+				isProgrammaticSeekRef.current = false;
+				const pos = locateSourcePosition(
+					clipsRef.current,
+					v.currentTime,
+					activeSourceId,
+					0.05,
+					activeClipIdRef.current ?? undefined,
+				);
+				if (pos) {
+					activeClipIdRef.current = pos.clip.id;
+					updateVirtualTime(clampVirtualTime(clipsRef.current, pos.virtualTimeSec));
+				}
+				return;
+			}
 			// Trims only trim ahead during actual playback — scrubbing/paused seeks are
 			// intentionally NOT clamped, so the user can navigate freely into a trim while
 			// editing; only Play/export treats it as a cut (mirrors the pre-existing intent
@@ -1218,7 +1251,10 @@ export function VirtualPreview({
 						return;
 					}
 					v.pause();
-					updateVirtualTime(virtualDurationSecRef.current);
+					const endPos = locateVirtualPosition(clipsRef.current, virtualDurationSecRef.current);
+					if (activeClipIdRef.current === endPos?.clip.id) {
+						updateVirtualTime(virtualDurationSecRef.current);
+					}
 					return;
 				}
 			}
@@ -1290,21 +1326,6 @@ export function VirtualPreview({
 				updateVirtualTime(v.currentTime);
 				return;
 			}
-			if (isProgrammaticSeekRef.current) {
-				isProgrammaticSeekRef.current = false;
-				const pos = locateSourcePosition(
-					clipsRef.current,
-					v.currentTime,
-					activeSourceId,
-					0.05,
-					activeClipIdRef.current ?? undefined,
-				);
-				if (pos) {
-					activeClipIdRef.current = pos.clip.id;
-					updateVirtualTime(clampVirtualTime(clipsRef.current, pos.virtualTimeSec));
-				}
-				return;
-			}
 			const position = locateSourcePosition(
 				clipsRef.current,
 				v.currentTime,
@@ -1319,7 +1340,10 @@ export function VirtualPreview({
 				if (nextClip) seekToVirtualTimeRef.current?.(nextClip.timelineStartSec, true);
 				else {
 					v.pause();
-					updateVirtualTime(virtualDurationSecRef.current);
+					const endPos = locateVirtualPosition(clipsRef.current, virtualDurationSecRef.current);
+					if (activeClipIdRef.current === endPos?.clip.id) {
+						updateVirtualTime(virtualDurationSecRef.current);
+					}
 				}
 				return;
 			}
@@ -1340,7 +1364,10 @@ export function VirtualPreview({
 				);
 				if (!nextClip) {
 					v.pause();
-					updateVirtualTime(virtualDurationSecRef.current);
+					const endPos = locateVirtualPosition(clipsRef.current, virtualDurationSecRef.current);
+					if (activeClipIdRef.current === endPos?.clip.id) {
+						updateVirtualTime(virtualDurationSecRef.current);
+					}
 					return;
 				}
 				seekToVirtualTimeRef.current?.(nextClip.timelineStartSec, true);
@@ -1491,8 +1518,11 @@ export function VirtualPreview({
 			const shouldContinuePlayback = preservePlayback && (forceResume || !videoRef.current?.paused);
 
 			if (isAssetSwitch) {
+				if (!shouldContinuePlayback) {
+					videoRef.current?.pause();
+				}
 				setSourceIndex(targetIndex);
-				setLoadState("loading");
+				updateLoadState("loading");
 				updateVirtualTime(position.virtualTimeSec);
 				pendingSeekRef.current = {
 					sourceTimeSec: position.sourceTimeSec,
@@ -1522,12 +1552,12 @@ export function VirtualPreview({
 				// A rejection here means playback never actually started, so the browser
 				// never fired 'play' — nothing to reconcile, just avoid an unhandled
 				// rejection warning.
-				void video.play().catch(() => {
+				void video.play()?.catch(() => {
 					// swallow: rejection just means playback never started
 				});
 			}
 		},
-		[applySourceTime, clips, videoSources, sourceIndex, updateVirtualTime],
+		[applySourceTime, clips, videoSources, sourceIndex, updateLoadState, updateVirtualTime],
 	);
 
 	const seekToSourceTime = useCallback(
@@ -1550,52 +1580,55 @@ export function VirtualPreview({
 	 * queue the position to come back to. Everything is read through refs, so the
 	 * callback is stable and the scheduled work always sees current state.
 	 */
-	const reloadActiveSource = useCallback((play: boolean, delayMs: number) => {
-		if (retryTimerRef.current !== null) {
-			window.clearTimeout(retryTimerRef.current);
-			retryTimerRef.current = null;
-		}
-		recoveringRef.current = true;
-		setLoadState("loading");
-		retryTimerRef.current = window.setTimeout(() => {
-			retryTimerRef.current = null;
-			const video = videoRef.current;
-			if (!video) return;
-			// Resolved HERE rather than when the error fired: the user can scrub
-			// during the backoff, and the position they left the playhead on is
-			// the one that has to come back. An asset switch queued in the
-			// meantime is newer intent still, so it wins outright.
-			if (!pendingSeekRef.current) {
-				const position = locateVirtualPosition(clipsRef.current, virtualTimeSecRef.current);
-				// `locateVirtualPosition` answers for whatever clip the playhead
-				// is on, which after a boundary advance can belong to a DIFFERENT
-				// asset — its source time would be a meaningless offset into the
-				// file we are about to reload. The mounted source is read from the
-				// same two mirrors the rAF tick uses, rather than kept in a third.
-				const clipIsOnThisSource =
-					position?.clip.assetId === videoSourcesRef.current[sourceIndexRef.current]?.id;
-				if (position && clipIsOnThisSource) {
-					// The rAF resumes against this; leaving it stale would resolve
-					// the next tick against the clip we were on before the failure.
-					activeClipIdRef.current = position.clip.id;
-				}
-				const resumeSec =
-					position && clipIsOnThisSource ? position.sourceTimeSec : lastGoodSourceTimeRef.current;
-				pendingSeekRef.current = {
-					sourceTimeSec: Number.isFinite(resumeSec) ? resumeSec : 0,
-					play,
-				};
+	const reloadActiveSource = useCallback(
+		(play: boolean, delayMs: number) => {
+			if (retryTimerRef.current !== null) {
+				window.clearTimeout(retryTimerRef.current);
+				retryTimerRef.current = null;
 			}
-			// The restore itself rides the cross-asset path `onLoadedMetadata`
-			// already implements — one resume path in this component, not two.
-			//
-			// load() and nothing else: per spec it unconditionally re-runs the
-			// media load algorithm. Re-assigning `src` first (the obvious
-			// alternative) starts a SECOND load that aborts the first, which
-			// surfaces as a spurious MEDIA_ERR_ABORTED.
-			video.load();
-		}, delayMs);
-	}, []);
+			recoveringRef.current = true;
+			updateLoadState("loading");
+			retryTimerRef.current = window.setTimeout(() => {
+				retryTimerRef.current = null;
+				const video = videoRef.current;
+				if (!video) return;
+				// Resolved HERE rather than when the error fired: the user can scrub
+				// during the backoff, and the position they left the playhead on is
+				// the one that has to come back. An asset switch queued in the
+				// meantime is newer intent still, so it wins outright.
+				if (!pendingSeekRef.current) {
+					const position = locateVirtualPosition(clipsRef.current, virtualTimeSecRef.current);
+					// `locateVirtualPosition` answers for whatever clip the playhead
+					// is on, which after a boundary advance can belong to a DIFFERENT
+					// asset — its source time would be a meaningless offset into the
+					// file we are about to reload. The mounted source is read from the
+					// same two mirrors the rAF tick uses, rather than kept in a third.
+					const clipIsOnThisSource =
+						position?.clip.assetId === videoSourcesRef.current[sourceIndexRef.current]?.id;
+					if (position && clipIsOnThisSource) {
+						// The rAF resumes against this; leaving it stale would resolve
+						// the next tick against the clip we were on before the failure.
+						activeClipIdRef.current = position.clip.id;
+					}
+					const resumeSec =
+						position && clipIsOnThisSource ? position.sourceTimeSec : lastGoodSourceTimeRef.current;
+					pendingSeekRef.current = {
+						sourceTimeSec: Number.isFinite(resumeSec) ? resumeSec : 0,
+						play,
+					};
+				}
+				// The restore itself rides the cross-asset path `onLoadedMetadata`
+				// already implements — one resume path in this component, not two.
+				//
+				// load() and nothing else: per spec it unconditionally re-runs the
+				// media load algorithm. Re-assigning `src` first (the obvious
+				// alternative) starts a SECOND load that aborts the first, which
+				// surfaces as a spurious MEDIA_ERR_ABORTED.
+				video.load();
+			}, delayMs);
+		},
+		[updateLoadState],
+	);
 
 	/** The element is loaded again, so the reload is over and any failure the
 	 *  caller is showing can go. Note what this does NOT do: re-arm the retry
@@ -1669,7 +1702,11 @@ export function VirtualPreview({
 		if (seekTarget.isSource) {
 			seekToSourceTimeRef.current(seekTarget.timeSec);
 		} else {
-			seekToVirtualTimeRef.current?.(seekTarget.timeSec);
+			seekToVirtualTimeRef.current?.(
+				seekTarget.timeSec,
+				seekTarget.preservePlayback,
+				seekTarget.preservePlayback,
+			);
 		}
 	}, [seekTarget]);
 
@@ -1701,7 +1738,7 @@ export function VirtualPreview({
 							muted
 							playsInline
 							onLoadedMetadata={(e) => {
-								setLoadState("ready");
+								updateLoadState("ready");
 								markSourceLoaded();
 								// ponytail: forward the raw duration (possibly NaN for
 								// MediaRecorder WebMs) to the parent. handleLoadedMetadata
@@ -1739,6 +1776,7 @@ export function VirtualPreview({
 								}
 							}}
 							onSeeked={(e) => {
+								isProgrammaticSeekRef.current = false;
 								// The demuxer is free again: apply the newest target that
 								// arrived while it was busy, if the playhead has moved on.
 								const queued = pendingScrubTargetRef.current;
@@ -1747,9 +1785,9 @@ export function VirtualPreview({
 									applySourceTime(e.currentTarget, queued);
 								}
 							}}
-							onWaiting={() => setLoadState("loading")}
+							onWaiting={() => updateLoadState("loading")}
 							onCanPlay={() => {
-								setLoadState("ready");
+								updateLoadState("ready");
 								markSourceLoaded();
 							}}
 							onError={(e) => {
@@ -1811,14 +1849,36 @@ export function VirtualPreview({
 								// Latched so an expiring window cannot restart the cycle behind
 								// the card. Only Retry or a media change lifts it.
 								gaveUpRef.current = true;
-								setLoadState("error");
+								updateLoadState("error");
 								// An 'error' doesn't itself fire 'pause', so make sure the shell's
 								// transport state (single source of truth, see NewEditorShell's
 								// own play/pause/ended listener) actually learns playback stopped.
 								el.pause();
 								onVideoError?.(activeSource.id, detail);
 							}}
-							onEnded={() => {
+							onPlay={() => {
+								// The edited timeline can end before the underlying file. A
+								// plain play() would hit that same boundary and pause again.
+								// Resolve the rewind here so cross-asset restarts also carry
+								// playback intent through the pending metadata load.
+								const duration = virtualDurationSecRef.current;
+								const vTime = virtualTimeSecRef.current;
+								const endPos = locateVirtualPosition(clipsRef.current, duration);
+								const currentPos = locateVirtualPosition(clipsRef.current, vTime);
+								const hasNextClip = clipsRef.current.some((c) => c.timelineStartSec > vTime + 0.1);
+								if (
+									duration > 0 &&
+									vTime >= duration - 0.05 &&
+									!hasNextClip &&
+									currentPos?.clip.id === endPos?.clip.id
+								) {
+									seekToVirtualTimeRef.current?.(0, true, true);
+								}
+							}}
+							onEnded={(e) => {
+								if (!e.currentTarget.paused || pendingSeekRef.current !== null) {
+									return;
+								}
 								// BUG corrigé : ce handler stoppait TOUJOURS la lecture dès que le
 								// <video> brut atteignait SA PROPRE fin de fichier — une course
 								// avec la boucle rAF (reachedClipEnd, plus haut) qui gère
@@ -1833,7 +1893,7 @@ export function VirtualPreview({
 								// navigateur a déjà mis `.paused = true` avant de déclencher
 								// 'ended', donc le check `!video.paused` habituel empêcherait
 								// toujours la reprise de la lecture sur le clip suivant. Si aucun
-								// clip suivant n'existe, on ne fait rien de plus ici : le navigateur
+								// clip suivant n'existe, on publie la fin de timeline : le navigateur
 								// a déjà mis la vidéo en pause, et NewEditorShell (seule source de
 								// vérité pour l'état de lecture) l'apprend via son propre listener
 								// 'ended'/'pause' sur ce même élément.
@@ -1845,6 +1905,14 @@ export function VirtualPreview({
 									: undefined;
 								if (nextClip) {
 									seekToVirtualTime(nextClip.timelineStartSec, true, true);
+								} else {
+									const endPos = locateVirtualPosition(
+										clipsRef.current,
+										virtualDurationSecRef.current,
+									);
+									if (current && current.id === endPos?.clip.id) {
+										updateVirtualTime(virtualDurationSecRef.current);
+									}
 								}
 							}}
 							// ponytail: handleTimeUpdate is now driven by the rAF loop
diff --git a/src/lib/ai-edition/timeline/virtual-preview.test.ts b/src/lib/ai-edition/timeline/virtual-preview.test.ts
index f3dd64888..2150e519d 100644
--- a/src/lib/ai-edition/timeline/virtual-preview.test.ts
+++ b/src/lib/ai-edition/timeline/virtual-preview.test.ts
@@ -44,6 +44,10 @@ describe("virtual-preview pure functions", () => {
 		expect(totalVirtualDuration([])).toBe(0);
 	});
 
+	it("totalVirtualDuration returns the maximum timelineEndSec even when clips are out of order", () => {
+		expect(totalVirtualDuration([clips[1], clips[0]])).toBe(20);
+	});
+
 	it("clampVirtualTime bounds to [0, total]", () => {
 		expect(clampVirtualTime(clips, -5)).toBe(0);
 		expect(clampVirtualTime(clips, 999)).toBe(20);
@@ -57,6 +61,29 @@ describe("virtual-preview pure functions", () => {
 		expect(pos?.sourceTimeSec).toBe(22);
 	});
 
+	it("locateVirtualPosition locates the end of the timeline when clips are out of order", () => {
+		const pos = locateVirtualPosition([clips[1], clips[0]], 20);
+		expect(pos?.clip.id).toBe("clip_2");
+		expect(pos?.virtualTimeSec).toBe(20);
+	});
+
+	it("locateVirtualPosition prefers a positive-duration clip ending at the timeline end over a zero-length clip", () => {
+		const zeroLengthClip: AxcutClip = {
+			id: "clip_zero",
+			assetId: "a1",
+			sourceStartSec: 30,
+			sourceEndSec: 30,
+			timelineStartSec: 20,
+			timelineEndSec: 20,
+			wordRefs: [],
+			origin: "system",
+			reason: "",
+		};
+		const pos = locateVirtualPosition([...clips, zeroLengthClip], 20);
+		expect(pos?.clip.id).toBe("clip_2");
+		expect(pos?.virtualTimeSec).toBe(20);
+	});
+
 	it("locateVirtualPosition returns null for empty clips", () => {
 		expect(locateVirtualPosition([], 0)).toBeNull();
 	});
diff --git a/src/lib/ai-edition/timeline/virtual-preview.ts b/src/lib/ai-edition/timeline/virtual-preview.ts
index 1cdc5d2f6..686e1d811 100644
--- a/src/lib/ai-edition/timeline/virtual-preview.ts
+++ b/src/lib/ai-edition/timeline/virtual-preview.ts
@@ -11,7 +11,7 @@ export type VirtualPosition = {
 };
 
 export function totalVirtualDuration(clips: AxcutClip[]): number {
-	return clips.at(-1)?.timelineEndSec ?? 0;
+	return clips.reduce((end, clip) => Math.max(end, clip.timelineEndSec), 0);
 }
 
 export function clampVirtualTime(clips: AxcutClip[], value: number): number {
@@ -25,8 +25,17 @@ export function locateVirtualPosition(
 ): VirtualPosition | null {
 	if (clips.length === 0) return null;
 	const clamped = clampVirtualTime(clips, virtualTimeSec);
+	const duration = totalVirtualDuration(clips);
+	let endpointClipIndex = -1;
+	for (let i = clips.length - 1; i >= 0; i--) {
+		const clip = clips[i];
+		if (clip.timelineEndSec === duration && clip.timelineEndSec > clip.timelineStartSec) {
+			endpointClipIndex = i;
+			break;
+		}
+	}
 	const clipIndex = clips.findIndex((clip, index) => {
-		const isLast = index === clips.length - 1;
+		const isLast = index === endpointClipIndex;
 		return clamped >= clip.timelineStartSec && (clamped < clip.timelineEndSec || isLast);
 	});
 	const resolvedIndex = clipIndex >= 0 ? clipIndex : clips.length - 1;