@@ -1108,13 +1108,28 @@ describe("VcsStatusBroadcaster", () => {
       yield* Deferred.await(remoteStarted);
 
       assert.equal(state.remoteStatusCalls, 1);
+      assert.equal(state.localStatusCalls, 1);
 
       yield* Scope.close(firstScope, Exit.void);
       assert.isTrue(Option.isNone(yield* Deferred.poll(remoteInterrupted)));
 
       yield* Scope.close(secondScope, Exit.void).pipe(Effect.forkScoped);
       yield* Deferred.await(remoteInterrupted);
       assert.isTrue(Option.isSome(yield* Deferred.poll(remoteInterrupted)));
+
+      const nextSnapshot = yield* Deferred.make<VcsStatusStreamEvent>();
+      const nextScope = yield* Scope.make();
+      yield* Stream.runForEach(broadcaster.streamStatus({ cwd: "/repo" }), (event) =>
+        event._tag === "snapshot"
+          ? Deferred.succeed(nextSnapshot, event).pipe(Effect.ignore)
+          : Effect.void,
+      ).pipe(Effect.forkIn(nextScope));
+      yield* Deferred.await(nextSnapshot);
+
+      // Releasing the final poller also evicts its cwd cache entry, so a later
+      // subscription reloads local status instead of retaining state forever.
+      assert.equal(state.localStatusCalls, 2);
+      yield* Scope.close(nextScope, Exit.void);
     }).pipe(Effect.provide(testLayer));
   });
 });
@@ -695,10 +695,24 @@ export const make = Effect.gen(function* () {
         );
       }
 
-      return Effect.succeed([
-        existing.fiber,
-        new Map([...activePollers].filter(([activeCwd]) => activeCwd !== cwd)),
-      ] as const);
+      // Drop the cached status for this cwd in the same critical section that
+      // removes the poller, so a concurrent retainRemotePoller (which reloads
+      // the cache and installs a fresh poller) cannot have its new entry wiped
+      // by this release. Otherwise the cache keeps one entry per cwd for the
+      // broadcaster's lifetime; a future subscriber re-loads and re-seeds it.
+      return Ref.update(cacheRef, (cache) => {
+        if (!cache.has(cwd)) {
+          return cache;
+        }
+        const nextCache = new Map(cache);
+        nextCache.delete(cwd);
+        return nextCache;
+      }).pipe(
+        Effect.as([
+          existing.fiber,
+          new Map([...activePollers].filter(([activeCwd]) => activeCwd !== cwd)),
+        ] as const),
+      );
     });
 
     if (pollerToInterrupt) {
 
@@ -150,18 +150,16 @@ describe("browserSurfaceStore", () => {
     });
   });
 
-  it("hides a surface when its current lease is released", () => {
+  it("removes a surface entry when its current lease is released", () => {
     const tabId = "released-browser-surface";
     const lease = acquireBrowserSurface(tabId);
     lease.present({ x: 10, y: 20, width: 900, height: 640 }, true);
 
     lease.release();
+    // A stale present() from the released lease must not resurrect the entry.
     lease.present({ x: 0, y: 0, width: 1, height: 1 }, true);
 
-    expect(useBrowserSurfaceStore.getState().byTabId[tabId]).toMatchObject({
-      visible: false,
-      owner: null,
-    });
+    expect(useBrowserSurfaceStore.getState().byTabId[tabId]).toBeUndefined();
   });
 
   it("keeps the requested layer with the active surface lease", () => {
@@ -190,11 +188,7 @@ describe("browserSurfaceStore", () => {
 
     fittedLease.release();
 
-    expect(useBrowserSurfaceStore.getState().byTabId[tabId]).toMatchObject({
-      fittedSourceContent: null,
-      fitSourceContent: false,
-      owner: null,
-      visible: false,
-    });
+    // Release removes the entry entirely, fitted presentation state included.
+    expect(useBrowserSurfaceStore.getState().byTabId[tabId]).toBeUndefined();
   });
 });
@@ -188,19 +188,12 @@ export const useBrowserSurfaceStore = create<BrowserSurfaceStoreState>()((set) =
     set((state) => {
       const current = state.byTabId[tabId];
       if (current?.owner !== owner) return state;
-      return {
-        byTabId: {
-          ...state.byTabId,
-          [tabId]: {
-            ...current,
-            visible: false,
-            fittedSourceContent: null,
-            fitSourceContent: false,
-            updatedAt: Date.now(),
-            owner: null,
-          },
-        },
-      };
+      // Delete the entry instead of leaving a released tombstone: readers only
+      // consider `visible` entries, so removal is behavior-preserving and
+      // byTabId does not accumulate one dead entry per preview tab ever opened.
+      // A stale present() from the released lease cannot resurrect it.
+      const { [tabId]: _released, ...byTabId } = state.byTabId;
+      return { byTabId };
     }),
 }));
 
 
@@ -17,6 +17,10 @@ import { useCallback, useMemo, useRef } from "react";
 
 import { getFallbackThreadIdAfterDelete, pinOrderKeyBetween } from "../components/Sidebar.logic";
 import { useComposerDraftStore } from "../composerDraftStore";
+import { useDiffPanelStore } from "../diffPanelStore";
+import { usePreviewMiniPlayerStore } from "../previewMiniPlayerStore";
+import { removePreviewThread } from "../previewStateStore";
+import { useRightPanelStore } from "../rightPanelStore";
 import { terminalEnvironment } from "../state/terminal";
 import { appAtomRegistry } from "../rpc/atomRegistry";
 import { environmentServerConfigsAtom } from "../state/server";
@@ -193,6 +197,24 @@ export async function navigateAfterThreadDeletion(navigate: () => Promise<void>)
   }
 }
 
+/**
+ * Prune per-thread client state that would otherwise accumulate forever.
+ *
+ * These stores keep one entry per thread (preview atom, right-panel surfaces,
+ * diff-panel selection, floating mini player, visited/expanded ui state) that
+ * was never cleaned up on deletion — a long-lived tab leaked one entry per
+ * thread ever visited, persisted to localStorage. The zustand cleanup functions
+ * already existed but had no callers; this wires them into deletion.
+ */
+function clearPerThreadClientState(ref: ScopedThreadRef): void {
+  removePreviewThread(ref);
+  useRightPanelStore.getState().removeThread(ref);
+  useDiffPanelStore.getState().removeThread(ref);
+  usePreviewMiniPlayerStore.getState().removeThread(ref);
+  // uiStateStore is keyed by the scoped thread key (see markThreadVisited).
+  useUiStateStore.getState().removeThread(scopedThreadKey(ref));
+}
+
 /**
  * Marks a thread unread. Servers with visited tracking own the unread marker
  * (thread.mark-unread rewinds the server-side visited watermark, syncing the
@@ -421,6 +443,10 @@ export function useThreadActions() {
         });
         if (result._tag === "Success") {
           refreshArchivedThreadsForEnvironment(target.environmentId);
+          releaseComposerDraftUploads(target);
+          clearComposerDraftForThread(target);
+          clearTerminalUiState(target);
+          clearPerThreadClientState(target);
         }
         return result;
       }
@@ -524,6 +550,7 @@ export function useThreadActions() {
         threadRef,
       );
       clearTerminalUiState(threadRef);
+      clearPerThreadClientState(threadRef);
 
       if (shouldNavigateToFallback) {
         const fallbackThread = fallbackThreadId
 
@@ -17,6 +17,7 @@ import {
   previewStateAtom,
   readThreadPreviewState,
   reconcilePreviewServerSessions,
+  removePreviewThread,
   rememberPreviewUrl,
   resetPreviewStateForTests,
   setActivePreviewTab,
@@ -72,6 +73,27 @@ describe("previewStateStore (single-tab)", () => {
     expect(readThreadPreviewState(otherRef)).toEqual(__testing.EMPTY_THREAD_PREVIEW_STATE);
   });
 
+  it("removePreviewThread resets a deleted thread's state and leaves other threads intact", () => {
+    applyPreviewServerSnapshot(ref, makeSnapshot());
+    applyPreviewServerSnapshot(otherRef, makeSnapshot({ threadId: "thread-2", tabId: "tab_b" }));
+
+    removePreviewThread(ref);
+
+    expect(readThreadPreviewState(ref)).toEqual(__testing.EMPTY_THREAD_PREVIEW_STATE);
+    expect(readThreadPreviewState(otherRef).snapshot?.tabId).toBe("tab_b");
+
+    // A later event for the removed thread re-seeds from empty and still lands.
+    const reopened = makeSnapshot({ updatedAt: "2026-01-01T00:01:00.000Z" });
+    applyPreviewServerEvent(ref, {
+      type: "opened",
+      threadId: "thread-1",
+      tabId: reopened.tabId,
+      createdAt: reopened.updatedAt,
+      snapshot: reopened,
+    });
+    expect(readThreadPreviewState(ref).snapshot?.tabId).toBe("tab_a");
+  });
+
   it("opened event seeds the snapshot and remembers the URL", () => {
     const snapshot = makeSnapshot();
     applyPreviewServerEvent(ref, {
 
@@ -65,9 +65,16 @@ const emptyPreviewStateAtom = Atom.make<ThreadPreviewState>(EMPTY_THREAD_PREVIEW
   Atom.withLabel("preview:empty-thread"),
 );
 
+// Idle-TTL, not keepAlive: keepAlive pinned one registry node per thread key
+// ever visited for the process lifetime. Threads with live sessions stay
+// resident because the observed aggregate `activePreviewSessionsAtom` reads
+// them; only idle threads are collected, re-seeding from EMPTY on next use and
+// repopulating from the next server snapshot (see usePreviewSession).
+const PREVIEW_STATE_IDLE_TTL_MS = 5 * 60_000;
+
 export const previewStateAtom = Atom.family((threadKey: string) =>
   Atom.make<ThreadPreviewState>(EMPTY_THREAD_PREVIEW_STATE).pipe(
-    Atom.keepAlive,
+    Atom.setIdleTTL(PREVIEW_STATE_IDLE_TTL_MS),
     Atom.withLabel(`preview:thread:${threadKey}`),
   ),
 );
@@ -464,6 +471,24 @@ export function isPreviewSupportedInRuntime(): boolean {
   return Boolean(window.desktopBridge?.preview);
 }
 
+/**
+ * Drop a deleted thread's preview state. Resets the atom to EMPTY (the family
+ * entry is only weakly held, so the registry drops the node once idle) and
+ * removes the key from the active-session index so the desktop aggregate view
+ * stops enumerating it.
+ */
+export function removePreviewThread(ref: ScopedThreadRef): void {
+  const threadKey = scopedThreadKey(ref);
+  appAtomRegistry.set(previewStateAtom(threadKey), EMPTY_THREAD_PREVIEW_STATE);
+  changedPreviewThreadKeys.delete(threadKey);
+  appAtomRegistry.update(activePreviewThreadKeysAtom, (current) => {
+    if (!current.keys.has(threadKey)) return current;
+    const keys = new Set(current.keys);
+    keys.delete(threadKey);
+    return { keys };
+  });
+}
+
 export function resetPreviewStateForTests(): void {
   for (const threadKey of changedPreviewThreadKeys) {
     appAtomRegistry.set(previewStateAtom(threadKey), EMPTY_THREAD_PREVIEW_STATE);
 
@@ -6,6 +6,7 @@ import {
   markThreadUnread,
   markThreadVisited,
   parsePersistedState,
+  removeThreadUiState,
   PERSISTED_STATE_KEY,
   type PersistedUiState,
   persistState,
@@ -56,6 +57,27 @@ describe("uiStateStore pure functions", () => {
     expect(markThreadUnread(next, threadId, null)).toBe(next);
   });
 
+  it("removes all per-thread ui state for a deleted thread", () => {
+    const threadId = ThreadId.make("thread-1");
+    const otherId = ThreadId.make("thread-2");
+    const state = makeUiState({
+      threadLastVisitedAtById: {
+        [threadId]: "2026-02-25T12:30:00.000Z",
+        [otherId]: "2026-02-25T12:31:00.000Z",
+      },
+      threadChangedFilesExpandedById: {
+        [threadId]: { "turn-1": false },
+        [otherId]: { "turn-1": false },
+      },
+    });
+
+    const next = removeThreadUiState(state, threadId);
+    expect(next.threadLastVisitedAtById).toEqual({ [otherId]: "2026-02-25T12:31:00.000Z" });
+    expect(next.threadChangedFilesExpandedById).toEqual({ [otherId]: { "turn-1": false } });
+    // No-op (same reference) when the thread has no state.
+    expect(removeThreadUiState(next, threadId)).toBe(next);
+  });
+
   it("resolves project expansion from logical, physical, and legacy preference keys", () => {
     const physicalKey = "environment:/repo/project";
     const legacyKey = legacyProjectCwdPreferenceKey("/repo/project");
 
@@ -295,6 +295,27 @@ export function markThreadUnread(
   };
 }
 
+/**
+ * Drop all per-thread UI state for a deleted thread. Without this, both
+ * `threadLastVisitedAtById` and `threadChangedFilesExpandedById` keep one entry
+ * per thread ever visited, persisted to localStorage indefinitely.
+ */
+export function removeThreadUiState(state: UiState, threadId: string): UiState {
+  const hasVisited = threadId in state.threadLastVisitedAtById;
+  const hasChangedFiles = threadId in state.threadChangedFilesExpandedById;
+  if (!hasVisited && !hasChangedFiles) {
+    return state;
+  }
+  const { [threadId]: _visited, ...threadLastVisitedAtById } = state.threadLastVisitedAtById;
+  const { [threadId]: _changed, ...threadChangedFilesExpandedById } =
+    state.threadChangedFilesExpandedById;
+  return {
+    ...state,
+    threadLastVisitedAtById,
+    threadChangedFilesExpandedById,
+  };
+}
+
 export function setThreadChangedFilesExpanded(
   state: UiState,
   threadId: string,
@@ -426,6 +447,7 @@ export function reorderProjects(
 interface UiStateStore extends UiState {
   markThreadVisited: (threadId: string, visitedAt: string) => void;
   markThreadUnread: (threadId: string, latestTurnCompletedAt: string | null | undefined) => void;
+  removeThread: (threadId: string) => void;
   setThreadChangedFilesExpanded: (threadId: string, turnId: string, expanded: boolean) => void;
   setDefaultAdvertisedEndpointKey: (key: string | null) => void;
   setSidebarProjectScopeKey: (projectKey: string | null) => void;
@@ -444,6 +466,7 @@ export const useUiStateStore = create<UiStateStore>((set) => ({
     set((state) => markThreadVisited(state, threadId, visitedAt)),
   markThreadUnread: (threadId, latestTurnCompletedAt) =>
     set((state) => markThreadUnread(state, threadId, latestTurnCompletedAt)),
+  removeThread: (threadId) => set((state) => removeThreadUiState(state, threadId)),
   setThreadChangedFilesExpanded: (threadId, turnId, expanded) =>
     set((state) => setThreadChangedFilesExpanded(state, threadId, turnId, expanded)),
   setDefaultAdvertisedEndpointKey: (key) =>