fix(capture): clean up stale audio submissions

Author: dongdongbh

apps/desktop/src/components/QuickAddModal.test.tsx

@@ -1305,6 +1305,8 @@ describe('QuickAddModal', () => {
 
         expect(addTask).not.toHaveBeenCalled();
         expect(screen.getByPlaceholderText('Add Task')).toHaveValue('Second capture');
+        expect(fsMocks.remove).toHaveBeenCalledWith('/data/audio-a.wav');
+        expect(fsMocks.remove).toHaveBeenCalledTimes(1);
     });
 
     it('cancels an active audio recorder when the modal owner unmounts', async () => {

apps/desktop/src/components/QuickAddModal.tsx

@@ -649,7 +649,6 @@ export function QuickAddModal({ standaloneWindow = false }: QuickAddModalProps)
                 const audioSession = await queueRecordingDeviceOperation(async () => {
                     if (!isStartCurrent()) return null;
                     const acquired = await startAudioCapture({
-                        defaultName: () => `mindwtr-audio-${safeFormatDate(new Date(), 'yyyyMMdd-HHmmss')}.wav`,
                         isCurrent: isStartCurrent,
                     });
                     if (!isStartCurrent()) {
@@ -702,6 +701,8 @@ export function QuickAddModal({ standaloneWindow = false }: QuickAddModalProps)
         const isSubmissionCurrent = () => (
             captureSurfaceSession === null || submissionCoordinatorRef.current.isCurrent(captureSurfaceSession)
         );
+        let stoppedCapturePath: string | null = null;
+        let stoppedCaptureAdopted = false;
         setRecordingBusy(true);
         setIsRecording(false);
         const audioSession = captureSessionRef.current;
@@ -715,6 +716,7 @@ export function QuickAddModal({ standaloneWindow = false }: QuickAddModalProps)
             }
 
             const capture = await queueRecordingDeviceOperation(() => audioSession.stop());
+            stoppedCapturePath = capture.path;
             if (!isSubmissionCurrent()) return;
             const fileName = capture.name;
             const absolutePath = capture.path;
@@ -753,6 +755,7 @@ export function QuickAddModal({ standaloneWindow = false }: QuickAddModalProps)
             }
             if (!isSubmissionCurrent()) return;
             const addTaskResult = await addTask(displayTitle, props);
+            if (addTaskResult.success && addTaskResult.id) stoppedCaptureAdopted = true;
             if (!isSubmissionCurrent()) return;
             if (addTaskResult.success && standaloneWindow) {
                 await flushPendingSave().catch((error) => reportError('Failed to save quick add task', error));
@@ -827,6 +830,14 @@ export function QuickAddModal({ standaloneWindow = false }: QuickAddModalProps)
             const message = error instanceof Error ? error.message : String(error);
             setRecordingError(`${t('quickAdd.audioErrorBody')} (${message})`);
         } finally {
+            if (stoppedCapturePath && !stoppedCaptureAdopted && !isSubmissionCurrent()) {
+                await remove(stoppedCapturePath).catch((error) => {
+                    void logWarn('Stale audio cleanup failed', {
+                        scope: 'audio',
+                        extra: { error: error instanceof Error ? error.message : String(error) },
+                    });
+                });
+            }
             if (submissionSession === null) {
                 if (captureSurfaceSession === null || submissionCoordinatorRef.current.isCurrent(captureSurfaceSession)) {
                     setRecordingBusy(false);

apps/desktop/src/lib/audio-capture.test.ts

@@ -56,6 +56,7 @@ beforeEach(() => {
 });
 
 afterEach(() => {
+    vi.useRealTimers();
     delete (window as any).__TAURI_INTERNALS__;
     delete (navigator as any).mediaDevices;
     delete (window as any).AudioContext;
@@ -107,6 +108,23 @@ describe('startAudioCapture — native backend', () => {
 });
 
 describe('startAudioCapture — fallback', () => {
+    it('uses distinct default paths for captures stopped in the same second', async () => {
+        vi.useFakeTimers();
+        vi.setSystemTime(new Date('2026-08-31T12:00:00.000Z'));
+        const firstGraph = installFakeWebAudio();
+        const firstSession = await startAudioCapture();
+        pushSamples(firstGraph.processor, new Float32Array([0.1]));
+        const firstCapture = await firstSession.stop();
+
+        const secondGraph = installFakeWebAudio();
+        const secondSession = await startAudioCapture();
+        pushSamples(secondGraph.processor, new Float32Array([0.1]));
+        const secondCapture = await secondSession.stop();
+
+        expect(firstCapture.path).not.toBe(secondCapture.path);
+        expect(firstCapture.name).not.toBe(secondCapture.name);
+    });
+
     it('falls back to web capture when the native recorder refuses to start', async () => {
         // This is the defect the shared module fixes: the task editor used to
         // hard-fail here instead of recording through the page.

apps/desktop/src/lib/audio-capture.ts

@@ -1,5 +1,6 @@
 import { join } from '@tauri-apps/api/path';
 import { mkdir, readFile, remove, writeFile } from '@tauri-apps/plugin-fs';
+import { generateUUID } from '@mindwtr/core';
 
 import { logWarn } from './app-log';
 import { appendAudioChunkWithLimit, getMaxAudioSamples } from './audio-capture-buffer';
@@ -243,7 +244,7 @@ export async function startAudioCapture(
     options: { defaultName?: () => string; isCurrent?: () => boolean } = {},
 ): Promise<AudioCaptureSession> {
     const timestampedName = options.defaultName
-        ?? (() => `mindwtr-audio-${new Date().toISOString().replace(/[-:]/g, '').replace(/\..+$/, '')}.wav`);
+        ?? (() => `mindwtr-audio-${new Date().toISOString().replace(/[-:]/g, '').replace(/\..+$/, '')}-${generateUUID()}.wav`);
     const isCurrent = options.isCurrent ?? (() => true);
 
     if (!isCurrent()) throw new Error('Audio capture start was cancelled');

apps/mobile/components/use-quick-capture-audio.test.tsx

@@ -69,6 +69,10 @@ const fileMocks = vi.hoisted(() => ({
   delete: vi.fn(),
 }));
 
+const coreMocks = vi.hoisted(() => ({
+  generateUUID: vi.fn(),
+}));
+
 const appLogMock = vi.hoisted(() => ({
   logInfo: vi.fn(),
 }));
@@ -146,7 +150,7 @@ vi.mock('@mindwtr/core', async (importOriginal) => {
   // Only the id and clock are pinned, so attachment names stay deterministic;
   // `buildTaskUpdatesFromSpeechResult` runs for real.
   return mockCore(importOriginal, () => ({}), {
-    generateUUID: () => 'attachment-1',
+    generateUUID: coreMocks.generateUUID,
     safeFormatDate: (_value: Date | string, format: string) => {
       if (format === 'yyyyMMdd-HHmmss') return '20260629-090027';
       if (format === 'Pp') return '06/29/2026, 9:00 AM';
@@ -269,6 +273,8 @@ describe('useQuickCaptureAudio', () => {
     latest = null;
     submissionCoordinator = new CaptureSessionCoordinator();
     activeSubmissionSession = submissionCoordinator.beginSession();
+    let uuidSequence = 0;
+    coreMocks.generateUUID.mockImplementation(() => `capture-${uuidSequence += 1}`);
     storeMocks.state.areas = [];
     storeMocks.state.projects = [];
     storeMocks.state.settings = settings;
@@ -280,9 +286,9 @@ describe('useQuickCaptureAudio', () => {
     audioMocks.release.mockReturnValue(undefined);
     audioMocks.stop.mockResolvedValue(undefined);
     attachmentMocks.getAttachmentsDir.mockResolvedValue('file:///document/attachments/');
-    attachmentMocks.persistAttachmentLocally.mockImplementation(async (attachment: { uri: string }) => ({
+    attachmentMocks.persistAttachmentLocally.mockImplementation(async (attachment: { id: string; uri: string }) => ({
       ...attachment,
-      uri: 'file:///document/attachments/attachment-1.wav',
+      uri: `file:///document/attachments/${attachment.id}.wav`,
     }));
     buildTaskProps.mockImplementation(async (fallbackTitle: string, extraProps?: Record<string, unknown>) => ({
       title: fallbackTitle,
@@ -339,6 +345,7 @@ describe('useQuickCaptureAudio', () => {
     // so this line asserted behaviour the app does not have.
     expect(storeMocks.updateTask).toHaveBeenCalledWith('task-1', { title: 'Buy milk' });
     expect(handleClose).toHaveBeenCalledOnce();
+    expect(fileMocks.delete).not.toHaveBeenCalled();
   });
 
   it('shows a notice and never starts the recorder when speech-to-text is unconfigured', async () => {
@@ -694,6 +701,12 @@ describe('useQuickCaptureAudio', () => {
     expect(stopAHandler).toHaveBeenCalledTimes(1);
     expect(speechMocks.startWhisperRealtimeCapture).toHaveBeenCalledTimes(2);
     expect(audioMocks.setAudioModeAsync).toHaveBeenCalledTimes(2);
+    const firstOutputPath = String(speechMocks.startWhisperRealtimeCapture.mock.calls[0]?.[0]);
+    const secondOutputPath = String(speechMocks.startWhisperRealtimeCapture.mock.calls[1]?.[0]);
+    expect(firstOutputPath).not.toBe(secondOutputPath);
+    expect(fileMocks.delete).toHaveBeenCalledWith(`file://${firstOutputPath}`);
+    expect(fileMocks.delete).not.toHaveBeenCalledWith(`file://${secondOutputPath}`);
+    expect(fileMocks.delete).toHaveBeenCalledTimes(1);
     expect(latest?.recording).toEqual(expect.objectContaining({ kind: 'whisper', stop: stopBHandler }));
     expect(latest?.recordingBusy).toBe(false);
   });
@@ -737,5 +750,143 @@ describe('useQuickCaptureAudio', () => {
     expect(handleClose).not.toHaveBeenCalled();
     expect(submissionCoordinator.isSubmitting(reopenedSession)).toBe(true);
     expect(latest?.recordingBusy).toBe(false);
+    expect(fileMocks.delete).toHaveBeenCalledWith(
+      'file:///document/audio-captures/mindwtr-audio-20260629-090027-capture-1.wav',
+    );
+    expect(fileMocks.delete).toHaveBeenCalledWith(
+      'file:///document/attachments/capture-2.wav',
+    );
+    expect(fileMocks.delete).toHaveBeenCalledTimes(2);
+  });
+
+  it('keeps reopened capture settings when stopped audio A resolves its model late', async () => {
+    speechMocks.startWhisperRealtimeCapture.mockRejectedValueOnce(new Error('use Expo fallback'));
+    let tree!: ReturnType<typeof create>;
+    await act(async () => {
+      tree = create(<Harness submissionKey={1} />);
+      await flushPromises();
+    });
+    await act(async () => {
+      await latest?.startRecording();
+      await flushPromises();
+    });
+
+    const modelResolution = deferred<{
+      exists: boolean;
+      path: string;
+      uri: string;
+      size: number;
+    }>();
+    speechMocks.ensureWhisperModelPathForConfigAsync.mockReturnValueOnce(modelResolution.promise);
+    updateSpeechSettings.mockClear();
+    let stopRun!: Promise<void>;
+    await act(async () => {
+      stopRun = latest!.stopRecording({ saveTask: true });
+      await flushPromises();
+    });
+
+    const audioSession = activeSubmissionSession!;
+    submissionCoordinator.invalidateSession(audioSession);
+    activeSubmissionSession = submissionCoordinator.beginSession();
+    await act(async () => {
+      tree.update(<Harness submissionKey={2} />);
+      modelResolution.resolve({
+        exists: true,
+        path: '/document/whisper-models/reopened-b.bin',
+        uri: 'file:///document/whisper-models/reopened-b.bin',
+        size: 77704715,
+      });
+      await stopRun;
+      await flushPromises();
+    });
+
+    expect(updateSpeechSettings).not.toHaveBeenCalled();
+    expect(addTask).not.toHaveBeenCalled();
+    expect(fileMocks.delete).toHaveBeenCalledWith('file:///recording.m4a');
+    expect(fileMocks.delete).toHaveBeenCalledTimes(1);
+  });
+
+  it('keeps a newer speech model selected while the same audio save is resolving', async () => {
+    speechMocks.startWhisperRealtimeCapture.mockRejectedValueOnce(new Error('use Expo fallback'));
+    await act(async () => {
+      create(<Harness />);
+      await flushPromises();
+    });
+    await act(async () => {
+      await latest?.startRecording();
+      await flushPromises();
+    });
+
+    const modelResolution = deferred<{
+      exists: boolean;
+      path: string;
+      uri: string;
+      size: number;
+    }>();
+    speechMocks.ensureWhisperModelPathForConfigAsync.mockReturnValueOnce(modelResolution.promise);
+    updateSpeechSettings.mockClear();
+    let stopRun!: Promise<void>;
+    await act(async () => {
+      stopRun = latest!.stopRecording({ saveTask: true });
+      await flushPromises();
+    });
+
+    storeMocks.state.settings = {
+      ...settings,
+      ai: {
+        speechToText: {
+          ...settings.ai.speechToText,
+          model: 'whisper-base',
+          offlineModelPath: 'file:///document/whisper-models/newer-b.bin',
+        },
+      },
+    };
+    await act(async () => {
+      modelResolution.resolve({
+        exists: true,
+        path: '/document/whisper-models/obsolete-a.bin',
+        uri: 'file:///document/whisper-models/obsolete-a.bin',
+        size: 77704715,
+      });
+      await stopRun;
+      await flushPromises();
+    });
+
+    expect(updateSpeechSettings).not.toHaveBeenCalled();
+    expect(addTask).toHaveBeenCalledTimes(1);
+  });
+
+  it('does not persist a model path from a canceled Whisper preload', async () => {
+    const modelResolution = deferred<{
+      exists: boolean;
+      path: string;
+      uri: string;
+      size: number;
+    }>();
+    speechMocks.ensureWhisperModelPathForConfigAsync.mockReturnValueOnce(modelResolution.promise);
+    let tree!: ReturnType<typeof create>;
+    await act(async () => {
+      tree = create(<Harness />);
+      await flushPromises();
+    });
+    updateSpeechSettings.mockClear();
+
+    await act(async () => {
+      tree.unmount();
+      await flushPromises();
+    });
+    await act(async () => {
+      modelResolution.resolve({
+        exists: true,
+        path: '/document/whisper-models/obsolete-a.bin',
+        uri: 'file:///document/whisper-models/obsolete-a.bin',
+        size: 77704715,
+      });
+      await modelResolution.promise;
+      await flushPromises();
+    });
+
+    expect(updateSpeechSettings).not.toHaveBeenCalled();
+    expect(speechMocks.preloadWhisperContext).not.toHaveBeenCalled();
   });
 });