@brimveyn/aimux 1.20.4 → 1.22.0

package/src/state/project-catalog.ts

@@ -0,0 +1,275 @@
+import { copyFileSync, existsSync, mkdirSync, readFileSync, writeFileSync } from 'node:fs'
+import { join } from 'node:path'
+
+import type { ProjectRecord } from './types'
+
+import { loadConfig, saveConfig } from '../config'
+import { logDebug } from '../debug/input-log'
+import { getProfileConfigDir } from '../profile-paths'
+import { ensureProjectWorkspaces } from './project-workspaces'
+import { toast } from './toast-store'
+import { isProjectRecord } from './validation'
+
+const CATALOG_VERSION = 2
+
+interface ProjectCatalogFile {
+  version: typeof CATALOG_VERSION
+  projects: ProjectRecord[]
+}
+
+// Resolved per call, never module-cached: $HOME is read at call time so tests
+// that redirect it cannot clobber the real catalog.
+function projectsPath(): string {
+  return join(getProfileConfigDir(), 'aimux-projects.json')
+}
+
+// ponytail: the v1 file is left on disk so a downgrade still works. Drop this
+// helper, migrateV1 and the fallback branch a release or two out.
+function legacySessionsPath(): string {
+  return join(getProfileConfigDir(), 'aimux-sessions.json')
+}
+
+/** The v1 shape, before project/workspace naming. Only what migrateV1 reads. */
+interface LegacyProjectRecordV1 {
+  projectPath?: string
+  workspaceSnapshot?: {
+    tabs?: { worktreeId?: string }[]
+    lastActiveTabByWorktree?: Record<string, string>
+  }
+  worktrees?: { source?: string; repoRoot?: string }[]
+  activeWorktreeId?: string
+}
+
+/**
+ * v1 -> v2: `worktrees` became `workspaces`, `workspaceSnapshot` became
+ * `projectSnapshot`, and each tab's `worktreeId` became `workspaceId`. Record
+ * ids are deliberately left alone — they are opaque and may be scripted.
+ *
+ * `projectPath` is also healed here: v1 rewrote it with the *active worktree's*
+ * path, so it usually pointed inside the worktree root rather than at the repo.
+ */
+function migrateV1(records: LegacyProjectRecordV1[]): unknown[] {
+  return records.map((record) => {
+    const { activeWorktreeId, workspaceSnapshot, worktrees, ...rest } = record
+    const primaryRepoRoot = worktrees?.find((w) => w.source === 'primary')?.repoRoot
+    return {
+      ...rest,
+      ...(primaryRepoRoot != null && primaryRepoRoot !== ''
+        ? { projectPath: primaryRepoRoot }
+        : null),
+      ...(worktrees ? { workspaces: worktrees } : null),
+      ...(activeWorktreeId != null ? { activeWorkspaceId: activeWorktreeId } : null),
+      ...(workspaceSnapshot
+        ? {
+            projectSnapshot: (() => {
+              const { lastActiveTabByWorktree, tabs, ...snapshot } = workspaceSnapshot
+              return {
+                ...snapshot,
+                ...(lastActiveTabByWorktree
+                  ? { lastActiveTabByWorkspace: lastActiveTabByWorktree }
+                  : null),
+                ...(tabs
+                  ? {
+                      tabs: tabs.map(({ worktreeId, ...tab }) => ({
+                        ...tab,
+                        ...(worktreeId != null ? { workspaceId: worktreeId } : null),
+                      })),
+                    }
+                  : null),
+              }
+            })(),
+          }
+        : null),
+    }
+  })
+}
+
+/**
+ * Copy the catalog aside before the load path writes over it. Called whenever
+ * we could not read the file whole: the app is about to persist its own
+ * reduced view, and without this that write is the point of no return.
+ */
+function backupUnreadableCatalog(): void {
+  const source = projectsPath()
+  if (!existsSync(source)) return
+  const target = `${source}.unreadable`
+  try {
+    copyFileSync(source, target)
+    logDebug('projects.catalog.backup', { target })
+  } catch (error) {
+    logDebug('projects.catalog.backupFailed', {
+      error: error instanceof Error ? error.message : String(error),
+    })
+  }
+}
+
+function parseCatalog(path: string, version: number): { projects: unknown[] } | { issue: string } {
+  const parsed = JSON.parse(readFileSync(path, 'utf8')) as {
+    version?: unknown
+    projects?: unknown
+    sessions?: unknown
+  }
+  if (parsed.version !== version) {
+    return { issue: `invalid project catalog header in ${path}` }
+  }
+  // v1 called the array `sessions`.
+  const records = parsed.projects ?? parsed.sessions
+  if (!Array.isArray(records)) {
+    return { issue: `invalid project catalog header in ${path}` }
+  }
+  return { projects: records }
+}
+
+function readCatalogFile(): { file: ProjectCatalogFile | null; issue?: string } {
+  try {
+    let records: unknown[]
+    if (existsSync(projectsPath())) {
+      const parsed = parseCatalog(projectsPath(), CATALOG_VERSION)
+      if ('issue' in parsed) {
+        backupUnreadableCatalog()
+        return { file: null, issue: parsed.issue }
+      }
+      records = parsed.projects
+    } else if (existsSync(legacySessionsPath())) {
+      const parsed = parseCatalog(legacySessionsPath(), 1)
+      if ('issue' in parsed) return { file: null, issue: parsed.issue }
+      records = migrateV1(parsed.projects as LegacyProjectRecordV1[])
+      logDebug('projects.catalog.migrateV1', { projectCount: records.length })
+    } else {
+      return { file: null }
+    }
+
+    // Keep the records that survive validation instead of failing the whole
+    // file: one malformed entry used to cost the user every project, and since
+    // the load path writes back what it loaded, that loss became permanent on
+    // the next save. Whatever we could not read is preserved by the backup
+    // below, so nothing is destroyed either way.
+    const valid = records.filter(isProjectRecord)
+    if (valid.length !== records.length) {
+      backupUnreadableCatalog()
+      return {
+        file: { projects: valid, version: CATALOG_VERSION },
+        issue: `${records.length - valid.length} unreadable project record(s) skipped`,
+      }
+    }
+
+    return { file: { projects: valid, version: CATALOG_VERSION } }
+  } catch (error) {
+    backupUnreadableCatalog()
+    return {
+      file: null,
+      issue: `failed to load project catalog: ${error instanceof Error ? error.message : String(error)}`,
+    }
+  }
+}
+
+export function loadProjectCatalog(): ProjectRecord[] {
+  const { file, issue } = readCatalogFile()
+  if (file) {
+    logDebug('projects.catalog.load', { projectCount: file.projects.length })
+    if (issue != null && issue !== '') {
+      // Same reasoning as the save path below: losing projects is not something
+      // the user should have to read a debug log to discover.
+      toast.error(`${issue} — original kept at ${projectsPath()}.unreadable`)
+    }
+    const normalized = normalizeProjects(file.projects)
+    // A fresh migration has no v2 file yet, so write even when normalizing
+    // changed nothing.
+    if (
+      !existsSync(projectsPath()) ||
+      JSON.stringify(normalized) !== JSON.stringify(file.projects)
+    ) {
+      saveProjectCatalog(normalized)
+    }
+    return normalized
+  }
+
+  if (issue != null && issue !== '') {
+    logDebug('projects.catalog.loadIssue', { issue, path: projectsPath() })
+  }
+
+  const config = loadConfig()
+  if (!config.projectSnapshot) {
+    logDebug('projects.catalog.load', { projectCount: 0 })
+    return []
+  }
+
+  const now = new Date().toISOString()
+  const migrated: ProjectRecord = {
+    createdAt: now,
+    id: `project-${Date.now()}`,
+    lastOpenedAt: now,
+    name: 'Last project',
+    projectSnapshot: config.projectSnapshot,
+    updatedAt: now,
+  }
+
+  const normalized = normalizeProjects([migrated])
+  saveProjectCatalog(normalized)
+  saveConfig({ ...config, projectSnapshot: undefined })
+  logDebug('projects.catalog.migrateLegacyProject', {
+    migratedProjectId: migrated.id,
+    tabCount: migrated.projectSnapshot?.tabs.length ?? 0,
+  })
+  return normalized
+}
+
+export function saveProjectCatalog(projects: ProjectRecord[]): void {
+  try {
+    mkdirSync(getProfileConfigDir(), { recursive: true })
+    writeFileSync(
+      projectsPath(),
+      `${JSON.stringify({ projects, version: CATALOG_VERSION }, null, 2)}\n`
+    )
+    logDebug('projects.catalog.save', { projectCount: projects.length })
+  } catch (error) {
+    const message = error instanceof Error ? error.message : String(error)
+    logDebug('projects.catalog.saveError', {
+      error: message,
+      path: projectsPath(),
+      projectCount: projects.length,
+    })
+    // Persisting the catalog underpins project/workspace state — a silent
+    // failure means the user loses projects on restart. Surface it.
+    toast.error(`Failed to save projects: ${message}`)
+  }
+}
+
+export function getProjectCatalogPath(): string {
+  return projectsPath()
+}
+
+export function findMostRecentProject(projects: ProjectRecord[]): ProjectRecord | undefined {
+  let best: ProjectRecord | undefined
+  for (const candidate of projects) {
+    if (!best || candidate.lastOpenedAt.localeCompare(best.lastOpenedAt) > 0) {
+      best = candidate
+    }
+  }
+  return best
+}
+
+/**
+ * Assign a stable `order` to every project. Records with an existing numeric
+ * `order` keep their slot (sorted ascending); the rest are appended by
+ * createdAt ascending so older projects come first.
+ */
+function normalizeOrder(projects: ProjectRecord[]): ProjectRecord[] {
+  const withOrder: ProjectRecord[] = []
+  const withoutOrder: ProjectRecord[] = []
+  for (const s of projects) {
+    if (typeof s.order === 'number' && Number.isFinite(s.order)) {
+      withOrder.push(s)
+    } else {
+      withoutOrder.push(s)
+    }
+  }
+  withOrder.sort((a, b) => (a.order ?? 0) - (b.order ?? 0))
+  withoutOrder.sort((a, b) => a.createdAt.localeCompare(b.createdAt))
+  const merged = [...withOrder, ...withoutOrder]
+  return merged.map((s, i) => (s.order === i ? s : { ...s, order: i }))
+}
+
+function normalizeProjects(projects: ProjectRecord[]): ProjectRecord[] {
+  return normalizeOrder(projects).map((project) => ensureProjectWorkspaces(project))
+}

package/src/state/project-data.ts

@@ -0,0 +1,143 @@
+import { chmodSync, existsSync, mkdirSync, readFileSync, statSync, writeFileSync } from 'node:fs'
+import { join } from 'node:path'
+
+import { getProfileConfigDir } from '../profile-paths'
+
+const SETUP_HEADER = `#!/usr/bin/env bash
+set -euo pipefail
+
+`
+
+const SETUP_STUB = `#!/usr/bin/env bash
+set -euo pipefail
+
+# aimux setup script.
+#
+# Runs once per newly created workspace, with the working directory set to that
+# workspace's root. A workspace is a fresh \`git worktree\`, so it contains only
+# files tracked by git — no .env, no node_modules, no .venv, no build cache.
+#
+# Keep it idempotent and non-interactive. A non-zero exit is surfaced in the
+# setup widget and recorded on the workspace.
+
+echo "nothing to do yet — edit this script"
+`
+
+// Resolved per call, never module-cached: --profile is applied after module
+// import, so a cached path would point at the wrong profile.
+export function getProjectDataDir(projectId: string): string {
+  return join(getProfileConfigDir(), 'projects', projectId)
+}
+
+export function getSetupScriptPath(projectId: string): string {
+  return join(getProjectDataDir(projectId), 'setup.sh')
+}
+
+export function hasSetupScript(projectId: string): boolean {
+  return existsSync(getSetupScriptPath(projectId))
+}
+
+/** Returns the script path, creating an executable stub if there is none. */
+export function ensureSetupScriptStub(projectId: string): string {
+  const path = getSetupScriptPath(projectId)
+  if (existsSync(path)) return path
+  mkdirSync(getProjectDataDir(projectId), { recursive: true })
+  writeFileSync(path, SETUP_STUB)
+  chmodSync(path, 0o755)
+  return path
+}
+
+const EMPTY_LINES: readonly string[] = []
+
+/**
+ * Keyed by path, not project id: the path depends on the active profile, which is
+ * resolved per call. Holds one small array per project that has a setup script.
+ */
+const setupLinesCache = new Map<string, { mtimeMs: number; lines: string[] }>()
+
+/** A line that does something, as opposed to a shebang, an option or a comment. */
+function isWorkLine(line: string): boolean {
+  const trimmed = line.trim()
+  return (
+    trimmed !== '' &&
+    !trimmed.startsWith('#') &&
+    !/^set\s+-[a-zA-Z]/.test(trimmed) &&
+    !/^set\s+-o\s/.test(trimmed)
+  )
+}
+
+function parseSetupScript(source: string): string[] {
+  return source
+    .split('\n')
+    .filter((line) => isWorkLine(line))
+    .map((line) => line.trim())
+}
+
+/**
+ * The script's actual work, with the boilerplate stripped: the shebang, the
+ * `set -e…` line, comments and blank lines. One line left means the script is a
+ * command, and a single text field can hold all of it; more than one means it is
+ * a script, and a text field would silently truncate it.
+ *
+ * Cached against the file's mtime, because the settings screen builds its Setup
+ * rows from this: the search filter runs it for every project on every keystroke,
+ * and `getModalOptionCount` runs it from inside the reducer. A `statSync` per
+ * project is a syscall; a read-and-parse per project per keystroke is a habit
+ * that gets worse with every project the user adds. An edit made outside aimux
+ * still lands — that is what the mtime is for.
+ *
+ * `readonly` because the array it hands back is the cached one, not a copy: a
+ * caller that sorted or spliced it would be editing every later caller's answer.
+ */
+export function readSetupScriptLines(projectId: string): readonly string[] {
+  const path = getSetupScriptPath(projectId)
+  try {
+    const { mtimeMs } = statSync(path)
+    const cached = setupLinesCache.get(path)
+    if (cached?.mtimeMs === mtimeMs) return cached.lines
+    const lines = parseSetupScript(readFileSync(path, 'utf8'))
+    setupLinesCache.set(path, { lines, mtimeMs })
+    return lines
+  } catch {
+    // Missing or unreadable. Not the same thing, but the caller has nothing
+    // better to show for either, and the editor path still works.
+    setupLinesCache.delete(path)
+    return EMPTY_LINES
+  }
+}
+
+/**
+ * Put this one command in the script, replacing the work line that was there.
+ * Round-trips with `readSetupScriptLines`.
+ *
+ * Everything that is not that line survives: the shebang, the `set -e…`, and any
+ * comments. Rewriting the file from a fixed header was simpler and quietly threw
+ * away whatever the user had written around their one command — a field that
+ * deletes the notes next to what it edits is not an editor.
+ */
+export function writeSetupCommand(projectId: string, command: string): void {
+  mkdirSync(getProjectDataDir(projectId), { recursive: true })
+  const path = getSetupScriptPath(projectId)
+  writeFileSync(path, nextSetupSource(path, command.trim()))
+  chmodSync(path, 0o755)
+  // Not left to the mtime: a write and the read that follows it can land in the
+  // same millisecond, and the cache would hand back what was there before.
+  setupLinesCache.delete(path)
+}
+
+function nextSetupSource(path: string, command: string): string {
+  let existing: string
+  try {
+    existing = readFileSync(path, 'utf8')
+  } catch {
+    // No script yet (or none we can read): the template is all there is to keep.
+    return `${SETUP_HEADER}${command}\n`
+  }
+
+  const lines = existing.split('\n')
+  const first = lines.findIndex((line) => isWorkLine(line))
+  // Nothing to replace — the stub, or comments only. Append rather than drop them.
+  if (first === -1) return `${existing.replace(/\n*$/, '')}\n\n${command}\n`
+  lines[first] = command
+  return lines.join('\n')
+}

package/src/state/{session-persistence.ts → project-persistence.ts}

@@ -1,8 +1,8 @@
-import type { AppState, TabSession, TabStatus, WorkspaceSnapshotV1 } from './types'
+import type { AppState, ProjectSnapshotV1, TabSession, TabStatus } from './types'
 
 import { allLeafIds, createGroupId, type LayoutNode, pruneLayoutTree } from './layout-tree'
 
-export function createEmptyWorkspaceSnapshot(): WorkspaceSnapshotV1 {
+export function createEmptyProjectSnapshot(): ProjectSnapshotV1 {
   return {
     activeTabId: null,
     savedAt: new Date().toISOString(),
@@ -16,13 +16,13 @@ export function createEmptyWorkspaceSnapshot(): WorkspaceSnapshotV1 {
 }
 
 /**
- * The per-worktree last-tab memory is serialized into every snapshot now so the
- * data accrues across sessions, but restoring it at startup stays dormant until
+ * The per-workspace last-tab memory is serialized into every snapshot now so the
+ * data accrues across projects, but restoring it at startup stays dormant until
  * a future (non-breaking) change is ready to consume it. Flipping this to true
- * makes restart restore the last-viewed tab per worktree; until then restart
+ * makes restart restore the last-viewed tab per workspace; until then restart
  * behavior is unchanged and the live in-memory map is never clobbered on switch.
  */
-const RESTORE_LAST_ACTIVE_TAB_BY_WORKTREE: boolean = false
+const RESTORE_LAST_ACTIVE_TAB_BY_WORKSPACE: boolean = false
 
 function getDisconnectedStatus(status: TabStatus): TabStatus {
   if (status === 'running' || status === 'starting') {
@@ -32,73 +32,81 @@ function getDisconnectedStatus(status: TabStatus): TabStatus {
   return status
 }
 
-export function serializeWorkspace(state: AppState): WorkspaceSnapshotV1 {
+export function serializeProject(state: AppState): ProjectSnapshotV1 {
   return {
     activeTabId: state.activeTabId,
-    lastActiveTabByWorktree:
-      Object.keys(state.lastActiveTabByWorktree).length > 0
-        ? state.lastActiveTabByWorktree
+    lastActiveTabByWorkspace:
+      Object.keys(state.lastActiveTabByWorkspace).length > 0
+        ? state.lastActiveTabByWorkspace
         : undefined,
     layoutTree: Object.values(state.layoutTrees)[0] ?? undefined,
     layoutTrees: Object.keys(state.layoutTrees).length > 0 ? state.layoutTrees : undefined,
     savedAt: new Date().toISOString(),
+    // Mirror of the left bar. `isProjectSnapshotV1` requires this key —
+    // dropping it invalidates every entry in the project catalog.
     sidebar: {
-      visible: state.sidebar.visible,
-      width: state.sidebar.width,
+      visible: state.bars.left.visible,
+      width: state.bars.left.width,
     },
     tabGroupMap: Object.keys(state.tabGroupMap).length > 0 ? state.tabGroupMap : undefined,
-    tabs: state.tabs.map((tab) => ({
-      assistant: tab.assistant,
-      autoRenameStatus: tab.autoRenameStatus,
-      buffer: tab.buffer,
-      command: tab.command,
-      errorMessage: tab.errorMessage,
-      exitCode: tab.exitCode,
-      id: tab.id,
-      status: tab.status === 'disconnected' ? 'running' : tab.status,
-      terminalModes: tab.terminalModes,
-      title: tab.title,
-      viewport: tab.viewport,
-      workerName: tab.workerName,
-      worktreeId: tab.worktreeId,
-    })),
+    // Hidden tabs (the setup runner's PTY) are session-scoped on purpose: the
+    // durable record of a setup run is `WorkspaceRecord.setupRanAt`, and keeping
+    // them out here is what lets `hidden` stay off the ipc/daemon wire.
+    tabs: state.tabs
+      .filter((tab) => tab.hidden !== true)
+      .map((tab) => ({
+        assistant: tab.assistant,
+        autoRenameStatus: tab.autoRenameStatus,
+        buffer: tab.buffer,
+        command: tab.command,
+        errorMessage: tab.errorMessage,
+        exitCode: tab.exitCode,
+        id: tab.id,
+        status: tab.status === 'disconnected' ? 'running' : tab.status,
+        terminalModes: tab.terminalModes,
+        title: tab.title,
+        viewport: tab.viewport,
+        workerName: tab.workerName,
+        workspaceId: tab.workspaceId,
+      })),
     version: 1,
   }
 }
 
 export interface RestoreOptions {
   // Force any running/starting tab to 'disconnected' on restore. True for
-  // cold-start (daemon may not own the sessions yet) and the daemon's own
-  // catalog hydration. False for live in-app workspace switches where an
-  // attach() is guaranteed to follow within a frame and hydrate-workspace
+  // cold-start (daemon may not own the projects yet) and the daemon's own
+  // catalog hydration. False for live in-app project switches where an
+  // attach() is guaranteed to follow within a frame and hydrate-project
   // will overwrite the status with daemon truth — leaving the flag on would
   // briefly flash the "Restored snapshot" hint on every j/k cycle.
   forceDisconnected?: boolean
-  // When provided, drop tabs pinned to a worktree id that the session no
-  // longer owns. Some delete paths (notably the sidebar's "Remove worktree")
-  // historically removed the worktree record without closing its tabs, leaving
+  // When provided, drop tabs pinned to a workspace id that the project no
+  // longer owns. Some delete paths (notably the sidebar's "Remove workspace")
+  // historically removed the workspace record without closing its tabs, leaving
   // orphans bound to a vanished id. Those orphans are invisible (filtered out
-  // by the active-worktree filter) yet keep a worktree id that a *future*
-  // delete can collide with — exactly what closes "another worktree's" tabs.
+  // by the active-workspace filter) yet keep a workspace id that a *future*
+  // delete can collide with — exactly what closes "another workspace's" tabs.
   // Pruning them on restore both repairs corrupted catalogs and prevents the
-  // collision. Tabs with no worktree id (legacy/unbound) are always kept.
-  validWorktreeIds?: ReadonlySet<string>
+  // collision. Tabs with no workspace id (legacy/unbound) are always kept.
+  validWorkspaceIds?: ReadonlySet<string>
 }
 
-// Drop tabs bound to a worktree id the session no longer owns. Unbound tabs
-// (no worktreeId) are kept — they surface under the primary worktree.
+// Drop tabs bound to a workspace id the project no longer owns. Unbound tabs
+// (no workspaceId) are kept — they surface under the primary workspace.
 function pruneOrphanedTabs(
   tabs: TabSession[],
-  validWorktreeIds: ReadonlySet<string> | undefined
+  validWorkspaceIds: ReadonlySet<string> | undefined
 ): TabSession[] {
-  if (!validWorktreeIds) return tabs
+  if (!validWorkspaceIds) return tabs
   return tabs.filter(
-    (tab) => tab.worktreeId == null || tab.worktreeId === '' || validWorktreeIds.has(tab.worktreeId)
+    (tab) =>
+      tab.workspaceId == null || tab.workspaceId === '' || validWorkspaceIds.has(tab.workspaceId)
   )
 }
 
-export function restoreTabsFromWorkspace(
-  snapshot: WorkspaceSnapshotV1 | undefined,
+export function restoreTabsFromProject(
+  snapshot: ProjectSnapshotV1 | undefined,
   options: RestoreOptions = {}
 ): TabSession[] {
   if (!snapshot || snapshot.version !== 1) {
@@ -126,13 +134,13 @@ export function restoreTabsFromWorkspace(
       title: tab.title,
       viewport: tab.viewport,
       workerName: tab.workerName,
-      worktreeId: tab.worktreeId,
+      workspaceId: tab.workspaceId,
     }))
-  return pruneOrphanedTabs(restored, options.validWorktreeIds)
+  return pruneOrphanedTabs(restored, options.validWorkspaceIds)
 }
 
 export function restoreLayoutTrees(
-  snapshot: WorkspaceSnapshotV1 | undefined,
+  snapshot: ProjectSnapshotV1 | undefined,
   tabs: TabSession[]
 ): { layoutTrees: Record<string, LayoutNode>; tabGroupMap: Record<string, string> } {
   const validTabIds = new Set(tabs.map((t) => t.id))
@@ -165,16 +173,16 @@ export function restoreLayoutTrees(
   return { layoutTrees, tabGroupMap }
 }
 
-// When a worktree is removed, its tabs are killed live via disposeWorktreeTabs
-// — but the session's persisted workspaceSnapshot still references them by
-// worktreeId. Without this pruning, a subsequent load-session (session switch
+// When a workspace is removed, its tabs are killed live via disposeWorkspaceTabs
+// — but the project's persisted projectSnapshot still references them by
+// workspaceId. Without this pruning, a subsequent load-project (project switch
 // or restart) resurrects the dead tabs and they reappear in h-l navigation.
-export function pruneSnapshotOfWorktree(
-  snapshot: WorkspaceSnapshotV1 | undefined,
-  worktreeId: string
-): WorkspaceSnapshotV1 | undefined {
+export function pruneSnapshotOfWorkspace(
+  snapshot: ProjectSnapshotV1 | undefined,
+  workspaceId: string
+): ProjectSnapshotV1 | undefined {
   if (!snapshot) return snapshot
-  const keptTabs = snapshot.tabs.filter((tab) => tab.worktreeId !== worktreeId)
+  const keptTabs = snapshot.tabs.filter((tab) => tab.workspaceId !== workspaceId)
   if (keptTabs.length === snapshot.tabs.length) return snapshot
   const validTabIds = new Set(keptTabs.map((tab) => tab.id))
 
@@ -273,41 +281,37 @@ export function normalizeGroupedTabOrder(
   return orderedTabs
 }
 
-export function restoreWorkspaceState(
+export function restoreProjectState(
   state: AppState,
-  workspaceSnapshot: WorkspaceSnapshotV1 | undefined,
+  projectSnapshot: ProjectSnapshotV1 | undefined,
   options: RestoreOptions = {}
-): Pick<
-  AppState,
-  'tabs' | 'activeTabId' | 'focusMode' | 'sidebar' | 'layoutTrees' | 'tabGroupMap'
-> &
-  Partial<Pick<AppState, 'lastActiveTabByWorktree'>> {
-  const tabs = restoreTabsFromWorkspace(workspaceSnapshot, options)
+): Pick<AppState, 'tabs' | 'activeTabId' | 'focusMode' | 'layoutTrees' | 'tabGroupMap'> &
+  Partial<Pick<AppState, 'lastActiveTabByWorkspace'>> {
+  const tabs = restoreTabsFromProject(projectSnapshot, options)
   const activeTabId =
-    workspaceSnapshot?.activeTabId != null &&
-    workspaceSnapshot?.activeTabId !== '' &&
-    tabs.some((tab) => tab.id === workspaceSnapshot.activeTabId)
-      ? workspaceSnapshot.activeTabId
+    projectSnapshot?.activeTabId != null &&
+    projectSnapshot?.activeTabId !== '' &&
+    tabs.some((tab) => tab.id === projectSnapshot.activeTabId)
+      ? projectSnapshot.activeTabId
       : (tabs[0]?.id ?? null)
 
-  const { layoutTrees, tabGroupMap } = restoreLayoutTrees(workspaceSnapshot, tabs)
+  const { layoutTrees, tabGroupMap } = restoreLayoutTrees(projectSnapshot, tabs)
   const orderedTabs = normalizeGroupedTabOrder(tabs, layoutTrees, tabGroupMap)
 
-  // Dormant until the gate flips: merge the persisted per-worktree memory over
+  // Dormant until the gate flips: merge the persisted per-workspace memory over
   // the live in-memory map. While off, the key is omitted entirely so callers
   // that spread the result never overwrite their existing map on a switch.
   const persistedLastActiveTab =
-    RESTORE_LAST_ACTIVE_TAB_BY_WORKTREE && workspaceSnapshot?.lastActiveTabByWorktree
-      ? { ...state.lastActiveTabByWorktree, ...workspaceSnapshot.lastActiveTabByWorktree }
+    RESTORE_LAST_ACTIVE_TAB_BY_WORKSPACE && projectSnapshot?.lastActiveTabByWorkspace
+      ? { ...state.lastActiveTabByWorkspace, ...projectSnapshot.lastActiveTabByWorkspace }
       : undefined
 
   return {
     activeTabId,
     focusMode: 'navigation',
     layoutTrees,
-    sidebar: state.sidebar,
     tabGroupMap,
     tabs: orderedTabs,
-    ...(persistedLastActiveTab ? { lastActiveTabByWorktree: persistedLastActiveTab } : {}),
+    ...(persistedLastActiveTab ? { lastActiveTabByWorkspace: persistedLastActiveTab } : {}),
   }
 }