fix(session): remember closed and initialized runtime tabs

src/main/persistence-host-admitted-terminal-membership.test.ts

@@ -89,6 +89,29 @@ describe('host-admitted terminal membership survives a stale renderer replay', (
     expect(persistedTabIds(store.getWorkspaceSession(), OTHER_WORKTREE)).toContain('host-tab-other')
   })
 
+  it('stamps default-terminal-tab markers so a renderer persist snapshot cannot un-apply them', async () => {
+    const store = await createStore()
+    store.setWorkspaceSession(rendererSession())
+
+    expect(
+      store.persistPtyBinding({
+        worktreeId: WORKTREE,
+        tabId: 'host-tab',
+        leafId: TEST_LEAF_2,
+        ptyId: 'host-pty',
+        hostAdmittedMembership: true
+      })
+    ).toBe(true)
+    expect(store.getWorkspaceSession().defaultTerminalTabsAppliedByWorktreeId?.[WORKTREE]).toBe(
+      true
+    )
+
+    store.setWorkspaceSession(rendererSession())
+    expect(store.getWorkspaceSession().defaultTerminalTabsAppliedByWorktreeId?.[WORKTREE]).toBe(
+      true
+    )
+  })
+
   // Polarity: without the flag the renderer still owns membership, so a renderer
   // spawn racing its own writer must not freeze the tab list.
   it('leaves renderer-owned membership alone when the binding is not host-admitted', async () => {

src/main/persistence/loading-store/pty-binding-persistence.ts

@@ -218,6 +218,11 @@ function applyPtyBinding(
       [bindingWorktreeId]: session.activeTabIdByWorktree?.[bindingWorktreeId] ?? args.tabId
     }
   }
+  // Why: host-initiated persist snapshots used to omit this write-once guard, so every launch or reattach treated the worktree as never having default terminals applied.
+  session.defaultTerminalTabsAppliedByWorktreeId = {
+    ...session.defaultTerminalTabsAppliedByWorktreeId,
+    [bindingWorktreeId]: true
+  }
   if (!isTerminalLeafId(args.leafId)) {
     // Why: keep legacy renderer-local pane ids out of durable leaf-keyed layout state after the UUID migration.
     advanceTopologyFence()

src/main/persistence/runtime-authored-workspace-session-fields.test.ts

@@ -63,6 +63,27 @@ describe('preserving runtime-authored workspace session fields', () => {
     expect(preserveRuntimeAuthoredWorkspaceSessionFields(next, session())).toBe(next)
     expect(preserveRuntimeAuthoredWorkspaceSessionFields(next, null)).toBe(next)
   })
+
+  it('keeps default-terminal-tab markers a persist snapshot omitted', () => {
+    const next = preserveRuntimeAuthoredWorkspaceSessionFields(session(), {
+      ...session(),
+      defaultTerminalTabsAppliedByWorktreeId: { 'repo-1::/wt-a': true }
+    })
+
+    expect(next.defaultTerminalTabsAppliedByWorktreeId).toEqual({ 'repo-1::/wt-a': true })
+  })
+
+  it('unions default-terminal-tab markers instead of replacing with a partial snapshot', () => {
+    const next = preserveRuntimeAuthoredWorkspaceSessionFields(
+      { ...session(), defaultTerminalTabsAppliedByWorktreeId: { 'repo-1::/wt-b': true } },
+      { ...session(), defaultTerminalTabsAppliedByWorktreeId: { 'repo-1::/wt-a': true } }
+    )
+
+    expect(next.defaultTerminalTabsAppliedByWorktreeId).toEqual({
+      'repo-1::/wt-a': true,
+      'repo-1::/wt-b': true
+    })
+  })
 })
 
 function session(

src/main/persistence/runtime-authored-workspace-session-fields.ts

@@ -1,32 +1,50 @@
 import type { WorkspaceSessionState } from '../../shared/workspace-session-state-types'
 
 /**
- * Keeps runtime-authored session state alive across a renderer's full write.
+ * Keeps session fields the renderer persist snapshot does not author across a full write.
  *
- * A session write replaces the stored object, and the renderer builds its payload from Zustand --
- * which has no idea the runtime authority sharing this profile also persists the client-hosted
- * pages it owns. Without this, every ordinary desktop session write erases them, and the loss only
- * shows up a restart later when there is nothing left to rehydrate.
+ * A session write replaces the stored object. Zustand-built payloads omit runtime-owned
+ * client-hosted pages, and they omit-when-empty the write-once default-terminal-tab marker.
+ * Without this, those slices vanish on the next desktop write and only show up missing after
+ * restart.
  *
  * Callers do not opt in: the Store applies this inside setLocalWorkspaceSession and
- * setHostWorkspaceSession, so the before-unload stage path inherits it too. Guarding the individual
- * writers instead is what let the quit write -- the most common one there is -- erase the field.
+ * setHostWorkspaceSession, so the before-unload stage path inherits it too.
  *
- * A runtime clearing its own rows writes an empty map, not `undefined`, so this can never pin a
- * stale set: only an author that never mentioned the field inherits the previous one.
+ * A runtime clearing client-hosted pages writes an empty map, not `undefined`. The default-tab
+ * marker is write-once: omission means "never stamped", not "never applied".
  */
+function unionWriteOnceDefaultTerminalTabsApplied(
+  next: WorkspaceSessionState,
+  prior: WorkspaceSessionState | null | undefined
+): WorkspaceSessionState {
+  const priorMarks = prior?.defaultTerminalTabsAppliedByWorktreeId
+  if (!priorMarks || Object.keys(priorMarks).length === 0) {
+    return next
+  }
+  const nextMarks = next.defaultTerminalTabsAppliedByWorktreeId
+  const merged = { ...priorMarks, ...nextMarks }
+  if (nextMarks && Object.keys(merged).length === Object.keys(nextMarks).length) {
+    return next
+  }
+  return { ...next, defaultTerminalTabsAppliedByWorktreeId: merged }
+}
+
 export function preserveRuntimeAuthoredWorkspaceSessionFields(
   next: WorkspaceSessionState,
   prior: WorkspaceSessionState | null | undefined
 ): WorkspaceSessionState {
+  let result = next
   if (
-    next.clientHostedBrowserPagesByWorktree !== undefined ||
-    prior?.clientHostedBrowserPagesByWorktree === undefined
+    next.clientHostedBrowserPagesByWorktree === undefined &&
+    prior?.clientHostedBrowserPagesByWorktree !== undefined
   ) {
-    return next
-  }
-  return {
-    ...next,
-    clientHostedBrowserPagesByWorktree: prior.clientHostedBrowserPagesByWorktree
+    result = {
+      ...result,
+      clientHostedBrowserPagesByWorktree: prior.clientHostedBrowserPagesByWorktree
+    }
   }
+  // Why union: persist snapshots omit this write-once map (empty Zustand slice, omit-when-empty
+  // payload). Treating omission as "never applied" re-spawns default terminals on every attach.
+  return unionWriteOnceDefaultTerminalTabsApplied(result, prior)
 }

src/main/runtime/workspace-session-worktree-id.test.ts

@@ -0,0 +1,62 @@
+/**
+ * Re-keying a workspace's session rows must not invent state the user never created.
+ *
+ * `tabsByWorktree` carries three states, not two: an absent row is "never initialized" and an
+ * explicit empty row is the closed-last-terminal tombstone that `shouldAutoCreateInitialTerminal`
+ * honours. Writing `[]` for a source that had no row turns the first into the second, and the
+ * workspace then never gets its initial terminal.
+ */
+import { describe, expect, it } from 'vitest'
+import { getDefaultWorkspaceSession } from '../../shared/constants'
+import type { WorkspaceSessionState } from '../../shared/workspace-session-state-types'
+import { canonicalizeTerminalSessionWorktreeId } from './workspace-session-worktree-id'
+
+const SOURCE = 'repo-1::/old/path'
+const TARGET = 'repo-1::/new/path'
+
+function tab(id: string, worktreeId: string) {
+  return {
+    id,
+    ptyId: `pty-${id}`,
+    worktreeId,
+    title: id,
+    customTitle: null,
+    color: null,
+    sortOrder: 0,
+    createdAt: 1
+  }
+}
+
+function session(overrides: Partial<WorkspaceSessionState> = {}): WorkspaceSessionState {
+  return { ...getDefaultWorkspaceSession(), ...overrides }
+}
+
+describe('canonicalizeTerminalSessionWorktreeId', () => {
+  it('does not fabricate a tombstone for a workspace that had no tabs row', () => {
+    const next = session({ tabsByWorktree: {} })
+
+    canonicalizeTerminalSessionWorktreeId(next, SOURCE, TARGET)
+
+    expect(Object.hasOwn(next.tabsByWorktree, TARGET)).toBe(false)
+  })
+
+  it('carries a real closed-last-terminal tombstone across the re-key', () => {
+    // The other direction: an explicit empty row is user intent and must survive, so the guard has
+    // to be about the source row's presence and not about the tabs being empty.
+    const next = session({ tabsByWorktree: { [SOURCE]: [] } })
+
+    canonicalizeTerminalSessionWorktreeId(next, SOURCE, TARGET)
+
+    expect(Object.hasOwn(next.tabsByWorktree, TARGET)).toBe(true)
+    expect(next.tabsByWorktree[TARGET]).toEqual([])
+    expect(Object.hasOwn(next.tabsByWorktree, SOURCE)).toBe(false)
+  })
+
+  it('re-keys the tabs and their own worktree ids', () => {
+    const next = session({ tabsByWorktree: { [SOURCE]: [tab('tab-1', SOURCE)] } })
+
+    canonicalizeTerminalSessionWorktreeId(next, SOURCE, TARGET)
+
+    expect(next.tabsByWorktree[TARGET]?.map((entry) => entry.worktreeId)).toEqual([TARGET])
+  })
+})

src/main/runtime/workspace-session-worktree-id.ts

@@ -8,12 +8,18 @@ export function canonicalizeTerminalSessionWorktreeId(
   if (sourceWorktreeId === targetWorktreeId) {
     return
   }
-  const tabs = session.tabsByWorktree[sourceWorktreeId] ?? []
-  delete session.tabsByWorktree[sourceWorktreeId]
-  session.tabsByWorktree[targetWorktreeId] = tabs.map((tab) => ({
-    ...tab,
-    worktreeId: targetWorktreeId
-  }))
+  // Why presence and not `?? []`: an absent row means never initialized, an explicit empty one is
+  // the closed-last-terminal tombstone. Writing `[]` for a source that had no row invents that
+  // tombstone, and the workspace then never gets its initial terminal. Same guard the keyed maps
+  // below already use.
+  if (Object.hasOwn(session.tabsByWorktree, sourceWorktreeId)) {
+    const tabs = session.tabsByWorktree[sourceWorktreeId] ?? []
+    delete session.tabsByWorktree[sourceWorktreeId]
+    session.tabsByWorktree[targetWorktreeId] = tabs.map((tab) => ({
+      ...tab,
+      worktreeId: targetWorktreeId
+    }))
+  }
 
   const groups = session.tabGroups?.[sourceWorktreeId]
   if (groups) {

src/renderer/src/lib/default-terminal-tabs-applied-persist.test.ts

@@ -0,0 +1,132 @@
+import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest'
+import { getDefaultWorkspaceSession } from '../../../shared/constants'
+import { parseWorkspaceSession } from '../../../shared/workspace-session-schema'
+import { useAppStore, type AppState } from '@/store'
+import { applyDefaultTerminalTabs } from './worktree-default-terminal-tabs'
+import {
+  createSessionWriteSubscriber,
+  type WorkspaceSessionWrite
+} from './session-write-subscriber'
+import { createTestStore, makeWorktree, seedStore } from '@/store/slices/store-test-helpers'
+
+let initialState: AppState
+
+const WORKTREE_ID = 'repo1::/wt-1'
+const DEFAULT_TABS = {
+  runCommands: false,
+  tabs: [{ title: 'Claude' }]
+}
+
+function preserveRuntimeAuthoredWorkspaceSessionFields<T extends Record<string, unknown>>(
+  next: T,
+  prior: T
+): T {
+  const marks = prior.defaultTerminalTabsAppliedByWorktreeId
+  if (!marks || typeof marks !== 'object') {
+    return next
+  }
+  return {
+    ...next,
+    defaultTerminalTabsAppliedByWorktreeId: {
+      ...marks,
+      ...(next.defaultTerminalTabsAppliedByWorktreeId as Record<string, boolean> | undefined)
+    }
+  }
+}
+
+describe('defaultTerminalTabsAppliedByWorktreeId persist round-trip', () => {
+  beforeEach(() => {
+    initialState = useAppStore.getState()
+    vi.useFakeTimers()
+  })
+
+  afterEach(() => {
+    vi.useRealTimers()
+    useAppStore.setState(initialState, true)
+  })
+
+  it('keeps the marker through mark, persist patch, omitted snapshot, and hydration', () => {
+    const persist = vi.fn<(payload: WorkspaceSessionWrite) => void>()
+    const cleanup = createSessionWriteSubscriber({ store: useAppStore, persist })
+
+    useAppStore.setState({ workspaceSessionReady: true, hydrationSucceeded: true })
+    vi.advanceTimersByTime(200)
+    persist.mockClear()
+
+    useAppStore.getState().markDefaultTerminalTabsApplied(WORKTREE_ID)
+    vi.advanceTimersByTime(200)
+
+    expect(persist.mock.calls[0][0].patch.defaultTerminalTabsAppliedByWorktreeId).toEqual({
+      [WORKTREE_ID]: true
+    })
+
+    const patched = {
+      ...getDefaultWorkspaceSession(),
+      ...persist.mock.calls[0][0].patch
+    }
+    // Persist snapshots omit this write-once slice (empty payload / renderer never mentioned it).
+    const omittedSnapshot = getDefaultWorkspaceSession()
+    const preserved = preserveRuntimeAuthoredWorkspaceSessionFields(omittedSnapshot, patched)
+    const parsed = parseWorkspaceSession(JSON.parse(JSON.stringify(preserved)))
+    expect(parsed.ok).toBe(true)
+    if (!parsed.ok) {
+      return
+    }
+
+    const store = createTestStore()
+    seedStore(store, {
+      worktreesByRepo: {
+        repo1: [makeWorktree({ id: WORKTREE_ID, repoId: 'repo1', path: '/wt-1' })]
+      }
+    })
+    store.getState().hydrateWorkspaceSession(parsed.value)
+
+    expect(store.getState().defaultTerminalTabsAppliedByWorktreeId[WORKTREE_ID]).toBe(true)
+    expect(
+      applyDefaultTerminalTabs(
+        store.getState(),
+        WORKTREE_ID,
+        undefined,
+        undefined,
+        undefined,
+        DEFAULT_TABS,
+        undefined,
+        undefined
+      )
+    ).toBeNull()
+    expect(store.getState().tabsByWorktree[WORKTREE_ID]).toBeUndefined()
+    cleanup()
+  })
+
+  it('does not drop in-memory markers when hydration omits the map', () => {
+    const store = createTestStore()
+    seedStore(store, {
+      worktreesByRepo: {
+        repo1: [makeWorktree({ id: WORKTREE_ID, repoId: 'repo1', path: '/wt-1' })]
+      }
+    })
+    store.getState().markDefaultTerminalTabsApplied(WORKTREE_ID)
+
+    store.getState().hydrateWorkspaceSession({
+      activeRepoId: 'repo1',
+      activeWorktreeId: WORKTREE_ID,
+      activeTabId: null,
+      terminalLayoutsByTabId: {},
+      tabsByWorktree: {}
+    })
+
+    expect(store.getState().defaultTerminalTabsAppliedByWorktreeId[WORKTREE_ID]).toBe(true)
+    expect(
+      applyDefaultTerminalTabs(
+        store.getState(),
+        WORKTREE_ID,
+        undefined,
+        undefined,
+        undefined,
+        DEFAULT_TABS,
+        undefined,
+        undefined
+      )
+    ).toBeNull()
+  })
+})

src/renderer/src/lib/session-write-subscriber.test.ts

@@ -190,6 +190,25 @@ describe('createSessionWriteSubscriber', () => {
     cleanup()
   })
 
+  it('persists defaultTerminalTabsAppliedByWorktreeId after markDefaultTerminalTabsApplied', () => {
+    const persist = vi.fn<(payload: WorkspaceSessionWrite) => void>()
+    const cleanup = createSessionWriteSubscriber({ store: useAppStore, persist })
+
+    useAppStore.setState({ workspaceSessionReady: true, hydrationSucceeded: true })
+    vi.advanceTimersByTime(200)
+    persist.mockClear()
+
+    const worktreeId = 'repo1::/wt-1'
+    useAppStore.getState().markDefaultTerminalTabsApplied(worktreeId)
+    vi.advanceTimersByTime(200)
+
+    expect(persist).toHaveBeenCalledTimes(1)
+    expect(persist.mock.calls[0][0].patch.defaultTerminalTabsAppliedByWorktreeId).toEqual({
+      [worktreeId]: true
+    })
+    cleanup()
+  })
+
   it('writes exactly once when a relevant field changes', () => {
     const persist = vi.fn<(payload: WorkspaceSessionWrite) => void>()
     const cleanup = createSessionWriteSubscriber({ store: useAppStore, persist })