Fix live listener attach lifecycle

Prevent overlapping attach calls from leaking listeners and clear stale timers when snapshots switch active sessions.

Author: ComputelessComputer

apps/desktop/src/routes/app/-note.$sessionId.test.tsx

@@ -6,6 +6,12 @@ import { resetTabsStore } from "~/store/zustand/tabs/test-utils";
 const mocks = vi.hoisted(() => ({
   attachLiveSession: vi.fn(),
   close: vi.fn(),
+  listenerState: {
+    attachLiveSession: vi.fn(),
+    live: {
+      eventUnlistenersBySession: {} as Record<string, (() => void)[]>,
+    },
+  },
 }));
 
 vi.mock("@tauri-apps/api/window", () => ({
@@ -15,11 +21,8 @@ vi.mock("@tauri-apps/api/window", () => ({
 }));
 
 vi.mock("~/stt/contexts", () => ({
-  useListener: (
-    selector: (state: {
-      attachLiveSession: typeof mocks.attachLiveSession;
-    }) => unknown,
-  ) => selector({ attachLiveSession: mocks.attachLiveSession }),
+  useListener: (selector: (state: typeof mocks.listenerState) => unknown) =>
+    selector(mocks.listenerState),
 }));
 
 import {
@@ -32,6 +35,8 @@ import { useTabs } from "~/store/zustand/tabs";
 
 describe("standalone note window route", () => {
   beforeEach(() => {
+    mocks.listenerState.attachLiveSession = mocks.attachLiveSession;
+    mocks.listenerState.live.eventUnlistenersBySession = {};
     mocks.attachLiveSession.mockClear();
     mocks.close.mockClear();
     resetTabsStore();
@@ -88,6 +93,23 @@ describe("standalone note window route", () => {
 
     expect(mocks.attachLiveSession).toHaveBeenCalledWith("session-1");
   });
+
+  it("reattaches after standalone live session events are removed", () => {
+    const { rerender } = renderHook(() =>
+      useAttachStandaloneNoteToLiveSession("session-1"),
+    );
+    expect(mocks.attachLiveSession).toHaveBeenCalledTimes(1);
+
+    mocks.listenerState.live.eventUnlistenersBySession = {
+      "session-1": [vi.fn()],
+    };
+    rerender();
+    expect(mocks.attachLiveSession).toHaveBeenCalledTimes(1);
+
+    mocks.listenerState.live.eventUnlistenersBySession = {};
+    rerender();
+    expect(mocks.attachLiveSession).toHaveBeenCalledTimes(2);
+  });
 });
 
 function dispatchKeyDown(key: string) {

apps/desktop/src/routes/app/note.$sessionId.tsx

@@ -31,10 +31,17 @@ function Component() {
 
 export function useAttachStandaloneNoteToLiveSession(sessionId: string) {
   const attachLiveSession = useListener((state) => state.attachLiveSession);
+  const hasLiveSessionEvents = useListener((state) =>
+    Boolean(state.live.eventUnlistenersBySession[sessionId]),
+  );
 
   useEffect(() => {
+    if (hasLiveSessionEvents) {
+      return;
+    }
+
     void attachLiveSession(sessionId);
-  }, [attachLiveSession, sessionId]);
+  }, [attachLiveSession, hasLiveSessionEvents, sessionId]);
 }
 
 export function useStandaloneNoteTab(sessionId: string) {

apps/desktop/src/store/zustand/listener/general-live.ts

@@ -357,10 +357,25 @@ export const attachLiveSession = <T extends LiveStore>(
     return Promise.resolve();
   }
 
+  const pendingUnlisteners: (() => void)[] = [];
+  let registeredUnlisteners = pendingUnlisteners;
+  setLiveState(set, (live) => {
+    live.eventUnlistenersBySession[targetSessionId] = pendingUnlisteners;
+  });
+
   const handlers = createSessionEventHandlers(set, get, targetSessionId);
 
   const program = Effect.gen(function* () {
     const unlisteners = yield* listenToAllSessionEvents(handlers);
+    if (
+      get().live.eventUnlistenersBySession[targetSessionId] !==
+      pendingUnlisteners
+    ) {
+      clearLiveEventUnlisteners(unlisteners);
+      return;
+    }
+
+    registeredUnlisteners = unlisteners;
     setLiveState(set, (live) => {
       live.eventUnlistenersBySession[targetSessionId] = unlisteners;
     });
@@ -373,11 +388,14 @@ export const attachLiveSession = <T extends LiveStore>(
     Exit.match(exit, {
       onFailure: (cause) => {
         console.error("[listener] failed to attach live session:", cause);
-        clearLiveEventUnlisteners(
-          get().live.eventUnlistenersBySession[targetSessionId],
-        );
+        clearLiveEventUnlisteners(registeredUnlisteners);
         setLiveState(set, (live) => {
-          delete live.eventUnlistenersBySession[targetSessionId];
+          if (
+            live.eventUnlistenersBySession[targetSessionId] ===
+            registeredUnlisteners
+          ) {
+            delete live.eventUnlistenersBySession[targetSessionId];
+          }
         });
       },
       onSuccess: () => undefined,
@@ -396,6 +414,10 @@ function applyCaptureSnapshot<T extends GeneralState>(
     snapshot.activeSessionId === targetSessionId
   ) {
     const currentLive = get().live;
+    if (currentLive.sessionId !== targetSessionId) {
+      clearLiveInterval(currentLive.intervalId);
+    }
+
     const intervalId =
       currentLive.sessionId === targetSessionId && currentLive.intervalId
         ? currentLive.intervalId
@@ -428,6 +450,9 @@ function applyCaptureSnapshot<T extends GeneralState>(
     snapshot.finalizingSessionIds.includes(targetSessionId)
   ) {
     setLiveState(set, (live) => {
+      if (!live.sessionId) {
+        live.sessionId = targetSessionId;
+      }
       markLiveFinalizing(live, targetSessionId);
     });
   }

apps/desktop/src/store/zustand/listener/general.test.ts

@@ -676,6 +676,46 @@ describe("General Listener Slice", () => {
       expect(listenCaptureDataMock).toHaveBeenCalledTimes(1);
     });
 
+    test("attachLiveSession ignores overlapping attaches for the same session", async () => {
+      await Promise.all([
+        store.getState().attachLiveSession("session-a"),
+        store.getState().attachLiveSession("session-a"),
+      ]);
+
+      expect(listenCaptureLifecycleMock).toHaveBeenCalledTimes(1);
+      expect(listenCaptureStatusMock).toHaveBeenCalledTimes(1);
+      expect(listenCaptureDataMock).toHaveBeenCalledTimes(1);
+      expect(getCaptureSnapshotMock).toHaveBeenCalledTimes(1);
+    });
+
+    test("attachLiveSession clears the previous session interval before applying an active snapshot", async () => {
+      const intervalId = setInterval(() => {}, 1000);
+      const clearIntervalSpy = vi.spyOn(globalThis, "clearInterval");
+      getCaptureSnapshotMock.mockResolvedValueOnce({
+        status: "ok",
+        data: {
+          activeSessionId: "session-b",
+          finalizingSessionIds: [],
+          liveTranscriptionActive: true,
+          requestedLiveTranscription: true,
+          state: "active",
+        },
+      });
+      store.setState((state) =>
+        mutate(state, (draft) => {
+          markLiveActive(draft.live, "session-a", intervalId, true, true, null);
+        }),
+      );
+
+      await store.getState().attachLiveSession("session-b");
+
+      expect(clearIntervalSpy).toHaveBeenCalledWith(intervalId);
+      expect(store.getState().live.sessionId).toBe("session-b");
+
+      clearInterval(store.getState().live.intervalId);
+      clearIntervalSpy.mockRestore();
+    });
+
     test("attachLiveSession does not mark a different active native capture as current", async () => {
       getCaptureSnapshotMock.mockResolvedValueOnce({
         status: "ok",
@@ -694,6 +734,63 @@ describe("General Listener Slice", () => {
       expect(store.getState().live.sessionId).toBeNull();
     });
 
+    test("attachLiveSession hydrates finalizing native capture for the same session", async () => {
+      let dataHandler:
+        | ((event: {
+            payload: {
+              session_id: string;
+              type: "transcript_segment_delta";
+              delta: unknown;
+            };
+          }) => void)
+        | undefined;
+      listenCaptureDataMock.mockImplementationOnce((handler) => {
+        dataHandler = handler;
+        return Promise.resolve(() => {});
+      });
+      getCaptureSnapshotMock.mockResolvedValueOnce({
+        status: "ok",
+        data: {
+          activeSessionId: null,
+          finalizingSessionIds: ["session-a"],
+          liveTranscriptionActive: null,
+          requestedLiveTranscription: null,
+          state: "finalizing",
+        },
+      });
+
+      await store.getState().attachLiveSession("session-a");
+
+      expect(store.getState().live.sessionId).toBe("session-a");
+      expect(store.getState().getSessionMode("session-a")).toBe("finalizing");
+
+      dataHandler?.({
+        payload: {
+          delta: {
+            removed_ids: [],
+            upserts: [
+              {
+                end_ms: 1000,
+                id: "segment-1",
+                key: {
+                  channel: "DirectMic",
+                },
+                start_ms: 0,
+                text: "hello",
+                words: [],
+              },
+            ],
+          },
+          session_id: "session-a",
+          type: "transcript_segment_delta",
+        },
+      });
+
+      expect(store.getState().liveSegments).toMatchObject([
+        { id: "segment-1", text: "hello" },
+      ]);
+    });
+
     test("start returns false while another session is active", async () => {
       store.setState((state) =>
         mutate(state, (draft) => {