diff --git a/src/components/ai-edition/NewEditorShell.tsx b/src/components/ai-edition/NewEditorShell.tsx
index b82c2a1cf..966926aa0 100644
--- a/src/components/ai-edition/NewEditorShell.tsx
+++ b/src/components/ai-edition/NewEditorShell.tsx
@@ -14,10 +14,7 @@ import {
 	migrateProjectDataToAxcutDocument,
 	migrateRawDocumentToCurrent,
 } from "@/lib/ai-edition/document/migrate";
-import {
-	applyProbedDuration,
-	replaceTimeline as replaceTimelineOp,
-} from "@/lib/ai-edition/document/timeline";
+import { documentAfterProbedDuration } from "@/lib/ai-edition/document/timeline";
 import {
 	type InsertSide,
 	insertDocumentWord,
@@ -426,50 +423,39 @@ export function NewEditorShell() {
 			// ponytail: WebM recordings from MediaRecorder report NaN/Infinity
 			// until the main-process EBML fix lands. Fall back to a 60s seed if
 			// duration is unknown so the timeline never gets stuck on an empty
-			// placeholder. All store reads go through getState() to avoid
-			// stale-closure bugs.
+			// placeholder.
 			const known = Number.isFinite(durationSec) && durationSec > 0 ? durationSec : 60;
-			const state = useProjectStore.getState();
 			setSourceDuration(known);
-			const doc = state.document;
-			if (!doc || doc.assets.length === 0) return;
-			if (doc.timeline.clips.length === 0) {
-				// ponytail: replaceTimeline derives clip length from
-				// asset.durationSec, which import never populates — without this
-				// patch the first auto-created clip silently comes out empty
-				// (normalizeIntervals clamps against a 0 duration and drops it).
-				const primaryAssetId = doc.project.primaryAssetId ?? doc.assets[0]?.id;
-				const docWithDuration = primaryAssetId
-					? {
-							...doc,
-							assets: doc.assets.map((a) =>
-								a.id === primaryAssetId ? { ...a, durationSec: known } : a,
-							),
-						}
-					: doc;
-				const next = replaceTimelineOp(
-					docWithDuration,
-					[{ startSec: 0, endSec: known }],
-					"Auto-created full-duration clip",
+			// Read before queueing: this is the project the event belongs to. What the
+			// decision does with it is `documentAfterProbedDuration`'s business.
+			const originatingProjectId = useProjectStore.getState().document?.project.id;
+			// On the shared write queue, and reading the document inside it. Folding a
+			// probed duration in is a read-modify-write of the whole document, which is
+			// what `useSequentialTimelineOps` exists for -- its header says anything that
+			// reads the doc and saves it back belongs there. Off the queue, `getState()`
+			// returns the PRE-edit document while a user's save is still in flight (the
+			// store is only written once the bridge answers), and the full snapshot built
+			// from it lands after theirs and takes their edit with it.
+			void enqueueTimelineWrite(async () => {
+				const state = useProjectStore.getState();
+				const next = documentAfterProbedDuration(
+					state.document,
+					assetId,
+					known,
+					originatingProjectId,
 				);
-				// `history: false` for both writes in this callback: they are the probed
-				// duration being folded into the document on load, not something the user
-				// did — an undo landing on one of them would empty their timeline.
-				void state.saveDocument(next, { history: false });
-				return;
-			}
-			// Hand the probed duration to the pure document layer: it patches only the
-			// clips of THIS asset that are still waiting for a real length (the
-			// pre-probe placeholder, or the extent-less clip a legacy v2 import mints),
-			// shifts what follows, and brings the modifiers along — anchoring the ones
-			// migration had to leave unanchored. Returns the document untouched when
-			// nothing is waiting, so there is nothing to guard here.
-			const next = applyProbedDuration(doc, assetId, known);
-			if (next !== doc) {
-				void state.saveDocument(next, { history: false });
-			}
+				if (!next) return;
+				// `history: false`: this is the probed duration being folded into the
+				// document on load, not something the user did — an undo landing on it would
+				// empty their timeline.
+				//
+				// Awaited, not `void`ed: the queue only serialises what it can see finish, so
+				// a fire-and-forget write would let the next queued edit read a document this
+				// one has not committed yet.
+				await state.saveDocument(next, { history: false });
+			});
 		},
-		[setSourceDuration],
+		[setSourceDuration, enqueueTimelineWrite],
 	);
 
 	const handleSeek = useCallback(
@@ -1559,6 +1545,10 @@ export function NewEditorShell() {
 									hasProject={hasProject}
 									hasAsset={hasAsset}
 									videoSources={videoSources}
+									// While the timeline is empty the preview mounts this asset rather
+									// than whichever one sorts first, so the clip `handleLoadedMetadata`
+									// seeds comes from the video it is sized against.
+									primaryAssetId={document?.project.primaryAssetId}
 									// Imported audio tracks (issue #350). `videoSources` already
 									// resolves a URL for every asset (audio included), so it doubles as
 									// the audio source list; VirtualPreview looks each track up by assetId.
diff --git a/src/components/ai-edition/Preview.test.tsx b/src/components/ai-edition/Preview.test.tsx
index db84828b8..d4810ce70 100644
--- a/src/components/ai-edition/Preview.test.tsx
+++ b/src/components/ai-edition/Preview.test.tsx
@@ -75,6 +75,7 @@ function source(id: string): VideoSource {
 function previewProps(props: {
 	videoSources: VideoSource[];
 	clips: AxcutClip[];
+	primaryAssetId?: string;
 	hasAsset?: boolean;
 	hasProject?: boolean;
 }) {
@@ -84,6 +85,7 @@ function previewProps(props: {
 				hasProject={props.hasProject ?? true}
 				hasAsset={props.hasAsset ?? true}
 				videoSources={props.videoSources}
+				primaryAssetId={props.primaryAssetId}
 				clips={props.clips}
 				seekTarget={null}
 				onTimeChange={vi.fn()}
@@ -157,12 +159,48 @@ describe("Preview follows the timeline, not the asset list", () => {
 	// The bootstrap path: `handleLoadedMetadata` mints the very first clip from
 	// the <video>'s own metadata, so a just-imported asset has to be mounted
 	// while nothing references it yet.
-	it("falls back to every asset while the timeline is empty", () => {
+	it("mounts the asset while the timeline is empty", () => {
 		renderPreview({ videoSources: [source("fresh_import")], clips: [] });
 
 		expect(canvas()).toHaveAttribute("data-sources", "fresh_import");
 	});
 
+	// A project whose first import was audio: audio never claims the empty primary
+	// slot, so `assets[0]` is the audio track and the primary is the video added
+	// after it. Only one source is mounted at a time and nothing on an empty
+	// timeline moves that index off 0 — so mounting the audio would hand
+	// `handleLoadedMetadata` an event for an asset it refuses to seed from, and the
+	// timeline would never get its first clip at all.
+	it("mounts the primary asset, not the one that sorts first", () => {
+		renderPreview({
+			videoSources: [source("bgm"), source("screen")],
+			primaryAssetId: "screen",
+			clips: [],
+		});
+
+		expect(canvas()).toHaveAttribute("data-sources", "screen");
+	});
+
+	// No primary recorded (a v1.7 project that predates the field): fall back to
+	// `assets[0]`, which is what the seed itself falls back to.
+	it("mounts the first asset when the project has no primary", () => {
+		renderPreview({ videoSources: [source("first"), source("second")], clips: [] });
+
+		expect(canvas()).toHaveAttribute("data-sources", "first");
+	});
+
+	// A primary id pointing at an asset with no source would otherwise mount
+	// nothing and collapse the stage to the empty state.
+	it("keeps every asset when the primary has no source", () => {
+		renderPreview({
+			videoSources: [source("a"), source("b")],
+			primaryAssetId: "gone",
+			clips: [],
+		});
+
+		expect(canvas()).toHaveAttribute("data-sources", "a,b");
+	});
+
 	// A clip landing on a healthy asset takes over the preview regardless of what
 	// happened to the asset that was mounted before it.
 	it("switches to the asset a new clip references", () => {
diff --git a/src/components/ai-edition/Preview.tsx b/src/components/ai-edition/Preview.tsx
index 3a1db9756..666af3ae7 100644
--- a/src/components/ai-edition/Preview.tsx
+++ b/src/components/ai-edition/Preview.tsx
@@ -23,6 +23,9 @@ interface PreviewProps {
 	hasProject: boolean;
 	hasAsset: boolean;
 	videoSources: VideoSource[];
+	/** `document.project.primaryAssetId`, when the project has one. Read only while
+	 *  the timeline is empty — see `previewSources`. */
+	primaryAssetId?: string;
 	/** Imported audio tracks and the (unfiltered) asset URLs they resolve to
 	 *  (issue #350). Passed straight through to VirtualPreview — unlike the video
 	 *  `previewSources` below, these are NOT narrowed to clip-referenced assets,
@@ -61,6 +64,7 @@ export function Preview({
 	hasProject,
 	hasAsset,
 	videoSources,
+	primaryAssetId,
 	audioTracks = [],
 	audioSources = [],
 	clips,
@@ -116,8 +120,23 @@ export function Preview({
 			const source = videoSources.find((s) => s.id === clip.assetId);
 			if (source) referenced.push(source);
 		}
-		return referenced.length > 0 ? referenced : videoSources;
-	}, [clips, videoSources]);
+		if (referenced.length > 0) return referenced;
+		// Empty timeline: mount the asset the seed is minted FOR, not whichever asset
+		// happens to sort first. `handleLoadedMetadata` sizes that first clip against
+		// `primaryAssetId ?? assets[0]` and ignores an event from any other asset, and
+		// only ONE source is ever mounted (`videoSources[sourceIndex]` in
+		// VirtualPreview, index 0 while nothing on the timeline moves it) — so mounting
+		// a non-primary asset here fires an event nothing acts on and the timeline
+		// stays empty for good. A project whose first import was audio is exactly that
+		// case: audio never claims the empty primary slot (document-service.addAsset),
+		// so `assets[0]` is the audio and the primary is the video added after it.
+		// `videoSources` mirrors `document.assets` in order, so index 0 is the same
+		// `assets[0]` the seed itself falls back to.
+		const primary = primaryAssetId
+			? videoSources.find((source) => source.id === primaryAssetId)
+			: videoSources[0];
+		return primary ? [primary] : videoSources;
+	}, [clips, videoSources, primaryAssetId]);
 
 	// ponytail: a media failure used to fall through to `EditorEmptyState`, and
 	// that is issue #395: ONE `error` event on the hidden <video> — including the
diff --git a/src/components/ai-edition/v4/V4Timeline.tsx b/src/components/ai-edition/v4/V4Timeline.tsx
index a4b41ff32..86524447c 100644
--- a/src/components/ai-edition/v4/V4Timeline.tsx
+++ b/src/components/ai-edition/v4/V4Timeline.tsx
@@ -1491,27 +1491,38 @@ export function V4Timeline({
 		}
 		setAutoBusy(true);
 		try {
-			// Read once, up front: every clip reserves against the zooms the document
-			// ALREADY holds, and two clips can never contest the same stretch of ruler, so
-			// nothing here depends on the order the assets are visited — which is what lets
-			// their telemetry be fetched concurrently rather than one IPC round trip after
-			// another. `Promise.all` preserves input order, so the suggestions come out in
-			// the same sequence a loop would have produced.
-			const existingRegions = tl.zoomRegions.map((z) => ({ startMs: z.startMs, endMs: z.endMs }));
+			// Telemetry first, and nothing derived from the document until it is back.
+			// `Promise.all` preserves input order, so the suggestions still come out in the
+			// same sequence a loop would have produced.
 			const perSource = await Promise.all(
-				sources.map(async (source) => {
-					const telemetry =
-						(await nativeBridgeClient.cursor.getTelemetry(fromFileUrl(source.src))) ?? [];
-					return buildAutoZoomSuggestionsForClips({
-						cursorTelemetry: telemetry,
-						assetId: source.id,
-						clips,
-						existingRegions,
-						defaultDurationMs: 2000,
-					});
+				sources.map(async (source) => ({
+					assetId: source.id,
+					telemetry: (await nativeBridgeClient.cursor.getTelemetry(fromFileUrl(source.src))) ?? [],
+				})),
+			);
+			// Read AFTER the round trip, not before it. `addZoomsBulk` anchors what comes out
+			// of here against the document IT reads at write time, so building the spans from
+			// the pre-await `clips` puts the two halves on different rulers: a trim landing
+			// during the wait moves every clip, and a span that no longer falls in one is
+			// stored unanchored. A stale `zoomRegions` is the same shape one step over — a
+			// zoom the user added during the wait would not be reserved, and the region
+			// minted here would sit on top of it.
+			//
+			// Still read ONCE for every asset rather than per asset: each clip reserves
+			// against the zooms the document already holds, and two clips can never contest
+			// the same stretch of ruler, so nothing depends on the order they are visited.
+			const doc = useProjectStore.getState().document;
+			if (!doc) return;
+			const existingRegions = doc.zoomRanges.map((z) => ({ startMs: z.startMs, endMs: z.endMs }));
+			const suggestions: AutoZoomSuggestion[] = perSource.flatMap(({ assetId, telemetry }) =>
+				buildAutoZoomSuggestionsForClips({
+					cursorTelemetry: telemetry,
+					assetId,
+					clips: doc.timeline.clips,
+					existingRegions,
+					defaultDurationMs: 2000,
 				}),
 			);
-			const suggestions: AutoZoomSuggestion[] = perSource.flat();
 			if (suggestions.length === 0) {
 				toast.info(t("toolbar.noAutoZoomMoments"), {
 					description: t("toolbar.noAutoZoomMomentsDescription"),
diff --git a/src/lib/ai-edition/document/probedDuration.test.ts b/src/lib/ai-edition/document/probedDuration.test.ts
new file mode 100644
index 000000000..1f7aac939
--- /dev/null
+++ b/src/lib/ai-edition/document/probedDuration.test.ts
@@ -0,0 +1,127 @@
+// The decision a `loadedmetadata` event makes, on its own.
+//
+// The event itself arrives through Preview -> PreviewCanvas -> VirtualPreview and a
+// real <video>, which no test environment here can decode, so the component cannot be
+// driven end to end. `documentAfterProbedDuration` is the part that decides what gets
+// written, and every guard below lives in it: the queue the shell puts this write on
+// is what makes them necessary, because it puts real time between the event and the
+// write. The queue's own serialization is covered by useSequentialTimelineOps.test.
+import { describe, expect, it } from "vitest";
+import { type AxcutDocument, createEmptyDocument, documentSchema } from "@/lib/ai-edition/schema";
+import { migrateProjectDataToAxcutDocument } from "./migrate";
+import { documentAfterProbedDuration } from "./timeline";
+
+const PROJECT = "proj_a";
+
+/** A fresh import: assets on the document, nothing on the timeline yet. */
+function emptyTimeline(primaryAssetId: string, assetIds: string[]): AxcutDocument {
+	const doc = createEmptyDocument({ projectId: PROJECT, title: "A" });
+	return {
+		...doc,
+		project: { ...doc.project, primaryAssetId },
+		assets: assetIds.map((id) => ({
+			id,
+			kind: "video" as const,
+			label: `${id}.mp4`,
+			originalPath: `/tmp/${id}.mp4`,
+			cameraTrack: null,
+		})),
+	};
+}
+
+/** A v1.7 project: one clip with no source extent, waiting for a real length. */
+function legacyWithClip(): AxcutDocument {
+	return documentSchema.parse(
+		migrateProjectDataToAxcutDocument({
+			version: 2,
+			videoPath: "C:/rec/screen.webm",
+			media: { videoPath: "C:/rec/screen.webm" },
+			editor: {
+				zoomRegions: [],
+				annotationRegions: [],
+				trimRegions: [],
+				speedRegions: [],
+				cameraFullscreenRegions: [],
+			},
+		} as never),
+	);
+}
+
+describe("documentAfterProbedDuration", () => {
+	it("seeds a full-duration clip when the primary asset reports its length", () => {
+		const doc = emptyTimeline("asset_1", ["asset_1"]);
+
+		const next = documentAfterProbedDuration(doc, "asset_1", 30, PROJECT);
+
+		expect(next).not.toBeNull();
+		expect(next?.assets[0].durationSec).toBe(30);
+		expect(next?.timeline.clips).toHaveLength(1);
+		expect(next?.timeline.clips[0].timelineStartSec).toBe(0);
+		expect(next?.timeline.clips[0].timelineEndSec).toBe(30);
+	});
+
+	// The write is queued, so the user can switch projects between the event and this
+	// decision. `knownSec` came off the OLD video; applying it to whatever is loaded
+	// now writes one recording's length into another project.
+	it("writes nothing when the project changed after the event fired", () => {
+		const doc = emptyTimeline("asset_1", ["asset_1"]);
+
+		expect(documentAfterProbedDuration(doc, "asset_1", 30, "proj_switched_to")).toBeNull();
+		expect(documentAfterProbedDuration(doc, "asset_1", 30, undefined)).toBeNull();
+	});
+
+	// `replaceTimeline` pins every clip it builds to the primary asset, and the seed
+	// sizes that clip from `knownSec` — so seeding on another asset's event would put
+	// one video's length under a different asset's id. The primary's own event seeds it.
+	it("does not seed from an asset that is not the one the seed is about", () => {
+		const doc = emptyTimeline("asset_1", ["asset_1", "asset_2"]);
+
+		expect(documentAfterProbedDuration(doc, "asset_2", 30, PROJECT)).toBeNull();
+		// And the primary still seeds normally on the same document.
+		expect(documentAfterProbedDuration(doc, "asset_1", 30, PROJECT)).not.toBeNull();
+	});
+
+	it("folds the length into a clip that was waiting for one", () => {
+		const doc = legacyWithClip();
+		const assetId = doc.assets[0].id;
+
+		const next = documentAfterProbedDuration(doc, assetId, 30, doc.project.id);
+
+		expect(next?.timeline.clips[0].sourceEndSec).toBe(30);
+		expect(next?.assets[0].durationSec).toBe(30);
+	});
+
+	it("writes nothing when the length is already recorded", () => {
+		const doc = legacyWithClip();
+		const assetId = doc.assets[0].id;
+		const settled = documentAfterProbedDuration(doc, assetId, 30, doc.project.id);
+
+		expect(settled).not.toBeNull();
+		expect(
+			documentAfterProbedDuration(settled as AxcutDocument, assetId, 30, doc.project.id),
+		).toBeNull();
+	});
+
+	// Empty is not the same as unseeded — the user can delete their only clip — and
+	// `knownSec` is 60 whenever the <video> reports a non-finite duration. Overwriting
+	// here traded a real length for the fallback under `history: false`.
+	it("keeps a length the asset already carries, and sizes the seed against it", () => {
+		const doc = emptyTimeline("asset_1", ["asset_1"]);
+		const measured: AxcutDocument = {
+			...doc,
+			assets: doc.assets.map((a) => ({ ...a, durationSec: 26.517 })),
+		};
+
+		const next = documentAfterProbedDuration(measured, "asset_1", 60, PROJECT);
+
+		expect(next?.assets[0].durationSec).toBe(26.517);
+		expect(next?.timeline.clips[0].timelineEndSec).toBeCloseTo(26.517, 3);
+	});
+
+	it("writes nothing without a document or without assets", () => {
+		expect(documentAfterProbedDuration(null, "asset_1", 30, PROJECT)).toBeNull();
+		expect(
+			documentAfterProbedDuration(emptyTimeline("asset_1", []), "asset_1", 30, PROJECT),
+		).toBeNull();
+	});
+});
diff --git a/src/lib/ai-edition/document/timeline.ts b/src/lib/ai-edition/document/timeline.ts
index 8ae93098f..f997ddc18 100644
--- a/src/lib/ai-edition/document/timeline.ts
+++ b/src/lib/ai-edition/document/timeline.ts
@@ -562,6 +562,70 @@ export function applyProbedDuration(
 	);
 }
 
+/**
+ * What a `loadedmetadata` event should write, or `null` for "write nothing".
+ *
+ * Lives here rather than in the component that fires it because it is pure document
+ * logic: `applyProbedDuration` above and `replaceTimeline` below are the whole body.
+ *
+ * `originatingProjectId` is the project that was open when the event fired. It matters
+ * because the write is queued (`NewEditorShell.handleLoadedMetadata` puts it on the
+ * shared timeline write queue): by the time this runs the user may have switched, and
+ * `knownSec` came off the OLD video, so applying it to the new project is simply a wrong
+ * number. `saveDocument`'s epoch check cannot catch that — the write is issued after the
+ * switch rather than across it.
+ */
+export function documentAfterProbedDuration(
+	doc: AxcutDocument | null,
+	assetId: string,
+	knownSec: number,
+	originatingProjectId: string | undefined,
+): AxcutDocument | null {
+	if (!doc || doc.assets.length === 0) return null;
+	if (doc.project.id !== originatingProjectId) return null;
+	if (doc.timeline.clips.length === 0) {
+		// ponytail: replaceTimeline derives clip length from asset.durationSec, which
+		// import never populates — without this the first auto-created clip silently
+		// comes out empty (normalizeIntervals clamps against a 0 duration, dropping it).
+		const primaryAssetId = doc.project.primaryAssetId ?? doc.assets[0]?.id;
+		// Only the asset that actually fired. `replaceTimeline` pins every clip it
+		// builds to the primary asset, and the seed sizes that clip from `knownSec` —
+		// so seeding on an event from any OTHER asset writes one video's length under
+		// another's id. Not a lost seed: the primary's own event does its own seeding.
+		if (!primaryAssetId || primaryAssetId !== assetId) return null;
+		const docWithDuration: AxcutDocument = {
+			...doc,
+			// Only a length that was never measured, which is `applyProbedDuration`'s rule
+			// above widened to cover a stored 0 — the seed exists to give `replaceTimeline` a
+			// duration to clamp against, and a 0 defeats that exactly as a missing one does.
+			//
+			// An empty timeline is NOT proof the asset is unmeasured: the user can delete
+			// their only clip. And `knownSec` is the 60 s fallback whenever a MediaRecorder
+			// WebM reports a non-finite duration, so writing it unconditionally traded a real
+			// 26.517 for 60 under `history: false`, with no undo to get it back. Left alone,
+			// the recorded length is what the clip below is clamped against, which is the
+			// right number either way.
+			assets: doc.assets.map((a) =>
+				a.id === primaryAssetId && !(a.durationSec && a.durationSec > 0)
+					? { ...a, durationSec: knownSec }
+					: a,
+			),
+		};
+		return replaceTimeline(
+			docWithDuration,
+			[{ startSec: 0, endSec: knownSec }],
+			"Auto-created full-duration clip",
+		);
+	}
+	// The pure document layer patches only the clips of THIS asset that are still
+	// waiting for a real length (the pre-probe placeholder, or the extent-less clip a
+	// legacy v2 import mints), shifts what follows, and brings the modifiers along —
+	// anchoring the ones migration had to leave unanchored. It returns the document
+	// untouched when nothing is waiting, which is this function's "write nothing".
+	const next = applyProbedDuration(doc, assetId, knownSec);
+	return next === doc ? null : next;
+}
+
 /** One interval of a rebuilt timeline, plus the identity it inherits. `keepClipId`
  *  is set when the CALLER'S raw interval is (to the epsilon) an existing clip's own
  *  source window: the same stretch of media, so the same clip. */
diff --git a/src/lib/ai-edition/store/documentWriteAudit.test.ts b/src/lib/ai-edition/store/documentWriteAudit.test.ts
index 9a832b356..4a58c0fb6 100644
--- a/src/lib/ai-edition/store/documentWriteAudit.test.ts
+++ b/src/lib/ai-edition/store/documentWriteAudit.test.ts
@@ -126,7 +126,6 @@ const DECLARED: WritePath[] = [
 	// The probed duration folded into the document when the <video> loads. Twice:
 	// the first clip seed, and the backfill for clips still on a placeholder length.
 	w("src/components/ai-edition/NewEditorShell.tsx", "handleLoadedMetadata", "save", "automatic"),
-	w("src/components/ai-edition/NewEditorShell.tsx", "handleLoadedMetadata", "save", "automatic"),
 	// Renaming the project from the title field.
 	w("src/components/ai-edition/NewEditorShell.tsx", "handleRenameProject", "save", "gesture"),
 	// Ctrl+S / File > Save.
diff --git a/src/lib/ai-edition/store/useTimeline.test.ts b/src/lib/ai-edition/store/useTimeline.test.ts
index 2bc430311..9721e3d18 100644
--- a/src/lib/ai-edition/store/useTimeline.test.ts
+++ b/src/lib/ai-edition/store/useTimeline.test.ts
@@ -1596,3 +1596,91 @@ describe("useTimeline audio tracks", () => {
 		expect(probeAudioDurationMock).toHaveBeenCalledTimes(1);
 	});
 });
+
+// The wand (`V4Timeline.runAutoZooms`) captures this callback, awaits a
+// multi-second cursor-telemetry IPC, and only then calls it. Anything the user
+// commits during that wait is in the store but not in the callback's render
+// closure, so reading the closure writes back a snapshot that drops their edit.
+// Its `add*` siblings compute and save in the same tick, which is why this one
+// is the reachable case.
+describe("useTimeline.addZoomsBulk reads the document at write time", () => {
+	afterEach(() => {
+		vi.clearAllMocks();
+	});
+
+	beforeEach(() => {
+		useProjectStore.getState().clear();
+		for (const mock of Object.values(bridgeMocks)) mock.mockReset();
+		toastErrorMock.mockReset();
+		bridgeMocks.save.mockImplementation(async (document: AxcutDocument) => ({
+			success: true,
+			document,
+		}));
+		useProjectStore.setState({
+			projectId: "proj_test",
+			document: sampleDoc,
+			revision: 1,
+			status: "ready",
+			error: null,
+		});
+	});
+
+	it("does not write back the document from before the telemetry wait", async () => {
+		const { result } = renderTimeline();
+		// Captured the way the wand captures it: before the wait, not after.
+		const addZoomsBulk = result.current.addZoomsBulk;
+
+		// The user's edit lands while the wand is off fetching telemetry.
+		const edited: AxcutDocument = {
+			...sampleDoc,
+			project: { ...sampleDoc.project, title: "Edited while the wand was busy" },
+		};
+		act(() => {
+			useProjectStore.setState({ document: edited, revision: 2 });
+		});
+
+		let added: number | undefined;
+		await act(async () => {
+			added = await addZoomsBulk([
+				{ span: { start: 1000, end: 2000 }, focus: { cx: 0.5, cy: 0.5 } },
+			]);
+		});
+
+		expect(added).toBe(1);
+		const saved = bridgeMocks.save.mock.calls.at(-1)?.[0] as AxcutDocument;
+		// The zoom was added, and the edit is still there.
+		expect(saved.zoomRanges).toHaveLength(1);
+		expect(saved.project.title).toBe("Edited while the wand was busy");
+		expect(useProjectStore.getState().document?.project.title).toBe(
+			"Edited while the wand was busy",
+		);
+	});
+
+	// Reading the document fresh is what makes this reachable: the spans were built
+	// from the OLD project's telemetry and its ruler, so writing them into whatever is
+	// loaded now puts one project's zooms in another. `saveDocument`'s epoch check does
+	// not cover it -- the write is issued after the switch, not across it.
+	it("writes nothing when the project changed during the telemetry wait", async () => {
+		const { result } = renderTimeline();
+		const addZoomsBulk = result.current.addZoomsBulk;
+
+		// The user switches projects while the wand is off fetching telemetry.
+		act(() => {
+			useProjectStore.setState({
+				projectId: "proj_switched_to",
+				document: sampleDoc,
+				revision: 2,
+			});
+		});
+
+		let added: number | undefined;
+		await act(async () => {
+			added = await addZoomsBulk([
+				{ span: { start: 1000, end: 2000 }, focus: { cx: 0.5, cy: 0.5 } },
+			]);
+		});
+
+		expect(added).toBe(0);
+		expect(bridgeMocks.save).not.toHaveBeenCalled();
+	});
+});
diff --git a/src/lib/ai-edition/store/useTimeline.ts b/src/lib/ai-edition/store/useTimeline.ts
index 40e2408fd..a16605f32 100644
--- a/src/lib/ai-edition/store/useTimeline.ts
+++ b/src/lib/ai-edition/store/useTimeline.ts
@@ -334,7 +334,22 @@ export function useTimeline() {
 	// Returns the count actually added (0 when there's no doc/suggestions).
 	const addZoomsBulk = useCallback(
 		async (suggestions: AutoZoomSuggestion[]) => {
-			if (!document || suggestions.length === 0) return 0;
+			// Read from the store, not off the render closure. Unlike its `add*` siblings,
+			// which compute and save in the same tick, this one is reached from the wand
+			// AFTER a multi-second cursor-telemetry IPC: the closure document is the one
+			// from before that wait, so anything the user committed during it is missing
+			// from the snapshot, and writing the snapshot back drops their edit. Reading
+			// here is also what lets this compose with `useSequentialTimelineOps` -- same
+			// reason as `applyClipEdit`, `setTrimEntries` and `insertClipAt`.
+			const doc = useProjectStore.getState().document;
+			if (!doc || suggestions.length === 0) return 0;
+			// The same wait makes the PROJECT stale, and reading the document fresh is what
+			// exposes it: the suggestions were built from the OLD project's telemetry and its
+			// ruler, so applying them to whatever is loaded now writes one project's zooms into
+			// another. `saveDocument`'s epoch check cannot see this one -- the write is issued
+			// after the switch, not across it -- which is the same reason
+			// `documentAfterProbedDuration` carries an `originatingProjectId`.
+			if (useProjectStore.getState().projectId !== projectId) return 0;
 			const anchored = suggestions.flatMap((s) =>
 				anchorRegionsWithDerivedMs(
 					[
@@ -347,18 +362,21 @@ export function useTimeline() {
 							focusMode: "auto" as const,
 						},
 					],
-					document.timeline.clips,
+					// Anchored against the SAME document the write is built from: anchoring
+					// on the stale clips and saving the fresh document would place regions
+					// against a timeline that no longer exists.
+					doc.timeline.clips,
 					() => createId("zoom"),
 				),
 			);
 			const next: AxcutDocument = {
-				...document,
-				zoomRanges: [...document.zoomRanges, ...anchored] as AxcutDocument["zoomRanges"],
+				...doc,
+				zoomRanges: [...doc.zoomRanges, ...anchored] as AxcutDocument["zoomRanges"],
 			};
 			if (!(await saveDocument(next, { history: true }))) return 0;
 			return suggestions.length;
 		},
-		[document, saveDocument],
+		[projectId, saveDocument],
 	);
 
 	const addTrim = useCallback(