@@ -10,6 +10,7 @@ import {
 	InstantRecordingUploader,
 	initialLocalRecordingState,
 	initiateMultipartUpload,
+	isRecordingSpoolUploaded,
 	isUserCancellationError,
 	type LocalRecordingState,
 	listRecordingSpoolSessions,
@@ -758,6 +759,12 @@ const sweepOrphanedRecordingSpools = async () => {
 				remainingSessions.add(orphan.sessionId);
 				continue;
 			}
+			if (isRecordingSpoolUploaded(orphan.sessionId)) {
+				void deleteRecoveredRecordingSpool(orphan.sessionId).catch(
+					() => undefined,
+				);
+				continue;
+			}
 			const manifest = manifestsBySession.get(orphan.sessionId);
 			// A surviving manifest belongs to a previous offscreen document. This
 			// document is the extension's only spool writer, so the shared live
@@ -2037,14 +2044,30 @@ const finalizeRecording = async (recording: ActiveRecording) => {
 			fps: recording.fps,
 			subpath: recording.subpath,
 		});
-		await recording.spool.dispose();
-		await recording.cameraSpool?.dispose();
-		await recording.inputSidecar?.dispose().catch(() => undefined);
-		await Promise.all(
-			recording.audioSidecars.map((sidecar) =>
-				sidecar.disposeBackup().catch(() => undefined),
+		recording.spool.markUploaded();
+		recording.cameraSpool?.markUploaded();
+		if (recording.inputSidecar?.isUploadCompleted) {
+			recording.inputSidecar.spool.markUploaded();
+		}
+		for (const sidecar of recording.audioSidecars) {
+			sidecar.markUploadedBackup();
+		}
+		void Promise.all([
+			recording.spool.dispose().catch((error) => {
+				console.error("Failed to remove uploaded screen backup", error);
+			}),
+			recording.cameraSpool?.dispose().catch((error) => {
+				console.error("Failed to remove uploaded camera backup", error);
+			}),
+			recording.inputSidecar?.dispose().catch((error) => {
+				console.error("Failed to remove uploaded input backup", error);
+			}),
+			...recording.audioSidecars.map((sidecar) =>
+				sidecar.disposeBackup().catch((error) => {
+					console.error("Failed to remove uploaded audio backup", error);
+				}),
 			),
-		);
+		]);
 		await removeFailedRecording(recording.spool.sessionId).catch(
 			() => undefined,
 		);
 
@@ -1,13 +1,22 @@
+import {
+	RecordingSpool,
+	recoverOrphanedRecordingSpools,
+} from "@cap/recorder-core/recording-spool";
 import { useEffect } from "react";
 import { createRoot } from "react-dom/client";
 import { useWebRecorder } from "../app/(org)/dashboard/caps/components/web-recorder-dialog/useWebRecorder";
 
 declare global {
 	interface Window {
 		capRecorderHarness?: ReturnType<typeof useWebRecorder>;
+		capRecorderSpool?: typeof RecordingSpool;
+		capRecorderRecoverOrphans?: typeof recoverOrphanedRecordingSpools;
 	}
 }
 
+window.capRecorderSpool = RecordingSpool;
+window.capRecorderRecoverOrphans = recoverOrphanedRecordingSpools;
+
 function RecorderHarness() {
 	const captureMic = new URLSearchParams(location.search).get("mic") === "1";
 	const recorder = useWebRecorder({
 
@@ -118,6 +118,7 @@ async function replayPairedCapture(
 	failCameraSpool = false,
 	failCameraCompletion = false,
 	failAudioResume = false,
+	failBackupDeletion = false,
 ) {
 	const requests = [];
 	const parts = [];
@@ -413,6 +414,13 @@ async function replayPairedCapture(
 			);
 		}
 		await page.waitForTimeout(engine.name === "WebKit" ? 5000 : 1700);
+		if (failBackupDeletion) {
+			await page.evaluate(() => {
+				window.capRecorderSpool.prototype.dispose = async () => {
+					throw new Error("Simulated backup deletion failure");
+				};
+			});
+		}
 		await page.evaluate(() => window.capRecorderHarness.stopRecording());
 		try {
 			await page.waitForFunction(
@@ -482,6 +490,12 @@ async function replayPairedCapture(
 		if (failAudioResume) {
 			assert.equal(browserErrors.length, 1);
 			assert.ok(browserErrors[0].includes("Failed to resume recording"));
+		} else if (failBackupDeletion) {
+			assert.ok(
+				browserErrors.some((error) =>
+					error.includes("Failed to dispose camera recording spool"),
+				),
+			);
 		} else {
 			assert.deepEqual(browserErrors, []);
 		}
@@ -567,10 +581,33 @@ async function replayPairedCapture(
 			[screenComplete.body.width, screenComplete.body.height],
 			[640, 360],
 		);
+		if (failBackupDeletion) {
+			const markers = await page.evaluate(() =>
+				Object.keys(localStorage).filter((key) =>
+					key.startsWith("cap-recording-spool-uploaded:"),
+				),
+			);
+			assert.equal(markers.length, engine.extension === "webm" ? 2 : 1);
+			if (engine.extension === "webm") {
+				assert.deepEqual(
+					await page.evaluate(() => window.capRecorderRecoverOrphans()),
+					[],
+				);
+				await page.waitForFunction(
+					() =>
+						Object.keys(localStorage).every(
+							(key) => !key.startsWith("cap-recording-spool-uploaded:"),
+						),
+					null,
+					{ timeout: 5000 },
+				);
+			}
+		}
 		return {
 			engine: engine.name,
 			pauseResume,
 			failAudioResume,
+			failBackupDeletion,
 			failCameraSpool,
 			cameraBytes,
 			screenBytes,
@@ -630,6 +667,18 @@ try {
 					),
 				);
 			}
+			results.push(
+				await replayPairedCapture(
+					browser,
+					bundle,
+					false,
+					engine,
+					false,
+					false,
+					false,
+					true,
+				),
+			);
 		} finally {
 			await browser.close();
 		}
 
@@ -297,6 +297,7 @@ export const useWebRecorder = ({
 	const audioErrorDownloadUrlsRef = useRef<string[]>([]);
 	const stopInFlightRef = useRef(false);
 	const recordingSpoolRef = useRef<RecordingSpool | null>(null);
+	const degradedRecordingSpoolRef = useRef<RecordingSpool | null>(null);
 	const recordingSpoolDegradingRef = useRef(false);
 	const recordingSpoolWarningShownRef = useRef(false);
 	const recordingSpoolHeartbeatRef = useRef<number | null>(null);
@@ -580,6 +581,7 @@ export const useWebRecorder = ({
 	const disposeRecordingSpool = useCallback(async () => {
 		const spool = recordingSpoolRef.current;
 		recordingSpoolRef.current = null;
+		degradedRecordingSpoolRef.current = null;
 		recordingSpoolDegradingRef.current = false;
 		recordingSpoolWarningShownRef.current = false;
 		stopRecordingSpoolHeartbeat();
@@ -743,6 +745,7 @@ export const useWebRecorder = ({
 
 				recordingSpoolDegradingRef.current = true;
 				recordingSpoolRef.current = null;
+				degradedRecordingSpoolRef.current = spool;
 				stopRecordingSpoolHeartbeat();
 				const backupOverflowed = await moveRecordingSpoolToInMemoryBackup({
 					spool,
@@ -760,6 +763,9 @@ export const useWebRecorder = ({
 
 				try {
 					await spool.dispose();
+					if (degradedRecordingSpoolRef.current === spool) {
+						degradedRecordingSpoolRef.current = null;
+					}
 				} catch (disposeError) {
 					console.error(
 						"Failed to dispose degraded recording spool",
@@ -2102,6 +2108,11 @@ export const useWebRecorder = ({
 			cameraSettingsRef.current = undefined;
 			recordingPipelineRef.current = null;
 			pendingInstantVideoIdRef.current = null;
+			recordingSpoolRef.current?.markUploaded();
+			degradedRecordingSpoolRef.current?.markUploaded();
+			degradedRecordingSpoolRef.current = null;
+			cameraSpoolRef.current?.markUploaded();
+			for (const sidecar of audioSidecars) sidecar.markUploadedBackup();
 			void Promise.all([
 				disposeRecordingSpool(),
 				disposeCameraSpool(),
 
@@ -242,6 +242,51 @@ describe("RecordingSpool", () => {
 		expect(backend.getChunkCount("session-2")).toBe(0);
 	});
 
+	it("hides uploaded backups until a stalled deletion can finish", async () => {
+		const values = new Map<string, string>();
+		vi.stubGlobal("localStorage", {
+			getItem: (key: string) => values.get(key) ?? null,
+			setItem: (key: string, value: string) => values.set(key, value),
+			removeItem: (key: string) => values.delete(key),
+		});
+		const consoleError = vi
+			.spyOn(console, "error")
+			.mockImplementation(() => {});
+		try {
+			const backend = new MemoryRecordingSpoolBackend();
+			const spool = await RecordingSpool.create(
+				{ mimeType: "video/webm", sessionId: "uploaded-backup" },
+				backend,
+			);
+			await spool.appendChunk(new Blob(["uploaded"], { type: "video/webm" }));
+			spool.markUploaded();
+			const key = "cap-recording-spool-uploaded:uploaded-backup";
+			expect(values.get(key)).toBe("1");
+
+			const originalDeleteSession = backend.deleteSession.bind(backend);
+			backend.deleteSession = async () => {
+				throw new Error("Backup deletion stalled");
+			};
+			await expect(spool.dispose()).rejects.toThrow("Backup deletion stalled");
+			const readChunks = vi.spyOn(backend, "readChunks");
+			expect(await recoverOrphanedRecordingSpools(backend)).toEqual([]);
+			expect(readChunks).not.toHaveBeenCalled();
+			expect(backend.getSessionCount()).toBe(1);
+			expect(values.get(key)).toBe("1");
+			await vi.waitFor(() => expect(consoleError).toHaveBeenCalled());
+
+			backend.deleteSession = originalDeleteSession;
+			expect(await recoverOrphanedRecordingSpools(backend)).toEqual([]);
+			await vi.waitFor(() => {
+				expect(backend.getSessionCount()).toBe(0);
+				expect(values.has(key)).toBe(false);
+			});
+		} finally {
+			consoleError.mockRestore();
+			vi.unstubAllGlobals();
+		}
+	});
+
 	it("fails fast when the pending spool backlog grows beyond its limit", async () => {
 		const backend = new DelayedRecordingSpoolBackend();
 		const spool = await RecordingSpool.create(
 
@@ -306,6 +306,10 @@ export class AudioRecordingSidecar {
 		this.memoryBackup = initialLocalRecordingState();
 	}
 
+	markUploadedBackup() {
+		this.spool?.markUploaded();
+	}
+
 	async prepareRetryMetadata(): Promise<AudioSidecarMetadata | null> {
 		await this.stop().catch(() => undefined);
 		if (this.bytes === 0) return null;
 
@@ -38,6 +38,34 @@ const SESSIONS_STORE = "sessions";
 const CHUNKS_STORE = "chunks";
 const DEFAULT_MAX_PENDING_CHUNK_BYTES = 32 * 1024 * 1024;
 const TRANSACTION_TIMEOUT_MS = 15_000;
+const UPLOADED_SESSION_KEY_PREFIX = "cap-recording-spool-uploaded:";
+
+const uploadedSessionKey = (sessionId: string) =>
+	`${UPLOADED_SESSION_KEY_PREFIX}${sessionId}`;
+
+const isUploadedSession = (sessionId: string) => {
+	try {
+		return (
+			globalThis.localStorage?.getItem(uploadedSessionKey(sessionId)) === "1"
+		);
+	} catch {
+		return false;
+	}
+};
+
+export const isRecordingSpoolUploaded = isUploadedSession;
+
+const markUploadedSession = (sessionId: string) => {
+	try {
+		globalThis.localStorage?.setItem(uploadedSessionKey(sessionId), "1");
+	} catch {}
+};
+
+const clearUploadedSession = (sessionId: string) => {
+	try {
+		globalThis.localStorage?.removeItem(uploadedSessionKey(sessionId));
+	} catch {}
+};
 
 // Liveness contract between live recorders and recovery sweeps: a spool whose
 // session was updated within this window must be treated as live and never
@@ -296,6 +324,10 @@ export class RecordingSpool {
 		return [...this.pendingChunks];
 	}
 
+	markUploaded() {
+		markUploadedSession(this.session.sessionId);
+	}
+
 	appendChunk(chunk: Blob) {
 		if (this.disposed) {
 			return Promise.reject(new Error("Recording spool has been disposed"));
@@ -414,6 +446,7 @@ export class RecordingSpool {
 			await this.pendingWrite;
 		} catch {}
 		await this.backend.deleteSession(this.session.sessionId);
+		clearUploadedSession(this.session.sessionId);
 	}
 
 	private enqueue(task: () => Promise<void>) {
@@ -457,6 +490,19 @@ export const recoverOrphanedRecordingSpools = async (
 		if (minIdleMs > 0 && now - session.updatedAt < minIdleMs) {
 			continue;
 		}
+		if (isUploadedSession(session.sessionId)) {
+			void backend
+				.deleteSession(session.sessionId)
+				.then(() => clearUploadedSession(session.sessionId))
+				.catch((error) => {
+					console.error(
+						"Failed to remove uploaded recording backup",
+						session.sessionId,
+						error,
+					);
+				});
+			continue;
+		}
 
 		try {
 			const chunks = await backend.readChunks(session.sessionId);
@@ -527,4 +573,5 @@ export const deleteRecoveredRecordingSpool = async (
 ) => {
 	await backend.initialize();
 	await backend.deleteSession(sessionId);
+	clearUploadedSession(sessionId);
 };