From 20114d9c663523fc55891cbc4d3037965259edcf Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?=E8=B6=85=E8=B6=85=E8=B6=85=E8=B6=85=E8=B6=85=E7=BA=A7?=
 =?UTF-8?q?=E5=96=9C=E6=AC=A2=E4=BD=A0=E7=9A=84=E8=BE=BE=E5=A6=AE=E5=A8=85?=
 <176143450+My-Denia@users.noreply.github.com>
Date: Mon, 12 Oct 2026 22:28:27 +0800
Subject: [PATCH 1/4] feat: mute recording audio

---
 src/cli/CliExportRunner.audio.test.ts         |  64 +++++
 src/cli/CliExportRunner.tsx                   |   6 +-
 .../ai-edition/ExportDialog.params.test.tsx   |  10 +
 src/components/ai-edition/ExportDialog.tsx    |   8 +-
 src/components/ai-edition/RightPanes.tsx      |  18 ++
 .../ai-edition/VirtualPreview.audio.test.ts   |  32 +++
 .../VirtualPreview.playback.test.tsx          | 245 +++++++++++++++++-
 src/components/ai-edition/VirtualPreview.tsx  | 126 ++++++++-
 src/i18n/locales/ar/settings.json             |   2 +
 src/i18n/locales/cs/settings.json             |   2 +
 src/i18n/locales/de/settings.json             |   2 +
 src/i18n/locales/en/settings.json             |   2 +
 src/i18n/locales/es/settings.json             |   2 +
 src/i18n/locales/fr/settings.json             |   2 +
 src/i18n/locales/it/settings.json             |   2 +
 src/i18n/locales/ja-JP/settings.json          |   2 +
 src/i18n/locales/ko-KR/settings.json          |   2 +
 src/i18n/locales/pt-BR/settings.json          |   2 +
 src/i18n/locales/ru/settings.json             |   2 +
 src/i18n/locales/tr/settings.json             |   2 +
 src/i18n/locales/vi/settings.json             |   2 +
 src/i18n/locales/zh-CN/settings.json          |   2 +
 src/i18n/locales/zh-TW/settings.json          |   2 +
 .../ai-edition/store/editorSettings.test.ts   |  12 +
 src/lib/ai-edition/store/editorSettings.ts    |   9 +
 .../store/useEditorSettings.test.ts           |  19 +-
 src/native/sceneDescription.test.ts           |  65 ++++-
 src/native/sceneDescription.ts                |  12 +-
 28 files changed, 623 insertions(+), 33 deletions(-)
 create mode 100644 src/cli/CliExportRunner.audio.test.ts

diff --git a/src/cli/CliExportRunner.audio.test.ts b/src/cli/CliExportRunner.audio.test.ts
new file mode 100644
index 0000000000..2cdbd5fbe4
--- /dev/null
+++ b/src/cli/CliExportRunner.audio.test.ts
@@ -0,0 +1,64 @@
+import { describe, expect, it } from "vitest";
+import type { AxcutDocument } from "@/lib/ai-edition/schema";
+import { axcutSchemaVersion } from "@/lib/ai-edition/schema";
+import { buildNativeClipList } from "./CliExportRunner";
+
+const document: AxcutDocument = {
+	schemaVersion: axcutSchemaVersion,
+	project: {
+		id: "project",
+		title: "Audio mute",
+		createdAt: "2026-10-12T00:00:00.000Z",
+		updatedAt: "2026-10-12T00:00:00.000Z",
+		primaryAssetId: "recording",
+	},
+	assets: [
+		{
+			id: "recording",
+			kind: "video",
+			label: "recording.mp4",
+			originalPath: "/tmp/recording.mp4",
+			cameraTrack: null,
+			durationSec: 4,
+			video: { codec: "h264", width: 1920, height: 1080, fps: 30 },
+		},
+	],
+	transcript: null,
+	timeline: {
+		clips: [
+			{
+				id: "clip",
+				assetId: "recording",
+				sourceStartSec: 0,
+				sourceEndSec: 4,
+				timelineStartSec: 0,
+				timelineEndSec: 4,
+				wordRefs: [],
+				origin: "user",
+				reason: "",
+			},
+		],
+		gaps: [],
+		trimRanges: [],
+		muteRanges: [],
+		speedRanges: [],
+		captionRanges: [],
+	},
+	annotations: [],
+	zoomRanges: [],
+	audioTracks: [],
+	transcripts: [],
+	legacyEditor: null,
+};
+
+describe("CLI recording audio mute", () => {
+	it("keeps clip audio by default and disables it only for a muted project", () => {
+		expect(buildNativeClipList(document)[0]?.hasAudio).toBe(true);
+		expect(
+			buildNativeClipList({
+				...document,
+				legacyEditor: { recordingAudioMuted: true },
+			})[0]?.hasAudio,
+		).toBe(false);
+	});
+});
diff --git a/src/cli/CliExportRunner.tsx b/src/cli/CliExportRunner.tsx
index 85b0668519..27cff7088c 100644
--- a/src/cli/CliExportRunner.tsx
+++ b/src/cli/CliExportRunner.tsx
@@ -80,7 +80,9 @@ function replaceExtension(filePath: string, newExtension: string): string {
 /** Mirrors ExportDialog.buildNativeClipList: trim-narrowed visible clips mapped
  * onto the native multiclip contract. Kept in lock-step with
  * buildSceneDescription so export and scene agree on the clip stream. */
-function buildNativeClipList(axcutDocument: AxcutDocument): CompositorClipInput[] {
+/** @internal Exported for the focused clip-audio policy test. */
+export function buildNativeClipList(axcutDocument: AxcutDocument): CompositorClipInput[] {
+	const recordingAudioMuted = getEditorSettings(axcutDocument).recordingAudioMuted;
 	const assetById = new Map(axcutDocument.assets.map((asset) => [asset.id, asset]));
 	return resolveVisibleClips(axcutDocument).flatMap((clip) => {
 		const asset = assetById.get(clip.assetId);
@@ -96,7 +98,7 @@ function buildNativeClipList(axcutDocument: AxcutDocument): CompositorClipInput[
 				sourceStartSec: clip.sourceStartSec,
 				sourceEndSec,
 				webcamOffsetSec: camera.offsetSec,
-				hasAudio: true,
+				hasAudio: !recordingAudioMuted,
 			},
 		];
 	});
diff --git a/src/components/ai-edition/ExportDialog.params.test.tsx b/src/components/ai-edition/ExportDialog.params.test.tsx
index d78ad091c2..4e2de3e66f 100644
--- a/src/components/ai-edition/ExportDialog.params.test.tsx
+++ b/src/components/ai-edition/ExportDialog.params.test.tsx
@@ -142,6 +142,16 @@ describe("ExportDialog MP4 params", () => {
 		expect(at30).toMatchObject({ fps: 30, bitrate: expected(30) });
 		expect(at30?.bitrate).toBeLessThan(at60?.bitrate ?? 0);
 	});
+
+	it.each([false, true])("sets clip hasAudio when recording mute is %s", async (muted) => {
+		renderDialog({
+			...DOC,
+			legacyEditor: { ...DOC.legacyEditor, recordingAudioMuted: muted },
+		});
+		await exportMp4();
+		const clips = vi.mocked(exportMultiNative).mock.calls.at(-1)?.[0];
+		expect(clips?.[0]?.hasAudio).toBe(!muted);
+	});
 });
 
 describe("ExportDialog format settings", () => {
diff --git a/src/components/ai-edition/ExportDialog.tsx b/src/components/ai-edition/ExportDialog.tsx
index a336901d85..0857319b86 100644
--- a/src/components/ai-edition/ExportDialog.tsx
+++ b/src/components/ai-edition/ExportDialog.tsx
@@ -111,6 +111,7 @@ function revealExportedFile(filePath: string): void {
  *  each with its asset's screen file + camera file (falls back to the screen when a clip has
  *  no camera — the no-webcam layout is a later step) and its source trim. */
 function buildNativeClipList(document: AxcutDocument): CompositorClipInput[] {
+	const recordingAudioMuted = getEditorSettings(document).recordingAudioMuted;
 	const assetById = new Map(document.assets.map((a) => [a.id, a]));
 	return resolveVisibleClips(document).flatMap((clip) => {
 		const asset = assetById.get(clip.assetId);
@@ -122,9 +123,8 @@ function buildNativeClipList(document: AxcutDocument): CompositorClipInput[] {
 		// the single canonical precedence used by every consumer (clip.probe → asset.duration
 		// → timeline-length guess). See `resolveClipSourceEndSec` for the full order.
 		const sourceEndSec = resolveClipSourceEndSec(clip, asset);
-		// ponytail: `hasAudio` stays optimistic for the same reason as in
-		// `buildSceneDescription` — nothing populates `asset.audio` yet, and the
-		// native side degrades cleanly on a stream-less file.
+		// `asset.audio` is not populated by the probe yet, so keep the current
+		// optimistic default unless the project explicitly mutes its recording audio.
 		return [
 			{
 				screenPath: asset.originalPath,
@@ -132,7 +132,7 @@ function buildNativeClipList(document: AxcutDocument): CompositorClipInput[] {
 				sourceStartSec: clip.sourceStartSec,
 				sourceEndSec,
 				webcamOffsetSec: camera.offsetSec,
-				hasAudio: true,
+				hasAudio: !recordingAudioMuted,
 			},
 		];
 	});
diff --git a/src/components/ai-edition/RightPanes.tsx b/src/components/ai-edition/RightPanes.tsx
index 17f3350487..7f4f55a050 100644
--- a/src/components/ai-edition/RightPanes.tsx
+++ b/src/components/ai-edition/RightPanes.tsx
@@ -3462,6 +3462,24 @@ export function AudioPane() {
 					onCommit={() => void commit()}
 				/>
 			</div>
+			<div
+				style={{
+					display: "flex",
+					alignItems: "center",
+					justifyContent: "space-between",
+					gap: 12,
+					marginTop: 12,
+				}}
+			>
+				<span>{ts("audio.muteRecording")}</span>
+				<Toggle
+					checked={settings.recordingAudioMuted}
+					disabled={!hasDocument}
+					ariaLabel={ts("audio.muteRecording")}
+					tooltip={ts("audio.muteRecordingHelp")}
+					onChange={(checked) => void set({ recordingAudioMuted: checked })}
+				/>
+			</div>
 			<button
 				type="button"
 				className={styles.secondaryBtn}
diff --git a/src/components/ai-edition/VirtualPreview.audio.test.ts b/src/components/ai-edition/VirtualPreview.audio.test.ts
index d87e65816a..f8fc87cb96 100644
--- a/src/components/ai-edition/VirtualPreview.audio.test.ts
+++ b/src/components/ai-edition/VirtualPreview.audio.test.ts
@@ -142,6 +142,38 @@ describe("applyPreviewAudioSettings", () => {
 		applyPreviewAudioSettings(null, [element], 0, 6.0206);
 		expect(element.volume).toBe(1);
 	});
+
+	it("mutes routed and direct-output recording elements without changing output gain", () => {
+		const graph = fakeGraph();
+		const primary = { volume: 0.2 } as HTMLAudioElement;
+		const supplemental = { volume: 0.2 } as HTMLAudioElement;
+		const directFallback = { volume: 0.2 } as HTMLAudioElement;
+		const fallbackGain = { gain: { value: 1 } } as GainNode;
+		applyPreviewAudioSettings(
+			graph,
+			[primary, supplemental, directFallback],
+			6.0206,
+			9.5424,
+			true,
+			{
+				routedElements: new Set([primary, supplemental]),
+				fallbackGainNodes: new Map([[supplemental, fallbackGain]]),
+			},
+		);
+
+		expect(graph.gain.gain.value).toBeCloseTo(2, 3);
+		expect(graph.voice.gain.value).toBe(0);
+		expect(primary.volume).toBe(1);
+		expect(supplemental.volume).toBe(1);
+		expect(fallbackGain.gain.value).toBe(0);
+		expect(directFallback.volume).toBe(0);
+	});
+
+	it("silences newly mounted direct-output sources before WebAudio is available", () => {
+		const element = { volume: 1 } as HTMLAudioElement;
+		applyPreviewAudioSettings(null, [element], 6.0206, 9.5424, true);
+		expect(element.volume).toBe(0);
+	});
 });
 
 describe("previewCeilingCurve", () => {
diff --git a/src/components/ai-edition/VirtualPreview.playback.test.tsx b/src/components/ai-edition/VirtualPreview.playback.test.tsx
index c2be743922..019b7a1b6d 100644
--- a/src/components/ai-edition/VirtualPreview.playback.test.tsx
+++ b/src/components/ai-edition/VirtualPreview.playback.test.tsx
@@ -2,7 +2,13 @@
 import "@testing-library/jest-dom";
 import { act, cleanup, fireEvent, render } from "@testing-library/react";
 import { afterEach, beforeEach, describe, expect, it, vi } from "vitest";
-import type { AxcutClip, AxcutTrimRange } from "@/lib/ai-edition/schema";
+import type {
+	AxcutAudioTrack,
+	AxcutClip,
+	AxcutDocument,
+	AxcutTrimRange,
+} from "@/lib/ai-edition/schema";
+import { useProjectStore } from "@/lib/ai-edition/store/projectStore";
 import type { SpeedRegion } from "@/lib/ai-edition/timeline/speed";
 import { type VideoSource, VirtualPreview } from "./VirtualPreview";
 
@@ -13,6 +19,7 @@ let frameCallbacks: FrameRequestCallback[] = [];
 
 beforeEach(() => {
 	frameCallbacks = [];
+	useProjectStore.setState({ document: null, projectId: null });
 	vi.stubGlobal("requestAnimationFrame", (cb: FrameRequestCallback) => {
 		frameCallbacks.push(cb);
 		return frameCallbacks.length;
@@ -25,6 +32,7 @@ beforeEach(() => {
 
 afterEach(() => {
 	cleanup();
+	useProjectStore.setState({ document: null, projectId: null });
 	vi.unstubAllGlobals();
 });
 
@@ -307,7 +315,7 @@ describe("VirtualPreview imported audio tracks", () => {
 // in the export. `element.volume` caps at 1, so the boost has to ride a WebAudio gain node.
 // jsdom has no WebAudio, so install a minimal fake context and watch the nodes it mints.
 class FakeAudioNode {
-	connect = vi.fn();
+	connect = vi.fn((_destination?: unknown) => undefined);
 	disconnect = vi.fn();
 }
 class FakeGainNode extends FakeAudioNode {
@@ -315,21 +323,55 @@ class FakeGainNode extends FakeAudioNode {
 }
 let createdGains: FakeGainNode[] = [];
 let createdShapers: Array<FakeAudioNode & { curve: Float32Array | null }> = [];
+let voiceGainNodes = new Set<FakeGainNode>();
+let failSourceCreationFor = new Set<string>();
+let failVoiceConnectionFor = new Set<string>();
+let failAnalyserConnectionFor = new Set<string>();
+let sourceAttempts: Array<{ testId: string; src: string; volume: number }> = [];
+let createdSources: Array<{ testId: string; source: FakeAudioNode }> = [];
 class FakeAudioContext {
 	state = "running";
 	destination = new FakeAudioNode();
+	private gainNodes: FakeGainNode[] = [];
+	private analyserNode: FakeAudioNode | null = null;
 	resume = vi.fn(() => Promise.resolve());
 	close = vi.fn(() => Promise.resolve());
-	createMediaElementSource = vi.fn(() => new FakeAudioNode());
+	createMediaElementSource = vi.fn((element: HTMLAudioElement) => {
+		const testId = element.getAttribute("data-testid") ?? "";
+		sourceAttempts.push({ testId, src: element.src, volume: element.volume });
+		if (failSourceCreationFor.has(testId)) throw new Error("source creation failed");
+		const source = new FakeAudioNode();
+		createdSources.push({ testId, source });
+		if (failVoiceConnectionFor.has(testId) || failAnalyserConnectionFor.has(testId)) {
+			source.connect.mockImplementation((destination) => {
+				if (failVoiceConnectionFor.has(testId) && destination === this.gainNodes[2]) {
+					throw new Error("voice connection failed");
+				}
+				if (failAnalyserConnectionFor.has(testId) && destination instanceof FakeGainNode) {
+					destination.connect.mockImplementation((output) => {
+						if (output === this.analyserNode) throw new Error("analyser connection failed");
+					});
+				}
+			});
+		}
+		return source;
+	});
 	createGain = vi.fn(() => {
 		const node = new FakeGainNode();
+		this.gainNodes.push(node);
+		if (this.gainNodes.length === 3) voiceGainNodes.add(node);
 		createdGains.push(node);
 		return node;
 	});
 	// The music ducker listens to the voice; silence here, so nothing ducks.
-	createAnalyser = vi.fn(() =>
-		Object.assign(new FakeAudioNode(), { fftSize: 2048, getFloatTimeDomainData: vi.fn() }),
-	);
+	createAnalyser = vi.fn(() => {
+		const node = Object.assign(new FakeAudioNode(), {
+			fftSize: 2048,
+			getFloatTimeDomainData: vi.fn(),
+		});
+		this.analyserNode = node;
+		return node;
+	});
 	createWaveShaper = vi.fn(() => {
 		const node = Object.assign(new FakeAudioNode(), { curve: null });
 		createdShapers.push(node);
@@ -341,6 +383,12 @@ describe("VirtualPreview imported audio track boost", () => {
 	beforeEach(() => {
 		createdGains = [];
 		createdShapers = [];
+		voiceGainNodes = new Set();
+		failSourceCreationFor = new Set();
+		failVoiceConnectionFor = new Set();
+		failAnalyserConnectionFor = new Set();
+		sourceAttempts = [];
+		createdSources = [];
 		vi.stubGlobal("AudioContext", FakeAudioContext);
 	});
 
@@ -416,6 +464,191 @@ describe("VirtualPreview imported audio track boost", () => {
 			expect(gain.connect).not.toHaveBeenCalledWith(speakers);
 		}
 	});
+
+	it("mutes only the recording when source creation and connection fail independently", async () => {
+		useProjectStore.setState({
+			document: { legacyEditor: { recordingAudioMuted: true } } as unknown as AxcutDocument,
+		});
+		failSourceCreationFor.add("preview-audio-primary");
+		failVoiceConnectionFor.add("preview-audio-supplemental");
+		const music: AxcutAudioTrack = {
+			id: "music-track",
+			assetId: "music",
+			kind: "music",
+			startMs: 0,
+			endMs: 4000,
+			durationSec: 10,
+			offsetMs: 0,
+			gainDb: 6.0206,
+			loop: false,
+			fadeInMs: 0,
+			fadeOutMs: 0,
+			muted: false,
+			label: "",
+			origin: "user",
+		};
+		const voiceover: AxcutAudioTrack = {
+			...music,
+			id: "voiceover-track",
+			assetId: "voiceover",
+			kind: "voiceover",
+			gainDb: 3,
+		};
+		window.electronAPI = {
+			preparePreviewAudioTrack: vi.fn(async (path: string) => ({
+				success: true,
+				path: `${path}.mic.wav`,
+			})),
+		} as unknown as Window["electronAPI"];
+		const videoSources: VideoSource[] = [
+			{
+				id: "a1",
+				src: "file:///tmp/a1.mp4",
+				filePath: "/tmp/a1.mp4",
+				label: "recording",
+			},
+		];
+		const audioSources: VideoSource[] = [
+			{ id: "music", src: "file:///tmp/music.mp3", label: "music" },
+			{ id: "voiceover", src: "file:///tmp/voiceover.mp3", label: "voiceover" },
+		];
+		const { container } = render(
+			<VirtualPreview
+				videoSources={videoSources}
+				audioTracks={[music, voiceover]}
+				audioSources={audioSources}
+				clips={[clip("c1", "a1", 0, 4, 0)]}
+				onTimeChange={vi.fn()}
+			/>,
+		);
+		const primary = container.querySelector<HTMLAudioElement>(
+			"[data-testid='preview-audio-primary']",
+		);
+		if (!primary) throw new Error("no primary recording audio element");
+		const video = container.querySelector("video");
+		if (!video) throw new Error("no preview video");
+		driveVideo(video as HTMLVideoElement);
+		act(() => fireEvent.loadedMetadata(video));
+		await act(async () => {
+			await Promise.resolve();
+			await Promise.resolve();
+		});
+
+		const supplemental = container.querySelector<HTMLAudioElement>(
+			"[data-testid='preview-audio-supplemental']",
+		);
+		if (!supplemental) throw new Error("no supplemental recording audio element");
+		for (const id of ["music-track", "voiceover-track"]) {
+			const audio = container.querySelector<HTMLAudioElement>(
+				`[data-testid='preview-audio-track-${id}']`,
+			);
+			if (!audio) throw new Error(`no imported audio element for ${id}`);
+			driveAudioEl(audio);
+		}
+		tick();
+
+		expect(primary.volume).toBe(0);
+		expect(supplemental.volume).toBe(1);
+		expect([...voiceGainNodes][0]?.gain.value).toBe(0);
+		const supplementalSource = createdSources.find(
+			(entry) => entry.testId === "preview-audio-supplemental",
+		)?.source;
+		const fallbackGain = supplementalSource?.connect.mock.calls.at(-1)?.[0] as
+			| FakeGainNode
+			| undefined;
+		expect(fallbackGain?.gain.value).toBe(0);
+		for (const testId of [
+			"preview-audio-track-music-track",
+			"preview-audio-track-voiceover-track",
+		]) {
+			const source = createdSources.find((entry) => entry.testId === testId)?.source;
+			const trackGain = source?.connect.mock.calls.at(-1)?.[0] as FakeGainNode | undefined;
+			expect(trackGain?.gain.value).toBeGreaterThan(0);
+		}
+	});
+
+	it("remounts a new recording source muted before its graph route is ready", async () => {
+		useProjectStore.setState({
+			document: { legacyEditor: { recordingAudioMuted: true } } as unknown as AxcutDocument,
+		});
+		window.electronAPI = {
+			preparePreviewAudioTrack: vi.fn(async (path: string) => ({
+				success: true,
+				path: `${path}.mic.wav`,
+			})),
+		} as unknown as Window["electronAPI"];
+		const videoSources: VideoSource[] = [
+			{ id: "a1", src: "file:///tmp/a1.mp4", filePath: "/tmp/a1.mp4", label: "first" },
+			{ id: "a2", src: "file:///tmp/a2.mp4", filePath: "/tmp/a2.mp4", label: "second" },
+		];
+		const clips = [clip("c1", "a1", 0, 4, 0), clip("c2", "a2", 0, 4, 4)];
+		const view = render(
+			<VirtualPreview videoSources={videoSources} clips={clips} onTimeChange={vi.fn()} />,
+		);
+		await act(async () => {
+			await Promise.resolve();
+			await Promise.resolve();
+		});
+		expect(sourceAttempts.find((attempt) => attempt.src.includes("a1.mp4"))?.volume).toBe(0);
+
+		failSourceCreationFor.add("preview-audio-primary");
+		await act(async () => {
+			view.rerender(
+				<VirtualPreview
+					videoSources={videoSources}
+					clips={clips}
+					seekTarget={{ timeSec: 6, requestId: 1 }}
+					onTimeChange={vi.fn()}
+				/>,
+			);
+			await Promise.resolve();
+			await Promise.resolve();
+		});
+		const activePrimary = view.container.querySelector<HTMLAudioElement>(
+			"[data-testid='preview-audio-primary']",
+		);
+		if (!activePrimary) throw new Error("no remounted primary recording audio element");
+		expect(activePrimary.src).toContain("a2.mp4");
+		expect(sourceAttempts.find((attempt) => attempt.src.includes("a2.mp4"))?.volume).toBe(0);
+		expect(activePrimary.volume).toBe(0);
+	});
+
+	it("disconnects a partial fallback when the analyser route fails after output connects", async () => {
+		useProjectStore.setState({
+			document: { legacyEditor: { recordingAudioMuted: true } } as unknown as AxcutDocument,
+		});
+		failVoiceConnectionFor.add("preview-audio-primary");
+		failAnalyserConnectionFor.add("preview-audio-primary");
+		const videoSources: VideoSource[] = [
+			{ id: "a1", src: "file:///tmp/a1.mp4", filePath: "/tmp/a1.mp4", label: "recording" },
+		];
+		const { container } = render(
+			<VirtualPreview
+				videoSources={videoSources}
+				clips={[clip("c1", "a1", 0, 4, 0)]}
+				onTimeChange={vi.fn()}
+			/>,
+		);
+		const video = container.querySelector("video");
+		if (!video) throw new Error("no preview video");
+		driveVideo(video as HTMLVideoElement);
+		act(() => fireEvent.loadedMetadata(video));
+		await act(async () => {
+			await Promise.resolve();
+			await Promise.resolve();
+		});
+
+		const source = createdSources.find((entry) => entry.testId === "preview-audio-primary")?.source;
+		if (!source) throw new Error("no primary recording source");
+		const fallbackGain = source.connect.mock.calls.at(-1)?.[0] as FakeGainNode | undefined;
+		if (!fallbackGain) throw new Error("no source-only fallback gain");
+		expect(fallbackGain.connect.mock.results.map((result) => result.type)).toEqual([
+			"return",
+			"throw",
+		]);
+		expect(fallbackGain.disconnect).toHaveBeenCalled();
+		expect(source.disconnect.mock.calls.length).toBeGreaterThanOrEqual(3);
+	});
 });
 
 // The recording's sound is a second element over the same file: a muted <video> is the clock
diff --git a/src/components/ai-edition/VirtualPreview.tsx b/src/components/ai-edition/VirtualPreview.tsx
index 4e4ec9e550..664bf9d88a 100644
--- a/src/components/ai-edition/VirtualPreview.tsx
+++ b/src/components/ai-edition/VirtualPreview.tsx
@@ -355,6 +355,13 @@ export interface PreviewAudioGraph {
 	ceiling: WaveShaperNode;
 }
 
+export interface PreviewRecordingAudioRouting {
+	/** Elements connected to the recording-only voice path or its source fallback. */
+	routedElements: ReadonlySet<HTMLAudioElement>;
+	/** Source nodes that need an individual fallback gain instead of `graph.voice`. */
+	fallbackGainNodes: ReadonlyMap<HTMLAudioElement, GainNode>;
+}
+
 /** The export limiter's ceiling, `LIMITER_CEILING` in audio.rs: −1.5 dBFS. */
 export const PREVIEW_AUDIO_CEILING = 0.841_395_1;
 /** Loudest mix the ceiling stage reads, as a multiple of full scale: +24 dB, a full-scale file
@@ -414,17 +421,34 @@ export function applyPreviewAudioSettings(
 	elements: Array<HTMLAudioElement | null>,
 	gainDb: number,
 	voiceGainDb = 0,
+	recordingAudioMuted = false,
+	routing?: PreviewRecordingAudioRouting,
 ): void {
 	const outputGain = audioGainScalar(gainDb);
 	const voiceGain = audioGainScalar(voiceGainDb);
 	if (!graph) {
 		for (const element of elements) {
-			if (element) element.volume = Math.min(1, outputGain * voiceGain);
+			if (element) element.volume = recordingAudioMuted ? 0 : Math.min(1, outputGain * voiceGain);
 		}
 		return;
 	}
 	graph.gain.gain.value = outputGain;
-	graph.voice.gain.value = voiceGain;
+	graph.voice.gain.value = recordingAudioMuted ? 0 : voiceGain;
+	if (routing) {
+		for (const element of elements) {
+			if (!element) continue;
+			const fallbackGain = routing.fallbackGainNodes.get(element);
+			if (fallbackGain) {
+				element.volume = 1;
+				fallbackGain.gain.value = recordingAudioMuted ? 0 : voiceGain;
+			} else if (!routing.routedElements.has(element)) {
+				// A failed source-node creation leaves this element on direct output.
+				element.volume = recordingAudioMuted ? 0 : Math.min(1, outputGain * voiceGain);
+			} else {
+				element.volume = 1;
+			}
+		}
+	}
 }
 
 /** First clip (by timeline order) starting strictly after `afterTimelineStartSec` —
@@ -537,6 +561,8 @@ export function VirtualPreview({
 	useEffect(() => {
 		audioGainDbRef.current = settings.audioGainDb;
 	}, [settings.audioGainDb]);
+	const recordingAudioMutedRef = useRef(settings.recordingAudioMuted);
+	recordingAudioMutedRef.current = settings.recordingAudioMuted;
 	const audioContextRef = useRef<AudioContext | null>(null);
 	const audioContextCloseTimerRef = useRef<ReturnType<typeof setTimeout> | null>(null);
 	const audioSourceNodesRef = useRef(new WeakMap<HTMLAudioElement, MediaElementAudioSourceNode>());
@@ -546,6 +572,9 @@ export function VirtualPreview({
 	// their lifecycle; the map is cleared and rebuilt whenever the routing is torn down.
 	const audioTrackGainNodesRef = useRef<Map<string, GainNode>>(new Map());
 	const audioGraphRef = useRef<PreviewAudioGraph | null>(null);
+	const recordingAudioRoutingRef = useRef<
+		(PreviewRecordingAudioRouting & { graph: PreviewAudioGraph }) | null
+	>(null);
 	const videoFrameRef = useRef<HTMLDivElement | null>(null);
 
 	const isProgrammaticSeekRef = useRef(false);
@@ -719,14 +748,26 @@ export function VirtualPreview({
 		if (!graph) {
 			// WebAudio can be unavailable in unit tests or under a denied audio policy. No source
 			// node was created, so `volume` still reaches the output — capped at 0 dB.
-			applyPreviewAudioSettings(null, elements, audioGainDbRef.current, voiceGainDbRef.current);
+			audioGraphRef.current = null;
+			recordingAudioRoutingRef.current = null;
+			applyPreviewAudioSettings(
+				null,
+				elements,
+				audioGainDbRef.current,
+				voiceGainDbRef.current,
+				recordingAudioMutedRef.current,
+			);
 			return;
 		}
 
 		const connectedSources: MediaElementAudioSourceNode[] = [];
+		const voiceFallbackGainNodes: GainNode[] = [];
+		const routedElements = new Set<HTMLAudioElement>();
+		const fallbackGainNodes = new Map<HTMLAudioElement, GainNode>();
 		for (const element of elements) {
+			let source: MediaElementAudioSourceNode | undefined;
 			try {
-				let source = audioSourceNodesRef.current.get(element);
+				source = audioSourceNodesRef.current.get(element);
 				if (!source) {
 					source = graph.context.createMediaElementSource(element);
 					audioSourceNodesRef.current.set(element, source);
@@ -734,11 +775,41 @@ export function VirtualPreview({
 				source.disconnect();
 				source.connect(graph.voice);
 				connectedSources.push(source);
+				routedElements.add(element);
 			} catch {
-				// Routing THIS element failed; leave the others alone. Once
-				// createMediaElementSource has run for an element its audio no longer reaches
-				// the default output, so tearing the whole graph down here would mute the
-				// preview outright rather than degrade it.
+				// Routing THIS element failed; leave the others alone. A created source no longer
+				// reaches the default output, so give it a source-only fallback node. A source
+				// creation failure leaves the element on direct output and uses `volume` below.
+				if (source) {
+					if (!connectedSources.includes(source)) connectedSources.push(source);
+					let fallbackGain: GainNode | undefined;
+					try {
+						source.disconnect();
+						fallbackGain = graph.context.createGain();
+						// Keep a partially connected fallback silent until every required route succeeds.
+						fallbackGain.gain.value = 0;
+						source.connect(fallbackGain);
+						fallbackGain.connect(graph.gain);
+						fallbackGain.connect(graph.analyser);
+						fallbackGainNodes.set(element, fallbackGain);
+						voiceFallbackGainNodes.push(fallbackGain);
+						routedElements.add(element);
+					} catch {
+						// A route may have connected to output before another connection failed. Remove
+						// every partial path so it cannot bypass the recording mute.
+						try {
+							fallbackGain?.disconnect();
+						} catch {
+							// The gain starts at zero, so a failed disconnect remains silent.
+						}
+						try {
+							source.disconnect();
+						} catch {
+							// Keep the element off direct output as a final safeguard.
+						}
+						routedElements.add(element);
+					}
+				}
 			}
 		}
 		// Imported tracks (issue #350): each mounted element gets source → per-track gain →
@@ -772,11 +843,22 @@ export function VirtualPreview({
 			}
 		}
 		audioGraphRef.current = graph;
-		applyPreviewAudioSettings(graph, elements, audioGainDbRef.current, voiceGainDbRef.current);
+		const routing = { graph, routedElements, fallbackGainNodes };
+		recordingAudioRoutingRef.current = routing;
+		applyPreviewAudioSettings(
+			graph,
+			elements,
+			audioGainDbRef.current,
+			voiceGainDbRef.current,
+			recordingAudioMutedRef.current,
+			routing,
+		);
 		return () => {
 			audioGraphRef.current = null;
+			recordingAudioRoutingRef.current = null;
 			for (const source of connectedSources) source.disconnect();
 			for (const trackGain of trackGainNodes) trackGain.disconnect();
+			for (const fallbackGain of voiceFallbackGainNodes) fallbackGain.disconnect();
 			audioTrackGainNodesRef.current = new Map();
 			graph.voice.disconnect();
 			graph.analyser.disconnect();
@@ -820,20 +902,42 @@ export function VirtualPreview({
 	}, []);
 
 	useEffect(() => {
+		const graph = audioGraphRef.current;
+		const routing = recordingAudioRoutingRef.current;
 		applyPreviewAudioSettings(
-			audioGraphRef.current,
+			graph,
 			[primaryAudioRef.current, supplementalAudioRef.current],
 			settings.audioGainDb,
 			voiceGainDb,
+			settings.recordingAudioMuted,
+			routing?.graph === graph ? routing : undefined,
 		);
-	}, [settings.audioGainDb, voiceGainDb]);
+	}, [settings.audioGainDb, settings.recordingAudioMuted, voiceGainDb]);
 
 	const setPrimaryAudioElement = useCallback((element: HTMLAudioElement | null) => {
 		primaryAudioRef.current = element;
+		if (element) {
+			applyPreviewAudioSettings(
+				null,
+				[element],
+				audioGainDbRef.current,
+				voiceGainDbRef.current,
+				recordingAudioMutedRef.current,
+			);
+		}
 		setPrimaryAudioEl(element);
 	}, []);
 	const setSupplementalAudioElement = useCallback((element: HTMLAudioElement | null) => {
 		supplementalAudioRef.current = element;
+		if (element) {
+			applyPreviewAudioSettings(
+				null,
+				[element],
+				audioGainDbRef.current,
+				voiceGainDbRef.current,
+				recordingAudioMutedRef.current,
+			);
+		}
 		setSupplementalAudioEl(element);
 	}, []);
 
diff --git a/src/i18n/locales/ar/settings.json b/src/i18n/locales/ar/settings.json
index 0810409f12..e0485f2bd7 100644
--- a/src/i18n/locales/ar/settings.json
+++ b/src/i18n/locales/ar/settings.json
@@ -387,6 +387,8 @@
 		}
 	},
 	"audio": {
+		"muteRecording": "كتم صوت التسجيل",
+		"muteRecordingHelp": "يكتم الصوت الأصلي للتسجيل في المعاينة والتصدير. تظل الموسيقى والتعليقات الصوتية المستوردة مسموعة.",
 		"outputGain": "ضبط مستوى الإخراج",
 		"help": "تُضبط الأصوات تلقائيًا على مستوى جهارة قياسي. اضبط مستوى الإخراج انطلاقًا منه؛ يُطبَّق بالطريقة نفسها في المعاينة وعند التصدير.",
 		"reset": "إعادة ضبط الصوت",
diff --git a/src/i18n/locales/cs/settings.json b/src/i18n/locales/cs/settings.json
index 80eb9b2687..7b1935799c 100644
--- a/src/i18n/locales/cs/settings.json
+++ b/src/i18n/locales/cs/settings.json
@@ -387,6 +387,8 @@
 		}
 	},
 	"audio": {
+		"muteRecording": "Ztlumit zvuk nahrávky",
+		"muteRecordingHelp": "Ztlumí původní zvuk nahrávky v náhledu i exportu. Importovaná hudba a komentář zůstanou slyšet.",
 		"outputGain": "Výstupní úroveň",
 		"help": "Hlas se automaticky vyrovná na standardní hlasitost. Výstupní úroveň upravte od ní; aplikuje se stejně v náhledu i při exportu.",
 		"reset": "Obnovit zvuk",
diff --git a/src/i18n/locales/de/settings.json b/src/i18n/locales/de/settings.json
index 715d3c9bb9..51f17181aa 100644
--- a/src/i18n/locales/de/settings.json
+++ b/src/i18n/locales/de/settings.json
@@ -387,6 +387,8 @@
 		}
 	},
 	"audio": {
+		"muteRecording": "Aufnahmeton stummschalten",
+		"muteRecordingHelp": "Schaltet den Originalton der Aufnahme in Vorschau und Export stumm. Importierte Musik und Sprachaufnahmen bleiben hörbar.",
 		"outputGain": "Ausgangspegel",
 		"help": "Stimmen werden automatisch auf eine Standardlautheit gebracht. Passe den Ausgangspegel davon ausgehend an; er gilt in der Vorschau und im Export identisch.",
 		"reset": "Audio zurücksetzen",
diff --git a/src/i18n/locales/en/settings.json b/src/i18n/locales/en/settings.json
index be8b13a694..4e620102ca 100644
--- a/src/i18n/locales/en/settings.json
+++ b/src/i18n/locales/en/settings.json
@@ -387,6 +387,8 @@
 		}
 	},
 	"audio": {
+		"muteRecording": "Mute recording audio",
+		"muteRecordingHelp": "Mutes the original recording in preview and exports. Imported music and voiceover remain audible.",
 		"outputGain": "Output level",
 		"help": "Voices are levelled to a standard loudness automatically. Adjust the output level from there; it applies identically in the preview and the export.",
 		"reset": "Reset audio",
diff --git a/src/i18n/locales/es/settings.json b/src/i18n/locales/es/settings.json
index f9efcfab37..474f73a316 100644
--- a/src/i18n/locales/es/settings.json
+++ b/src/i18n/locales/es/settings.json
@@ -387,6 +387,8 @@
 		}
 	},
 	"audio": {
+		"muteRecording": "Silenciar audio de la grabación",
+		"muteRecordingHelp": "Silencia el sonido original de la grabación en la vista previa y las exportaciones. La música y la voz en off importadas siguen sonando.",
 		"outputGain": "Ajuste de salida",
 		"help": "Las voces se nivelan automáticamente a una sonoridad estándar. Ajusta el nivel de salida a partir de ahí; se aplica igual en la vista previa y en la exportación.",
 		"reset": "Restablecer audio",
diff --git a/src/i18n/locales/fr/settings.json b/src/i18n/locales/fr/settings.json
index cbd0536996..f3c8c298a6 100644
--- a/src/i18n/locales/fr/settings.json
+++ b/src/i18n/locales/fr/settings.json
@@ -387,6 +387,8 @@
 		}
 	},
 	"audio": {
+		"muteRecording": "Couper le son de l enregistrement",
+		"muteRecordingHelp": "Coupe le son original de l enregistrement dans l aperçu et les exports. La musique et la voix off importées restent audibles.",
 		"outputGain": "Niveau de sortie",
 		"help": "Les voix sont automatiquement ramenées à une sonie standard. Ajustez le niveau de sortie à partir de là ; il s’applique à l’identique dans l’aperçu et à l’export.",
 		"reset": "Réinitialiser l’audio",
diff --git a/src/i18n/locales/it/settings.json b/src/i18n/locales/it/settings.json
index fd37547e2f..d2f82c8ef4 100644
--- a/src/i18n/locales/it/settings.json
+++ b/src/i18n/locales/it/settings.json
@@ -387,6 +387,8 @@
 		}
 	},
 	"audio": {
+		"muteRecording": "Disattiva audio registrazione",
+		"muteRecordingHelp": "Disattiva l audio originale della registrazione nell anteprima e nelle esportazioni. La musica e il voiceover importati restano udibili.",
 		"outputGain": "Livello di uscita",
 		"help": "Le voci vengono livellate automaticamente a un volume percepito standard. Regola il livello di uscita a partire da lì; si applica allo stesso modo nell’anteprima e nell’esportazione.",
 		"reset": "Reimposta audio",
diff --git a/src/i18n/locales/ja-JP/settings.json b/src/i18n/locales/ja-JP/settings.json
index 3b88112567..839430ace0 100644
--- a/src/i18n/locales/ja-JP/settings.json
+++ b/src/i18n/locales/ja-JP/settings.json
@@ -387,6 +387,8 @@
 		}
 	},
 	"audio": {
+		"muteRecording": "録画音声をミュート",
+		"muteRecordingHelp": "プレビューと書き出しで録画の元の音声をミュートします。読み込んだ音楽やナレーションは再生されます。",
 		"outputGain": "出力レベル",
 		"help": "音声は標準のラウドネスに自動で揃えられます。そこから出力レベルを調整してください。プレビューと書き出しで同じように適用されます。",
 		"reset": "オーディオをリセット",
diff --git a/src/i18n/locales/ko-KR/settings.json b/src/i18n/locales/ko-KR/settings.json
index c464581da8..315cea631a 100644
--- a/src/i18n/locales/ko-KR/settings.json
+++ b/src/i18n/locales/ko-KR/settings.json
@@ -387,6 +387,8 @@
 		}
 	},
 	"audio": {
+		"muteRecording": "녹화 오디오 음소거",
+		"muteRecordingHelp": "미리보기와 내보내기에서 녹화 원본 오디오를 음소거합니다. 가져온 음악과 내레이션은 계속 재생됩니다.",
 		"outputGain": "출력 레벨",
 		"help": "음성은 표준 라우드니스로 자동 조정됩니다. 거기서부터 출력 레벨을 조정하세요. 미리보기와 내보내기에 동일하게 적용됩니다.",
 		"reset": "오디오 재설정",
diff --git a/src/i18n/locales/pt-BR/settings.json b/src/i18n/locales/pt-BR/settings.json
index 53a4c89de0..d1b63388ee 100644
--- a/src/i18n/locales/pt-BR/settings.json
+++ b/src/i18n/locales/pt-BR/settings.json
@@ -387,6 +387,8 @@
 		}
 	},
 	"audio": {
+		"muteRecording": "Silenciar áudio da gravação",
+		"muteRecordingHelp": "Silencia o áudio original da gravação na prévia e nas exportações. Músicas e narrações importadas continuam audíveis.",
 		"outputGain": "Nível de saída",
 		"help": "As vozes são niveladas automaticamente a uma loudness padrão. Ajuste o nível de saída a partir daí; ele se aplica da mesma forma na prévia e na exportação.",
 		"reset": "Redefinir áudio",
diff --git a/src/i18n/locales/ru/settings.json b/src/i18n/locales/ru/settings.json
index 08c1a76c9d..3b6276735f 100644
--- a/src/i18n/locales/ru/settings.json
+++ b/src/i18n/locales/ru/settings.json
@@ -387,6 +387,8 @@
 		}
 	},
 	"audio": {
+		"muteRecording": "Отключить звук записи",
+		"muteRecordingHelp": "Отключает исходный звук записи в предпросмотре и экспорте. Импортированная музыка и озвучка остаются слышны.",
 		"outputGain": "Уровень выхода",
 		"help": "Голос автоматически выравнивается до стандартной громкости. Настройте уровень выхода относительно неё; он одинаково применяется в предпросмотре и при экспорте.",
 		"reset": "Сбросить аудио",
diff --git a/src/i18n/locales/tr/settings.json b/src/i18n/locales/tr/settings.json
index 2f3fd2c676..d91ffb99c2 100644
--- a/src/i18n/locales/tr/settings.json
+++ b/src/i18n/locales/tr/settings.json
@@ -387,6 +387,8 @@
 		}
 	},
 	"audio": {
+		"muteRecording": "Kayıt sesini kapat",
+		"muteRecordingHelp": "Önizleme ve dışa aktarmada kaydın özgün sesini kapatır. İçe aktarılan müzik ve seslendirme çalmaya devam eder.",
 		"outputGain": "Çıkış seviyesi",
 		"help": "Sesler otomatik olarak standart bir ses yüksekliğine getirilir. Çıkış seviyesini buradan ayarlayın; önizlemede ve dışa aktarmada aynı şekilde uygulanır.",
 		"reset": "Sesi sıfırla",
diff --git a/src/i18n/locales/vi/settings.json b/src/i18n/locales/vi/settings.json
index ece372040f..0432cc3862 100644
--- a/src/i18n/locales/vi/settings.json
+++ b/src/i18n/locales/vi/settings.json
@@ -387,6 +387,8 @@
 		}
 	},
 	"audio": {
+		"muteRecording": "Tắt tiếng âm thanh bản ghi",
+		"muteRecordingHelp": "Tắt tiếng gốc của bản ghi trong bản xem trước và khi xuất. Nhạc và lời thuyết minh đã nhập vẫn phát.",
 		"outputGain": "Mức đầu ra",
 		"help": "Giọng nói được tự động cân bằng về độ lớn tiêu chuẩn. Hãy điều chỉnh mức đầu ra từ đó; nó được áp dụng giống hệt nhau trong bản xem trước và khi xuất.",
 		"reset": "Đặt lại âm thanh",
diff --git a/src/i18n/locales/zh-CN/settings.json b/src/i18n/locales/zh-CN/settings.json
index 3aa4b4b485..0428b0e9ef 100644
--- a/src/i18n/locales/zh-CN/settings.json
+++ b/src/i18n/locales/zh-CN/settings.json
@@ -387,6 +387,8 @@
 		}
 	},
 	"audio": {
+		"muteRecording": "静音录制音频",
+		"muteRecordingHelp": "在预览和导出中静音原始录制音频。导入的音乐和旁白仍会播放。",
 		"outputGain": "输出电平",
 		"help": "人声会自动统一到标准响度。在此基础上调整输出电平；它在预览和导出中的效果完全一致。",
 		"reset": "重置音频",
diff --git a/src/i18n/locales/zh-TW/settings.json b/src/i18n/locales/zh-TW/settings.json
index f33f5439d9..7738664117 100644
--- a/src/i18n/locales/zh-TW/settings.json
+++ b/src/i18n/locales/zh-TW/settings.json
@@ -387,6 +387,8 @@
 		}
 	},
 	"audio": {
+		"muteRecording": "靜音錄製音訊",
+		"muteRecordingHelp": "在預覽和匯出中靜音原始錄製音訊。匯入的音樂和旁白仍會播放。",
 		"outputGain": "輸出音量",
 		"help": "人聲會自動統一到標準響度。在此基礎上調整輸出音量；它在預覽與匯出中的效果完全一致。",
 		"reset": "重設音訊",
diff --git a/src/lib/ai-edition/store/editorSettings.test.ts b/src/lib/ai-edition/store/editorSettings.test.ts
index 7acecab2a9..5a3676ed7a 100644
--- a/src/lib/ai-edition/store/editorSettings.test.ts
+++ b/src/lib/ai-edition/store/editorSettings.test.ts
@@ -49,6 +49,7 @@ describe("getEditorSettings", () => {
 		expect(snap.webcamLayoutPreset).toBe(DEFAULT_WEBCAM_LAYOUT_PRESET);
 		expect(snap.webcamMaskShape).toBe(DEFAULT_WEBCAM_MASK_SHAPE);
 		expect(snap.cursor.size).toBe(DEFAULT_CURSOR_SIZE);
+		expect(snap.recordingAudioMuted).toBe(false);
 	});
 
 	it("reads every appearance number into its bound, whatever wrote it", () => {
@@ -147,6 +148,17 @@ describe("getEditorSettings", () => {
 });
 
 describe("patchEditorSettings", () => {
+	it("round-trips the recording-only mute setting through legacyEditor", () => {
+		expect(getEditorSettings(baseDoc).recordingAudioMuted).toBe(false);
+		const muted = patchEditorSettings(baseDoc, { recordingAudioMuted: true });
+		expect(muted.legacyEditor).toMatchObject({ recordingAudioMuted: true });
+		expect(getEditorSettings(muted).recordingAudioMuted).toBe(true);
+		expect(
+			getEditorSettings(patchEditorSettings(muted, { recordingAudioMuted: false }))
+				.recordingAudioMuted,
+		).toBe(false);
+	});
+
 	it("writes a single field and leaves others intact", () => {
 		const next = patchEditorSettings(baseDoc, { backgroundBlur: 0.5 });
 		const snap = getEditorSettings(next);
diff --git a/src/lib/ai-edition/store/editorSettings.ts b/src/lib/ai-edition/store/editorSettings.ts
index 2fc464ad6b..b9f3ae4662 100644
--- a/src/lib/ai-edition/store/editorSettings.ts
+++ b/src/lib/ai-edition/store/editorSettings.ts
@@ -123,6 +123,8 @@ export interface EditorSettingsSnapshot {
 	 *  Authoritative: `webcamCropRegion.x/y` are rebuilt from it on read. */
 	webcamCropPan: CropPan;
 	audioGainDb: number;
+	/** Mutes audio carried by the original recording, without muting imported tracks. */
+	recordingAudioMuted: boolean;
 	webcamBackgroundMode: WebcamBackgroundMode;
 	webcamWallpaper: string;
 	webcamBlurIntensity: number;
@@ -144,6 +146,7 @@ export const DEFAULT_EDITOR_SETTINGS: EditorSettingsSnapshot = {
 	webcamCropRegion: DEFAULT_CROP_REGION,
 	webcamCropPan: DEFAULT_CROP_PAN,
 	audioGainDb: 0,
+	recordingAudioMuted: false,
 	formatFollowCursor: null,
 };
 
@@ -176,6 +179,7 @@ interface LegacyShape {
 	webcamCropRegion?: CropRegion;
 	webcamCropPan?: CropPan;
 	audioGainDb?: number;
+	recordingAudioMuted?: boolean;
 	webcamBackgroundMode?: WebcamBackgroundMode;
 	webcamWallpaper?: string;
 	webcamBlurIntensity?: number;
@@ -319,6 +323,10 @@ export function getEditorSettings(doc: AxcutDocument | null | undefined): Editor
 			AUDIO_GAIN_DB_LIMIT,
 			Math.max(-AUDIO_GAIN_DB_LIMIT, num(legacy?.audioGainDb, 0)),
 		),
+		recordingAudioMuted: bool(
+			legacy?.recordingAudioMuted,
+			DEFAULT_EDITOR_SETTINGS.recordingAudioMuted,
+		),
 		webcamBackgroundMode: isWebcamBackgroundMode(legacy?.webcamBackgroundMode)
 			? legacy.webcamBackgroundMode
 			: DEFAULT_EDITOR_SETTINGS.webcamBackgroundMode,
@@ -364,6 +372,7 @@ export interface EditorSettingsPatch {
 	webcamCropRegion?: CropRegion;
 	webcamCropPan?: CropPan;
 	audioGainDb?: number;
+	recordingAudioMuted?: boolean;
 	webcamBackgroundMode?: WebcamBackgroundMode;
 	webcamWallpaper?: string;
 	webcamBlurIntensity?: number;
diff --git a/src/lib/ai-edition/store/useEditorSettings.test.ts b/src/lib/ai-edition/store/useEditorSettings.test.ts
index bb991aa1b1..a823fd7499 100644
--- a/src/lib/ai-edition/store/useEditorSettings.test.ts
+++ b/src/lib/ai-edition/store/useEditorSettings.test.ts
@@ -16,7 +16,7 @@ import type { AxcutDocument } from "../schema";
 import { axcutSchemaVersion } from "../schema";
 import { getEditorSettings } from "./editorSettings";
 import { useProjectStore } from "./projectStore";
-import { clearHistory, undo } from "./undo";
+import { clearHistory, redo, undo } from "./undo";
 import { past } from "./undoStack";
 import { useEditorSettings } from "./useEditorSettings";
 
@@ -118,6 +118,23 @@ describe("useEditorSettings drag snapshots", () => {
 		await expect(result.current.set({ borderRadius: 20 })).resolves.toBe(false);
 	});
 
+	it("persists recording audio mute as one undoable settings edit", async () => {
+		const { result } = renderHook(() => useEditorSettings());
+
+		await act(async () => {
+			await expect(result.current.set({ recordingAudioMuted: true })).resolves.toBe(true);
+		});
+		expect(getEditorSettings(useProjectStore.getState().document).recordingAudioMuted).toBe(true);
+		expect(bridgeMocks.save.mock.calls.at(-1)?.[0].legacyEditor).toMatchObject({
+			recordingAudioMuted: true,
+		});
+
+		act(() => expect(undo()).toBe(true));
+		expect(getEditorSettings(useProjectStore.getState().document).recordingAudioMuted).toBe(false);
+		act(() => expect(redo()).toBe(true));
+		expect(getEditorSettings(useProjectStore.getState().document).recordingAudioMuted).toBe(true);
+	});
+
 	it("does not record a snapshot of the project the user left", async () => {
 		const { result, rerender } = renderHook(() => useEditorSettings());
 
diff --git a/src/native/sceneDescription.test.ts b/src/native/sceneDescription.test.ts
index 0d84461b54..79badad04e 100644
--- a/src/native/sceneDescription.test.ts
+++ b/src/native/sceneDescription.test.ts
@@ -518,7 +518,7 @@ describe("buildSceneDescription.clips", () => {
 		expect(buildSceneDescription(doc).clips).toEqual([]);
 	});
 
-	it("sets hasAudio=true for a clip whose screen asset has an originalPath", () => {
+	it("defaults to audio for a clip whose screen asset has an originalPath", () => {
 		// ponytail: the rule is "screen recordings from this app always carry a decodable
 		// audio track" (per product convention + ffprobe on real recordings). The visibleClips
 		// filter above guarantees only clips with originalPath reach the producer, so every
@@ -536,6 +536,69 @@ describe("buildSceneDescription.clips", () => {
 		expect(buildSceneDescription(doc).clips[0].hasAudio).toBe(true);
 	});
 
+	it("mutes only the recording clip while preserving imported audio and click settings", async () => {
+		const asset = makeAsset({ id: "a", originalPath: "/screen.mp4" });
+		const music = makeAsset({ id: "music", kind: "audio", originalPath: "/music.mp3" });
+		const clip = makeClip({
+			id: "c1",
+			assetId: "a",
+			sourceStartSec: 0,
+			sourceEndSec: 4,
+			timelineStartSec: 0,
+			timelineEndSec: 4,
+		});
+		const track = {
+			id: "music-track",
+			assetId: "music",
+			kind: "music" as const,
+			startMs: 0,
+			endMs: 4000,
+			durationSec: 4,
+			offsetMs: 0,
+			gainDb: 3,
+			loop: false,
+			fadeInMs: 0,
+			fadeOutMs: 0,
+			muted: false,
+			label: "",
+			origin: "user" as const,
+		};
+		const doc = makeDoc({
+			assets: [asset, music],
+			clips: [clip],
+			audioTracks: [track],
+			legacyEditor: { recordingAudioMuted: true, cursorShow: true, cursorClickSound: true },
+		});
+		const click: CursorTelemetryPoint = {
+			timeMs: 2000,
+			cx: 0.5,
+			cy: 0.5,
+			interactionType: "click",
+		};
+		const telemetry = vi
+			.spyOn(nativeBridgeClient.cursor, "getTelemetry")
+			.mockResolvedValue([click]);
+		vi.stubGlobal("window", {
+			location: { href: "http://localhost/" },
+			electronAPI: {
+				stageClickSoundHit: async (name: string) => ({ success: true, path: `/sfx/${name}` }),
+			},
+		});
+		vi.stubGlobal("fetch", async () => new Response(new Uint8Array([1])));
+		try {
+			await prepareClickSound(doc);
+			const scene = buildSceneDescription(doc);
+
+			expect(scene.clips[0]?.hasAudio).toBe(false);
+			expect(scene.audioTracks).toHaveLength(1);
+			expect(scene.audioTracks[0]).toMatchObject({ path: "/music.mp3", gainDb: 3 });
+			expect(scene.clickSound?.hits).toHaveLength(2);
+		} finally {
+			telemetry.mockRestore();
+			vi.unstubAllGlobals();
+		}
+	});
+
 	it("sets hasAudio=true consistently across multiple clips in the same scene", () => {
 		const asset = makeAsset({ id: "a", originalPath: "/screen.mp4" });
 		const clip1 = makeClip({
diff --git a/src/native/sceneDescription.ts b/src/native/sceneDescription.ts
index 5cf2a8e5d5..6e5ac13684 100644
--- a/src/native/sceneDescription.ts
+++ b/src/native/sceneDescription.ts
@@ -960,17 +960,13 @@ export function buildSceneDescription(
 		return entries;
 	});
 	const visibleClips = resolveVisibleClips(document);
+	const recordingAudioMuted = getEditorSettings(document).recordingAudioMuted;
 	const clips: CompositorClipInput[] = visibleClips.flatMap((clip) => {
 		const asset = assetById.get(clip.assetId);
 		if (!asset?.originalPath) return [];
 		const camera = assetCameraSource(asset);
-		// ponytail: `asset.audio` exists in the schema but the probe pipeline never
-		// populates it, so there is no per-asset "is there a track?" signal to read
-		// yet. Every consumer downstream degrades on a stream-less file (audio.rs
-		// returns Ok(None)), so this stays optimistic. NOT "recordings always carry
-		// audio" — a capture made with no mic and no system audio has no audio
-		// stream at all (issue #348). Swap to `Boolean(asset.audio)` the day the
-		// probe fills it in.
+		// `asset.audio` is not populated by the probe yet, so keep the current
+		// optimistic default unless the project explicitly mutes its recording audio.
 		return [
 			{
 				screenPath: asset.originalPath,
@@ -978,7 +974,7 @@ export function buildSceneDescription(
 				sourceStartSec: clip.sourceStartSec,
 				sourceEndSec: resolveClipSourceEndSec(clip, asset),
 				webcamOffsetSec: camera.offsetSec,
-				hasAudio: true,
+				hasAudio: !recordingAudioMuted,
 				// A held segment has an empty source window and exists only for the frames it
 				// holds; every other clip holds nothing.
 			},

From 97e7939aff3cdd7e688994532b93ed7a29752635 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?=E8=B6=85=E8=B6=85=E8=B6=85=E8=B6=85=E8=B6=85=E7=BA=A7?=
 =?UTF-8?q?=E5=96=9C=E6=AC=A2=E4=BD=A0=E7=9A=84=E8=BE=BE=E5=A6=AE=E5=A8=85?=
 <176143450+My-Denia@users.noreply.github.com>
Date: Mon, 12 Oct 2026 22:40:21 +0800
Subject: [PATCH 2/4] fix: reset recording mute with audio settings

---
 .../ai-edition/RightPanes.audioPane.test.tsx  | 45 +++++++++++++++++++
 src/components/ai-edition/RightPanes.tsx      |  2 +-
 2 files changed, 46 insertions(+), 1 deletion(-)
 create mode 100644 src/components/ai-edition/RightPanes.audioPane.test.tsx

diff --git a/src/components/ai-edition/RightPanes.audioPane.test.tsx b/src/components/ai-edition/RightPanes.audioPane.test.tsx
new file mode 100644
index 0000000000..e55206192e
--- /dev/null
+++ b/src/components/ai-edition/RightPanes.audioPane.test.tsx
@@ -0,0 +1,45 @@
+// @vitest-environment jsdom
+import "@testing-library/jest-dom";
+import { cleanup, fireEvent, render, screen } from "@testing-library/react";
+import { afterEach, beforeEach, describe, expect, it, vi } from "vitest";
+import { I18nProvider } from "@/contexts/I18nContext";
+import { LOCALE_STORAGE_KEY } from "@/i18n/config";
+
+const { setSettings } = vi.hoisted(() => ({ setSettings: vi.fn() }));
+
+vi.mock("@/lib/ai-edition/store/useEditorSettings", () => ({
+	useEditorSettings: () => ({
+		settings: { audioGainDb: -6, recordingAudioMuted: true },
+		set: setSettings,
+		setLive: vi.fn(),
+		commit: vi.fn(),
+		hasDocument: true,
+	}),
+}));
+
+import { AudioPane } from "./RightPanes";
+
+beforeEach(() => {
+	localStorage.clear();
+	localStorage.setItem(LOCALE_STORAGE_KEY, "en");
+	setSettings.mockClear();
+});
+
+afterEach(() => {
+	cleanup();
+	localStorage.clear();
+});
+
+describe("AudioPane reset button", () => {
+	it("resets output gain and unmutes recording audio", () => {
+		render(
+			<I18nProvider>
+				<AudioPane />
+			</I18nProvider>,
+		);
+
+		fireEvent.click(screen.getByRole("button", { name: "Reset audio" }));
+
+		expect(setSettings).toHaveBeenCalledWith({ audioGainDb: 0, recordingAudioMuted: false });
+	});
+});
diff --git a/src/components/ai-edition/RightPanes.tsx b/src/components/ai-edition/RightPanes.tsx
index 7f4f55a050..cff4294439 100644
--- a/src/components/ai-edition/RightPanes.tsx
+++ b/src/components/ai-edition/RightPanes.tsx
@@ -3484,7 +3484,7 @@ export function AudioPane() {
 				type="button"
 				className={styles.secondaryBtn}
 				disabled={!hasDocument}
-				onClick={() => void set({ audioGainDb: 0 })}
+				onClick={() => void set({ audioGainDb: 0, recordingAudioMuted: false })}
 			>
 				{ts("audio.reset")}
 			</button>

From 326158c0f142148d072abd8cc8b2ac6ae4d52e7a Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?=E8=B6=85=E8=B6=85=E8=B6=85=E8=B6=85=E8=B6=85=E7=BA=A7?=
 =?UTF-8?q?=E5=96=9C=E6=AC=A2=E4=BD=A0=E7=9A=84=E8=BE=BE=E5=A6=AE=E5=A8=85?=
 <176143450+My-Denia@users.noreply.github.com>
Date: Mon, 12 Oct 2026 23:11:50 +0800
Subject: [PATCH 3/4] chore: support isolated dev user data

---
 vite.config.ts | 8 +++++++-
 1 file changed, 7 insertions(+), 1 deletion(-)

diff --git a/vite.config.ts b/vite.config.ts
index cb1bffcbf4..c0d47cb044 100644
--- a/vite.config.ts
+++ b/vite.config.ts
@@ -29,7 +29,13 @@ export default defineConfig({
 					}
 					const env = { ...process.env };
 					delete env.ELECTRON_RUN_AS_NODE;
-					return startup(["."], { env });
+					// A disposable profile keeps dev launches working when the host's default
+					// %APPDATA%\openscreen directory is unavailable (for example, in a sandbox).
+					const devUserDataDir = process.env.OPENSCREEN_DEV_USER_DATA_DIR?.trim();
+					const args = devUserDataDir
+						? [`--user-data-dir=${path.resolve(devUserDataDir)}`, "."]
+						: ["."];
+					return startup(args, { env });
 				},
 				vite: {
 					build: {},

From 8128683f2591b487dd98c476fdc1075aeaa7ab3e Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?=E8=B6=85=E8=B6=85=E8=B6=85=E8=B6=85=E8=B6=85=E7=BA=A7?=
 =?UTF-8?q?=E5=96=9C=E6=AC=A2=E4=BD=A0=E7=9A=84=E8=BE=BE=E5=A6=AE=E5=A8=85?=
 <176143450+My-Denia@users.noreply.github.com>
Date: Mon, 12 Oct 2026 23:23:21 +0800
Subject: [PATCH 4/4] Revert "chore: support isolated dev user data"

This reverts commit 326158c0f142148d072abd8cc8b2ac6ae4d52e7a.
---
 vite.config.ts | 8 +-------
 1 file changed, 1 insertion(+), 7 deletions(-)

diff --git a/vite.config.ts b/vite.config.ts
index c0d47cb044..cb1bffcbf4 100644
--- a/vite.config.ts
+++ b/vite.config.ts
@@ -29,13 +29,7 @@ export default defineConfig({
 					}
 					const env = { ...process.env };
 					delete env.ELECTRON_RUN_AS_NODE;
-					// A disposable profile keeps dev launches working when the host's default
-					// %APPDATA%\openscreen directory is unavailable (for example, in a sandbox).
-					const devUserDataDir = process.env.OPENSCREEN_DEV_USER_DATA_DIR?.trim();
-					const args = devUserDataDir
-						? [`--user-data-dir=${path.resolve(devUserDataDir)}`, "."]
-						: ["."];
-					return startup(args, { env });
+					return startup(["."], { env });
 				},
 				vite: {
 					build: {},