feat(desktop): cap session tabs, skip restoring them, reopen closed ones (#1550)

Session tabs pile up when many chats run in parallel. Settings → General
gains a Tabs section, and every default keeps today's behavior:

- Session tabs to keep (no limit / 5 / 8 / 12 / 20). Checked only when a
  chat tab is added or the limit is lowered, so a tab never disappears
  while nobody is acting. The tab looked at least recently goes first;
  the active tab, running or waiting chats, unsent drafts, team leads and
  chats another open tab views are kept, even past the limit.
- Restore tabs on launch. Off starts with an empty strip and keeps the
  saved tabs, so turning it back on restores them.
- Reopen Closed Tab in the tab menu brings back the last ten chat tabs
  closed in this run, skipping deleted sessions. Cmd/Ctrl+Shift+T stays
  with the workspace panel, which already uses it.

Auto-closing reuses the tab strip's own close path, now in
stores/tabClose.ts, so it never stops or deletes a session. Not active in
the phone and tablet shells.

Author: NanmiCoder

desktop/src/App.tsx

@@ -6,6 +6,7 @@ import { RemoteAccessGate } from './pages/RemoteAccess'
 import { isPublicAccessRuntime } from './lib/publicAccessRuntime'
 import { useChatStore } from './stores/chatStore'
 import { installHiddenSessionRelease } from './stores/hiddenSessionRelease'
+import { installSessionTabLimit } from './stores/sessionTabLimit'
 import { useMobileShellLayout } from './components/mobile/mobileShellLayout'
 import { isDesktopRuntime } from './lib/desktopRuntime'
 
@@ -24,6 +25,11 @@ function ConnectedApp() {
     }),
     [shellLayout],
   )
+  // Phones and tablets keep one page on screen; their tabs are only a way back.
+  useEffect(
+    () => (shellLayout === 'desktop' ? installSessionTabLimit() : undefined),
+    [shellLayout],
+  )
   useEffect(() => {
     let cleanup: (() => void) | undefined
     let cancelled = false

desktop/src/components/layout/TabBar.test.tsx

@@ -175,6 +175,7 @@ vi.mock('../../i18n', () => ({
       'tabs.closeLeft': 'Close Left',
       'tabs.closeRight': 'Close Right',
       'tabs.closeAll': 'Close All',
+      'tabs.reopenClosed': 'Reopen Closed Tab',
       'tabs.closeConfirmTitle': 'Session Running',
       'tabs.closeConfirmMessage': 'Still running',
       'tabs.closeConfirmKeep': 'Keep Running',
@@ -3229,6 +3230,55 @@ describe('TabBar', () => {
     })
   })
 
+  it('reopens a closed chat tab from the tab menu, and offers it only after one was closed', async () => {
+    const { TabBar } = await import('./TabBar')
+    const { useTabStore } = await import('../../stores/tabStore')
+    const { useChatStore } = await import('../../stores/chatStore')
+    const { useSessionStore } = await import('../../stores/sessionStore')
+    const connectToSession = vi.fn()
+    const disconnectSession = vi.fn()
+
+    useSessionStore.setState({
+      sessions: [
+        { id: 'tab-a', title: 'Session A', createdAt: '2026-10-01T00:00:00.000Z', modifiedAt: '2026-10-01T00:00:00.000Z', messageCount: 3, projectPath: '-repo', workDir: '/repo', workDirExists: true },
+      ],
+    } as never)
+    useTabStore.setState({
+      tabs: [
+        { sessionId: 'tab-a', title: 'Session A', type: 'session', status: 'idle' },
+        { sessionId: 'tab-b', title: 'Session B', type: 'session', status: 'idle' },
+      ],
+      activeTabId: 'tab-b',
+      closedSessionTabs: [],
+    })
+    useChatStore.setState({
+      sessions: { 'tab-a': makeChatSession('idle'), 'tab-b': makeChatSession('idle') },
+      connectToSession,
+      disconnectSession,
+    } as Partial<ReturnType<typeof useChatStore.getState>>)
+
+    await act(async () => {
+      render(<TabBar />)
+    })
+
+    fireEvent.contextMenu(screen.getByText('Session B'))
+    expect(screen.getByText('Reopen Closed Tab')).toBeDisabled()
+
+    fireEvent.click(screen.getByText('Close Others'))
+    expect(useTabStore.getState().tabs.map((tab) => tab.sessionId)).toEqual(['tab-b'])
+    expect(disconnectSession).toHaveBeenCalledWith('tab-a')
+
+    fireEvent.contextMenu(screen.getByText('Session B'))
+    await act(async () => {
+      fireEvent.click(screen.getByText('Reopen Closed Tab'))
+    })
+
+    expect(useTabStore.getState().tabs.map((tab) => tab.sessionId)).toEqual(['tab-b', 'tab-a'])
+    expect(useTabStore.getState().activeTabId).toBe('tab-a')
+    expect(connectToSession).toHaveBeenCalledWith('tab-a')
+    expect(screen.queryByText('Reopen Closed Tab')).not.toBeInTheDocument()
+  })
+
   it('shows a running marker on tabs from tab status, live chat state, or background tasks', async () => {
     const { TabBar } = await import('./TabBar')
     const { useTabStore } = await import('../../stores/tabStore')

desktop/src/components/layout/TabBar.tsx

@@ -1,25 +1,21 @@
 import { forwardRef, useMemo, useRef, useState, useEffect, useLayoutEffect, useCallback, useId } from 'react'
 import { useShallow } from 'zustand/react/shallow'
 import {
-  SCHEDULED_TAB_ID,
-  SETTINGS_TAB_ID,
-  MARKET_TAB_ID,
-  CONNECTORS_TAB_ID,
-  SUBAGENT_TAB_PREFIX,
-  TEAM_MEMBER_TAB_PREFIX,
-  TEAM_TAB_PREFIX,
-  TERMINAL_TAB_PREFIX,
-  WORKBENCH_TAB_PREFIX,
   useTabStore,
   type Tab,
   type TabType,
 } from '../../stores/tabStore'
+import {
+  closeTabsWithPolicy,
+  getRunningSessionIds,
+  isSessionTab,
+  isSessionTabId,
+  reopenClosedSessionTab,
+} from '../../stores/tabClose'
 import { useChatStore } from '../../stores/chatStore'
 import { useSessionStore } from '../../stores/sessionStore'
 import type { UIMessage } from '../../types/chat'
-import { isPlaceholderSessionTitle } from '../../lib/sessionTitle'
 import { useWorkspaceStore } from '../../stores/workspaceStore'
-import { releaseWorkspaceSession } from '../../lib/workspace/releaseSession'
 import { useCLITaskStore } from '../../stores/cliTaskStore'
 import { teamTaskWindowsForSnapshot, useTeamStore } from '../../stores/teamStore'
 import { StatusDot } from '@/components/ui/Badge'
@@ -28,7 +24,7 @@ import { tabChipClass, tabChipLabelClass } from '@/components/ui/tabChip'
 import { useDismissable } from '@/hooks/useDismissable'
 import { useTranslation } from '../../i18n'
 import { getDesktopHost } from '../../lib/desktopHost'
-import { hasRunningBackgroundTasks, listRunningBackgroundTasks } from '../../lib/backgroundTasks'
+import { hasRunningBackgroundTasks } from '../../lib/backgroundTasks'
 import { collectAttentionIds, nextAttentionSessionId } from '../../lib/sessionAttention'
 import { SessionAttentionMark } from './SessionAttentionMark'
 import { TabAttentionJump } from './TabAttentionJump'
@@ -110,32 +106,11 @@ type PendingCloseRequest = {
   runningSessionIds: string[]
 }
 
-function isSessionTab(tab: Tab | null) {
-  if (!tab) return false
-  const tabType = (tab as Partial<Tab>).type
-  if (tabType === 'session') return true
-  if (tabType) return false
-  return isSessionTabId(tab.sessionId)
-}
-
-function isSessionTabId(tabId: string | null) {
-  if (!tabId) return false
-  return tabId !== SETTINGS_TAB_ID &&
-    tabId !== SCHEDULED_TAB_ID &&
-    tabId !== MARKET_TAB_ID &&
-    tabId !== CONNECTORS_TAB_ID &&
-    !tabId.startsWith(TERMINAL_TAB_PREFIX) &&
-    !tabId.startsWith(WORKBENCH_TAB_PREFIX) &&
-    !tabId.startsWith(SUBAGENT_TAB_PREFIX) &&
-    !tabId.startsWith(TEAM_TAB_PREFIX) &&
-    !tabId.startsWith(TEAM_MEMBER_TAB_PREFIX)
-}
-
 export function TabBar() {
   const tabs = useTabStore((s) => s.tabs)
   const activeTabId = useTabStore((s) => s.activeTabId)
   const setActiveTab = useTabStore((s) => s.setActiveTab)
-  const closeTab = useTabStore((s) => s.closeTab)
+  const canReopenClosedTab = useTabStore((s) => s.closedSessionTabs.length > 0)
   const sessionTabIds = useMemo(
     () => tabs.filter((tab) => isSessionTab(tab)).map((tab) => tab.sessionId),
     [tabs],
@@ -156,7 +131,6 @@ export function TabBar() {
   // The waiting tabs other than the one on screen: the places a jump can take
   // you, and so the number on the button that offers it.
   const otherAttentionCount = attentionList.filter((sessionId) => sessionId !== activeTabId).length
-  const disconnectSession = useChatStore((s) => s.disconnectSession)
   const activeTab = tabs.find((tab) => tab.sessionId === activeTabId) ?? null
   const isActiveSessionTab = isSessionTab(activeTab) || isSessionTabId(activeTabId)
   const activeSession = useSessionStore((state) =>
@@ -426,65 +400,6 @@ export function TabBar() {
     el.scrollBy({ left: direction === 'left' ? -step : step, behavior: 'smooth' })
   }
 
-  const closeTabWithCleanup = useCallback((tab: Tab) => {
-    if (isSessionTab(tab)) {
-      releaseWorkspaceSession(tab.sessionId)
-    }
-    closeTab(tab.sessionId)
-  }, [closeTab])
-
-  const getRunningSessionIds = useCallback((targetTabs: Tab[]) => {
-    const chatSessions = useChatStore.getState().sessions
-    return targetTabs
-      .filter((tab) => isSessionTab(tab))
-      .filter((tab) => {
-        const sessionState = chatSessions[tab.sessionId]
-        return !!sessionState &&
-          (sessionState.chatState !== 'idle' || hasRunningBackgroundTasks(sessionState.backgroundAgentTasks))
-      })
-      .map((tab) => tab.sessionId)
-  }, [])
-
-  const closeTabsWithPolicy = useCallback((targetTabs: Tab[], runningSessionIds: string[], stopRunning: boolean) => {
-    const runningSessionSet = new Set(runningSessionIds)
-
-    for (const tab of targetTabs) {
-      if (isSessionTab(tab)) {
-        const isRunning = runningSessionSet.has(tab.sessionId)
-        if (isRunning && stopRunning) {
-          const chat = useChatStore.getState()
-          const runningTasks = listRunningBackgroundTasks(chat.sessions[tab.sessionId]?.backgroundAgentTasks)
-          chat.stopGeneration(tab.sessionId)
-          // The dialog counts background tasks as the session running, but
-          // stopGeneration only reaches the foreground turn and Agent tasks (and
-          // marks the latter as stopping, which stopBackgroundTask skips). A shell
-          // command would outlive "Stop & Close" and keep the reopened session
-          // running. Both must go out before disconnectSession closes the socket.
-          for (const task of runningTasks) {
-            chat.stopBackgroundTask(tab.sessionId, task.taskId)
-          }
-        }
-        if (!isRunning || stopRunning) {
-          // Auto-delete only when both server metadata and the loaded transcript
-          // confirm this is an empty placeholder. Missing state can mean a timed-out
-          // recovery load, so treating it as empty risks deleting a real session.
-          const sessionEntry = useSessionStore.getState().sessions.find((s) => s.id === tab.sessionId)
-          const chatEntry = useChatStore.getState().sessions[tab.sessionId]
-          if (
-            sessionEntry?.messageCount === 0 &&
-            isPlaceholderSessionTitle(sessionEntry.title) &&
-            chatEntry?.historyStatus === 'ready' &&
-            chatEntry.messages.length === 0
-          ) {
-            void useSessionStore.getState().deleteSession(tab.sessionId)
-          }
-          disconnectSession(tab.sessionId)
-        }
-      }
-      closeTabWithCleanup(tab)
-    }
-  }, [closeTabWithCleanup, disconnectSession])
-
   const requestCloseTabs = useCallback((targetTabs: Tab[]) => {
     if (targetTabs.length === 0) return
     const runningSessionIds = getRunningSessionIds(targetTabs)
@@ -495,7 +410,7 @@ export function TabBar() {
     }
 
     closeTabsWithPolicy(targetTabs, [], false)
-  }, [closeTabsWithPolicy, getRunningSessionIds])
+  }, [])
 
   const handleClose = (sessionId: string) => {
     const tab = tabs.find((t) => t.sessionId === sessionId)
@@ -877,6 +792,14 @@ export function TabBar() {
           >
             {t('tabs.closeAll')}
           </button>
+          <div className="mx-1 my-1 border-t border-[var(--color-border)]" />
+          <button
+            disabled={!canReopenClosedTab}
+            onClick={() => { setContextMenu(null); void reopenClosedSessionTab() }}
+            className="flex h-8 w-full items-center rounded-[var(--radius-sm)] px-2.5 text-left text-[13px] text-[var(--color-text-primary)] transition-colors hover:bg-[var(--color-surface-hover)] disabled:cursor-default disabled:text-[var(--color-text-tertiary)] disabled:hover:bg-transparent"
+          >
+            {t('tabs.reopenClosed')}
+          </button>
         </div>
       )}
 

desktop/src/i18n/locales/en.ts

@@ -3771,6 +3771,16 @@ Row 9, all 8 cells: continuing from straight down, turning left through lower-le
   'tabs.closeLeft': 'Close to the Left',
   'tabs.closeRight': 'Close to the Right',
   'tabs.closeAll': 'Close All',
+  'tabs.reopenClosed': 'Reopen Closed Tab',
+  'settings.tabs.title': 'Tabs',
+  'settings.tabs.description': 'How the session tabs at the top behave. Closing a tab never deletes the session: find it again in the sidebar, or right-click a tab and choose Reopen Closed Tab.',
+  'settings.tabs.limit': 'Session tabs to keep',
+  'settings.tabs.limitHint': 'When there are more, the tab you looked at least recently is closed. Tabs that are running, waiting for you, or hold an unsent message are kept.',
+  'settings.tabs.limitUnlimited': 'No limit',
+  'settings.tabs.limitCount': '{count} tabs',
+  'settings.tabs.restoreOnLaunch': 'Restore tabs on launch',
+  'settings.tabs.restoreOnLaunchHintOn': 'Tabs left open last time come back when the app starts.',
+  'settings.tabs.restoreOnLaunchHintOff': 'The app starts with no tabs open. Your sessions stay in the sidebar.',
   'tabs.closeConfirmTitle': 'Session Running',
   'tabs.closeConfirmMessage': 'This session is still running. What would you like to do?',
   'tabs.closeConfirmKeep': 'Keep Running',

desktop/src/i18n/locales/jp.ts

@@ -3772,6 +3772,16 @@ export const jp: Record<TranslationKey, string> = {
   'tabs.closeLeft': '左側を閉じる',
   'tabs.closeRight': '右側を閉じる',
   'tabs.closeAll': 'すべて閉じる',
+  'tabs.reopenClosed': '閉じたタブを再度開く',
+  'settings.tabs.title': 'タブ',
+  'settings.tabs.description': '上部のセッションタブの動作を設定します。タブを閉じてもセッションは削除されません。サイドバーから、またはタブを右クリックして「閉じたタブを再度開く」で戻せます。',
+  'settings.tabs.limit': '保持するセッションタブ数',
+  'settings.tabs.limitHint': '上限を超えると、最も長く表示していないタブを自動で閉じます。実行中、対応待ち、未送信の入力があるタブは閉じません。',
+  'settings.tabs.limitUnlimited': '無制限',
+  'settings.tabs.limitCount': '{count} 個',
+  'settings.tabs.restoreOnLaunch': '起動時に前回のタブを復元',
+  'settings.tabs.restoreOnLaunchHintOn': 'アプリを再起動すると、前回開いていたタブがそのまま戻ります。',
+  'settings.tabs.restoreOnLaunchHintOff': 'アプリはタブなしで起動します。セッションはサイドバーに残ります。',
   'tabs.closeConfirmTitle': 'セッション実行中',
   'tabs.closeConfirmMessage': 'このセッションはまだ実行中です。どうしますか？',
   'tabs.closeConfirmKeep': '実行を継続',

desktop/src/i18n/locales/kr.ts

@@ -3774,6 +3774,16 @@ export const kr: Record<TranslationKey, string> = {
   'tabs.closeLeft': '왼쪽 탭 닫기',
   'tabs.closeRight': '오른쪽 탭 닫기',
   'tabs.closeAll': '모두 닫기',
+  'tabs.reopenClosed': '닫은 탭 다시 열기',
+  'settings.tabs.title': '탭',
+  'settings.tabs.description': '상단 세션 탭의 동작을 설정합니다. 탭을 닫아도 세션은 삭제되지 않으며, 사이드바에서 또는 탭을 우클릭해 「닫은 탭 다시 열기」로 되찾을 수 있습니다.',
+  'settings.tabs.limit': '유지할 세션 탭 수',
+  'settings.tabs.limitHint': '초과하면 가장 오래 보지 않은 세션 탭을 자동으로 닫습니다. 실행 중이거나 응답을 기다리거나 보내지 않은 입력이 있는 탭은 닫지 않습니다.',
+  'settings.tabs.limitUnlimited': '제한 없음',
+  'settings.tabs.limitCount': '{count}개',
+  'settings.tabs.restoreOnLaunch': '시작할 때 이전 탭 복원',
+  'settings.tabs.restoreOnLaunchHintOn': '앱을 다시 열면 지난번에 열려 있던 탭이 그대로 돌아옵니다.',
+  'settings.tabs.restoreOnLaunchHintOff': '앱이 탭 없이 시작됩니다. 세션은 사이드바에 그대로 있습니다.',
   'tabs.closeConfirmTitle': '세션 실행 중',
   'tabs.closeConfirmMessage': '이 세션은 아직 실행 중입니다. 어떻게 하시겠습니까?',
   'tabs.closeConfirmKeep': '계속 실행',

desktop/src/i18n/locales/zh-TW.ts

@@ -3771,6 +3771,16 @@ export const zh: Record<TranslationKey, string> = {
   'tabs.closeLeft': '關閉左側',
   'tabs.closeRight': '關閉右側',
   'tabs.closeAll': '關閉所有',
+  'tabs.reopenClosed': '重新開啟已關閉的分頁',
+  'settings.tabs.title': '分頁',
+  'settings.tabs.description': '控制頂部的工作階段分頁。關閉分頁不會刪除工作階段，可以在左側清單或右鍵分頁選「重新開啟已關閉的分頁」找回。',
+  'settings.tabs.limit': '最多保留的工作階段分頁',
+  'settings.tabs.limitHint': '超出時自動關閉最久沒看過的工作階段分頁。正在執行、等你處理、有未送出內容的不會被關閉。',
+  'settings.tabs.limitUnlimited': '不限',
+  'settings.tabs.limitCount': '{count} 個',
+  'settings.tabs.restoreOnLaunch': '啟動時恢復上次開啟的分頁',
+  'settings.tabs.restoreOnLaunchHintOn': '重新開啟應用程式時，上次沒關的分頁會原樣回來。',
+  'settings.tabs.restoreOnLaunchHintOff': '重新開啟應用程式時分頁列為空，工作階段仍在左側清單裡。',
   'tabs.closeConfirmTitle': '會話執行中',
   'tabs.closeConfirmMessage': '此會話仍在執行，你想要怎麼做？',
   'tabs.closeConfirmKeep': '保持執行',

desktop/src/i18n/locales/zh.ts

@@ -3770,6 +3770,16 @@ export const zh: Record<TranslationKey, string> = {
   'tabs.closeLeft': '关闭左侧',
   'tabs.closeRight': '关闭右侧',
   'tabs.closeAll': '关闭所有',
+  'tabs.reopenClosed': '重新打开已关闭的标签',
+  'settings.tabs.title': '标签页',
+  'settings.tabs.description': '控制顶部会话标签。关闭标签不会删除会话，可以在左侧列表或右键标签选「重新打开已关闭的标签」找回。',
+  'settings.tabs.limit': '最多保留的会话标签',
+  'settings.tabs.limitHint': '超出时自动关闭最久没看过的会话标签。正在运行、等你处理、有未发送内容的不会被关闭。',
+  'settings.tabs.limitUnlimited': '不限',
+  'settings.tabs.limitCount': '{count} 个',
+  'settings.tabs.restoreOnLaunch': '启动时恢复上次打开的标签',
+  'settings.tabs.restoreOnLaunchHintOn': '重新打开应用时，上次没关的标签会原样回来。',
+  'settings.tabs.restoreOnLaunchHintOff': '重新打开应用时标签栏为空，会话仍在左侧列表里。',
   'tabs.closeConfirmTitle': '会话运行中',
   'tabs.closeConfirmMessage': '此会话仍在运行，你想要怎么做？',
   'tabs.closeConfirmKeep': '保持运行',

desktop/src/lib/tabBehavior.test.ts

@@ -0,0 +1,49 @@
+import { describe, expect, it } from 'vitest'
+import {
+  DEFAULT_TAB_BEHAVIOR,
+  TAB_BEHAVIOR_STORAGE_KEY,
+  persistTabBehavior,
+  readTabBehavior,
+} from './tabBehavior'
+
+function memoryStorage(initial: Record<string, string> = {}) {
+  const values = new Map(Object.entries(initial))
+  return {
+    getItem: (key: string) => values.get(key) ?? null,
+    setItem: (key: string, value: string) => { values.set(key, value) },
+    raw: (key: string) => values.get(key),
+  }
+}
+
+describe('tab behavior preference', () => {
+  it('reads storage written before the setting existed as today\'s behavior', () => {
+    // A pre-feature profile: open tabs saved, no tab behavior record.
+    const storage = memoryStorage({
+      'cc-haha-open-tabs': JSON.stringify({ openTabs: [{ sessionId: 's1', title: 'A', type: 'session' }], activeTabId: 's1' }),
+    })
+    expect(readTabBehavior(storage)).toEqual({ sessionTabLimit: null, restoreOnLaunch: true })
+    expect(storage.raw(TAB_BEHAVIOR_STORAGE_KEY)).toBeUndefined()
+  })
+
+  it('round-trips a saved choice', () => {
+    const storage = memoryStorage()
+    persistTabBehavior({ sessionTabLimit: 8, restoreOnLaunch: false }, storage)
+    expect(JSON.parse(storage.raw(TAB_BEHAVIOR_STORAGE_KEY)!)).toEqual({ version: 1, sessionTabLimit: 8, restoreOnLaunch: false })
+    expect(readTabBehavior(storage)).toEqual({ sessionTabLimit: 8, restoreOnLaunch: false })
+  })
+
+  it.each([
+    ['unparseable JSON', '{nope'],
+    ['an array', '[]'],
+    ['a limit that is not one of the presets', JSON.stringify({ version: 1, sessionTabLimit: 3, restoreOnLaunch: 'no' })],
+  ])('falls back to the default for %s', (_label, raw) => {
+    expect(readTabBehavior(memoryStorage({ [TAB_BEHAVIOR_STORAGE_KEY]: raw }))).toEqual(DEFAULT_TAB_BEHAVIOR)
+  })
+
+  it('reads a record from a newer build as the default without rewriting it', () => {
+    const raw = JSON.stringify({ version: 2, sessionTabLimit: 5, restoreOnLaunch: false, groups: true })
+    const storage = memoryStorage({ [TAB_BEHAVIOR_STORAGE_KEY]: raw })
+    expect(readTabBehavior(storage)).toEqual(DEFAULT_TAB_BEHAVIOR)
+    expect(storage.raw(TAB_BEHAVIOR_STORAGE_KEY)).toBe(raw)
+  })
+})