From 84b536eaf6ddaa9f2ca797788631ed60b2d9e599 Mon Sep 17 00:00:00 2001
From: Christian Bager Bach Houmann <christian@bagerbach.com>
Date: Sun, 11 Oct 2026 03:01:10 +0200
Subject: [PATCH 01/11] test: cover removing a local file from Local Files

Removing a file the user played with "Play with PodNotes" from the Local Files playlist must keep that file in the vault. Both tests fail on master: the removal trashes the user's own file.
---
 src/downloadEpisode.test.ts           |  26 ++++
 tests/e2e/harness.ts                  |  44 ++++++
 tests/e2e/local-files-runtime.test.ts | 193 ++++++++++++++++++++++++++
 tests/e2e/podnotes-runtime.test.ts    |  41 +-----
 4 files changed, 265 insertions(+), 39 deletions(-)
 create mode 100644 tests/e2e/local-files-runtime.test.ts

diff --git a/src/downloadEpisode.test.ts b/src/downloadEpisode.test.ts
index 1b1adfa8..51db6383 100644
--- a/src/downloadEpisode.test.ts
+++ b/src/downloadEpisode.test.ts
@@ -660,6 +660,32 @@ describe("removeDownloadedEpisode", () => {
 		expect(vault.removeFile).not.toHaveBeenCalled();
 		expect(get(downloadedEpisodes)[episode.podcastName]).toEqual([]);
 	});
+
+	it("drops a local file from the offline set but leaves the user's file on disk", async () => {
+		const vault = setupVault();
+		const filePath = "Recordings/Interview.wav";
+		const localEpisode: LocalEpisode = {
+			title: "Interview",
+			description: "",
+			content: "",
+			podcastName: "local file",
+			url: "[[Recordings/Interview.wav]]",
+			streamUrl: "app://local/Recordings/Interview.wav",
+			filePath,
+			mediaType: "audio",
+		};
+		vault.present.add(filePath);
+		vault.disk.add(filePath);
+		downloadedEpisodes.set({ "local file": [{ ...localEpisode, filePath, size: 4 }] });
+
+		await removeDownloadedEpisode(localEpisode);
+
+		expect(get(downloadedEpisodes)["local file"]).toEqual([]);
+		expect(vault.trashFile).not.toHaveBeenCalled();
+		expect(vault.removeFile).not.toHaveBeenCalled();
+		expect(vault.present.has(filePath)).toBe(true);
+		expect(vault.disk.has(filePath)).toBe(true);
+	});
 });
 
 describe("safeDownloadFilePath (#22)", () => {
diff --git a/tests/e2e/harness.ts b/tests/e2e/harness.ts
index 8a9ca094..c912f33d 100644
--- a/tests/e2e/harness.ts
+++ b/tests/e2e/harness.ts
@@ -72,6 +72,50 @@ export function evalJsonAsync<T>(obsidian: ObsidianClient, code: string): Promis
 	return obsidian.dev.evalJsonAsync<T>(code);
 }
 
+export async function writeSilentWav(
+	obsidian: ObsidianClient,
+	audioPath: string,
+	seconds: number,
+): Promise<void> {
+	await evalJsonAsync<boolean>(
+		obsidian,
+		`(async () => {
+			const sampleRate = 8_000;
+			const sampleCount = sampleRate * ${seconds};
+			const bytes = new Uint8Array(44 + sampleCount);
+			const view = new DataView(bytes.buffer);
+			const ascii = (offset, value) => {
+				for (let index = 0; index < value.length; index++) {
+					bytes[offset + index] = value.charCodeAt(index);
+				}
+			};
+
+			ascii(0, "RIFF");
+			view.setUint32(4, 36 + sampleCount, true);
+			ascii(8, "WAVE");
+			ascii(12, "fmt ");
+			view.setUint32(16, 16, true);
+			view.setUint16(20, 1, true);
+			view.setUint16(22, 1, true);
+			view.setUint32(24, sampleRate, true);
+			view.setUint32(28, sampleRate, true);
+			view.setUint16(32, 1, true);
+			view.setUint16(34, 8, true);
+			ascii(36, "data");
+			view.setUint32(40, sampleCount, true);
+			bytes.fill(128, 44);
+
+			const existing = app.vault.getAbstractFileByPath(${JSON.stringify(audioPath)});
+			if (existing) {
+				await app.vault.modifyBinary(existing, bytes.buffer);
+			} else {
+				await app.vault.createBinary(${JSON.stringify(audioPath)}, bytes.buffer);
+			}
+			return true;
+		})()`,
+	);
+}
+
 export async function waitForPodNotesReady(obsidian: ObsidianClient): Promise<void> {
 	await obsidian.waitFor(() => podNotesReady(obsidian), {
 		...WAIT_OPTS,
diff --git a/tests/e2e/local-files-runtime.test.ts b/tests/e2e/local-files-runtime.test.ts
new file mode 100644
index 00000000..a57b43c9
--- /dev/null
+++ b/tests/e2e/local-files-runtime.test.ts
@@ -0,0 +1,193 @@
+import type { ObsidianClient } from "obsidian-e2e";
+import { describe, expect, test } from "vitest";
+import type { IPodNotesSettings } from "../../src/types/IPodNotesSettings";
+import {
+	createPodNotesE2EHarness,
+	evalJsonAsync,
+	RELOAD_OPTIONS,
+	VIEW_TYPE,
+	WAIT_OPTS,
+	waitForPodNotesReady,
+	writeSilentWav,
+} from "./harness";
+
+type PodNotesData = Partial<IPodNotesSettings>;
+
+const getContext = createPodNotesE2EHarness("local-files-runtime");
+
+describe("local files runtime", () => {
+	test("removing a local file from Local Files keeps the user's file in the vault", async () => {
+		const { obsidian, plugin, sandbox } = getContext();
+		const title = `E2E Own Recording ${Date.now()}`;
+		const fileName = `${title}.wav`;
+		const audioPath = sandbox.path(fileName);
+		const inDownloads = (data: PodNotesData) =>
+			data.downloadedEpisodes?.["local file"]?.some(
+				(entry) => entry.filePath === audioPath,
+			) ?? false;
+		const inLocalFiles = (data: PodNotesData) =>
+			data.localFiles?.episodes.some((episode) => episode.title === title) ?? false;
+		const trashedFixture = async () =>
+			(await listTrash(obsidian)).filter((path) => path.includes(title));
+
+		await plugin.updateDataAndReload<PodNotesData>((data) => {
+			data.downloadedEpisodes = {};
+			data.playedEpisodes = {};
+		}, RELOAD_OPTIONS);
+		await waitForPodNotesReady(obsidian);
+		await writeSilentWav(obsidian, audioPath, 60);
+		await sandbox.waitForExists(fileName, WAIT_OPTS);
+		const fileExplorerWasEnabled = await setFileExplorerEnabled(obsidian, true);
+
+		try {
+			await openFileMenu(obsidian, audioPath);
+			await clickMenuItem(obsidian, "Play with PodNotes");
+			await plugin.waitForData<PodNotesData>(
+				(data) => inDownloads(data) && inLocalFiles(data),
+				WAIT_OPTS,
+			);
+			// Until #355 keeps the player's <audio> mounted, leaving the player before
+			// play() settles rejects it, and Svelte's bind:paused rethrows the rejection.
+			await obsidian.waitFor(
+				() =>
+					obsidian.dev.evalJson<boolean>(
+						`(app.workspace.getLeavesOfType(${JSON.stringify(VIEW_TYPE)})[0]?.view.containerEl.querySelector("audio")?.currentTime ?? 0) > 0`,
+					),
+				{ ...WAIT_OPTS, message: `${title} did not start playing.` },
+			);
+
+			await clickInPodNotesView(obsidian, 'button[aria-label="Podcast grid"]');
+			await clickInPodNotesView(obsidian, 'button.playlist-card[aria-label="Local Files"]');
+			await clickInPodNotesView(obsidian, `[aria-label="More options for ${title}"]`);
+			await clickMenuItem(obsidian, "Remove file");
+			await plugin.waitForData<PodNotesData>(
+				(data) => !inDownloads(data) && !inLocalFiles(data),
+				WAIT_OPTS,
+			);
+
+			const after = await evalJsonAsync<{ listed: boolean; original: boolean }>(
+				obsidian,
+				`(async () => {
+					const view = app.workspace.getLeavesOfType(${JSON.stringify(VIEW_TYPE)})[0]?.view;
+					return {
+						listed: Array.from(view?.containerEl.querySelectorAll(".episode-item-title") ?? [])
+							.some((candidate) => candidate.textContent?.trim() === ${JSON.stringify(title)}),
+						original: await app.vault.adapter.exists(${JSON.stringify(audioPath)}),
+					};
+				})()`,
+			);
+			expect({ ...after, trashed: await trashedFixture() }).toEqual({
+				listed: false,
+				original: true,
+				trashed: [],
+			});
+			expect(await obsidian.dev.runtimeErrors()).toEqual([]);
+		} finally {
+			await setFileExplorerEnabled(obsidian, fileExplorerWasEnabled);
+			await evalJsonAsync<boolean>(
+				obsidian,
+				`(async () => {
+					for (const path of ${JSON.stringify(await trashedFixture())}) {
+						await app.vault.adapter.remove(path);
+					}
+					return true;
+				})()`,
+			);
+		}
+	}, 60_000);
+});
+
+async function listTrash(obsidian: ObsidianClient): Promise<string[]> {
+	return evalJsonAsync<string[]>(
+		obsidian,
+		`(async () => {
+			const { adapter } = app.vault;
+			return (await adapter.exists(".trash")) ? (await adapter.list(".trash")).files : [];
+		})()`,
+	);
+}
+
+async function setFileExplorerEnabled(
+	obsidian: ObsidianClient,
+	enabled: boolean,
+): Promise<boolean> {
+	return evalJsonAsync<boolean>(
+		obsidian,
+		`(async () => {
+			const fileExplorer = app.internalPlugins.getPluginById("file-explorer");
+			const wasEnabled = fileExplorer.enabled;
+			if (${enabled} && !wasEnabled) await fileExplorer.enable(true);
+			if (${!enabled} && wasEnabled) fileExplorer.disable(true);
+			return wasEnabled;
+		})()`,
+	);
+}
+
+async function openFileMenu(obsidian: ObsidianClient, path: string): Promise<void> {
+	const selector = `.nav-file-title[data-path=${JSON.stringify(path)}]`;
+	await evalJsonAsync<boolean>(
+		obsidian,
+		`(async () => {
+			const leaf = app.workspace.getLeavesOfType("file-explorer")[0];
+			if (!leaf) throw new Error("File explorer is not open.");
+			await app.workspace.revealLeaf(leaf);
+			leaf.view.revealInFolder(app.vault.getAbstractFileByPath(${JSON.stringify(path)}));
+			return true;
+		})()`,
+	);
+	await obsidian.waitFor(
+		() =>
+			obsidian.dev.evalJson<boolean>(
+				`Boolean(document.querySelector(${JSON.stringify(selector)}))`,
+			),
+		{ ...WAIT_OPTS, message: `${path} is not shown in the file explorer.` },
+	);
+	await evalJsonAsync<boolean>(
+		obsidian,
+		`(() => {
+			const target = document.querySelector(${JSON.stringify(selector)});
+			const { left, top } = target.getBoundingClientRect();
+			target.dispatchEvent(new MouseEvent("contextmenu", {
+				bubbles: true,
+				cancelable: true,
+				button: 2,
+				clientX: left + 8,
+				clientY: top + 8,
+			}));
+			return true;
+		})()`,
+	);
+}
+
+async function clickMenuItem(obsidian: ObsidianClient, label: string): Promise<string[]> {
+	const items = `Array.from(document.querySelectorAll(".menu .menu-item"))`;
+	const titleOf = `(item) => item.querySelector(".menu-item-title")?.textContent?.trim()`;
+	await obsidian.waitFor(
+		() =>
+			obsidian.dev.evalJson<boolean>(
+				`${items}.map(${titleOf}).includes(${JSON.stringify(label)})`,
+			),
+		{ ...WAIT_OPTS, message: `Menu item "${label}" did not appear.` },
+	);
+	return evalJsonAsync<string[]>(
+		obsidian,
+		`(() => {
+			const items = ${items};
+			const offered = items.map(${titleOf});
+			items[offered.indexOf(${JSON.stringify(label)})].click();
+			return offered;
+		})()`,
+	);
+}
+
+async function clickInPodNotesView(obsidian: ObsidianClient, selector: string): Promise<void> {
+	const findTarget = `app.workspace.getLeavesOfType(${JSON.stringify(VIEW_TYPE)})[0]?.view.containerEl.querySelector(${JSON.stringify(selector)})`;
+	await obsidian.waitFor(
+		() =>
+			obsidian.dev.evalJson<boolean>(
+				`(() => { const target = ${findTarget}; return target instanceof HTMLElement && target.getBoundingClientRect().width > 0; })()`,
+			),
+		{ ...WAIT_OPTS, message: `${selector} is not visible in the PodNotes view.` },
+	);
+	await evalJsonAsync<boolean>(obsidian, `(() => { ${findTarget}.click(); return true; })()`);
+}
diff --git a/tests/e2e/podnotes-runtime.test.ts b/tests/e2e/podnotes-runtime.test.ts
index 61e29a7a..5850c8c6 100644
--- a/tests/e2e/podnotes-runtime.test.ts
+++ b/tests/e2e/podnotes-runtime.test.ts
@@ -14,6 +14,7 @@ import {
 	VIEW_TYPE,
 	WAIT_OPTS,
 	waitForPodNotesReady,
+	writeSilentWav,
 } from "./harness";
 
 type PodNotesData = Partial<IPodNotesSettings> & {
@@ -723,45 +724,7 @@ async function seedAudio(
 	const audioPath = sandbox.path(fileName);
 	if (audioFixtureReady) return audioPath;
 
-	await evalJsonAsync<boolean>(
-		obsidian,
-		`
-		(async () => {
-			const sampleRate = 8_000;
-			const sampleCount = sampleRate * 600;
-			const bytes = new Uint8Array(44 + sampleCount);
-			const view = new DataView(bytes.buffer);
-			const ascii = (offset, value) => {
-				for (let index = 0; index < value.length; index++) {
-					bytes[offset + index] = value.charCodeAt(index);
-				}
-			};
-
-			ascii(0, "RIFF");
-			view.setUint32(4, 36 + sampleCount, true);
-			ascii(8, "WAVE");
-			ascii(12, "fmt ");
-			view.setUint32(16, 16, true);
-			view.setUint16(20, 1, true);
-			view.setUint16(22, 1, true);
-			view.setUint32(24, sampleRate, true);
-			view.setUint32(28, sampleRate, true);
-			view.setUint16(32, 1, true);
-			view.setUint16(34, 8, true);
-			ascii(36, "data");
-			view.setUint32(40, sampleCount, true);
-			bytes.fill(128, 44);
-
-			const existing = app.vault.getAbstractFileByPath(${JSON.stringify(audioPath)});
-			if (existing) {
-				await app.vault.modifyBinary(existing, bytes.buffer);
-			} else {
-				await app.vault.createBinary(${JSON.stringify(audioPath)}, bytes.buffer);
-			}
-			return true;
-		})()
-	`,
-	);
+	await writeSilentWav(obsidian, audioPath, 600);
 	await sandbox.waitForExists(fileName, WAIT_OPTS);
 	audioFixtureReady = true;
 

From a338759f5f85d2335e4af7de95243e357edb6ab4 Mon Sep 17 00:00:00 2001
From: Christian Bager Bach Houmann <christian@bagerbach.com>
Date: Sun, 11 Oct 2026 03:06:47 +0200
Subject: [PATCH 02/11] fix: never trash a local file from Local Files

"Remove file" on a Local Files entry added by "Play with PodNotes" moved the user's own recording to the trash, because removal treated every offline entry as a PodNotes download. Removal now deletes the file only for PodNotes downloads. An entry in the "local file" bucket is dropped from Local Files and its file stays in the vault, which also covers local files already stored in existing data.json files. The menu item for those entries reads "Remove from Local Files".

Fixes #354
---
 src/downloadEpisode.ts                        |  8 +----
 src/store/downloads.ts                        |  5 ---
 .../spawnEpisodeContextMenu.test.ts           | 32 +++++++++++++++++--
 src/ui/PodcastView/spawnEpisodeContextMenu.ts |  4 ++-
 tests/e2e/local-files-runtime.test.ts         |  3 +-
 5 files changed, 36 insertions(+), 16 deletions(-)

diff --git a/src/downloadEpisode.ts b/src/downloadEpisode.ts
index 6fea28fe..d6651003 100644
--- a/src/downloadEpisode.ts
+++ b/src/downloadEpisode.ts
@@ -351,15 +351,9 @@ export function safeDownloadFilePath(
 	return enforceMaxPathLength(`${basename}.${extension}`, `.${extension}`);
 }
 
-/**
- * Remove a downloaded episode: drop it from the offline set and delete its
- * backing vault file. This composes the pure store removal with the file I/O so
- * callers can't do one without the other (and leak files); the download store
- * stays free of vault side effects.
- */
 export async function removeDownloadedEpisode(episode: Episode): Promise<void> {
 	const removedFilePath = downloadedEpisodes.removeEpisode(episode);
-	if (removedFilePath) {
+	if (removedFilePath && !isLocalFile(episode)) {
 		await deleteEpisodeFile(removedFilePath);
 	}
 }
diff --git a/src/store/downloads.ts b/src/store/downloads.ts
index 3d4626b6..5a9e4809 100644
--- a/src/store/downloads.ts
+++ b/src/store/downloads.ts
@@ -59,11 +59,6 @@ export const downloadedEpisodes = (() => {
 
 			return replacedFilePath;
 		},
-		/**
-		 * Drops an episode from the offline set and returns the vault path of the
-		 * file it backed (or `undefined` if it wasn't tracked). Pure state only: the
-		 * caller deletes the returned file (see `removeDownloadedEpisode`).
-		 */
 		removeEpisode: (episode: Episode): string | undefined => {
 			let removedFilePath: string | undefined;
 
diff --git a/src/ui/PodcastView/spawnEpisodeContextMenu.test.ts b/src/ui/PodcastView/spawnEpisodeContextMenu.test.ts
index 5f6671f1..d4e762c1 100644
--- a/src/ui/PodcastView/spawnEpisodeContextMenu.test.ts
+++ b/src/ui/PodcastView/spawnEpisodeContextMenu.test.ts
@@ -1,9 +1,9 @@
 // @vitest-environment jsdom
-import { Menu } from "obsidian";
+import { Menu, MenuItem } from "obsidian";
 import { beforeEach, describe, expect, test, vi } from "vitest";
 
 import spawnEpisodeContextMenu from "./spawnEpisodeContextMenu";
-import { playedEpisodes, playlists, queue } from "src/store";
+import { downloadedEpisodes, playedEpisodes, playlists, queue } from "src/store";
 import type { Episode } from "src/types/Episode";
 
 const episode: Episode = {
@@ -37,6 +37,7 @@ beforeEach(() => {
 	});
 	playlists.set({});
 	playedEpisodes.set({});
+	downloadedEpisodes.set({});
 });
 
 describe("spawnEpisodeContextMenu anchoring (CM-general)", () => {
@@ -66,3 +67,30 @@ describe("spawnEpisodeContextMenu anchoring (CM-general)", () => {
 		atPos.mockRestore();
 	});
 });
+
+describe("spawnEpisodeContextMenu removal item", () => {
+	function downloadItemTitles(target: Episode) {
+		const setTitle = vi.spyOn(MenuItem.prototype, "setTitle");
+		spawnEpisodeContextMenu(target, { x: 0, y: 0 }, { ...allDisabled, download: false });
+		const titles = setTitle.mock.calls.map(([title]) => title);
+		setTitle.mockRestore();
+		return titles;
+	}
+
+	test("offers to remove a tracked local file from Local Files", () => {
+		const localFile = { ...episode, title: "Interview", podcastName: "local file" };
+		downloadedEpisodes.set({
+			"local file": [{ ...localFile, filePath: "Recordings/Interview.wav", size: 4 }],
+		});
+
+		expect(downloadItemTitles(localFile)).toEqual(["Remove from Local Files"]);
+	});
+
+	test("offers to remove the file of a downloaded feed episode", () => {
+		downloadedEpisodes.set({
+			Podcast: [{ ...episode, filePath: "Podcasts/Episode.mp3", size: 4 }],
+		});
+
+		expect(downloadItemTitles(episode)).toEqual(["Remove file"]);
+	});
+});
diff --git a/src/ui/PodcastView/spawnEpisodeContextMenu.ts b/src/ui/PodcastView/spawnEpisodeContextMenu.ts
index fcce7192..2a779898 100644
--- a/src/ui/PodcastView/spawnEpisodeContextMenu.ts
+++ b/src/ui/PodcastView/spawnEpisodeContextMenu.ts
@@ -19,6 +19,7 @@ import { ViewState } from "src/types/ViewState";
 import { get } from "svelte/store";
 import { isEpisodeFinished } from "src/utility/episodeStatus";
 import { isSameStoredEpisode } from "src/utility/episodeKey";
+import { isLocalFile } from "src/utility/isLocalFile";
 import { buildQueueReorderMenuItems } from "./queueReorderMenu";
 
 interface DisabledMenuItems {
@@ -86,11 +87,12 @@ export default function spawnEpisodeContextMenu(
 
 	if (!disabledMenuItems?.download) {
 		const isDownloaded = downloadedEpisodes.isEpisodeDownloaded(episode);
+		const removeTitle = isLocalFile(episode) ? "Remove from Local Files" : "Remove file";
 
 		menu.addItem((item) =>
 			item
 				.setIcon(isDownloaded ? "cross" : "download")
-				.setTitle(isDownloaded ? "Remove file" : "Download")
+				.setTitle(isDownloaded ? removeTitle : "Download")
 				.onClick(() => {
 					if (isDownloaded) {
 						void removeDownloadedEpisode(episode);
diff --git a/tests/e2e/local-files-runtime.test.ts b/tests/e2e/local-files-runtime.test.ts
index a57b43c9..232ae3a7 100644
--- a/tests/e2e/local-files-runtime.test.ts
+++ b/tests/e2e/local-files-runtime.test.ts
@@ -59,7 +59,8 @@ describe("local files runtime", () => {
 			await clickInPodNotesView(obsidian, 'button[aria-label="Podcast grid"]');
 			await clickInPodNotesView(obsidian, 'button.playlist-card[aria-label="Local Files"]');
 			await clickInPodNotesView(obsidian, `[aria-label="More options for ${title}"]`);
-			await clickMenuItem(obsidian, "Remove file");
+			const removalMenu = await clickMenuItem(obsidian, "Remove from Local Files");
+			expect(removalMenu).not.toContain("Remove file");
 			await plugin.waitForData<PodNotesData>(
 				(data) => !inDownloads(data) && !inLocalFiles(data),
 				WAIT_OPTS,

From 00a30eccf748693161de50a5958908fe9cb130eb Mon Sep 17 00:00:00 2001
From: Christian Bager Bach Houmann <christian@bagerbach.com>
Date: Sun, 11 Oct 2026 05:01:49 +0200
Subject: [PATCH 03/11] test: cover downloads PodNotes cannot confirm it made

Releases 2.17.1 to 2.19.2 registered any file already at a download path as
a feed download. Removing such an entry must ask before trashing the file,
a fresh download must record that PodNotes made it, and reusing an older
registration must not claim it. Local Files entries, including legacy ones
without a media type, are never trashed.
---
 src/downloadEpisode.test.ts           | 176 ++++++++++++++++++++++----
 src/persistence/podNotesData.test.ts  |  36 ++++++
 tests/e2e/local-files-runtime.test.ts | 163 ++++++++++++++++++++++++
 tests/mocks/obsidian.ts               |   5 +-
 4 files changed, 354 insertions(+), 26 deletions(-)

diff --git a/src/downloadEpisode.test.ts b/src/downloadEpisode.test.ts
index 51db6383..5da8fa59 100644
--- a/src/downloadEpisode.test.ts
+++ b/src/downloadEpisode.test.ts
@@ -1,5 +1,6 @@
 // @vitest-environment jsdom
 import { afterEach, beforeEach, describe, expect, it, vi } from "vitest";
+import { fireEvent, screen } from "@testing-library/svelte";
 import { get } from "svelte/store";
 import { Notice, requestUrl, TFile } from "obsidian";
 import downloadEpisodeWithNotice, {
@@ -10,9 +11,12 @@ import downloadEpisodeWithNotice, {
 } from "./downloadEpisode";
 import { downloadedEpisodes, plugin } from "./store";
 import type PodNotes from "./main";
+import type DownloadedEpisode from "./types/DownloadedEpisode";
 import type { Episode } from "./types/Episode";
 import type { LocalEpisode } from "./types/LocalEpisode";
 
+type StoredDownload = DownloadedEpisode & { downloadedByPodNotes?: true };
+
 vi.mock("obsidian", async (importOriginal) => {
 	const actual = await importOriginal<typeof import("obsidian")>();
 	return { ...actual, requestUrl: vi.fn() };
@@ -645,46 +649,168 @@ describe("safeDownloadBasename (#183)", () => {
 });
 
 describe("removeDownloadedEpisode", () => {
-	it("trashes the indexed download through FileManager", async () => {
+	const promptFor = (filePath: string) =>
+		`PodNotes cannot confirm that it downloaded "${filePath}".`;
+	const keepFile = () => fireEvent.click(screen.getByRole("button", { name: "Keep file" }));
+	const moveToTrash = () =>
+		fireEvent.click(screen.getByRole("button", { name: "Move to trash" }));
+	const dismissPrompt = () => {
+		const closeButton = document.querySelector(".modal-close-button");
+		if (!closeButton) throw new Error("The prompt has no close button.");
+		fireEvent.click(closeButton);
+	};
+
+	function putOnDisk(vault: ReturnType<typeof setupVault>, filePath: string): void {
+		vault.present.add(filePath);
+		vault.disk.add(filePath);
+	}
+
+	function expectKeptOnDisk(vault: ReturnType<typeof setupVault>, filePath: string): void {
+		expect(vault.trashFile).not.toHaveBeenCalled();
+		expect(vault.removeFile).not.toHaveBeenCalled();
+		expect(vault.present.has(filePath)).toBe(true);
+		expect(vault.disk.has(filePath)).toBe(true);
+	}
+
+	function mockAudioResponse(): void {
+		requestUrlMock.mockResolvedValue({
+			status: 200,
+			headers: { "content-type": "audio/mpeg" },
+			arrayBuffer: bytes(0x49, 0x44, 0x33, 0x04),
+		} as unknown as Awaited<ReturnType<typeof requestUrl>>);
+	}
+
+	afterEach(() => {
+		document.body.replaceChildren();
+	});
+
+	it("trashes a file PodNotes downloaded without asking", async () => {
 		const vault = setupVault();
 		const episode = makeEpisode();
 		const filePath = "Podcasts/My Title.mp3";
-		vault.present.add(filePath);
-		vault.disk.add(filePath);
-		downloadedEpisodes.addEpisode(episode, filePath, 4);
+		putOnDisk(vault, filePath);
+		const owned: StoredDownload = { ...episode, filePath, size: 4, downloadedByPodNotes: true };
+		downloadedEpisodes.set({ Pod: [owned] });
 
 		await removeDownloadedEpisode(episode);
 
+		expect(screen.queryByText(promptFor(filePath))).toBeNull();
 		expect(vault.trashFile).toHaveBeenCalledOnce();
 		expect(vault.trashFile.mock.calls[0][0].path).toBe(filePath);
 		expect(vault.removeFile).not.toHaveBeenCalled();
-		expect(get(downloadedEpisodes)[episode.podcastName]).toEqual([]);
+		expect(get(downloadedEpisodes).Pod).toEqual([]);
 	});
 
-	it("drops a local file from the offline set but leaves the user's file on disk", async () => {
+	it.each([
+		["Keep file", keepFile, true],
+		["Move to trash", moveToTrash, false],
+		["a dismissal", dismissPrompt, true],
+	])(
+		"asks before trashing a feed file PodNotes cannot confirm it downloaded, answered with %s",
+		async (_answer, answer, keptOnDisk) => {
+			const vault = setupVault();
+			const episode = makeEpisode({
+				title: "Fixture Episode 2",
+				streamUrl: "https://example.com/episode-2.wav",
+			});
+			const filePath = "Recordings/Fixture Episode 2.wav";
+			putOnDisk(vault, filePath);
+			downloadedEpisodes.set({ Pod: [{ ...episode, filePath, size: 4 }] });
+
+			const removal = removeDownloadedEpisode(episode);
+			await vi.waitFor(() =>
+				expect({
+					asking: screen.queryByText(promptFor(filePath)) !== null,
+					onDisk: vault.present.has(filePath),
+				}).toEqual({ asking: true, onDisk: true }),
+			);
+			expect(screen.getByRole("button", { name: "Keep file" })).toHaveFocus();
+			answer();
+			await removal;
+
+			expect(screen.queryByText(promptFor(filePath))).toBeNull();
+			expect(get(downloadedEpisodes).Pod).toEqual([]);
+			expect(vault.present.has(filePath)).toBe(keptOnDisk);
+			expect(vault.trashFile).toHaveBeenCalledTimes(keptOnDisk ? 0 : 1);
+			expect(vault.removeFile).not.toHaveBeenCalled();
+		},
+	);
+
+	const interviewPath = "Recordings/Interview.wav";
+	const interview: LocalEpisode = {
+		title: "Interview",
+		description: "",
+		content: "",
+		podcastName: "local file",
+		url: `[[${interviewPath}]]`,
+		streamUrl: `app://local/${interviewPath}`,
+	};
+
+	it.each([
+		["without a media type", {}],
+		["as audio", { mediaType: "audio" }],
+		["as video", { mediaType: "video" }],
+	] as const)("drops a local file stored %s but leaves it on disk", async (_case, media) => {
 		const vault = setupVault();
-		const filePath = "Recordings/Interview.wav";
-		const localEpisode: LocalEpisode = {
-			title: "Interview",
-			description: "",
-			content: "",
-			podcastName: "local file",
-			url: "[[Recordings/Interview.wav]]",
-			streamUrl: "app://local/Recordings/Interview.wav",
-			filePath,
-			mediaType: "audio",
-		};
-		vault.present.add(filePath);
-		vault.disk.add(filePath);
-		downloadedEpisodes.set({ "local file": [{ ...localEpisode, filePath, size: 4 }] });
+		putOnDisk(vault, interviewPath);
+		const stored = { ...interview, ...media, filePath: interviewPath, size: 4 };
+		downloadedEpisodes.set({ "local file": [stored] });
 
-		await removeDownloadedEpisode(localEpisode);
+		await removeDownloadedEpisode(stored);
 
+		expect(screen.queryByText(promptFor(interviewPath))).toBeNull();
 		expect(get(downloadedEpisodes)["local file"]).toEqual([]);
-		expect(vault.trashFile).not.toHaveBeenCalled();
-		expect(vault.removeFile).not.toHaveBeenCalled();
-		expect(vault.present.has(filePath)).toBe(true);
-		expect(vault.disk.has(filePath)).toBe(true);
+		expectKeptOnDisk(vault, interviewPath);
+	});
+
+	it("drops a local file removed through an older snapshot without its path", async () => {
+		const vault = setupVault();
+		putOnDisk(vault, interviewPath);
+		downloadedEpisodes.set({
+			"local file": [{ ...interview, filePath: interviewPath, size: 4 }],
+		});
+
+		await removeDownloadedEpisode(interview);
+
+		expect(screen.queryByText(promptFor(interviewPath))).toBeNull();
+		expect(get(downloadedEpisodes)["local file"]).toEqual([]);
+		expectKeptOnDisk(vault, interviewPath);
+	});
+
+	it("trashes a file it downloaded itself without asking", async () => {
+		const vault = setupVault();
+		mockAudioResponse();
+		const episode = makeEpisode();
+		const filePath = "Podcasts/My Title.mp3";
+
+		await downloadEpisodeWithNotice(episode, "Podcasts/{{title}}");
+		expect(get(downloadedEpisodes).Pod).toEqual([
+			expect.objectContaining({ filePath, downloadedByPodNotes: true }),
+		]);
+		await removeDownloadedEpisode(episode);
+
+		expect(screen.queryByText(promptFor(filePath))).toBeNull();
+		expect(vault.trashFile).toHaveBeenCalledOnce();
+		expect(vault.present.has(filePath)).toBe(false);
+		expect(get(downloadedEpisodes).Pod).toEqual([]);
+	});
+
+	it.each([
+		["its URL extension", "https://example.com/ep.mp3"],
+		["its sniffed destination", "https://example.com/stream?id=42"],
+	])("keeps an earlier registration it reuses at %s unconfirmed", async (_case, streamUrl) => {
+		const vault = setupVault();
+		mockAudioResponse();
+		const episode = makeEpisode({ streamUrl });
+		const filePath = "Podcasts/My Title.mp3";
+		putOnDisk(vault, filePath);
+		const registered = { ...episode, filePath, size: 4 };
+		downloadedEpisodes.set({ Pod: [registered] });
+
+		await downloadEpisodeWithNotice(episode, "Podcasts/{{title}}");
+
+		expect(vault.writeBinary).not.toHaveBeenCalled();
+		expect(get(downloadedEpisodes).Pod).toEqual([registered]);
 	});
 });
 
diff --git a/src/persistence/podNotesData.test.ts b/src/persistence/podNotesData.test.ts
index f97b8cc1..52b811ed 100644
--- a/src/persistence/podNotesData.test.ts
+++ b/src/persistence/podNotesData.test.ts
@@ -266,6 +266,42 @@ describe("PodNotes data schema", () => {
 		expect(decoded.settings.downloadedEpisodes["Old Podcast"][0].size).toBe(0);
 	});
 
+	const storedDownload = (downloadedByPodNotes: unknown) => ({
+		...episode("Downloaded"),
+		episodeDate: episodeDate.toISOString(),
+		filePath: "Podcasts/downloaded.mp3",
+		size: 42,
+		downloadedByPodNotes,
+	});
+
+	it("keeps a download PodNotes recorded as its own through load and save", () => {
+		const decoded = decodePodNotesData({
+			downloadedEpisodes: { "Test Podcast": [storedDownload(true)] },
+		});
+		const persisted = encodePodNotesData(decoded.settings, decoded.unknownFields);
+
+		expect(decoded.warnings).toEqual([]);
+		expect(decoded.settings.downloadedEpisodes["Test Podcast"][0]).toMatchObject({
+			downloadedByPodNotes: true,
+		});
+		expect(persisted.downloadedEpisodes["Test Podcast"][0]).toMatchObject({
+			downloadedByPodNotes: true,
+		});
+	});
+
+	it.each([["true"], [1], [false]])("does not trust download ownership stored as %o", (value) => {
+		const decoded = decodePodNotesData({
+			downloadedEpisodes: { "Test Podcast": [storedDownload(value)] },
+		});
+
+		expect(decoded.settings.downloadedEpisodes["Test Podcast"][0]).not.toHaveProperty(
+			"downloadedByPodNotes",
+		);
+		expect(decoded.warnings).toEqual([
+			"downloadedEpisodes.Test Podcast[0].downloadedByPodNotes: value was normalized",
+		]);
+	});
+
 	it("preserves safe unknown root and nested fields across a schema upgrade", () => {
 		const decoded = decodePodNotesData({
 			schemaVersion: 1,
diff --git a/tests/e2e/local-files-runtime.test.ts b/tests/e2e/local-files-runtime.test.ts
index 232ae3a7..8f237968 100644
--- a/tests/e2e/local-files-runtime.test.ts
+++ b/tests/e2e/local-files-runtime.test.ts
@@ -4,6 +4,7 @@ import type { IPodNotesSettings } from "../../src/types/IPodNotesSettings";
 import {
 	createPodNotesE2EHarness,
 	evalJsonAsync,
+	openPodNotesView,
 	RELOAD_OPTIONS,
 	VIEW_TYPE,
 	WAIT_OPTS,
@@ -13,6 +14,8 @@ import {
 
 type PodNotesData = Partial<IPodNotesSettings>;
 
+const SILENT_WAV_SECOND_BYTES = 44 + 8_000;
+
 const getContext = createPodNotesE2EHarness("local-files-runtime");
 
 describe("local files runtime", () => {
@@ -96,6 +99,134 @@ describe("local files runtime", () => {
 			);
 		}
 	}, 60_000);
+
+	test("asks before trashing a download PodNotes cannot confirm it made", async () => {
+		const { obsidian, plugin, sandbox } = getContext();
+		const stamp = Date.now();
+		const feed = `E2E Feed ${stamp}`;
+		const kept = `E2E Adopted Recording ${stamp}`;
+		const discarded = `E2E Discarded Recording ${stamp}`;
+		const legacy = `E2E Legacy Recording ${stamp}`;
+		const recordingPath = (title: string) => sandbox.path("Recordings", `${title}.wav`);
+		const promptFor = (title: string) =>
+			`PodNotes cannot confirm that it downloaded "${recordingPath(title)}".`;
+		const inDownloads = (data: PodNotesData, podcastName: string, title: string) =>
+			data.downloadedEpisodes?.[podcastName]?.some((entry) => entry.title === title) ?? false;
+		const trashedFixtures = async () =>
+			(await listTrash(obsidian)).filter((path) => path.includes(String(stamp)));
+		const adoptedByAnOlderRelease = (title: string) => ({
+			title,
+			description: `${title} description.`,
+			content: "",
+			podcastName: feed,
+			url: "https://example.com/e2e/feed.xml",
+			streamUrl: `https://example.com/e2e/${stamp}/${encodeURIComponent(title)}.wav`,
+			feedUrl: "https://example.com/e2e/feed.xml",
+			artworkUrl: "",
+			episodeDate: "2026-06-30T09:00:00.000Z",
+			duration: 1,
+			mediaType: "audio",
+			filePath: recordingPath(title),
+			size: SILENT_WAV_SECOND_BYTES,
+		});
+
+		await sandbox.mkdir("Recordings");
+		for (const title of [kept, discarded, legacy]) {
+			await writeSilentWav(obsidian, recordingPath(title), 1);
+			await sandbox.waitForExists(`Recordings/${title}.wav`, WAIT_OPTS);
+		}
+		await plugin.updateDataAndReload<Record<string, unknown>>((data) => {
+			data.downloadedEpisodes = {
+				[feed]: [adoptedByAnOlderRelease(kept), adoptedByAnOlderRelease(discarded)],
+				"local file": [
+					{
+						title: legacy,
+						description: "",
+						content: "",
+						podcastName: "local file",
+						url: `[[${recordingPath(legacy)}]]`,
+						streamUrl: `app://local/${recordingPath(legacy)}`,
+						episodeDate: "2022-11-01T00:00:00.000Z",
+						filePath: recordingPath(legacy),
+						size: SILENT_WAV_SECOND_BYTES,
+					},
+				],
+			};
+			data.playedEpisodes = {};
+		}, RELOAD_OPTIONS);
+		await waitForPodNotesReady(obsidian);
+		await openPodNotesView(obsidian);
+
+		try {
+			await clickInPodNotesView(obsidian, 'button[aria-label="Podcast grid"]');
+			await clickInPodNotesView(obsidian, 'button.playlist-card[aria-label="Local Files"]');
+
+			await clickInPodNotesView(obsidian, `[aria-label="More options for ${kept}"]`);
+			await clickMenuItem(obsidian, "Remove file");
+			expect(await removalPrompt(obsidian, recordingPath(kept))).toEqual({
+				prompt: promptFor(kept),
+				focused: "Keep file",
+				original: true,
+			});
+			await clickModalButton(obsidian, "Keep file");
+			await plugin.waitForData<PodNotesData>(
+				(data) => !inDownloads(data, feed, kept),
+				WAIT_OPTS,
+			);
+
+			await clickInPodNotesView(obsidian, `[aria-label="More options for ${discarded}"]`);
+			await clickMenuItem(obsidian, "Remove file");
+			expect(await removalPrompt(obsidian, recordingPath(discarded))).toEqual({
+				prompt: promptFor(discarded),
+				focused: "Keep file",
+				original: true,
+			});
+			await clickModalButton(obsidian, "Move to trash");
+			await sandbox.waitForMissing(`Recordings/${discarded}.wav`, WAIT_OPTS);
+			await plugin.waitForData<PodNotesData>(
+				(data) => !inDownloads(data, feed, discarded),
+				WAIT_OPTS,
+			);
+
+			await clickInPodNotesView(obsidian, `[aria-label="More options for ${legacy}"]`);
+			await clickMenuItem(obsidian, "Remove from Local Files");
+			await plugin.waitForData<PodNotesData>(
+				(data) => !inDownloads(data, "local file", legacy),
+				WAIT_OPTS,
+			);
+
+			const after = await evalJsonAsync<Record<string, boolean>>(
+				obsidian,
+				`(async () => {
+					const { adapter } = app.vault;
+					return {
+						prompt: Boolean(document.querySelector(".modal-container")),
+						kept: await adapter.exists(${JSON.stringify(recordingPath(kept))}),
+						discarded: await adapter.exists(${JSON.stringify(recordingPath(discarded))}),
+						legacy: await adapter.exists(${JSON.stringify(recordingPath(legacy))}),
+					};
+				})()`,
+			);
+			expect({ ...after, trashed: await trashedFixtures() }).toEqual({
+				prompt: false,
+				kept: true,
+				discarded: false,
+				legacy: true,
+				trashed: [`.trash/${discarded}.wav`],
+			});
+			expect(await obsidian.dev.runtimeErrors()).toEqual([]);
+		} finally {
+			await evalJsonAsync<boolean>(
+				obsidian,
+				`(async () => {
+					for (const path of ${JSON.stringify(await trashedFixtures())}) {
+						await app.vault.adapter.remove(path);
+					}
+					return true;
+				})()`,
+			);
+		}
+	}, 60_000);
 });
 
 async function listTrash(obsidian: ObsidianClient): Promise<string[]> {
@@ -108,6 +239,38 @@ async function listTrash(obsidian: ObsidianClient): Promise<string[]> {
 	);
 }
 
+async function removalPrompt(
+	obsidian: ObsidianClient,
+	path: string,
+): Promise<{ prompt: string | null; focused: string | null; original: boolean }> {
+	const original = `app.vault.adapter.exists(${JSON.stringify(path)})`;
+	await obsidian.waitFor(
+		() =>
+			evalJsonAsync<boolean>(
+				obsidian,
+				`(async () => Boolean(document.querySelector(".modal-container")) || !(await ${original}))()`,
+			),
+		{ ...WAIT_OPTS, message: `Removing ${path} neither asked nor removed it.` },
+	);
+	return evalJsonAsync(
+		obsidian,
+		`(async () => ({
+			prompt: document.querySelector(".modal-container .modal-content p")?.textContent ?? null,
+			focused: document.activeElement instanceof HTMLButtonElement ? document.activeElement.textContent : null,
+			original: await ${original},
+		}))()`,
+	);
+}
+
+async function clickModalButton(obsidian: ObsidianClient, label: string): Promise<void> {
+	const button = `Array.from(document.querySelectorAll(".modal-container button")).find((button) => button.textContent?.trim() === ${JSON.stringify(label)})`;
+	await obsidian.waitFor(() => obsidian.dev.evalJson<boolean>(`Boolean(${button})`), {
+		...WAIT_OPTS,
+		message: `Modal button "${label}" did not appear.`,
+	});
+	await evalJsonAsync<boolean>(obsidian, `(() => { ${button}.click(); return true; })()`);
+}
+
 async function setFileExplorerEnabled(
 	obsidian: ObsidianClient,
 	enabled: boolean,
diff --git a/tests/mocks/obsidian.ts b/tests/mocks/obsidian.ts
index 2a36539f..3248075e 100644
--- a/tests/mocks/obsidian.ts
+++ b/tests/mocks/obsidian.ts
@@ -74,7 +74,10 @@ export class Modal {
 		this.containerEl = document.createElement("div");
 		this.titleEl = document.createElement("div");
 		this.contentEl = document.createElement("div");
-		this.containerEl.append(this.titleEl, this.contentEl);
+		const closeButtonEl = document.createElement("div");
+		closeButtonEl.className = "modal-close-button";
+		closeButtonEl.addEventListener("click", () => this.close());
+		this.containerEl.append(closeButtonEl, this.titleEl, this.contentEl);
 	}
 
 	open(): void {

From a6d5fe2a4269bcea0f2beddd75ee95bb522046cb Mon Sep 17 00:00:00 2001
From: Christian Bager Bach Houmann <christian@bagerbach.com>
Date: Sun, 11 Oct 2026 05:06:02 +0200
Subject: [PATCH 04/11] fix: ask before trashing a download PodNotes cannot
 confirm it made

A finished download now records downloadedByPodNotes on its entry. Removing
an entry with that flag trashes the file as before. Removing a feed entry
without it, such as a file an older release registered because it already
sat at the download path, opens a prompt that names the path. "Keep file" is
the default and removes only the entry; "Move to trash" trashes the file.

The decision reads the removed stored entry, not the menu's episode object,
so old snapshots without a path or media type cannot change it. Reusing an
earlier registration keeps its flag as it was, and the codec drops any
stored value other than true. Local Files entries are never trashed.
---
 docs/docs/local_files.md               |  2 +
 src/downloadEpisode.test.ts            |  9 +++--
 src/downloadEpisode.ts                 | 51 ++++++++++++++++++--------
 src/persistence/collectionCodecs.ts    |  8 +++-
 src/store/downloads.ts                 | 24 ++++++------
 src/store/index.test.ts                | 12 +++---
 src/types/DownloadedEpisode.ts         |  6 +++
 src/ui/ConfirmTrashUnownedFileModal.ts | 49 +++++++++++++++++++++++++
 8 files changed, 123 insertions(+), 38 deletions(-)
 create mode 100644 src/ui/ConfirmTrashUnownedFileModal.ts

diff --git a/docs/docs/local_files.md b/docs/docs/local_files.md
index ecf4cf79..9c6cc0c1 100644
--- a/docs/docs/local_files.md
+++ b/docs/docs/local_files.md
@@ -2,6 +2,8 @@ PodNotes supports local media files. You can right-click any audio or video file
 
 In the podcast grid, you will see a playlist with a folder icon. This is a playlist of every episode you have available offline: both local media files you have played with `Play with PodNotes` and episodes you have downloaded. Removing a downloaded file also removes it from this playlist.
 
+`Remove from Local Files` removes a local media file from the playlist and keeps the file in your vault. `Remove file` moves a downloaded episode's file to the trash. If PodNotes cannot confirm that it downloaded the file itself, which is the case for downloads made with an older PodNotes version, it asks first. `Keep file` removes the episode from the playlist and leaves the file where it is.
+
 PodNotes will attempt to treat all local files as podcast episodes. This means all standard features are available, such as timestamps, note creation, and persisting playback time. Any exceptions will be added here.
 
 Local files and downloaded episodes are played through Obsidian's native media resource path (the same mechanism Obsidian uses for embedded media), so they work on mobile (iOS and Android) as well as desktop.
diff --git a/src/downloadEpisode.test.ts b/src/downloadEpisode.test.ts
index 5da8fa59..5c841ada 100644
--- a/src/downloadEpisode.test.ts
+++ b/src/downloadEpisode.test.ts
@@ -15,8 +15,6 @@ import type DownloadedEpisode from "./types/DownloadedEpisode";
 import type { Episode } from "./types/Episode";
 import type { LocalEpisode } from "./types/LocalEpisode";
 
-type StoredDownload = DownloadedEpisode & { downloadedByPodNotes?: true };
-
 vi.mock("obsidian", async (importOriginal) => {
 	const actual = await importOriginal<typeof import("obsidian")>();
 	return { ...actual, requestUrl: vi.fn() };
@@ -689,7 +687,12 @@ describe("removeDownloadedEpisode", () => {
 		const episode = makeEpisode();
 		const filePath = "Podcasts/My Title.mp3";
 		putOnDisk(vault, filePath);
-		const owned: StoredDownload = { ...episode, filePath, size: 4, downloadedByPodNotes: true };
+		const owned: DownloadedEpisode = {
+			...episode,
+			filePath,
+			size: 4,
+			downloadedByPodNotes: true,
+		};
 		downloadedEpisodes.set({ Pod: [owned] });
 
 		await removeDownloadedEpisode(episode);
diff --git a/src/downloadEpisode.ts b/src/downloadEpisode.ts
index d6651003..528ff9a5 100644
--- a/src/downloadEpisode.ts
+++ b/src/downloadEpisode.ts
@@ -1,6 +1,7 @@
 import { normalizePath, Notice, TFile } from "obsidian";
 import { get } from "svelte/store";
 import { downloadedEpisodes, plugin } from "./store";
+import type DownloadedEpisode from "./types/DownloadedEpisode";
 import {
 	DownloadPathTemplateEngine,
 	replaceIllegalFileNameCharactersInString,
@@ -31,6 +32,7 @@ import {
 	MAX_DOWNLOAD_SIZE,
 } from "./download/streaming";
 import { detectAudioFileExtension } from "./download/mediaSignatures";
+import { confirmTrashUnownedFile } from "./ui/ConfirmTrashUnownedFileModal";
 import { NetworkError, requestWithTimeout } from "./utility/networkRequest";
 
 const WHOLE_FILE_DOWNLOAD_TIMEOUT_MS = 15 * 60_000;
@@ -139,24 +141,27 @@ function registeredDownloadOwnsPath(episode: Episode, filePath: string): boolean
 }
 
 // Fast-path variant: the path here is only the URL-extension guess, so a foreign
-// occupant is not a collision yet - the sniffed final path may differ. Returns a
-// size only when this episode already owns the file.
-function ownedExistingDownloadSize(episode: Episode, filePath: string): number | undefined {
+// occupant is not a collision yet - the sniffed final path may differ. Returns the
+// registered entry only when this episode already owns the file.
+function ownedExistingDownload(episode: Episode, filePath: string): DownloadedEpisode | undefined {
 	const existing = get(plugin).app.vault.getAbstractFileByPath(filePath);
 	if (!(existing instanceof TFile)) return undefined;
 	if (!registeredDownloadOwnsPath(episode, filePath)) return undefined;
-	return downloadedEpisodes.getEpisode(episode)?.size;
+	return downloadedEpisodes.getEpisode(episode);
 }
 
 // Resolved-destination variant: the final path is known, so a foreign occupant
 // is a hard collision.
-function reusableExistingDownloadSize(episode: Episode, filePath: string): number | undefined {
+function reusableExistingDownload(
+	episode: Episode,
+	filePath: string,
+): DownloadedEpisode | undefined {
 	const existing = get(plugin).app.vault.getAbstractFileByPath(filePath);
 	if (!(existing instanceof TFile)) return undefined;
 	if (!registeredDownloadOwnsPath(episode, filePath)) {
 		throw downloadDestinationCollisionError();
 	}
-	return downloadedEpisodes.getEpisode(episode)?.size;
+	return downloadedEpisodes.getEpisode(episode);
 }
 
 // Download an episode to a vault file with bounded memory using the binary append
@@ -173,9 +178,14 @@ async function startDownloadEpisodeToDisk(
 	const urlExtension = getUrlExtension(episode.streamUrl);
 	if (urlExtension) {
 		const provisionalPath = safeDownloadFilePath(downloadPathTemplate, episode, urlExtension);
-		const cachedSize = ownedExistingDownloadSize(episode, provisionalPath);
-		if (cachedSize !== undefined) {
-			downloadedEpisodes.addEpisode(episode, provisionalPath, cachedSize);
+		const cached = ownedExistingDownload(episode, provisionalPath);
+		if (cached) {
+			downloadedEpisodes.addEpisode(
+				episode,
+				provisionalPath,
+				cached.size,
+				cached.downloadedByPodNotes,
+			);
 			return provisionalPath;
 		}
 	}
@@ -192,9 +202,14 @@ async function startDownloadEpisodeToDisk(
 		probe.firstChunk,
 		probe.contentType,
 	);
-	const existingSize = reusableExistingDownloadSize(episode, filePath);
-	if (existingSize !== undefined) {
-		downloadedEpisodes.addEpisode(episode, filePath, existingSize);
+	const existing = reusableExistingDownload(episode, filePath);
+	if (existing) {
+		downloadedEpisodes.addEpisode(
+			episode,
+			filePath,
+			existing.size,
+			existing.downloadedByPodNotes,
+		);
 		return filePath;
 	}
 
@@ -218,7 +233,7 @@ async function startDownloadEpisodeToDisk(
 		await moveIntoPlace(tmpPath, filePath);
 		moved = true;
 
-		downloadedEpisodes.addEpisode(episode, filePath, total);
+		downloadedEpisodes.addEpisode(episode, filePath, total, true);
 		return filePath;
 	} finally {
 		if (!moved) await deleteEpisodeFile(tmpPath);
@@ -352,9 +367,13 @@ export function safeDownloadFilePath(
 }
 
 export async function removeDownloadedEpisode(episode: Episode): Promise<void> {
-	const removedFilePath = downloadedEpisodes.removeEpisode(episode);
-	if (removedFilePath && !isLocalFile(episode)) {
-		await deleteEpisodeFile(removedFilePath);
+	const removed = downloadedEpisodes.removeEpisode(episode);
+	if (!removed || isLocalFile(removed)) return;
+	if (
+		removed.downloadedByPodNotes ||
+		(await confirmTrashUnownedFile(get(plugin).app, removed.filePath))
+	) {
+		await deleteEpisodeFile(removed.filePath);
 	}
 }
 
diff --git a/src/persistence/collectionCodecs.ts b/src/persistence/collectionCodecs.ts
index e2e47f2d..22f35386 100644
--- a/src/persistence/collectionCodecs.ts
+++ b/src/persistence/collectionCodecs.ts
@@ -179,7 +179,13 @@ export function decodeDownloadedEpisodes(
 					? entry.size
 					: 0;
 			if (size !== entry.size) warn(warnings, `${path}.size`, "value was normalized");
-			return [{ ...decoded, filePath: entry.filePath, size }];
+
+			const download: DownloadedEpisode = { ...decoded, filePath: entry.filePath, size };
+			if ("downloadedByPodNotes" in entry && entry.downloadedByPodNotes !== true) {
+				delete download.downloadedByPodNotes;
+				warn(warnings, `${path}.downloadedByPodNotes`, "value was normalized");
+			}
+			return [download];
 		});
 	}
 	return downloads;
diff --git a/src/store/downloads.ts b/src/store/downloads.ts
index 5a9e4809..6554229d 100644
--- a/src/store/downloads.ts
+++ b/src/store/downloads.ts
@@ -26,7 +26,12 @@ export const downloadedEpisodes = (() => {
 		 * collision), or `undefined` otherwise. The caller surfaces a Notice — this
 		 * store stays pure (no UI/side effects), per the PR #211/#212 layering (#LF-06).
 		 */
-		addEpisode: (episode: Episode, filePath: string, size: number): string | undefined => {
+		addEpisode: (
+			episode: Episode,
+			filePath: string,
+			size: number,
+			downloadedByPodNotes?: true,
+		): string | undefined => {
 			let replacedFilePath: string | undefined;
 
 			update((downloadedEpisodes: { [podcastName: string]: DownloadedEpisode[] }) => {
@@ -44,13 +49,9 @@ export const downloadedEpisodes = (() => {
 					if (existingFilePath && existingFilePath !== filePath) {
 						replacedFilePath = existingFilePath;
 					}
-					podcastEpisodes[idx] = { ...episode, filePath, size };
+					podcastEpisodes[idx] = { ...episode, filePath, size, downloadedByPodNotes };
 				} else {
-					podcastEpisodes.push({
-						...episode,
-						filePath,
-						size,
-					});
+					podcastEpisodes.push({ ...episode, filePath, size, downloadedByPodNotes });
 				}
 
 				downloadedEpisodes[episode.podcastName] = podcastEpisodes;
@@ -59,8 +60,8 @@ export const downloadedEpisodes = (() => {
 
 			return replacedFilePath;
 		},
-		removeEpisode: (episode: Episode): string | undefined => {
-			let removedFilePath: string | undefined;
+		removeEpisode: (episode: Episode): DownloadedEpisode | undefined => {
+			let removed: DownloadedEpisode | undefined;
 
 			update((downloadedEpisodes) => {
 				const podcastEpisodes = downloadedEpisodes[episode.podcastName] || [];
@@ -71,14 +72,13 @@ export const downloadedEpisodes = (() => {
 					return downloadedEpisodes;
 				}
 
-				removedFilePath = podcastEpisodes[index].filePath;
-				podcastEpisodes.splice(index, 1);
+				[removed] = podcastEpisodes.splice(index, 1);
 
 				downloadedEpisodes[episode.podcastName] = podcastEpisodes;
 				return downloadedEpisodes;
 			});
 
-			return removedFilePath;
+			return removed;
 		},
 		getEpisode: (episode: Episode) => {
 			return get(store)[episode.podcastName]?.find((e) => e.title === episode.title);
diff --git a/src/store/index.test.ts b/src/store/index.test.ts
index 205d925d..0bd675fc 100644
--- a/src/store/index.test.ts
+++ b/src/store/index.test.ts
@@ -321,15 +321,15 @@ describe("downloadedEpisodes store — removeEpisode is pure (no vault I/O)", ()
 		downloadedEpisodes.set({});
 	});
 
-	test("removes the entry and returns its backing file path", () => {
+	test("removes the entry and returns the stored download", () => {
 		const downloaded = downloadedEpisode("Design Podcast", "Episode 1", {
 			filePath: "podcasts/design/ep1.mp3",
 		});
-		downloadedEpisodes.addEpisode(downloaded, downloaded.filePath, 2048);
+		downloadedEpisodes.addEpisode(downloaded, downloaded.filePath, 2048, true);
 
-		const removedFilePath = downloadedEpisodes.removeEpisode(downloaded);
+		const removed = downloadedEpisodes.removeEpisode(ep("Episode 1", "Design Podcast"));
 
-		expect(removedFilePath).toBe("podcasts/design/ep1.mp3");
+		expect(removed).toEqual({ ...downloaded, size: 2048, downloadedByPodNotes: true });
 		expect(downloadedEpisodes.isEpisodeDownloaded(downloaded)).toBe(false);
 		expect(get(downloadedEpisodes)["Design Podcast"]).toEqual([]);
 	});
@@ -339,9 +339,9 @@ describe("downloadedEpisodes store — removeEpisode is pure (no vault I/O)", ()
 		downloadedEpisodes.addEpisode(present, present.filePath, 1024);
 
 		const missing = downloadedEpisode("Design Podcast", "Never downloaded");
-		const removedFilePath = downloadedEpisodes.removeEpisode(missing);
+		const removed = downloadedEpisodes.removeEpisode(missing);
 
-		expect(removedFilePath).toBeUndefined();
+		expect(removed).toBeUndefined();
 		expect(downloadedEpisodes.isEpisodeDownloaded(present)).toBe(true);
 	});
 });
diff --git a/src/types/DownloadedEpisode.ts b/src/types/DownloadedEpisode.ts
index a10a9759..6b0189da 100644
--- a/src/types/DownloadedEpisode.ts
+++ b/src/types/DownloadedEpisode.ts
@@ -3,4 +3,10 @@ import type { Episode } from "./Episode";
 export default interface DownloadedEpisode extends Episode {
 	filePath: string;
 	size: number;
+	/**
+	 * Set only when PodNotes wrote the file itself. Older releases registered any
+	 * file already at a download path, so an entry without it may point at the
+	 * user's own file.
+	 */
+	downloadedByPodNotes?: true;
 }
diff --git a/src/ui/ConfirmTrashUnownedFileModal.ts b/src/ui/ConfirmTrashUnownedFileModal.ts
new file mode 100644
index 00000000..ab4b0c17
--- /dev/null
+++ b/src/ui/ConfirmTrashUnownedFileModal.ts
@@ -0,0 +1,49 @@
+import { type App, Modal, Setting } from "obsidian";
+
+class ConfirmTrashUnownedFileModal extends Modal {
+	private filePath: string;
+	private onAnswer: (moveToTrash: boolean) => void;
+	private moveToTrash = false;
+
+	constructor(app: App, filePath: string, onAnswer: (moveToTrash: boolean) => void) {
+		super(app);
+		this.filePath = filePath;
+		this.onAnswer = onAnswer;
+	}
+
+	override onOpen(): void {
+		this.contentEl.createEl("p", {
+			text: `PodNotes cannot confirm that it downloaded "${this.filePath}".`,
+		});
+
+		new Setting(this.contentEl)
+			.addButton((button) => {
+				button
+					.setButtonText("Keep file")
+					.setCta()
+					.onClick(() => this.close());
+				button.buttonEl.focus();
+			})
+			.addButton((button) =>
+				button
+					.setButtonText("Move to trash")
+					.setDestructive()
+					.onClick(() => {
+						this.moveToTrash = true;
+						this.close();
+					}),
+			);
+	}
+
+	override onClose(): void {
+		this.contentEl.empty();
+		this.onAnswer(this.moveToTrash);
+	}
+}
+
+/** Resolves true only when the user chooses "Move to trash". */
+export function confirmTrashUnownedFile(app: App, filePath: string): Promise<boolean> {
+	return new Promise((resolve) =>
+		new ConfirmTrashUnownedFileModal(app, filePath, resolve).open(),
+	);
+}

From cc44bffb4b3d49925734fbecb7d377a02dceb6c6 Mon Sep 17 00:00:00 2001
From: Christian Bager Bach Houmann <christian@bagerbach.com>
Date: Sun, 11 Oct 2026 05:11:00 +0200
Subject: [PATCH 05/11] test: dismiss the removal prompt through Obsidian's
 close control

Obsidian 1.13 renders a modal's close control as .modal-header-button, so
the Modal mock and the unit test use that class. The e2e test now closes
its own prompt when it fails partway, so a later run cannot read it.
---
 src/downloadEpisode.test.ts           | 2 +-
 tests/e2e/local-files-runtime.test.ts | 5 +++++
 tests/mocks/obsidian.ts               | 2 +-
 3 files changed, 7 insertions(+), 2 deletions(-)

diff --git a/src/downloadEpisode.test.ts b/src/downloadEpisode.test.ts
index 5c841ada..a4c5fcdc 100644
--- a/src/downloadEpisode.test.ts
+++ b/src/downloadEpisode.test.ts
@@ -653,7 +653,7 @@ describe("removeDownloadedEpisode", () => {
 	const moveToTrash = () =>
 		fireEvent.click(screen.getByRole("button", { name: "Move to trash" }));
 	const dismissPrompt = () => {
-		const closeButton = document.querySelector(".modal-close-button");
+		const closeButton = document.querySelector(".modal-header-button");
 		if (!closeButton) throw new Error("The prompt has no close button.");
 		fireEvent.click(closeButton);
 	};
diff --git a/tests/e2e/local-files-runtime.test.ts b/tests/e2e/local-files-runtime.test.ts
index 8f237968..5e8b6a42 100644
--- a/tests/e2e/local-files-runtime.test.ts
+++ b/tests/e2e/local-files-runtime.test.ts
@@ -219,6 +219,11 @@ describe("local files runtime", () => {
 			await evalJsonAsync<boolean>(
 				obsidian,
 				`(async () => {
+					for (const modal of document.querySelectorAll(".modal-container")) {
+						if (modal.textContent.includes(${JSON.stringify(String(stamp))})) {
+							modal.querySelector(".modal-header-button")?.click();
+						}
+					}
 					for (const path of ${JSON.stringify(await trashedFixtures())}) {
 						await app.vault.adapter.remove(path);
 					}
diff --git a/tests/mocks/obsidian.ts b/tests/mocks/obsidian.ts
index 3248075e..bc952f8d 100644
--- a/tests/mocks/obsidian.ts
+++ b/tests/mocks/obsidian.ts
@@ -75,7 +75,7 @@ export class Modal {
 		this.titleEl = document.createElement("div");
 		this.contentEl = document.createElement("div");
 		const closeButtonEl = document.createElement("div");
-		closeButtonEl.className = "modal-close-button";
+		closeButtonEl.className = "modal-header-button";
 		closeButtonEl.addEventListener("click", () => this.close());
 		this.containerEl.append(closeButtonEl, this.titleEl, this.contentEl);
 	}

From f3ea84de2e1794bbece8d1be2b5b6896b36c92d1 Mon Sep 17 00:00:00 2001
From: Christian Bager Bach Houmann <christian@bagerbach.com>
Date: Sun, 11 Oct 2026 05:23:10 +0200
Subject: [PATCH 06/11] fix: show the removal prompt's buttons in Obsidian's
 modal button row

The Setting row drew a divider and an empty label column above the two buttons. A modal-button-container matches Obsidian's own confirm dialogs.
---
 src/ui/ConfirmTrashUnownedFileModal.ts | 32 +++++++++++---------------
 1 file changed, 14 insertions(+), 18 deletions(-)

diff --git a/src/ui/ConfirmTrashUnownedFileModal.ts b/src/ui/ConfirmTrashUnownedFileModal.ts
index ab4b0c17..a81f3b42 100644
--- a/src/ui/ConfirmTrashUnownedFileModal.ts
+++ b/src/ui/ConfirmTrashUnownedFileModal.ts
@@ -1,4 +1,4 @@
-import { type App, Modal, Setting } from "obsidian";
+import { type App, ButtonComponent, Modal } from "obsidian";
 
 class ConfirmTrashUnownedFileModal extends Modal {
 	private filePath: string;
@@ -16,23 +16,19 @@ class ConfirmTrashUnownedFileModal extends Modal {
 			text: `PodNotes cannot confirm that it downloaded "${this.filePath}".`,
 		});
 
-		new Setting(this.contentEl)
-			.addButton((button) => {
-				button
-					.setButtonText("Keep file")
-					.setCta()
-					.onClick(() => this.close());
-				button.buttonEl.focus();
-			})
-			.addButton((button) =>
-				button
-					.setButtonText("Move to trash")
-					.setDestructive()
-					.onClick(() => {
-						this.moveToTrash = true;
-						this.close();
-					}),
-			);
+		const buttons = this.contentEl.createDiv({ cls: "modal-button-container" });
+		const keepFile = new ButtonComponent(buttons)
+			.setButtonText("Keep file")
+			.setCta()
+			.onClick(() => this.close());
+		new ButtonComponent(buttons)
+			.setButtonText("Move to trash")
+			.setDestructive()
+			.onClick(() => {
+				this.moveToTrash = true;
+				this.close();
+			});
+		keepFile.buttonEl.focus();
 	}
 
 	override onClose(): void {

From f7b12e6219c58e5cf0ab1bb6be97949d5488d05e Mon Sep 17 00:00:00 2001
From: Christian Bager Bach Houmann <christian@bagerbach.com>
Date: Sun, 11 Oct 2026 05:38:09 +0200
Subject: [PATCH 07/11] test: cover removing downloads the vault has not
 indexed

An unconfirmed entry whose file the vault index does not resolve must be
dropped without a prompt and without touching the disk, and a confirmed
removal must trash the indexed file, never unlink a path. Also cover the
owned direction of download reuse and name the two owned-removal tests
by how their entry came to be.
---
 src/downloadEpisode.test.ts | 103 +++++++++++++++++++++++++++++++++++-
 1 file changed, 101 insertions(+), 2 deletions(-)

diff --git a/src/downloadEpisode.test.ts b/src/downloadEpisode.test.ts
index a4c5fcdc..8f9488f7 100644
--- a/src/downloadEpisode.test.ts
+++ b/src/downloadEpisode.test.ts
@@ -678,11 +678,27 @@ describe("removeDownloadedEpisode", () => {
 		} as unknown as Awaited<ReturnType<typeof requestUrl>>);
 	}
 
+	// Plays a user who confirms whatever PodNotes asks, so a wrong prompt shows its effect.
+	async function removeConfirmingAnyPrompt(episode: Episode): Promise<{ asked: boolean }> {
+		let settled = false;
+		const removal = removeDownloadedEpisode(episode).finally(() => {
+			settled = true;
+		});
+		let asked = false;
+		await vi.waitFor(() => {
+			if (settled) return;
+			moveToTrash();
+			asked = true;
+		});
+		await removal;
+		return { asked };
+	}
+
 	afterEach(() => {
 		document.body.replaceChildren();
 	});
 
-	it("trashes a file PodNotes downloaded without asking", async () => {
+	it("trashes a stored entry marked as PodNotes' own without asking", async () => {
 		const vault = setupVault();
 		const episode = makeEpisode();
 		const filePath = "Podcasts/My Title.mp3";
@@ -739,6 +755,61 @@ describe("removeDownloadedEpisode", () => {
 		},
 	);
 
+	it("drops an unconfirmed entry whose file the vault has not indexed and leaves the file", async () => {
+		const vault = setupVault();
+		const episode = makeEpisode({ title: "Fixture Episode 2" });
+		const filePath = "Recordings/Fixture Episode 2.wav";
+		// A case-only folder rename on a case-insensitive disk: the adapter still
+		// finds the old path, the vault index does not.
+		vault.disk.add(filePath);
+		downloadedEpisodes.set({ Pod: [{ ...episode, filePath, size: 4 }] });
+
+		const { asked } = await removeConfirmingAnyPrompt(episode);
+
+		expect({
+			asked,
+			trashed: vault.trashFile.mock.calls.length,
+			unlinked: vault.removeFile.mock.calls.length,
+			onDisk: vault.disk.has(filePath),
+		}).toEqual({ asked: false, trashed: 0, unlinked: 0, onDisk: true });
+		expect(get(downloadedEpisodes).Pod).toEqual([]);
+	});
+
+	it.each([
+		["whose file is gone", "Recordings/Gone.wav"],
+		["without a file path", ""],
+	])("drops an unconfirmed entry %s without asking", async (_case, filePath) => {
+		const vault = setupVault();
+		const episode = makeEpisode();
+		downloadedEpisodes.set({ Pod: [{ ...episode, filePath, size: 4 }] });
+
+		const { asked } = await removeConfirmingAnyPrompt(episode);
+
+		expect(asked).toBe(false);
+		expect(get(downloadedEpisodes).Pod).toEqual([]);
+		expect(vault.trashFile).not.toHaveBeenCalled();
+		expect(vault.removeFile).not.toHaveBeenCalled();
+	});
+
+	it("trashes the file it asked about even if the vault index loses its path meanwhile", async () => {
+		const vault = setupVault();
+		const episode = makeEpisode({ title: "Fixture Episode 2" });
+		const filePath = "Recordings/Fixture Episode 2.wav";
+		putOnDisk(vault, filePath);
+		downloadedEpisodes.set({ Pod: [{ ...episode, filePath, size: 4 }] });
+
+		const removal = removeDownloadedEpisode(episode);
+		await vi.waitFor(() => expect(screen.getByText(promptFor(filePath))).toBeTruthy());
+		vault.present.delete(filePath);
+		moveToTrash();
+		await removal;
+
+		expect({
+			trashed: vault.trashFile.mock.calls.map(([file]) => file.path),
+			unlinked: vault.removeFile.mock.calls.length,
+		}).toEqual({ trashed: [filePath], unlinked: 0 });
+	});
+
 	const interviewPath = "Recordings/Interview.wav";
 	const interview: LocalEpisode = {
 		title: "Interview",
@@ -780,7 +851,7 @@ describe("removeDownloadedEpisode", () => {
 		expectKeptOnDisk(vault, interviewPath);
 	});
 
-	it("trashes a file it downloaded itself without asking", async () => {
+	it("trashes a file the download flow wrote without asking", async () => {
 		const vault = setupVault();
 		mockAudioResponse();
 		const episode = makeEpisode();
@@ -815,6 +886,34 @@ describe("removeDownloadedEpisode", () => {
 		expect(vault.writeBinary).not.toHaveBeenCalled();
 		expect(get(downloadedEpisodes).Pod).toEqual([registered]);
 	});
+
+	it.each([
+		["its URL extension", "https://example.com/ep.mp3", 1],
+		["its sniffed destination", "https://example.com/stream?id=42", 2],
+	])(
+		"keeps its own download confirmed when it reuses it at %s",
+		async (_case, streamUrl, requests) => {
+			const vault = setupVault();
+			mockAudioResponse();
+			const episode = makeEpisode({ streamUrl });
+			const filePath = "Podcasts/My Title.mp3";
+
+			await downloadEpisodeWithNotice(episode, "Podcasts/{{title}}");
+			await downloadEpisodeWithNotice(episode, "Podcasts/{{title}}");
+
+			expect(vault.writeBinary).toHaveBeenCalledOnce();
+			expect(requestUrlMock).toHaveBeenCalledTimes(requests);
+			expect(get(downloadedEpisodes).Pod).toEqual([
+				expect.objectContaining({ filePath, downloadedByPodNotes: true }),
+			]);
+
+			const { asked } = await removeConfirmingAnyPrompt(episode);
+
+			expect(asked).toBe(false);
+			expect(vault.trashFile).toHaveBeenCalledOnce();
+			expect(vault.present.has(filePath)).toBe(false);
+		},
+	);
 });
 
 describe("safeDownloadFilePath (#22)", () => {

From 16ab1e6d8909e00e8a45d26b31f1140eabc4e316 Mon Sep 17 00:00:00 2001
From: Christian Bager Bach Houmann <christian@bagerbach.com>
Date: Sun, 11 Oct 2026 05:39:21 +0200
Subject: [PATCH 08/11] fix: trash only an indexed file when removing an
 unconfirmed download

Removing a download PodNotes cannot confirm it made now resolves the file
through the vault index first. A missing or unindexed file drops the entry
without a prompt, and a confirmed removal trashes the resolved file through
FileManager instead of falling back to a permanent adapter delete.

A download blocked by an existing file now says what was checked. The
registered owner lookup returns the entry it found, and addEpisode takes
download ownership as an option.
---
 src/downloadEpisode.test.ts                  |  2 +-
 src/downloadEpisode.ts                       | 66 ++++++++++----------
 src/store/downloads.ts                       |  2 +-
 src/store/index.test.ts                      |  4 +-
 tests/e2e/marketplace-review-runtime.test.ts |  5 ++
 5 files changed, 44 insertions(+), 35 deletions(-)

diff --git a/src/downloadEpisode.test.ts b/src/downloadEpisode.test.ts
index 8f9488f7..fbb4799d 100644
--- a/src/downloadEpisode.test.ts
+++ b/src/downloadEpisode.test.ts
@@ -1638,7 +1638,7 @@ describe("downloadEpisodeWithNotice (streaming range path)", () => {
 
 		await downloadEpisodeWithNotice(episodeA, template);
 		await expect(downloadEpisodeWithNotice(episodeB, template)).rejects.toThrow(
-			"A different episode already occupies the selected destination.",
+			'A file already exists at "Podcasts/shared.mp3".',
 		);
 
 		// Episode B pays one Range probe before the collision surfaces: the
diff --git a/src/downloadEpisode.ts b/src/downloadEpisode.ts
index 528ff9a5..bed9ae54 100644
--- a/src/downloadEpisode.ts
+++ b/src/downloadEpisode.ts
@@ -97,8 +97,8 @@ function downloadAlreadyInProgressError(): Error {
 	return new Error("A download is already in progress for the selected destination.");
 }
 
-function downloadDestinationCollisionError(): Error {
-	return new Error("A different episode already occupies the selected destination.");
+function downloadDestinationCollisionError(filePath: string): Error {
+	return new Error(`A file already exists at "${filePath}".`);
 }
 
 // Single source of truth for "what extension and on-disk path does this download
@@ -121,10 +121,10 @@ function resolveDownloadTarget(
 	};
 }
 
-function registeredDownloadOwnsPath(episode: Episode, filePath: string): boolean {
+function registeredOwnerOfPath(episode: Episode, filePath: string): DownloadedEpisode | undefined {
 	const normalizedPath = normalizePath(filePath);
 	const registered = downloadedEpisodes.getEpisode(episode);
-	if (!registered || normalizePath(registered.filePath) !== normalizedPath) return false;
+	if (!registered || normalizePath(registered.filePath) !== normalizedPath) return undefined;
 
 	const anotherOwner = Object.values(get(downloadedEpisodes))
 		.flat()
@@ -132,12 +132,12 @@ function registeredDownloadOwnsPath(episode: Episode, filePath: string): boolean
 			(candidate) =>
 				candidate !== registered && normalizePath(candidate.filePath) === normalizedPath,
 		);
-	if (anotherOwner) return false;
+	if (anotherOwner) return undefined;
 
-	if (isLocalFile(episode)) {
-		return Boolean(episode.filePath && normalizePath(episode.filePath) === normalizedPath);
-	}
-	return isSameMediaSource(registered.streamUrl, episode.streamUrl);
+	const owns = isLocalFile(episode)
+		? Boolean(episode.filePath && normalizePath(episode.filePath) === normalizedPath)
+		: isSameMediaSource(registered.streamUrl, episode.streamUrl);
+	return owns ? registered : undefined;
 }
 
 // Fast-path variant: the path here is only the URL-extension guess, so a foreign
@@ -146,8 +146,7 @@ function registeredDownloadOwnsPath(episode: Episode, filePath: string): boolean
 function ownedExistingDownload(episode: Episode, filePath: string): DownloadedEpisode | undefined {
 	const existing = get(plugin).app.vault.getAbstractFileByPath(filePath);
 	if (!(existing instanceof TFile)) return undefined;
-	if (!registeredDownloadOwnsPath(episode, filePath)) return undefined;
-	return downloadedEpisodes.getEpisode(episode);
+	return registeredOwnerOfPath(episode, filePath);
 }
 
 // Resolved-destination variant: the final path is known, so a foreign occupant
@@ -158,10 +157,9 @@ function reusableExistingDownload(
 ): DownloadedEpisode | undefined {
 	const existing = get(plugin).app.vault.getAbstractFileByPath(filePath);
 	if (!(existing instanceof TFile)) return undefined;
-	if (!registeredDownloadOwnsPath(episode, filePath)) {
-		throw downloadDestinationCollisionError();
-	}
-	return downloadedEpisodes.getEpisode(episode);
+	const owner = registeredOwnerOfPath(episode, filePath);
+	if (!owner) throw downloadDestinationCollisionError(filePath);
+	return owner;
 }
 
 // Download an episode to a vault file with bounded memory using the binary append
@@ -180,12 +178,9 @@ async function startDownloadEpisodeToDisk(
 		const provisionalPath = safeDownloadFilePath(downloadPathTemplate, episode, urlExtension);
 		const cached = ownedExistingDownload(episode, provisionalPath);
 		if (cached) {
-			downloadedEpisodes.addEpisode(
-				episode,
-				provisionalPath,
-				cached.size,
-				cached.downloadedByPodNotes,
-			);
+			downloadedEpisodes.addEpisode(episode, provisionalPath, cached.size, {
+				downloadedByPodNotes: cached.downloadedByPodNotes,
+			});
 			return provisionalPath;
 		}
 	}
@@ -204,12 +199,9 @@ async function startDownloadEpisodeToDisk(
 	);
 	const existing = reusableExistingDownload(episode, filePath);
 	if (existing) {
-		downloadedEpisodes.addEpisode(
-			episode,
-			filePath,
-			existing.size,
-			existing.downloadedByPodNotes,
-		);
+		downloadedEpisodes.addEpisode(episode, filePath, existing.size, {
+			downloadedByPodNotes: existing.downloadedByPodNotes,
+		});
 		return filePath;
 	}
 
@@ -233,7 +225,7 @@ async function startDownloadEpisodeToDisk(
 		await moveIntoPlace(tmpPath, filePath);
 		moved = true;
 
-		downloadedEpisodes.addEpisode(episode, filePath, total, true);
+		downloadedEpisodes.addEpisode(episode, filePath, total, { downloadedByPodNotes: true });
 		return filePath;
 	} finally {
 		if (!moved) await deleteEpisodeFile(tmpPath);
@@ -369,11 +361,21 @@ export function safeDownloadFilePath(
 export async function removeDownloadedEpisode(episode: Episode): Promise<void> {
 	const removed = downloadedEpisodes.removeEpisode(episode);
 	if (!removed || isLocalFile(removed)) return;
-	if (
-		removed.downloadedByPodNotes ||
-		(await confirmTrashUnownedFile(get(plugin).app, removed.filePath))
-	) {
+	if (removed.downloadedByPodNotes) {
 		await deleteEpisodeFile(removed.filePath);
+		return;
+	}
+
+	// The file may be the user's own. Trash only a file the vault index resolves,
+	// because deleteEpisodeFile's adapter fallback deletes a path the index misses
+	// permanently.
+	const { app } = get(plugin);
+	const file = app.vault.getAbstractFileByPath(removed.filePath);
+	if (!(file instanceof TFile) || !(await confirmTrashUnownedFile(app, file.path))) return;
+	try {
+		await app.fileManager.trashFile(file);
+	} catch (error) {
+		console.error(`Failed to delete downloaded file "${file.path}":`, error);
 	}
 }
 
diff --git a/src/store/downloads.ts b/src/store/downloads.ts
index 6554229d..0fd93a83 100644
--- a/src/store/downloads.ts
+++ b/src/store/downloads.ts
@@ -30,7 +30,7 @@ export const downloadedEpisodes = (() => {
 			episode: Episode,
 			filePath: string,
 			size: number,
-			downloadedByPodNotes?: true,
+			{ downloadedByPodNotes }: { downloadedByPodNotes?: true } = {},
 		): string | undefined => {
 			let replacedFilePath: string | undefined;
 
diff --git a/src/store/index.test.ts b/src/store/index.test.ts
index 0bd675fc..ec677f44 100644
--- a/src/store/index.test.ts
+++ b/src/store/index.test.ts
@@ -325,7 +325,9 @@ describe("downloadedEpisodes store — removeEpisode is pure (no vault I/O)", ()
 		const downloaded = downloadedEpisode("Design Podcast", "Episode 1", {
 			filePath: "podcasts/design/ep1.mp3",
 		});
-		downloadedEpisodes.addEpisode(downloaded, downloaded.filePath, 2048, true);
+		downloadedEpisodes.addEpisode(downloaded, downloaded.filePath, 2048, {
+			downloadedByPodNotes: true,
+		});
 
 		const removed = downloadedEpisodes.removeEpisode(ep("Episode 1", "Design Podcast"));
 
diff --git a/tests/e2e/marketplace-review-runtime.test.ts b/tests/e2e/marketplace-review-runtime.test.ts
index 5ba23aca..c91ae5e9 100644
--- a/tests/e2e/marketplace-review-runtime.test.ts
+++ b/tests/e2e/marketplace-review-runtime.test.ts
@@ -214,6 +214,11 @@ describe("marketplace review runtime paths", () => {
 					AUDIO_BYTES.byteLength,
 				WAIT_OPTS,
 			);
+			const stored = await plugin.data<PodNotesData>().read();
+			expect(stored.downloadedEpisodes?.[episode.podcastName]?.[0]).toMatchObject({
+				filePath: expectedPath,
+				downloadedByPodNotes: true,
+			});
 
 			const downloaded = await evalJsonAsync<{
 				appendCalls: number;

From 0c9e6ef9a718e636de181f88a68b53d07326f8d2 Mon Sep 17 00:00:00 2001
From: Christian Bager Bach Houmann <christian@bagerbach.com>
Date: Sun, 11 Oct 2026 05:55:39 +0200
Subject: [PATCH 09/11] refactor: name the delete helper after the files it may
 remove

deleteFileWrittenByPodNotes falls back to a permanent adapter delete for paths the vault index misses, so only partial downloads and owned downloads go through it. Drop comments that restated names or explained that choice.
---
 src/downloadEpisode.test.ts            |  3 ---
 src/downloadEpisode.ts                 | 14 +++++---------
 src/types/DownloadedEpisode.ts         |  5 ++---
 src/ui/ConfirmTrashUnownedFileModal.ts |  1 -
 4 files changed, 7 insertions(+), 16 deletions(-)

diff --git a/src/downloadEpisode.test.ts b/src/downloadEpisode.test.ts
index fbb4799d..3a981da7 100644
--- a/src/downloadEpisode.test.ts
+++ b/src/downloadEpisode.test.ts
@@ -678,7 +678,6 @@ describe("removeDownloadedEpisode", () => {
 		} as unknown as Awaited<ReturnType<typeof requestUrl>>);
 	}
 
-	// Plays a user who confirms whatever PodNotes asks, so a wrong prompt shows its effect.
 	async function removeConfirmingAnyPrompt(episode: Episode): Promise<{ asked: boolean }> {
 		let settled = false;
 		const removal = removeDownloadedEpisode(episode).finally(() => {
@@ -759,8 +758,6 @@ describe("removeDownloadedEpisode", () => {
 		const vault = setupVault();
 		const episode = makeEpisode({ title: "Fixture Episode 2" });
 		const filePath = "Recordings/Fixture Episode 2.wav";
-		// A case-only folder rename on a case-insensitive disk: the adapter still
-		// finds the old path, the vault index does not.
 		vault.disk.add(filePath);
 		downloadedEpisodes.set({ Pod: [{ ...episode, filePath, size: 4 }] });
 
diff --git a/src/downloadEpisode.ts b/src/downloadEpisode.ts
index bed9ae54..716a0cf6 100644
--- a/src/downloadEpisode.ts
+++ b/src/downloadEpisode.ts
@@ -141,8 +141,7 @@ function registeredOwnerOfPath(episode: Episode, filePath: string): DownloadedEp
 }
 
 // Fast-path variant: the path here is only the URL-extension guess, so a foreign
-// occupant is not a collision yet - the sniffed final path may differ. Returns the
-// registered entry only when this episode already owns the file.
+// occupant is not a collision yet - the sniffed final path may differ.
 function ownedExistingDownload(episode: Episode, filePath: string): DownloadedEpisode | undefined {
 	const existing = get(plugin).app.vault.getAbstractFileByPath(filePath);
 	if (!(existing instanceof TFile)) return undefined;
@@ -228,7 +227,7 @@ async function startDownloadEpisodeToDisk(
 		downloadedEpisodes.addEpisode(episode, filePath, total, { downloadedByPodNotes: true });
 		return filePath;
 	} finally {
-		if (!moved) await deleteEpisodeFile(tmpPath);
+		if (!moved) await deleteFileWrittenByPodNotes(tmpPath);
 	}
 }
 
@@ -362,26 +361,23 @@ export async function removeDownloadedEpisode(episode: Episode): Promise<void> {
 	const removed = downloadedEpisodes.removeEpisode(episode);
 	if (!removed || isLocalFile(removed)) return;
 	if (removed.downloadedByPodNotes) {
-		await deleteEpisodeFile(removed.filePath);
+		await deleteFileWrittenByPodNotes(removed.filePath);
 		return;
 	}
 
-	// The file may be the user's own. Trash only a file the vault index resolves,
-	// because deleteEpisodeFile's adapter fallback deletes a path the index misses
-	// permanently.
 	const { app } = get(plugin);
 	const file = app.vault.getAbstractFileByPath(removed.filePath);
 	if (!(file instanceof TFile) || !(await confirmTrashUnownedFile(app, file.path))) return;
 	try {
 		await app.fileManager.trashFile(file);
 	} catch (error) {
-		console.error(`Failed to delete downloaded file "${file.path}":`, error);
+		console.error(`Failed to trash "${file.path}":`, error);
 	}
 }
 
 // Best-effort: a missing/already-removed file is a no-op, and failures are logged
 // rather than thrown so removing a stale entry never breaks the calling UI flow.
-async function deleteEpisodeFile(filePath: string): Promise<void> {
+async function deleteFileWrittenByPodNotes(filePath: string): Promise<void> {
 	if (!filePath) return;
 
 	const { app } = get(plugin);
diff --git a/src/types/DownloadedEpisode.ts b/src/types/DownloadedEpisode.ts
index 6b0189da..f189043d 100644
--- a/src/types/DownloadedEpisode.ts
+++ b/src/types/DownloadedEpisode.ts
@@ -4,9 +4,8 @@ export default interface DownloadedEpisode extends Episode {
 	filePath: string;
 	size: number;
 	/**
-	 * Set only when PodNotes wrote the file itself. Older releases registered any
-	 * file already at a download path, so an entry without it may point at the
-	 * user's own file.
+	 * Older releases registered any file already at a download path, so an entry
+	 * without it may point at the user's own file.
 	 */
 	downloadedByPodNotes?: true;
 }
diff --git a/src/ui/ConfirmTrashUnownedFileModal.ts b/src/ui/ConfirmTrashUnownedFileModal.ts
index a81f3b42..2dd4fc56 100644
--- a/src/ui/ConfirmTrashUnownedFileModal.ts
+++ b/src/ui/ConfirmTrashUnownedFileModal.ts
@@ -37,7 +37,6 @@ class ConfirmTrashUnownedFileModal extends Modal {
 	}
 }
 
-/** Resolves true only when the user chooses "Move to trash". */
 export function confirmTrashUnownedFile(app: App, filePath: string): Promise<boolean> {
 	return new Promise((resolve) =>
 		new ConfirmTrashUnownedFileModal(app, filePath, resolve).open(),

From 0cf4b694d912e9e386ae372ca4b1bf1b979ac24f Mon Sep 17 00:00:00 2001
From: Christian Bager Bach Houmann <christian@bagerbach.com>
Date: Sun, 11 Oct 2026 06:11:30 +0200
Subject: [PATCH 10/11] refactor: keep download reuse in one place

Both reuse sites now go through reuseOwnRegistration, which re-registers
this episode's own entry with its recorded ownership and reports whether
the path was free, reused, or held by another file. The fast path ignores
a foreign occupant and the resolved destination treats it as a collision,
as before. registeredOwnerOfPath becomes ownRegistrationAt.

The unindexed-file removal tests now use a dot-folder, which Obsidian
does not index, and the e2e removal test covers that case through the
real Local Files menu.
---
 src/downloadEpisode.test.ts           |  2 +-
 src/downloadEpisode.ts                | 47 ++++++++-------------------
 tests/e2e/local-files-runtime.test.ts | 32 ++++++++++++++++--
 3 files changed, 44 insertions(+), 37 deletions(-)

diff --git a/src/downloadEpisode.test.ts b/src/downloadEpisode.test.ts
index 3a981da7..8806d7db 100644
--- a/src/downloadEpisode.test.ts
+++ b/src/downloadEpisode.test.ts
@@ -757,7 +757,7 @@ describe("removeDownloadedEpisode", () => {
 	it("drops an unconfirmed entry whose file the vault has not indexed and leaves the file", async () => {
 		const vault = setupVault();
 		const episode = makeEpisode({ title: "Fixture Episode 2" });
-		const filePath = "Recordings/Fixture Episode 2.wav";
+		const filePath = ".recordings/Fixture Episode 2.wav";
 		vault.disk.add(filePath);
 		downloadedEpisodes.set({ Pod: [{ ...episode, filePath, size: 4 }] });
 
diff --git a/src/downloadEpisode.ts b/src/downloadEpisode.ts
index 716a0cf6..00752341 100644
--- a/src/downloadEpisode.ts
+++ b/src/downloadEpisode.ts
@@ -121,7 +121,7 @@ function resolveDownloadTarget(
 	};
 }
 
-function registeredOwnerOfPath(episode: Episode, filePath: string): DownloadedEpisode | undefined {
+function ownRegistrationAt(episode: Episode, filePath: string): DownloadedEpisode | undefined {
 	const normalizedPath = normalizePath(filePath);
 	const registered = downloadedEpisodes.getEpisode(episode);
 	if (!registered || normalizePath(registered.filePath) !== normalizedPath) return undefined;
@@ -140,25 +140,15 @@ function registeredOwnerOfPath(episode: Episode, filePath: string): DownloadedEp
 	return owns ? registered : undefined;
 }
 
-// Fast-path variant: the path here is only the URL-extension guess, so a foreign
-// occupant is not a collision yet - the sniffed final path may differ.
-function ownedExistingDownload(episode: Episode, filePath: string): DownloadedEpisode | undefined {
+function reuseOwnRegistration(episode: Episode, filePath: string): "reused" | "free" | "foreign" {
 	const existing = get(plugin).app.vault.getAbstractFileByPath(filePath);
-	if (!(existing instanceof TFile)) return undefined;
-	return registeredOwnerOfPath(episode, filePath);
-}
-
-// Resolved-destination variant: the final path is known, so a foreign occupant
-// is a hard collision.
-function reusableExistingDownload(
-	episode: Episode,
-	filePath: string,
-): DownloadedEpisode | undefined {
-	const existing = get(plugin).app.vault.getAbstractFileByPath(filePath);
-	if (!(existing instanceof TFile)) return undefined;
-	const owner = registeredOwnerOfPath(episode, filePath);
-	if (!owner) throw downloadDestinationCollisionError(filePath);
-	return owner;
+	if (!(existing instanceof TFile)) return "free";
+	const own = ownRegistrationAt(episode, filePath);
+	if (!own) return "foreign";
+	downloadedEpisodes.addEpisode(episode, filePath, own.size, {
+		downloadedByPodNotes: own.downloadedByPodNotes,
+	});
+	return "reused";
 }
 
 // Download an episode to a vault file with bounded memory using the binary append
@@ -175,13 +165,8 @@ async function startDownloadEpisodeToDisk(
 	const urlExtension = getUrlExtension(episode.streamUrl);
 	if (urlExtension) {
 		const provisionalPath = safeDownloadFilePath(downloadPathTemplate, episode, urlExtension);
-		const cached = ownedExistingDownload(episode, provisionalPath);
-		if (cached) {
-			downloadedEpisodes.addEpisode(episode, provisionalPath, cached.size, {
-				downloadedByPodNotes: cached.downloadedByPodNotes,
-			});
-			return provisionalPath;
-		}
+		// A foreign occupant is not a collision yet - the sniffed final path may differ.
+		if (reuseOwnRegistration(episode, provisionalPath) === "reused") return provisionalPath;
 	}
 
 	let probe;
@@ -196,13 +181,9 @@ async function startDownloadEpisodeToDisk(
 		probe.firstChunk,
 		probe.contentType,
 	);
-	const existing = reusableExistingDownload(episode, filePath);
-	if (existing) {
-		downloadedEpisodes.addEpisode(episode, filePath, existing.size, {
-			downloadedByPodNotes: existing.downloadedByPodNotes,
-		});
-		return filePath;
-	}
+	const reuse = reuseOwnRegistration(episode, filePath);
+	if (reuse === "reused") return filePath;
+	if (reuse === "foreign") throw downloadDestinationCollisionError(filePath);
 
 	await ensureFolderExists(parentFolderPath(filePath));
 
diff --git a/tests/e2e/local-files-runtime.test.ts b/tests/e2e/local-files-runtime.test.ts
index 5e8b6a42..851b649c 100644
--- a/tests/e2e/local-files-runtime.test.ts
+++ b/tests/e2e/local-files-runtime.test.ts
@@ -107,14 +107,16 @@ describe("local files runtime", () => {
 		const kept = `E2E Adopted Recording ${stamp}`;
 		const discarded = `E2E Discarded Recording ${stamp}`;
 		const legacy = `E2E Legacy Recording ${stamp}`;
+		const unindexed = `E2E Unindexed Recording ${stamp}`;
 		const recordingPath = (title: string) => sandbox.path("Recordings", `${title}.wav`);
+		const unindexedPath = sandbox.path(".recordings", `${unindexed}.wav`);
 		const promptFor = (title: string) =>
 			`PodNotes cannot confirm that it downloaded "${recordingPath(title)}".`;
 		const inDownloads = (data: PodNotesData, podcastName: string, title: string) =>
 			data.downloadedEpisodes?.[podcastName]?.some((entry) => entry.title === title) ?? false;
 		const trashedFixtures = async () =>
 			(await listTrash(obsidian)).filter((path) => path.includes(String(stamp)));
-		const adoptedByAnOlderRelease = (title: string) => ({
+		const adoptedByAnOlderRelease = (title: string, filePath = recordingPath(title)) => ({
 			title,
 			description: `${title} description.`,
 			content: "",
@@ -126,7 +128,7 @@ describe("local files runtime", () => {
 			episodeDate: "2026-06-30T09:00:00.000Z",
 			duration: 1,
 			mediaType: "audio",
-			filePath: recordingPath(title),
+			filePath,
 			size: SILENT_WAV_SECOND_BYTES,
 		});
 
@@ -135,9 +137,21 @@ describe("local files runtime", () => {
 			await writeSilentWav(obsidian, recordingPath(title), 1);
 			await sandbox.waitForExists(`Recordings/${title}.wav`, WAIT_OPTS);
 		}
+		await sandbox.mkdir(".recordings");
+		await evalJsonAsync<boolean>(
+			obsidian,
+			`(async () => {
+				await app.vault.adapter.writeBinary(${JSON.stringify(unindexedPath)}, new ArrayBuffer(${SILENT_WAV_SECOND_BYTES}));
+				return true;
+			})()`,
+		);
 		await plugin.updateDataAndReload<Record<string, unknown>>((data) => {
 			data.downloadedEpisodes = {
-				[feed]: [adoptedByAnOlderRelease(kept), adoptedByAnOlderRelease(discarded)],
+				[feed]: [
+					adoptedByAnOlderRelease(kept),
+					adoptedByAnOlderRelease(discarded),
+					adoptedByAnOlderRelease(unindexed, unindexedPath),
+				],
 				"local file": [
 					{
 						title: legacy,
@@ -195,6 +209,13 @@ describe("local files runtime", () => {
 				WAIT_OPTS,
 			);
 
+			await clickInPodNotesView(obsidian, `[aria-label="More options for ${unindexed}"]`);
+			await clickMenuItem(obsidian, "Remove file");
+			await plugin.waitForData<PodNotesData>(
+				(data) => !inDownloads(data, feed, unindexed),
+				WAIT_OPTS,
+			);
+
 			const after = await evalJsonAsync<Record<string, boolean>>(
 				obsidian,
 				`(async () => {
@@ -204,6 +225,7 @@ describe("local files runtime", () => {
 						kept: await adapter.exists(${JSON.stringify(recordingPath(kept))}),
 						discarded: await adapter.exists(${JSON.stringify(recordingPath(discarded))}),
 						legacy: await adapter.exists(${JSON.stringify(recordingPath(legacy))}),
+						unindexed: await adapter.exists(${JSON.stringify(unindexedPath)}),
 					};
 				})()`,
 			);
@@ -212,6 +234,7 @@ describe("local files runtime", () => {
 				kept: true,
 				discarded: false,
 				legacy: true,
+				unindexed: true,
 				trashed: [`.trash/${discarded}.wav`],
 			});
 			expect(await obsidian.dev.runtimeErrors()).toEqual([]);
@@ -227,6 +250,9 @@ describe("local files runtime", () => {
 					for (const path of ${JSON.stringify(await trashedFixtures())}) {
 						await app.vault.adapter.remove(path);
 					}
+					if (await app.vault.adapter.exists(${JSON.stringify(unindexedPath)})) {
+						await app.vault.adapter.remove(${JSON.stringify(unindexedPath)});
+					}
 					return true;
 				})()`,
 			);

From eaf9ba8cc39b65c72ee21e3c49ce88cd46bb895e Mon Sep 17 00:00:00 2001
From: Christian Bager Bach Houmann <christian@bagerbach.com>
Date: Sun, 11 Oct 2026 06:26:01 +0200
Subject: [PATCH 11/11] fix: label the removal prompt's destructive button
 Delete file

Obsidian uses Delete for FileManager.trashFile, which follows the user's Deleted files setting, so the label stays true when that setting deletes permanently.
---
 src/downloadEpisode.test.ts            | 9 ++++-----
 src/ui/ConfirmTrashUnownedFileModal.ts | 2 +-
 tests/e2e/local-files-runtime.test.ts  | 2 +-
 3 files changed, 6 insertions(+), 7 deletions(-)

diff --git a/src/downloadEpisode.test.ts b/src/downloadEpisode.test.ts
index 8806d7db..fec75c20 100644
--- a/src/downloadEpisode.test.ts
+++ b/src/downloadEpisode.test.ts
@@ -650,8 +650,7 @@ describe("removeDownloadedEpisode", () => {
 	const promptFor = (filePath: string) =>
 		`PodNotes cannot confirm that it downloaded "${filePath}".`;
 	const keepFile = () => fireEvent.click(screen.getByRole("button", { name: "Keep file" }));
-	const moveToTrash = () =>
-		fireEvent.click(screen.getByRole("button", { name: "Move to trash" }));
+	const deleteFile = () => fireEvent.click(screen.getByRole("button", { name: "Delete file" }));
 	const dismissPrompt = () => {
 		const closeButton = document.querySelector(".modal-header-button");
 		if (!closeButton) throw new Error("The prompt has no close button.");
@@ -686,7 +685,7 @@ describe("removeDownloadedEpisode", () => {
 		let asked = false;
 		await vi.waitFor(() => {
 			if (settled) return;
-			moveToTrash();
+			deleteFile();
 			asked = true;
 		});
 		await removal;
@@ -721,7 +720,7 @@ describe("removeDownloadedEpisode", () => {
 
 	it.each([
 		["Keep file", keepFile, true],
-		["Move to trash", moveToTrash, false],
+		["Delete file", deleteFile, false],
 		["a dismissal", dismissPrompt, true],
 	])(
 		"asks before trashing a feed file PodNotes cannot confirm it downloaded, answered with %s",
@@ -798,7 +797,7 @@ describe("removeDownloadedEpisode", () => {
 		const removal = removeDownloadedEpisode(episode);
 		await vi.waitFor(() => expect(screen.getByText(promptFor(filePath))).toBeTruthy());
 		vault.present.delete(filePath);
-		moveToTrash();
+		deleteFile();
 		await removal;
 
 		expect({
diff --git a/src/ui/ConfirmTrashUnownedFileModal.ts b/src/ui/ConfirmTrashUnownedFileModal.ts
index 2dd4fc56..4bd81079 100644
--- a/src/ui/ConfirmTrashUnownedFileModal.ts
+++ b/src/ui/ConfirmTrashUnownedFileModal.ts
@@ -22,7 +22,7 @@ class ConfirmTrashUnownedFileModal extends Modal {
 			.setCta()
 			.onClick(() => this.close());
 		new ButtonComponent(buttons)
-			.setButtonText("Move to trash")
+			.setButtonText("Delete file")
 			.setDestructive()
 			.onClick(() => {
 				this.moveToTrash = true;
diff --git a/tests/e2e/local-files-runtime.test.ts b/tests/e2e/local-files-runtime.test.ts
index 851b649c..ce12b327 100644
--- a/tests/e2e/local-files-runtime.test.ts
+++ b/tests/e2e/local-files-runtime.test.ts
@@ -195,7 +195,7 @@ describe("local files runtime", () => {
 				focused: "Keep file",
 				original: true,
 			});
-			await clickModalButton(obsidian, "Move to trash");
+			await clickModalButton(obsidian, "Delete file");
 			await sandbox.waitForMissing(`Recordings/${discarded}.wav`, WAIT_OPTS);
 			await plugin.waitForData<PodNotesData>(
 				(data) => !inDownloads(data, feed, discarded),