From a86e9e2c7e468331258b32c0957f4a2aff8a5521 Mon Sep 17 00:00:00 2001
From: xintaofei <itpkcn@gmail.com>
Date: Fri, 12 Jun 2026 15:40:50 +0800
Subject: [PATCH 1/2] fix(tabs): restore an active context after a draft-only
 restart

An unsent draft tab is device-local and never persisted, so quitting with only a draft open reopened to zero tabs: the chat area was blank and the New chat button, Mod+T, and context menu were all dead because each was gated on the now-null active folder.

Hydration now synthesizes an active draft whenever no tabs are restored, targeting the last-active folder or chat mode via a localStorage hint, without writing any conversation or folder row before the first send. The sidebar New chat button falls back to chat mode instead of disabling when there is no active folder.
---
 src/components/layout/sidebar.test.tsx |  10 +-
 src/components/layout/sidebar.tsx      |  16 ++-
 src/contexts/tab-context.test.tsx      | 168 +++++++++++++++++++++++++
 src/contexts/tab-context.tsx           |  72 +++++++++++
 src/lib/last-active-context-storage.ts |  59 +++++++++
 5 files changed, 317 insertions(+), 8 deletions(-)
 create mode 100644 src/lib/last-active-context-storage.ts

diff --git a/src/components/layout/sidebar.test.tsx b/src/components/layout/sidebar.test.tsx
index 9c2c5f20..de3ddee4 100644
--- a/src/components/layout/sidebar.test.tsx
+++ b/src/components/layout/sidebar.test.tsx
@@ -9,6 +9,7 @@ import enMessages from "@/i18n/messages/en.json"
 // factories below (vi.mock is hoisted above imports).
 const spies = vi.hoisted(() => ({
   openNewConversationTab: vi.fn(),
+  openChatModeTab: vi.fn(),
   setSearchOpen: vi.fn(),
 }))
 const mockState = vi.hoisted(() => ({
@@ -29,6 +30,7 @@ vi.mock("@/contexts/active-folder-context", () => ({
 vi.mock("@/contexts/tab-context", () => ({
   useTabContext: () => ({
     openNewConversationTab: spies.openNewConversationTab,
+    openChatModeTab: spies.openChatModeTab,
   }),
 }))
 vi.mock("@/contexts/search-dialog-context", () => ({
@@ -53,6 +55,7 @@ function renderSidebar() {
 describe("Sidebar — fixed New chat / Search region", () => {
   beforeEach(() => {
     spies.openNewConversationTab.mockClear()
+    spies.openChatModeTab.mockClear()
     spies.setSearchOpen.mockClear()
     mockState.activeFolder = { id: 7, path: "/x" }
   })
@@ -77,12 +80,15 @@ describe("Sidebar — fixed New chat / Search region", () => {
     expect(getByText("Ctrl+K")).toBeTruthy()
   })
 
-  it("disables New chat when no folder is active", () => {
+  it("falls back to chat mode (never disabled) when no folder is active", () => {
     mockState.activeFolder = null
     const { getByText } = renderSidebar()
     const btn = getByText("New chat").closest("button") as HTMLButtonElement
-    expect(btn.disabled).toBe(true)
+    // Defense-in-depth: the button stays clickable so a workspace that recovered
+    // to no active folder is never a dead end — it opens folderless chat mode.
+    expect(btn.disabled).toBe(false)
     fireEvent.click(btn)
+    expect(spies.openChatModeTab).toHaveBeenCalled()
     expect(spies.openNewConversationTab).not.toHaveBeenCalled()
   })
 })
diff --git a/src/components/layout/sidebar.tsx b/src/components/layout/sidebar.tsx
index 74165a15..3ee02a6b 100644
--- a/src/components/layout/sidebar.tsx
+++ b/src/components/layout/sidebar.tsx
@@ -61,7 +61,7 @@ export function Sidebar() {
   const t = useTranslations("Folder.sidebar")
   const { isOpen, toggle } = useSidebarContext()
   const { activeFolder } = useActiveFolder()
-  const { openNewConversationTab } = useTabContext()
+  const { openNewConversationTab, openChatModeTab } = useTabContext()
   const { setOpen: setSearchOpen } = useSearchDialog()
   const isMac = useIsMac()
   const { shortcuts } = useShortcutSettings()
@@ -113,9 +113,15 @@ export function Sidebar() {
   }, [allExpanded])
 
   const handleNewConversation = useCallback(() => {
-    if (!activeFolder) return
+    // Defense-in-depth: with no active folder (e.g. a cold start that recovered
+    // to nothing, or all folders closed) fall back to folderless chat mode
+    // rather than no-op, so this entry point is never a dead end.
+    if (!activeFolder) {
+      openChatModeTab()
+      return
+    }
     openNewConversationTab(activeFolder.id, activeFolder.path)
-  }, [activeFolder, openNewConversationTab])
+  }, [activeFolder, openChatModeTab, openNewConversationTab])
 
   if (!isOpen) return null
 
@@ -201,14 +207,12 @@ export function Sidebar() {
         <button
           type="button"
           onClick={handleNewConversation}
-          disabled={!activeFolder}
           title={t("newChat")}
           className={cn(
             "group flex h-8 w-full items-center gap-[0.4375rem] rounded-full pl-[0.4375rem] pr-1.5",
             "text-[0.875rem] text-sidebar-foreground outline-none",
             "transition-colors duration-150 hover:bg-sidebar-accent",
-            "focus-visible:ring-2 focus-visible:ring-ring focus-visible:ring-inset",
-            "disabled:pointer-events-none disabled:opacity-50"
+            "focus-visible:ring-2 focus-visible:ring-ring focus-visible:ring-inset"
           )}
         >
           <SquarePen className="h-[0.875rem] w-[0.875rem] shrink-0 text-muted-foreground" />
diff --git a/src/contexts/tab-context.test.tsx b/src/contexts/tab-context.test.tsx
index e95f7148..aaf8ee4d 100644
--- a/src/contexts/tab-context.test.tsx
+++ b/src/contexts/tab-context.test.tsx
@@ -19,6 +19,9 @@ const activateConversationPaneMock = vi.fn()
 const disconnectMock = vi.fn()
 const subscribeMock = vi.fn()
 const onTransportReconnectMock = vi.fn()
+const loadLastActiveContextMock = vi.fn()
+const saveLastActiveContextMock = vi.fn()
+const clearLastActiveContextMock = vi.fn()
 // Captured `tabs://changed` handler so tests can simulate inbound broadcasts.
 let tabsChangedHandler: ((change: TabsChanged) => void) | null = null
 
@@ -70,6 +73,13 @@ vi.mock("@/hooks/use-sorted-available-agents", () => ({
   }),
 }))
 
+vi.mock("@/lib/last-active-context-storage", () => ({
+  loadLastActiveContext: () => loadLastActiveContextMock(),
+  saveLastActiveContext: (...args: unknown[]) =>
+    saveLastActiveContextMock(...args),
+  clearLastActiveContext: () => clearLastActiveContextMock(),
+}))
+
 const defaultFoldersMock: FolderDetail[] = [
   {
     id: 1,
@@ -569,6 +579,7 @@ describe("TabProvider cross-client sync", () => {
         return Promise.resolve(() => {})
       }
     )
+    disconnectMock.mockResolvedValue(undefined)
     onTransportReconnectMock.mockReturnValue(() => {})
   })
 
@@ -756,7 +767,16 @@ describe("TabProvider cross-client sync", () => {
   })
 
   it("mirrors the focused tab from a remote snapshot", async () => {
+    // Seed real tabs so no recovery draft is synthesized on empty hydration — an
+    // active draft would legitimately hold focus (see "does not steal focus from
+    // an in-progress local draft"), which would mask the focus-mirror behavior
+    // this test isolates.
+    listOpenedTabsMock.mockResolvedValue({
+      items: [tabItem(1, 1, true), tabItem(1, 2)],
+      version: 0,
+    })
     await renderHydrated()
+    expect(screen.getByTestId("active")).toHaveTextContent("conv-1-codex-1")
 
     act(() => {
       tabsChangedHandler?.({
@@ -1068,3 +1088,151 @@ describe("TabProvider cross-client sync", () => {
     })
   })
 })
+
+describe("TabProvider post-hydration recovery", () => {
+  beforeEach(() => {
+    vi.clearAllMocks()
+    foldersMock = defaultFoldersMock
+    allFoldersMock = defaultFoldersMock
+    // Draft-only sessions persist nothing, so a fresh launch hydrates empty.
+    listOpenedTabsMock.mockResolvedValue({ items: [], version: 0 })
+    saveOpenedTabsMock.mockResolvedValue({
+      accepted: true,
+      version: 1,
+      tabs: [],
+    })
+    disconnectMock.mockResolvedValue(undefined)
+    loadLastActiveContextMock.mockReturnValue(null)
+    tabsChangedHandler = null
+    subscribeMock.mockImplementation(
+      (event: string, handler: (change: TabsChanged) => void) => {
+        if (event === TABS_CHANGED_EVENT) tabsChangedHandler = handler
+        return Promise.resolve(() => {})
+      }
+    )
+    onTransportReconnectMock.mockReturnValue(() => {})
+  })
+
+  async function renderHydrated() {
+    renderTabs()
+    await act(async () => {})
+  }
+
+  function activeTab() {
+    return latestContext?.tabs.find((t) => t.id === latestContext?.activeTabId)
+  }
+
+  it("restores a draft on the hinted folder when it still exists", async () => {
+    loadLastActiveContextMock.mockReturnValue({
+      folderId: 2,
+      isChat: false,
+    })
+    await renderHydrated()
+    await waitFor(() =>
+      expect(screen.getByTestId("active-folder")).toHaveTextContent("2")
+    )
+    expect(activeTab()?.id).toMatch(/^new-/)
+    expect(activeTab()?.conversationId).toBeNull()
+  })
+
+  it("falls back to the first folder when the hinted folder is gone", async () => {
+    loadLastActiveContextMock.mockReturnValue({
+      folderId: 999,
+      isChat: false,
+    })
+    await renderHydrated()
+    await waitFor(() =>
+      expect(screen.getByTestId("active-folder")).toHaveTextContent("1")
+    )
+    expect(activeTab()?.conversationId).toBeNull()
+  })
+
+  it("restores chat mode when the hint is a chat draft", async () => {
+    loadLastActiveContextMock.mockReturnValue({
+      folderId: 0,
+      isChat: true,
+    })
+    await renderHydrated()
+    await waitFor(() =>
+      expect(screen.getByTestId("active")).not.toHaveTextContent("none")
+    )
+    expect(activeTab()?.isChat).toBe(true)
+    expect(activeTab()?.folderId).toBe(0)
+    expect(activeTab()?.conversationId).toBeNull()
+  })
+
+  it("synthesizes a first-folder draft when there is no hint", async () => {
+    await renderHydrated()
+    await waitFor(() =>
+      expect(screen.getByTestId("active-folder")).toHaveTextContent("1")
+    )
+    expect(activeTab()?.id).toMatch(/^new-/)
+    expect(activeTab()?.conversationId).toBeNull()
+  })
+
+  it("synthesizes a chat draft when there are no folders (never blank)", async () => {
+    foldersMock = []
+    allFoldersMock = []
+    await renderHydrated()
+    await waitFor(() =>
+      expect(screen.getByTestId("active")).not.toHaveTextContent("none")
+    )
+    // An active tab exists → the panel is not blank and the sidebar is enabled.
+    expect(screen.getByTestId("tabs").textContent ?? "").toMatch(/^new-/)
+    expect(activeTab()?.isChat).toBe(true)
+  })
+
+  it("recovers only once — a later remote snapshot adds no second draft", async () => {
+    await renderHydrated()
+    await waitFor(() =>
+      expect(screen.getByTestId("active")).not.toHaveTextContent("none")
+    )
+    const draftId = latestContext?.activeTabId
+    act(() => {
+      tabsChangedHandler?.({ version: 1, origin: "x", tabs: [tabItem(1, 1)] })
+    })
+    const drafts =
+      latestContext?.tabs.filter((t) => t.conversationId == null) ?? []
+    expect(drafts).toHaveLength(1)
+    expect(drafts[0]?.id).toBe(draftId)
+  })
+
+  it("persists the active draft's context for the next launch", async () => {
+    await renderHydrated()
+    await waitFor(() =>
+      expect(saveLastActiveContextMock).toHaveBeenCalledWith(
+        expect.objectContaining({ folderId: 1, isChat: false })
+      )
+    )
+  })
+
+  it("clears the hint once a real conversation is focused", async () => {
+    await renderHydrated()
+    await waitFor(() => expect(saveLastActiveContextMock).toHaveBeenCalled())
+    clearLastActiveContextMock.mockClear()
+    act(() => {
+      latestContext?.openTab(1, 1, "codex", true, "First")
+      latestContext?.switchTab("conv-1-codex-1")
+    })
+    await waitFor(() => expect(clearLastActiveContextMock).toHaveBeenCalled())
+  })
+
+  it("does not recover when persisted tabs hydrate non-empty", async () => {
+    listOpenedTabsMock.mockResolvedValue({
+      items: [tabItem(1, 1, true)],
+      version: 1,
+    })
+    loadLastActiveContextMock.mockReturnValue({
+      folderId: 2,
+      isChat: false,
+    })
+    await renderHydrated()
+    await waitFor(() =>
+      expect(screen.getByTestId("tabs")).toHaveTextContent("conv-1-codex-1")
+    )
+    const drafts =
+      latestContext?.tabs.filter((t) => t.conversationId == null) ?? []
+    expect(drafts).toHaveLength(0)
+    expect(screen.getByTestId("active")).toHaveTextContent("conv-1-codex-1")
+  })
+})
diff --git a/src/contexts/tab-context.tsx b/src/contexts/tab-context.tsx
index 401bbba8..d57fd6d7 100644
--- a/src/contexts/tab-context.tsx
+++ b/src/contexts/tab-context.tsx
@@ -19,6 +19,11 @@ import { useSortedAvailableAgents } from "@/hooks/use-sorted-available-agents"
 import { listOpenedTabs, saveOpenedTabs } from "@/lib/api"
 import { onTransportReconnect, subscribe } from "@/lib/platform"
 import { resolveDefaultAgent } from "@/lib/resolve-default-agent"
+import {
+  loadLastActiveContext,
+  saveLastActiveContext,
+  clearLastActiveContext,
+} from "@/lib/last-active-context-storage"
 import {
   TABS_CHANGED_EVENT,
   type AgentType,
@@ -1721,6 +1726,73 @@ export function TabProvider({ children }: TabProviderProps) {
     correctDraftAgents()
   }, [agentsFresh, tabsHydrated, foldersHydrated, correctDraftAgents])
 
+  // ── Post-hydration recovery ────────────────────────────────────────────────
+  // Drafts are device-local (never in `opened_tabs`), so a session that ends on
+  // a draft-only workspace hydrates to ZERO tabs. With no active tab there is no
+  // active folder, which leaves the conversation panel blank AND disables every
+  // "new conversation" affordance (all gated on the active folder) — a deadlock
+  // the user can't escape. `applyRemoteSnapshot` already synthesizes a draft when
+  // tabs go empty; the initial DB-hydration path must do the same. One-shot via a
+  // ref; only "consumed" when we actually recover (so a non-empty hydration that
+  // later empties via closeTab still relies on that path's own synthesis).
+  const recoveryRanRef = useRef(false)
+  const recoverActiveContext = useCallback(() => {
+    // Restore the user to where they left off, falling back progressively:
+    //   (a) the persisted last-active hint (chat mode, or a folder still open),
+    //   (b) the first open folder, else
+    //   (c) folderless chat mode (always available — needs no folder).
+    const hint = loadLastActiveContext()
+    if (hint?.isChat) {
+      openChatModeTabRef.current()
+      return
+    }
+    if (hint) {
+      const f = foldersRef.current.find((x) => x.id === hint.folderId)
+      if (f) {
+        // The agent isn't persisted: resolve it like any new conversation (the
+        // folder's default + availability fallback), not from a possibly-
+        // provisional hint. `f` is already in `foldersRef`, so the internal
+        // lookup finds its default — no need to pass `folderDefaultAgent`.
+        openNewConversationTab(f.id, f.path)
+        return
+      }
+    }
+    const first = foldersRef.current[0]
+    if (first) {
+      openNewConversationTab(first.id, first.path)
+      return
+    }
+    openChatModeTabRef.current()
+  }, [openNewConversationTab])
+
+  useEffect(() => {
+    if (recoveryRanRef.current) return
+    if (!tabsHydrated || !foldersHydrated) return
+    if (rawTabs.length > 0) return
+    recoveryRanRef.current = true
+    recoverActiveContext()
+  }, [tabsHydrated, foldersHydrated, rawTabs, recoverActiveContext])
+
+  // Persist the active draft's context (folder + agent, or chat mode) so the
+  // next cold start can restore it via `recoverActiveContext`. This is UI state
+  // only — it writes no conversation/folder DB row, preserving the
+  // delayed-persistence invariant. Cleared once the draft binds to a real
+  // conversation. Gated on `tabsHydrated` so the transient cold-start empty
+  // window (active === undefined) never clobbers a good hint.
+  useEffect(() => {
+    if (!tabsHydrated) return
+    const active = rawTabs.find((t) => t.id === activeTabId)
+    if (!active) return
+    if (active.conversationId == null) {
+      saveLastActiveContext({
+        folderId: active.folderId,
+        isChat: active.isChat === true,
+      })
+    } else {
+      clearLastActiveContext()
+    }
+  }, [rawTabs, activeTabId, tabsHydrated])
+
   const value = useMemo(
     () => ({
       tabs,
diff --git a/src/lib/last-active-context-storage.ts b/src/lib/last-active-context-storage.ts
new file mode 100644
index 00000000..a26c3322
--- /dev/null
+++ b/src/lib/last-active-context-storage.ts
@@ -0,0 +1,59 @@
+"use client"
+
+const LAST_ACTIVE_CONTEXT_KEY = "codeg:last-active-context:v1"
+
+/** Lightweight, device-local hint describing where the user last had focus while
+ *  it was still an unsent draft. Persisted so a fresh launch can restore the
+ *  *same* folder (or chat mode) instead of a blank workspace — without ever
+ *  writing a conversation/folder DB row (the delayed-persistence invariant: rows
+ *  are created only on first send).
+ *
+ *  The agent is intentionally NOT persisted: the recovered draft resolves its
+ *  agent exactly like any new conversation (the folder's default, then the usual
+ *  availability fallback), which avoids laundering a provisional cold-start guess
+ *  into an explicit choice. `folderId` is `0` for chat mode (the folderless
+ *  sentinel) and goes unused there since `isChat` is checked first.
+ *
+ *  Authoritative tab state remains the synced `opened_tabs`; this hint is
+ *  advisory and resolves last-writer-wins across windows. */
+export interface LastActiveContext {
+  folderId: number
+  isChat: boolean
+}
+
+export function loadLastActiveContext(): LastActiveContext | null {
+  if (typeof window === "undefined") return null
+  try {
+    const raw = localStorage.getItem(LAST_ACTIVE_CONTEXT_KEY)
+    if (!raw) return null
+    const parsed = JSON.parse(raw) as unknown
+    if (!parsed || typeof parsed !== "object") return null
+    const obj = parsed as Record<string, unknown>
+    if (typeof obj.folderId !== "number") return null
+    if (typeof obj.isChat !== "boolean") return null
+    return {
+      folderId: obj.folderId,
+      isChat: obj.isChat,
+    }
+  } catch {
+    return null
+  }
+}
+
+export function saveLastActiveContext(ctx: LastActiveContext): void {
+  if (typeof window === "undefined") return
+  try {
+    localStorage.setItem(LAST_ACTIVE_CONTEXT_KEY, JSON.stringify(ctx))
+  } catch {
+    /* ignore storage quota/permission failures */
+  }
+}
+
+export function clearLastActiveContext(): void {
+  if (typeof window === "undefined") return
+  try {
+    localStorage.removeItem(LAST_ACTIVE_CONTEXT_KEY)
+  } catch {
+    /* ignore */
+  }
+}

From 0343506f007f27b76eb791066ad2a735a700bbd5 Mon Sep 17 00:00:00 2001
From: xintaofei <itpkcn@gmail.com>
Date: Fri, 12 Jun 2026 15:40:57 +0800
Subject: [PATCH 2/2] fix(conversations): reclaim orphaned chat scratch
 directories at startup

Each unsent chat draft eagerly creates a <data_dir>/chat-sessions/<date>/<uuid>/ scratch directory; quitting before the first send or deleting a chat conversation orphaned it forever. A startup sweep on both desktop and server now removes scratch directories that have no live is_chat folder row and are older than ten minutes, matching live directories by their (date, uuid) tail so a renamed or aliased data directory can never delete a live one.
---
 src-tauri/src/bin/codeg_server.rs          |  22 ++
 src-tauri/src/commands/conversations.rs    | 338 +++++++++++++++++++++
 src-tauri/src/db/service/folder_service.rs |  16 +
 src-tauri/src/lib.rs                       |  25 ++
 4 files changed, 401 insertions(+)

diff --git a/src-tauri/src/bin/codeg_server.rs b/src-tauri/src/bin/codeg_server.rs
index a8709089..c5c8ef2d 100644
--- a/src-tauri/src/bin/codeg_server.rs
+++ b/src-tauri/src/bin/codeg_server.rs
@@ -194,6 +194,28 @@ async fn async_main() {
     // config at build time, so this must run before the first one is constructed.
     codeg_lib::init_proxy_from_db(&db.conn).await;
 
+    // Reclaim orphaned chat scratch dirs (pre-send drafts that never bound to a
+    // conversation, plus dirs left behind by deleted chat conversations).
+    // Background, non-blocking; failures are logged but non-fatal.
+    {
+        let gc_conn = db.conn.clone();
+        let gc_data_dir = data_dir.clone();
+        tokio::spawn(async move {
+            match codeg_lib::commands::conversations::gc_orphan_chat_dirs_core(
+                &gc_conn,
+                &gc_data_dir,
+            )
+            .await
+            {
+                Ok(n) if n > 0 => {
+                    eprintln!("[SERVER] chat-dir GC: reclaimed {n} orphan scratch dir(s)")
+                }
+                Ok(_) => {}
+                Err(err) => eprintln!("[SERVER] chat-dir GC failed: {err}"),
+            }
+        });
+    }
+
     // Create shared broadcaster + internal ACP event bus.
     let broadcaster = Arc::new(WebEventBroadcaster::new());
     let event_bus_metrics = Arc::new(codeg_lib::acp::EventBusMetrics::default());
diff --git a/src-tauri/src/commands/conversations.rs b/src-tauri/src/commands/conversations.rs
index 32452968..420bfaea 100644
--- a/src-tauri/src/commands/conversations.rs
+++ b/src-tauri/src/commands/conversations.rs
@@ -993,6 +993,146 @@ pub fn create_chat_dir_core(data_dir: &std::path::Path) -> Result<String, AppCom
     Ok(dir.to_string_lossy().to_string())
 }
 
+/// How long a scratch dir must have sat untouched before the GC may reclaim it.
+/// Spares a directory that an in-flight chat draft in another window just minted
+/// (it has no conversation row yet, so it would otherwise look orphaned).
+const CHAT_SCRATCH_STALE: std::time::Duration = std::time::Duration::from_secs(10 * 60);
+
+/// Layout-invariant key for a chat scratch dir: its trailing `(<date>, <uuid>)`
+/// path components. The GC matches live dirs by this tail rather than the full
+/// path string, so a different *spelling* of the same data_dir (e.g. a symlinked
+/// vs canonical `CODEG_DATA_DIR` naming the same storage) still matches — a live
+/// dir must never be misclassified as an orphan and deleted. `<uuid>` is a v4
+/// UUID (globally unique), so the tail is collision-free in practice. Returns
+/// `None` if the path lacks a leaf or parent component.
+fn chat_dir_key(path: &std::path::Path) -> Option<(String, String)> {
+    let uuid = path.file_name()?.to_string_lossy().to_string();
+    let date = path.parent()?.file_name()?.to_string_lossy().to_string();
+    Some((date, uuid))
+}
+
+/// Reclaim orphaned chat scratch directories under
+/// `<data_dir>/chat-sessions/<date>/<uuid>/`. A chat draft eagerly mints a
+/// scratch dir (see [`create_chat_dir_core`]) the moment "no-folder mode" is
+/// picked, *before* any DB row exists; quitting before the first send — or
+/// deleting a chat conversation, which intentionally leaves the dir on disk —
+/// orphans it forever. This startup sweep removes the leak.
+///
+/// A `<uuid>` dir is reclaimed iff it is NOT bound to a live chat folder AND it
+/// is older than [`CHAT_SCRATCH_STALE`]. "Live" excludes both pre-send drafts
+/// (no row) and post-delete dirs (soft-deleted row), so both are reclaimed while
+/// bound chats are spared. Returns the number of `<uuid>` dirs removed. Never
+/// fatal: every filesystem error is logged and skipped.
+pub async fn gc_orphan_chat_dirs_core(
+    conn: &sea_orm::DatabaseConnection,
+    data_dir: &std::path::Path,
+) -> Result<usize, AppCommandError> {
+    gc_orphan_chat_dirs_core_with_threshold(conn, data_dir, CHAT_SCRATCH_STALE).await
+}
+
+/// [`gc_orphan_chat_dirs_core`] with the staleness threshold injected, for tests.
+/// A zero `stale` forces every dir to count as stale (deterministic, independent
+/// of clock/mtime resolution); the production entry point always passes
+/// [`CHAT_SCRATCH_STALE`].
+pub(crate) async fn gc_orphan_chat_dirs_core_with_threshold(
+    conn: &sea_orm::DatabaseConnection,
+    data_dir: &std::path::Path,
+    stale: std::time::Duration,
+) -> Result<usize, AppCommandError> {
+    let root = data_dir.join("chat-sessions");
+    if !root.is_dir() {
+        return Ok(0);
+    }
+
+    // Dirs bound to a live chat conversation, keyed by their layout-invariant
+    // `(<date>, <uuid>)` tail (see `chat_dir_key`) rather than the full path
+    // string. This survives a data_dir spelled differently across runs (e.g. a
+    // symlinked vs canonical `CODEG_DATA_DIR` pointing at the same storage),
+    // which a full-string compare would miss — misclassifying the live dir as an
+    // orphan and deleting it. We deliberately do NOT canonicalize (it fails on
+    // missing paths and could itself alias two distinct dirs); keying by the tail
+    // makes the worst case a missed deletion (a leak), never data loss.
+    let live: HashSet<(String, String)> = folder_service::list_live_chat_folder_paths(conn)
+        .await
+        .map_err(AppCommandError::from)?
+        .iter()
+        .filter_map(|p| chat_dir_key(std::path::Path::new(p)))
+        .collect();
+
+    let now = std::time::SystemTime::now();
+    let mut removed = 0usize;
+
+    let date_dirs = match std::fs::read_dir(&root) {
+        Ok(rd) => rd,
+        Err(err) => {
+            eprintln!(
+                "[conversations] chat-dir GC: read {} failed: {err}",
+                root.display()
+            );
+            return Ok(0);
+        }
+    };
+
+    for date_entry in date_dirs.filter_map(Result::ok) {
+        let date_path = date_entry.path();
+        if !date_path.is_dir() {
+            continue;
+        }
+        let date_key = match date_path.file_name() {
+            Some(name) => name.to_string_lossy().to_string(),
+            None => continue,
+        };
+        let uuid_dirs = match std::fs::read_dir(&date_path) {
+            Ok(rd) => rd,
+            Err(err) => {
+                eprintln!(
+                    "[conversations] chat-dir GC: read {} failed: {err}",
+                    date_path.display()
+                );
+                continue;
+            }
+        };
+        for uuid_entry in uuid_dirs.filter_map(Result::ok) {
+            let uuid_path = uuid_entry.path();
+            if !uuid_path.is_dir() {
+                continue;
+            }
+            // Match by the layout-invariant `(<date>, <uuid>)` tail, not the full
+            // path — see the `live` set above.
+            let uuid_key = uuid_entry.file_name().to_string_lossy().to_string();
+            if live.contains(&(date_key.clone(), uuid_key)) {
+                continue;
+            }
+            // Old enough to reclaim? Unknown age (mtime unreadable / in the
+            // future) → treat as fresh and spare it (a GC should leak before it
+            // deletes something possibly in use). A zero threshold short-circuits
+            // to "always stale" so tests don't race the filesystem clock.
+            let stale_enough = stale.is_zero()
+                || uuid_path
+                    .metadata()
+                    .and_then(|m| m.modified())
+                    .ok()
+                    .and_then(|m| now.duration_since(m).ok())
+                    .is_some_and(|age| age >= stale);
+            if !stale_enough {
+                continue;
+            }
+            match std::fs::remove_dir_all(&uuid_path) {
+                Ok(()) => removed += 1,
+                Err(err) => eprintln!(
+                    "[conversations] chat-dir GC: remove {} failed: {err}",
+                    uuid_path.display()
+                ),
+            }
+        }
+        // Best-effort: drop the date bucket if it is now empty (`remove_dir` only
+        // succeeds on an empty dir, so this never touches a bucket with survivors).
+        let _ = std::fs::remove_dir(&date_path);
+    }
+
+    Ok(removed)
+}
+
 /// Core logic for creating a folderless "chat mode" conversation. Mirrors
 /// Codex's date-grouped session dirs: each chat conversation gets its own
 /// scratch directory under `<data_dir>/chat-sessions/<YYYY-MM-DD>/<uuid>/` plus a
@@ -2023,6 +2163,204 @@ mod tests {
         );
     }
 
+    // ── Orphan chat scratch-dir GC ────────────────────────────────────────────
+    // The GC walks the real `chat-sessions` tree under a tempdir; the in-memory
+    // DB only supplies the live-chat-folder path set (matching the chat tests
+    // above). `Duration::ZERO` forces "always stale" so removal is deterministic.
+
+    #[tokio::test]
+    async fn gc_removes_pre_send_orphan_scratch_dir() {
+        let db = fresh_in_memory_db().await;
+        let data_dir = tempfile::tempdir().expect("tempdir");
+        // Eager pre-send dir: minted, but never bound to a conversation/folder.
+        let orphan = create_chat_dir_core(data_dir.path()).expect("prepare dir");
+        assert!(std::path::Path::new(&orphan).is_dir());
+
+        let removed = gc_orphan_chat_dirs_core_with_threshold(
+            &db.conn,
+            data_dir.path(),
+            std::time::Duration::ZERO,
+        )
+        .await
+        .expect("gc");
+
+        assert_eq!(removed, 1, "the unbound pre-send dir is reclaimed");
+        assert!(
+            !std::path::Path::new(&orphan).exists(),
+            "orphan scratch dir removed"
+        );
+        // Emptied date bucket is cleaned up too.
+        let date_dir = std::path::Path::new(&orphan).parent().expect("date dir");
+        assert!(!date_dir.exists(), "emptied date bucket removed");
+    }
+
+    #[tokio::test]
+    async fn gc_spares_live_chat_dir() {
+        let db = fresh_in_memory_db().await;
+        let data_dir = tempfile::tempdir().expect("tempdir");
+        let res =
+            create_chat_conversation_core(&db.conn, data_dir.path(), AgentType::Codex, None, None)
+                .await
+                .expect("create");
+
+        let removed = gc_orphan_chat_dirs_core_with_threshold(
+            &db.conn,
+            data_dir.path(),
+            std::time::Duration::ZERO,
+        )
+        .await
+        .expect("gc");
+
+        assert_eq!(removed, 0, "a dir bound to a live chat folder is spared");
+        assert!(
+            std::path::Path::new(&res.folder.path).is_dir(),
+            "live chat dir retained"
+        );
+    }
+
+    #[tokio::test]
+    async fn gc_reclaims_soft_deleted_chat_dir() {
+        let db = fresh_in_memory_db().await;
+        let data_dir = tempfile::tempdir().expect("tempdir");
+        let res =
+            create_chat_conversation_core(&db.conn, data_dir.path(), AgentType::Codex, None, None)
+                .await
+                .expect("create");
+        delete_conversation_core(&db.conn, res.conversation_id)
+            .await
+            .expect("delete conversation");
+        cleanup_chat_folder_for_deleted_conversation(&db.conn, res.folder_id).await;
+        // Cleanup soft-deletes the folder row but intentionally leaves the dir.
+        assert!(std::path::Path::new(&res.folder.path).is_dir());
+
+        let removed = gc_orphan_chat_dirs_core_with_threshold(
+            &db.conn,
+            data_dir.path(),
+            std::time::Duration::ZERO,
+        )
+        .await
+        .expect("gc");
+
+        assert_eq!(removed, 1, "the soft-deleted (not live) dir is reclaimed");
+        assert!(
+            !std::path::Path::new(&res.folder.path).exists(),
+            "post-delete scratch dir removed"
+        );
+    }
+
+    #[tokio::test]
+    async fn gc_spares_fresh_dir_below_threshold() {
+        let db = fresh_in_memory_db().await;
+        let data_dir = tempfile::tempdir().expect("tempdir");
+        let fresh = create_chat_dir_core(data_dir.path()).expect("prepare dir");
+
+        // A 10-minute threshold spares a dir an in-flight draft just minted.
+        let removed = gc_orphan_chat_dirs_core_with_threshold(
+            &db.conn,
+            data_dir.path(),
+            std::time::Duration::from_secs(600),
+        )
+        .await
+        .expect("gc");
+
+        assert_eq!(removed, 0, "a fresh dir below the staleness threshold is spared");
+        assert!(
+            std::path::Path::new(&fresh).is_dir(),
+            "fresh dir retained (anti-race)"
+        );
+    }
+
+    #[tokio::test]
+    async fn gc_missing_root_is_noop() {
+        let db = fresh_in_memory_db().await;
+        let data_dir = tempfile::tempdir().expect("tempdir");
+        // No `chat-sessions` dir exists at all.
+        let removed = gc_orphan_chat_dirs_core_with_threshold(
+            &db.conn,
+            data_dir.path(),
+            std::time::Duration::ZERO,
+        )
+        .await
+        .expect("gc");
+
+        assert_eq!(removed, 0, "absent chat-sessions root is a no-op");
+    }
+
+    #[tokio::test]
+    async fn gc_removes_orphan_but_spares_live_dir_in_same_bucket() {
+        let db = fresh_in_memory_db().await;
+        let data_dir = tempfile::tempdir().expect("tempdir");
+        // A live chat conversation — its scratch path is recorded in the DB via
+        // the real create path (`add_chat_folder`), the exact string the GC
+        // compares against ...
+        let live =
+            create_chat_conversation_core(&db.conn, data_dir.path(), AgentType::Codex, None, None)
+                .await
+                .expect("create live");
+        // ... alongside an unbound orphan dir in the same `chat-sessions` tree
+        // (same day → same date bucket).
+        let orphan = create_chat_dir_core(data_dir.path()).expect("orphan dir");
+        assert_ne!(live.folder.path, orphan);
+
+        let removed = gc_orphan_chat_dirs_core_with_threshold(
+            &db.conn,
+            data_dir.path(),
+            std::time::Duration::ZERO,
+        )
+        .await
+        .expect("gc");
+
+        // The predicate discriminates by exact stored path: only the orphan goes.
+        assert_eq!(removed, 1, "only the orphan is reclaimed");
+        assert!(
+            std::path::Path::new(&live.folder.path).is_dir(),
+            "the live chat dir is spared even with an orphan beside it"
+        );
+        assert!(
+            !std::path::Path::new(&orphan).exists(),
+            "the orphan is removed"
+        );
+    }
+
+    // A live dir must survive even when this GC run's data_dir is a different
+    // *spelling* (here a symlink) of the storage that created it — full-path
+    // matching would misclassify it as an orphan and delete it (data loss). The
+    // layout-invariant `(<date>, <uuid>)` keying is what prevents that.
+    #[cfg(unix)]
+    #[tokio::test]
+    async fn gc_spares_live_dir_under_aliased_data_dir() {
+        use std::os::unix::fs::symlink;
+        let db = fresh_in_memory_db().await;
+        let real = tempfile::tempdir().expect("tempdir");
+        // DB records the live path under the REAL data_dir spelling.
+        let live =
+            create_chat_conversation_core(&db.conn, real.path(), AgentType::Codex, None, None)
+                .await
+                .expect("create live");
+        // A second spelling of the same storage: a symlink pointing at it.
+        let link_parent = tempfile::tempdir().expect("link parent");
+        let link = link_parent.path().join("data-link");
+        symlink(real.path(), &link).expect("symlink");
+
+        // GC runs under the symlinked spelling; the live dir must still be spared.
+        let removed = gc_orphan_chat_dirs_core_with_threshold(
+            &db.conn,
+            &link,
+            std::time::Duration::ZERO,
+        )
+        .await
+        .expect("gc");
+
+        assert_eq!(
+            removed, 0,
+            "live dir spared despite an aliased data_dir spelling"
+        );
+        assert!(
+            std::path::Path::new(&live.folder.path).is_dir(),
+            "live chat dir retained under data_dir aliasing"
+        );
+    }
+
     #[tokio::test]
     async fn cleanup_chat_folder_keeps_folder_with_remaining_conversations() {
         let db = fresh_in_memory_db().await;
diff --git a/src-tauri/src/db/service/folder_service.rs b/src-tauri/src/db/service/folder_service.rs
index 2a68e182..d8865dbc 100644
--- a/src-tauri/src/db/service/folder_service.rs
+++ b/src-tauri/src/db/service/folder_service.rs
@@ -328,6 +328,22 @@ pub async fn list_all_folder_details(
     Ok(rows.into_iter().map(to_detail).collect())
 }
 
+/// Paths of all *live* (non-deleted) chat scratch folders. Consumed by the
+/// startup orphan-scratch-dir GC to spare directories still bound to a chat
+/// conversation, while reclaiming pre-send drafts (no row at all) and
+/// post-delete dirs (soft-deleted row → `DeletedAt` set → excluded here).
+pub async fn list_live_chat_folder_paths(
+    conn: &DatabaseConnection,
+) -> Result<Vec<String>, DbError> {
+    let rows = folder::Entity::find()
+        .filter(folder::Column::DeletedAt.is_null())
+        .filter(folder::Column::IsChat.eq(true))
+        .all(conn)
+        .await?;
+
+    Ok(rows.into_iter().map(|m| m.path).collect())
+}
+
 pub async fn reorder_folders(conn: &DatabaseConnection, ids: Vec<i32>) -> Result<(), DbError> {
     if ids.is_empty() {
         return Ok(());
diff --git a/src-tauri/src/lib.rs b/src-tauri/src/lib.rs
index 8d4209b8..60877cb4 100644
--- a/src-tauri/src/lib.rs
+++ b/src-tauri/src/lib.rs
@@ -323,6 +323,31 @@ mod tauri_app {
                     }
                 });
 
+                // Reclaim orphaned chat scratch dirs (pre-send drafts that never
+                // bound to a conversation, plus dirs left behind by deleted chat
+                // conversations). Background, non-blocking; failures are logged
+                // but non-fatal — anything still in use is left for next startup.
+                {
+                    let gc_conn = app.state::<db::AppDatabase>().conn.clone();
+                    let gc_data_dir = effective_data_dir.clone();
+                    tauri::async_runtime::spawn(async move {
+                        match crate::commands::conversations::gc_orphan_chat_dirs_core(
+                            &gc_conn,
+                            &gc_data_dir,
+                        )
+                        .await
+                        {
+                            Ok(n) if n > 0 => eprintln!(
+                                "[conversations] chat-dir GC: reclaimed {n} orphan scratch dir(s)"
+                            ),
+                            Ok(_) => {}
+                            Err(err) => {
+                                eprintln!("[conversations] chat-dir GC failed: {err}")
+                            }
+                        }
+                    });
+                }
+
                 // Start chat channel background tasks
                 {
                     let ccm = app.state::<ChatChannelManager>();