@brimveyn/aimux 1.12.6 → 1.13.0

package/src/state/session-worktrees.ts

@@ -0,0 +1,227 @@
+import { spawnSync } from 'node:child_process'
+import { createHash } from 'node:crypto'
+import { existsSync } from 'node:fs'
+import { basename } from 'node:path'
+
+import type { SessionRecord, TabSession, WorktreeRecord } from './types'
+
+import { createPrefixedId } from '../platform/id'
+import { isInsideAimuxWorktreeRoot } from '../platform/worktree-paths'
+
+const WORKTREE_COLORS = ['#7dd3fc', '#86efac', '#facc15', '#f0abfc', '#fb7185', '#c4b5fd']
+
+export function getWorktreeColor(worktreeId: string): string {
+  let hash = 0
+  for (let i = 0; i < worktreeId.length; i++) {
+    hash = (hash * 31 + worktreeId.charCodeAt(i)) >>> 0
+  }
+  return WORKTREE_COLORS[hash % WORKTREE_COLORS.length] ?? '#7dd3fc'
+}
+
+export function createPrimaryWorktree(projectPath: string, now: string): WorktreeRecord {
+  const id = createPrefixedId('worktree')
+  return {
+    createdAt: now,
+    createdByAimux: false,
+    id,
+    name: basename(projectPath) || projectPath,
+    path: projectPath,
+    repoRoot: projectPath,
+    source: 'primary',
+    updatedAt: now,
+  }
+}
+
+export function ensureSessionWorktrees(
+  session: SessionRecord,
+  now = new Date().toISOString()
+): SessionRecord {
+  if (session.worktrees?.length != null && session.worktrees?.length !== 0) {
+    const worktrees = mergeExistingGitWorktrees(
+      pruneMissingAimuxTempWorktrees(session.worktrees),
+      now
+    )
+    if (worktrees.length === 0 && session.projectPath != null && session.projectPath !== '') {
+      const worktree = createPrimaryWorktree(session.projectPath, now)
+      return { ...session, activeWorktreeId: worktree.id, worktrees: [worktree] }
+    }
+    const activeWorktreeId = worktrees.some((w) => w.id === session.activeWorktreeId)
+      ? session.activeWorktreeId
+      : worktrees[0]?.id
+    const active = worktrees.find((w) => w.id === activeWorktreeId)
+    return {
+      ...session,
+      activeWorktreeId,
+      projectPath: active?.path ?? session.projectPath,
+      worktrees,
+    }
+  }
+
+  if (!(session.projectPath != null && session.projectPath !== '')) {
+    return session
+  }
+
+  const worktree = createPrimaryWorktree(session.projectPath, now)
+  const worktrees = mergeExistingGitWorktrees([worktree], now)
+  return {
+    ...session,
+    activeWorktreeId:
+      worktrees.find((entry) => entry.path === session.projectPath)?.id ?? worktree.id,
+    worktrees,
+  }
+}
+
+function stableWorktreeId(path: string): string {
+  return `worktree-${createHash('sha1').update(path).digest('hex').slice(0, 10)}`
+}
+
+function mergeExistingGitWorktrees(worktrees: WorktreeRecord[], now: string): WorktreeRecord[] {
+  const anchor = worktrees.find((worktree) => existsSync(worktree.path)) ?? worktrees[0]
+  if (!anchor) return worktrees
+  const discovered = listGitWorktreesSync(anchor.path)
+  if (discovered.length === 0) return worktrees
+
+  // Git keeps admin entries for worktrees whose directory is gone (e.g. a temp
+  // dir cleared on reboot). Drop that stale state so the entries stop
+  // resurfacing in `git worktree list`, and ignore them while reconciling.
+  if (discovered.some((entry) => entry.prunable === true)) {
+    pruneGitWorktreesSync(anchor.path)
+  }
+  const live = discovered.filter((entry) => entry.prunable !== true)
+
+  const byPath = new Map(worktrees.map((worktree) => [worktree.path, worktree]))
+  // `git worktree list` reports the main worktree first; prefer the primary
+  // record's repoRoot when it still exists, then git's main worktree.
+  const primaryRepoRoot = worktrees.find((worktree) => worktree.source === 'primary')?.repoRoot
+  const repoRoot =
+    primaryRepoRoot !== undefined && existsSync(primaryRepoRoot)
+      ? primaryRepoRoot
+      : (live[0]?.path ?? anchor.repoRoot)
+  for (const entry of live) {
+    if (byPath.has(entry.path)) continue
+    if (isInsideAimuxWorktreeRoot(entry.path)) continue
+    const worktree: WorktreeRecord = {
+      branch: entry.branch,
+      commitSha: entry.head,
+      createdAt: now,
+      createdByAimux: false,
+      id: stableWorktreeId(entry.path),
+      name: basename(entry.path) || entry.path,
+      path: entry.path,
+      repoRoot,
+      source: 'external',
+      updatedAt: now,
+    }
+    byPath.set(entry.path, worktree)
+  }
+  return (
+    [...byPath.values()]
+      // Drop records whose directory no longer exists (a deleted external
+      // worktree that git already pruned) so they don't reappear on restart.
+      .filter((worktree) => worktree.source === 'primary' || existsSync(worktree.path))
+      // Heal records whose repoRoot points at a since-deleted sibling worktree
+      // so later git operations (e.g. `git -C repoRoot`) don't fail.
+      .map((worktree) =>
+        existsSync(worktree.repoRoot) ? worktree : { ...worktree, repoRoot, updatedAt: now }
+      )
+  )
+}
+
+interface DiscoveredWorktree {
+  path: string
+  head?: string
+  branch?: string
+  prunable?: boolean
+}
+
+function listGitWorktreesSync(cwd: string): DiscoveredWorktree[] {
+  const result = spawnSync('git', ['-C', cwd, 'worktree', 'list', '--porcelain'], {
+    encoding: 'utf8',
+  })
+  if (result.status !== 0 || !result.stdout) return []
+  const worktrees: DiscoveredWorktree[] = []
+  let current: DiscoveredWorktree | null = null
+  for (const line of result.stdout.split('\n')) {
+    if (line.startsWith('worktree ')) {
+      if (current) worktrees.push(current)
+      current = { path: line.slice('worktree '.length) }
+    } else if (current && line.startsWith('HEAD ')) {
+      current.head = line.slice('HEAD '.length)
+    } else if (current && line.startsWith('branch ')) {
+      current.branch = line.slice('branch '.length).replace(/^refs\/heads\//, '')
+    } else if (current && line.startsWith('prunable')) {
+      current.prunable = true
+    }
+  }
+  if (current) worktrees.push(current)
+  return worktrees
+}
+
+function pruneGitWorktreesSync(cwd: string): void {
+  spawnSync('git', ['-C', cwd, 'worktree', 'prune'], { encoding: 'utf8' })
+}
+
+function pruneMissingAimuxTempWorktrees(worktrees: WorktreeRecord[]): WorktreeRecord[] {
+  return worktrees.filter((worktree) => {
+    if (
+      worktree.source !== 'aimux-temp' ||
+      !worktree.createdByAimux ||
+      !isInsideAimuxWorktreeRoot(worktree.path)
+    ) {
+      return true
+    }
+    return existsSync(worktree.path)
+  })
+}
+
+export function getActiveWorktree(session: SessionRecord | undefined): WorktreeRecord | undefined {
+  if (!(session?.worktrees?.length != null && session?.worktrees?.length !== 0)) return undefined
+  return (
+    session.worktrees.find((worktree) => worktree.id === session.activeWorktreeId) ??
+    session.worktrees[0]
+  )
+}
+
+export function getSessionProjectPath(session: SessionRecord | undefined): string | undefined {
+  return getActiveWorktree(session)?.path ?? session?.projectPath
+}
+
+export function withActiveWorktree(session: SessionRecord, worktreeId: string): SessionRecord {
+  const worktree = session.worktrees?.find((entry) => entry.id === worktreeId)
+  if (!worktree) return session
+  return {
+    ...session,
+    activeWorktreeId: worktreeId,
+    projectPath: worktree.path,
+    updatedAt: new Date().toISOString(),
+  }
+}
+
+export function getRenderedTabWorktreeId(
+  tab: { worktreeId?: string },
+  worktrees: { id: string }[]
+): string {
+  return tab.worktreeId ?? worktrees[0]?.id ?? '__main__'
+}
+
+export function orderTabsByWorktree(
+  tabs: TabSession[],
+  session: SessionRecord | undefined
+): TabSession[] {
+  const worktrees = session?.worktrees ?? []
+  const order = new Map<string, number>()
+  for (const [index, worktree] of worktrees.entries()) {
+    order.set(worktree.id, index)
+  }
+  order.set('__main__', order.size)
+
+  return tabs
+    .map((tab, index) => ({ index, tab }))
+    .sort((a, b) => {
+      const aw = order.get(getRenderedTabWorktreeId(a.tab, worktrees)) ?? Number.MAX_SAFE_INTEGER
+      const bw = order.get(getRenderedTabWorktreeId(b.tab, worktrees)) ?? Number.MAX_SAFE_INTEGER
+      if (aw !== bw) return aw - bw
+      return a.index - b.index
+    })
+    .map((entry) => entry.tab)
+}

package/src/state/store.ts

@@ -117,6 +117,7 @@ export function createInitialState(
     snippets,
     tabGroupMap: {},
     tabs: [],
+    worktreeDivergence: {},
   }
 }
 

package/src/state/toast-store.ts

@@ -0,0 +1,95 @@
+import type { ReactNode } from 'react'
+
+import { useStore } from 'zustand'
+import { createStore } from 'zustand/vanilla'
+
+import { createPrefixedId } from '../platform/id'
+
+export type ToastVariant = 'info' | 'success' | 'warning' | 'error'
+export type ToastPosition = `${'top' | 'bottom'}-${'left' | 'center' | 'right'}`
+
+export interface ToastOptions {
+  title?: string
+  message?: string
+  /** Custom body — rendered inside the toast shell instead of title/message. */
+  content?: ReactNode
+  variant?: ToastVariant
+  /** Auto-dismiss after this many ms; 0 keeps it until dismissed. */
+  durationMs?: number
+  position?: ToastPosition
+}
+
+export interface Toast {
+  id: string
+  createdAt: number
+  content?: ReactNode
+  durationMs: number
+  message?: string
+  position: ToastPosition
+  title?: string
+  variant: ToastVariant
+}
+
+export const TOAST_CONFIG = {
+  defaultPosition: 'top-right' as ToastPosition,
+  // Default auto-dismiss per variant when `durationMs` isn't given. Errors (and
+  // warnings) linger longer than confirmations so they're not missed.
+  durations: { error: 7000, info: 3500, success: 3500, warning: 5000 } as Record<
+    ToastVariant,
+    number
+  >,
+  gap: 1,
+  /** Most recent toasts kept visible per position; older ones are evicted. */
+  maxVisible: 4,
+  /** Instant (no slide) — set in tests or for reduced motion. */
+  reduceMotion: false,
+  width: 40,
+}
+
+interface ToastStoreState {
+  toasts: Toast[]
+  show: (opts: ToastOptions) => string
+  dismiss: (id: string) => void
+  clear: () => void
+}
+
+export const toastStore = createStore<ToastStoreState>((set) => ({
+  clear: () => set({ toasts: [] }),
+  dismiss: (id) => set((state) => ({ toasts: state.toasts.filter((entry) => entry.id !== id) })),
+  show: (opts) => {
+    const id = createPrefixedId('toast')
+    const variant = opts.variant ?? 'info'
+    const next: Toast = {
+      content: opts.content,
+      createdAt: Date.now(),
+      durationMs: opts.durationMs ?? TOAST_CONFIG.durations[variant],
+      id,
+      message: opts.message,
+      position: opts.position ?? TOAST_CONFIG.defaultPosition,
+      title: opts.title,
+      variant,
+    }
+    set((state) => ({ toasts: [...state.toasts, next] }))
+    return id
+  },
+  toasts: [],
+}))
+
+export function useToastStore<T>(selector: (state: ToastStoreState) => T): T {
+  return useStore(toastStore, selector)
+}
+
+function variantShortcut(variant: ToastVariant) {
+  return (message: string, opts: Omit<ToastOptions, 'message' | 'variant'> = {}): string =>
+    toastStore.getState().show({ ...opts, message, variant })
+}
+
+// Imperative API usable anywhere (components, side effects) without React.
+export const toast = {
+  dismiss: (id: string) => toastStore.getState().dismiss(id),
+  error: variantShortcut('error'),
+  info: variantShortcut('info'),
+  show: (opts: ToastOptions) => toastStore.getState().show(opts),
+  success: variantShortcut('success'),
+  warning: variantShortcut('warning'),
+}

package/src/state/types.ts

@@ -1,6 +1,8 @@
 import type { ModeId, SnippetVar } from '@brimveyn/aimux-config'
 import type { ThemedToken } from 'shiki'
 
+import type { LayoutNode, SplitDirection } from './layout-tree'
+
 export type BuiltinAssistantId = 'claude' | 'codex' | 'opencode' | 'terminal' | 'antigravity'
 
 export type AssistantId = BuiltinAssistantId | (string & {})
@@ -43,6 +45,7 @@ export type ModalType =
   | 'git-commit'
   | 'update-available'
   | 'ai-usage'
+  | 'worktree-move'
   | null
 
 export interface TerminalSpan {
@@ -97,6 +100,7 @@ export interface PersistedTabSnapshot {
   scrollIntent?: ScrollIntent
   errorMessage?: string
   exitCode?: number
+  worktreeId?: string
 }
 
 export interface WorkspaceSnapshotV1 {
@@ -108,11 +112,28 @@ export interface WorkspaceSnapshotV1 {
     width: number
   }
   tabs: PersistedTabSnapshot[]
-  layoutTree?: import('./layout-tree').LayoutNode
-  layoutTrees?: Record<string, import('./layout-tree').LayoutNode>
+  layoutTree?: LayoutNode
+  layoutTrees?: Record<string, LayoutNode>
   tabGroupMap?: Record<string, string>
 }
 
+export type WorktreeSource = 'primary' | 'aimux-temp' | 'external'
+
+export interface WorktreeRecord {
+  id: string
+  name: string
+  path: string
+  repoRoot: string
+  branch?: string
+  baseRef?: string
+  commitSha?: string
+  source: WorktreeSource
+  createdByAimux: boolean
+  color?: string
+  createdAt: string
+  updatedAt: string
+}
+
 export interface SessionRecord {
   id: string
   name: string
@@ -122,6 +143,8 @@ export interface SessionRecord {
   lastOpenedAt: string
   order?: number
   workspaceSnapshot?: WorkspaceSnapshotV1
+  worktrees?: WorktreeRecord[]
+  activeWorktreeId?: string
 }
 
 export type SessionBarPosition = 'top' | 'bottom'
@@ -144,6 +167,7 @@ export interface TabSession {
   command: string
   errorMessage?: string
   exitCode?: number
+  worktreeId?: string
 }
 
 export interface SidebarState {
@@ -160,7 +184,9 @@ export type GitPanePathConfig =
   | { enabled: false }
   | { enabled: true; pathFn?: (path: string) => string }
 
-export type GitPaneDiffCountConfig = { enabled: boolean }
+export interface GitPaneDiffCountConfig {
+  enabled: boolean
+}
 
 export interface GitPaneState {
   visible: boolean
@@ -271,6 +297,8 @@ export interface GitModeState {
   folds: Record<string, Record<string, FoldState>>
   /** Working-tree-vs-HEAD~N offset. 0 = working tree vs HEAD (default). */
   headOffset: number
+  /** When true, diff the active worktree's working tree against its fork point. */
+  reviewBase: boolean
 }
 
 interface ModalBase {
@@ -289,6 +317,16 @@ export interface ModalClosed extends ModalBase {
 export interface ModalNewTab extends ModalBase {
   type: 'new-tab'
   editingCommand: AssistantId | null
+  activeField: 'assistant' | 'branch-name' | 'target-worktree' | 'worktree-name'
+  branchError: string | null
+  branchName: string
+  createWorktree: boolean
+  selectedAssistantId: AssistantId | null
+  step: 'assistant' | 'worktree' | 'worktree-create'
+  targetWorktreeIndex: number
+  worktreeDeleteConfirmId: string | null
+  worktreeDeleteMessage: string | null
+  worktreeName: string
 }
 
 export interface ModalSessionPicker extends ModalBase {
@@ -326,7 +364,7 @@ export interface ModalHelp extends ModalBase {
 
 export interface ModalSplitPicker extends ModalBase {
   type: 'split-picker'
-  splitDirection: import('./layout-tree').SplitDirection
+  splitDirection: SplitDirection
 }
 
 export interface ModalGitCommit extends ModalBase {
@@ -366,6 +404,13 @@ export interface ModalAIUsage extends ModalBase {
   type: 'ai-usage'
 }
 
+export interface ModalWorktreeMove extends ModalBase {
+  type: 'worktree-move'
+  /** The worktree being moved (may differ from the active one, e.g. a tab menu). */
+  sourceWorktreeId: string
+  deleteSource: boolean
+}
+
 export type DirectoryResultType = 'git-repo' | 'worktree' | 'workspace'
 
 export interface DirectoryResult {
@@ -388,6 +433,7 @@ export type ModalState =
   | ModalGitCommit
   | ModalUpdateAvailable
   | ModalAIUsage
+  | ModalWorktreeMove
 
 export interface LayoutState {
   terminalCols: number
@@ -423,7 +469,7 @@ export const EMPTY_MULTI_REPO_STATE: MultiRepoState = { prefixes: {}, repos: []
 export interface AppState {
   tabs: TabSession[]
   activeTabId: string | null
-  layoutTrees: Record<string, import('./layout-tree').LayoutNode>
+  layoutTrees: Record<string, LayoutNode>
   tabGroupMap: Record<string, string>
   sessions: SessionRecord[]
   currentSessionId: string | null
@@ -440,6 +486,11 @@ export interface AppState {
   gitMode: GitModeState
   autoCommit: AutoCommitState
   multiRepo: MultiRepoState
+  /**
+   * Commits each worktree's branch is ahead/behind the ref it forked from,
+   * keyed by worktree id. Ephemeral (polled); not persisted to the catalog.
+   */
+  worktreeDivergence: Record<string, BranchDivergence>
   /** Chord prefix the sequence resolver is currently waiting on, or null when idle. */
   pendingChords: string[] | null
 }
@@ -448,9 +499,18 @@ export interface AppState {
 export type ModalAction =
   | { type: 'move-modal-cursor'; delta?: number; to?: 'home' | 'end' }
   | { type: 'open-new-tab-modal' }
+  | { type: 'set-new-tab-branch-error'; message: string | null }
+  | {
+      type: 'set-new-tab-worktree-delete-state'
+      confirmWorktreeId?: string | null
+      message: string | null
+    }
+  | { type: 'enter-new-tab-worktree-create' }
+  | { type: 'select-new-tab-assistant'; assistantId?: AssistantId }
+  | { type: 'toggle-new-tab-worktree'; assistantId?: AssistantId }
   | { type: 'open-edit-custom-command'; assistantId: AssistantId }
   | { type: 'open-help-modal'; scope?: ModeId }
-  | { type: 'open-split-picker'; direction: import('./layout-tree').SplitDirection }
+  | { type: 'open-split-picker'; direction: SplitDirection }
   | { type: 'open-session-picker' }
   | {
       type: 'open-session-name-modal'
@@ -475,6 +535,8 @@ export type ModalAction =
   | { type: 'open-update-available-modal'; currentVersion: string; latestVersion: string }
   | { type: 'set-modal-selection-index'; index: number }
   | { type: 'open-ai-usage-modal' }
+  | { type: 'open-worktree-move-modal'; sourceWorktreeId: string }
+  | { type: 'toggle-worktree-move-delete' }
 
 // -- Session actions --
 export type SessionAction =
@@ -485,6 +547,15 @@ export type SessionAction =
   | { type: 'delete-session-record'; sessionId: string; openSessionPicker?: boolean }
   | { type: 'reorder-sessions'; orderedIds: string[] }
   | { type: 'set-session-status'; sessionId: string; status: SessionStatus }
+  | { type: 'add-worktree-record'; sessionId: string; worktree: WorktreeRecord; activate?: boolean }
+  | { type: 'remove-worktree-record'; sessionId: string; worktreeId: string }
+  | { type: 'set-active-worktree'; sessionId: string; worktreeId: string }
+  | {
+      type: 'update-worktree-record'
+      sessionId: string
+      worktreeId: string
+      patch: Partial<WorktreeRecord>
+    }
 
 // -- Tab actions --
 export type TabAction =
@@ -493,8 +564,8 @@ export type TabAction =
       type: 'hydrate-workspace'
       tabs: TabSession[]
       activeTabId: string | null
-      layoutTree?: import('./layout-tree').LayoutNode | null
-      layoutTrees?: Record<string, import('./layout-tree').LayoutNode>
+      layoutTree?: LayoutNode | null
+      layoutTrees?: Record<string, LayoutNode>
       tabGroupMap?: Record<string, string>
     }
   | { type: 'close-tab'; tabId: string }
@@ -520,7 +591,7 @@ export type TabAction =
 export type LayoutAction =
   | {
       type: 'split-pane'
-      direction: import('./layout-tree').SplitDirection
+      direction: SplitDirection
       newTab: TabSession
     }
   | { type: 'close-pane'; tabId: string }
@@ -532,13 +603,13 @@ export type LayoutAction =
       type: 'resize-pane'
       tabId: string
       delta: number
-      axis?: import('./layout-tree').SplitDirection
+      axis?: SplitDirection
     }
   | {
       type: 'set-split-ratio'
       tabId: string
       ratio: number
-      axis?: import('./layout-tree').SplitDirection
+      axis?: SplitDirection
     }
 
 // -- UI actions --
@@ -566,10 +637,17 @@ export interface GitRefreshPayload {
   files: GitFileEntry[]
 }
 
+/** Commits a worktree branch is ahead/behind the ref it forked from. */
+export interface BranchDivergence {
+  ahead: number
+  behind: number
+}
+
 export type GitPanelAction =
   | { type: 'git-refresh-success'; payload: GitRefreshPayload }
   | { type: 'git-refresh-error'; kind: GitPanelError }
   | { type: 'git-panel-reset' }
+  | { type: 'set-worktree-divergence'; divergence: Record<string, BranchDivergence> }
 
 // -- Auto-commit state & actions --
 export type AutoCommitSuggestion =
@@ -647,8 +725,8 @@ export type GitModeAction =
       key: string
       hash: string
       themeId: string
-      add: Array<{ start: number; tokens: unknown }>
-      del: Array<{ start: number; tokens: unknown }>
+      add: { start: number; tokens: unknown }[]
+      del: { start: number; tokens: unknown }[]
     }
   | { type: 'git-mode-invalidate-diffs'; paths: string[] }
   | { type: 'git-mode-set-loading'; key: string; loading: boolean }
@@ -657,6 +735,7 @@ export type GitModeAction =
   | { type: 'git-mode-set-message'; message: string | null }
   | { type: 'snippet-picker-set-message'; message: string | null }
   | { type: 'git-mode-toggle-diff-view' }
+  | { type: 'git-mode-toggle-review-base' }
   | { type: 'git-mode-shift-head-offset'; delta: number }
   | { type: 'git-mode-set-head-offset'; offset: number }
   | {

package/src/state/validation.ts

@@ -5,6 +5,7 @@ import type {
   TerminalModeState,
   TerminalSnapshot,
   WorkspaceSnapshotV1,
+  WorktreeRecord,
 } from './types'
 
 function isObjectRecord(value: unknown): value is Record<string, unknown> {
@@ -105,6 +106,24 @@ function isStringRecord(value: unknown): boolean {
   return Object.values(value).every(isString)
 }
 
+function isWorktreeRecord(value: unknown): value is WorktreeRecord {
+  return (
+    isObjectRecord(value) &&
+    isString(value.id) &&
+    isString(value.name) &&
+    isString(value.path) &&
+    isString(value.repoRoot) &&
+    (value.branch === undefined || isString(value.branch)) &&
+    (value.baseRef === undefined || isString(value.baseRef)) &&
+    (value.commitSha === undefined || isString(value.commitSha)) &&
+    (value.source === 'primary' || value.source === 'aimux-temp' || value.source === 'external') &&
+    isBoolean(value.createdByAimux) &&
+    (value.color === undefined || isString(value.color)) &&
+    isString(value.createdAt) &&
+    isString(value.updatedAt)
+  )
+}
+
 export function isWorkspaceSnapshotV1(value: unknown): value is WorkspaceSnapshotV1 {
   return (
     isObjectRecord(value) &&
@@ -132,7 +151,8 @@ export function isWorkspaceSnapshotV1(value: unknown): value is WorkspaceSnapsho
         (tab.viewport === undefined || isTerminalSnapshot(tab.viewport)) &&
         (tab.scrollIntent === undefined || isScrollIntent(tab.scrollIntent)) &&
         (tab.errorMessage === undefined || isString(tab.errorMessage)) &&
-        (tab.exitCode === undefined || isFiniteNumber(tab.exitCode))
+        (tab.exitCode === undefined || isFiniteNumber(tab.exitCode)) &&
+        (tab.worktreeId === undefined || isString(tab.worktreeId))
     ) &&
     (value.layoutTree === undefined || isLayoutNode(value.layoutTree)) &&
     (value.layoutTrees === undefined || isLayoutTreesMap(value.layoutTrees)) &&
@@ -151,7 +171,10 @@ export function isSessionRecord(value: unknown): value is SessionRecord {
     isString(value.lastOpenedAt) &&
     (value.order === undefined ||
       (typeof value.order === 'number' && Number.isFinite(value.order))) &&
-    (value.workspaceSnapshot === undefined || isWorkspaceSnapshotV1(value.workspaceSnapshot))
+    (value.workspaceSnapshot === undefined || isWorkspaceSnapshotV1(value.workspaceSnapshot)) &&
+    (value.worktrees === undefined ||
+      (Array.isArray(value.worktrees) && value.worktrees.every(isWorktreeRecord))) &&
+    (value.activeWorktreeId === undefined || isString(value.activeWorktreeId))
   )
 }