@brimveyn/aimux 1.20.4 → 1.22.0

package/src/cli/index.ts

@@ -2,7 +2,7 @@ import type { DaemonClient } from './client/daemon-client'
 import type { CliContext } from './context'
 
 import { connectToDaemon, DaemonUnreachableError } from './client/bootstrap'
-import { listWorkspaces, resolveWorkspaceWithOrigin } from './client/workspace-resolver'
+import { listProjects, resolveProjectWithOrigin } from './client/project-resolver'
 import { type ArgSpec, CliUsageError, type FlagSpec, parseArgs, SHARED_FLAGS } from './flags'
 import {
   EXIT_DAEMON_UNREACHABLE,
@@ -22,7 +22,7 @@ const EXIT_CODES_BLOCK = [
   '  4    daemon unreachable (socket missing and autostart failed)',
   '  10   question (tab run / tab await: worker is blocked on a question/permission)',
   '  11   pending submit (worker holds an unsubmitted prompt — see `worker submit`)',
-  '  124  timeout (tab run, tab await, tab wait, tab tail --timeout, workspace switch --wait)',
+  '  124  timeout (tab run, tab await, tab wait, tab tail --timeout, project switch --wait)',
 ].join('\n')
 
 const OUTPUT_CONTRACT_BLOCK = [
@@ -100,12 +100,12 @@ function printHelp(): void {
       '',
       'Env:',
       '  AIMUX_PROFILE                  Runtime profile (state dir, socket paths); --profile overrides.',
-      '  AIMUX_WORKSPACE                Pin the target workspace (id or name); --workspace overrides.',
+      '  AIMUX_PROJECT                Pin the target project (id or name); --project overrides.',
       '',
       'Agent recipe:',
       '  # create an isolated named worker, dispatch, and await one structured outcome',
-      '  # --workspace pins the target repo so a UI workspace switch cannot redirect it',
-      '  aimux worker run --workspace myrepo --name fixup --assistant claude "explain this repo"',
+      '  # --project pins the target repo so a UI project switch cannot redirect it',
+      '  aimux worker run --project myrepo --name fixup --assistant claude "explain this repo"',
       '',
       'Maintenance:',
       '  aimux doctor | update | restart-daemon | restart-terminal-manager | version',
@@ -172,6 +172,17 @@ export async function runCli(argv: readonly string[]): Promise<number> {
   const group = argv[0] ?? ''
   const verb = argv[1] ?? ''
 
+  // `aimux worktree` was renamed to `aimux workspace`, and the old
+  // `aimux workspace` became `aimux project`. Aliasing the groups would
+  // silently change what `aimux workspace create` does, so refuse loudly for
+  // a release instead.
+  if (group === 'worktree') {
+    writeError(
+      '`aimux worktree` was renamed to `aimux workspace`, and the old `aimux workspace` is now `aimux project`. See docs/reference/cli.md'
+    )
+    return EXIT_USAGE
+  }
+
   // `aimux <group> --help` (or bare `aimux <group>`) — group-scoped help. Print
   // the verb list without erroring on the missing verb, so agents can drill
   // down step by step.
@@ -225,17 +236,16 @@ export async function runCli(argv: readonly string[]): Promise<number> {
 
   const state: {
     daemon: DaemonClient | null
-    workspace: ReturnType<typeof resolveWorkspaceWithOrigin> | null
+    project: ReturnType<typeof resolveProjectWithOrigin> | null
   } = {
     daemon: null,
-    workspace: null,
+    project: null,
   }
-  const resolveOnce = (): ReturnType<typeof resolveWorkspaceWithOrigin> => {
-    if (state.workspace) return state.workspace
-    const workspaceFlag =
-      typeof parsed.flags.workspace === 'string' ? parsed.flags.workspace : undefined
-    state.workspace = resolveWorkspaceWithOrigin(workspaceFlag)
-    return state.workspace
+  const resolveOnce = (): ReturnType<typeof resolveProjectWithOrigin> => {
+    if (state.project) return state.project
+    const projectFlag = typeof parsed.flags.project === 'string' ? parsed.flags.project : undefined
+    state.project = resolveProjectWithOrigin(projectFlag)
+    return state.project
   }
   const ctx: CliContext = {
     args: parsed,
@@ -244,9 +254,9 @@ export async function runCli(argv: readonly string[]): Promise<number> {
       state.daemon = await connectToDaemon()
       return state.daemon
     },
-    getWorkspace: () => resolveOnce().record,
-    getWorkspaceOrigin: () => resolveOnce().origin,
-    getWorkspaces: () => listWorkspaces(),
+    getProject: () => resolveOnce().record,
+    getProjectOrigin: () => resolveOnce().origin,
+    getProjects: () => listProjects(),
   }
 
   try {

package/src/cli/output.ts

@@ -25,7 +25,7 @@ export function writeError(message: string): void {
 //   10  question (`tab run`: worker is blocked on a question/permission)
 //   11  pending submit (`worker run --detach`: prompt is in the composer but no
 //       turn started — recoverable with `worker submit`, unlike a real error)
-//   124 timeout (`tab wait`, `tab tail --timeout`, `workspace switch --wait`)
+//   124 timeout (`tab wait`, `tab tail --timeout`, `project switch --wait`)
 export const EXIT_OK = 0
 export const EXIT_USAGE = 2
 export const EXIT_RUNTIME = 3

package/src/cli/registry.ts

@@ -1,6 +1,11 @@
 import type { CliContext } from './context'
 import type { ArgSpec, FlagSpec } from './flags'
 
+import { projectClose } from './commands/project/close'
+import { projectCreate } from './commands/project/create'
+import { projectList } from './commands/project/list'
+import { projectShow } from './commands/project/show'
+import { projectSwitch } from './commands/project/switch'
 import { tabAwait } from './commands/tab/await'
 import { tabClose } from './commands/tab/close'
 import { tabCreate } from './commands/tab/create'
@@ -18,14 +23,9 @@ import { workerPrompt } from './commands/worker/prompt'
 import { workerRun } from './commands/worker/run'
 import { workerStop } from './commands/worker/stop'
 import { workerSubmit } from './commands/worker/submit'
-import { workspaceClose } from './commands/workspace/close'
 import { workspaceCreate } from './commands/workspace/create'
 import { workspaceList } from './commands/workspace/list'
-import { workspaceShow } from './commands/workspace/show'
-import { workspaceSwitch } from './commands/workspace/switch'
-import { worktreeCreate } from './commands/worktree/create'
-import { worktreeList } from './commands/worktree/list'
-import { worktreeRemove } from './commands/worktree/remove'
+import { workspaceRemove } from './commands/workspace/remove'
 
 export interface CliCommand {
   group: string
@@ -47,14 +47,14 @@ export const COMMANDS: readonly CliCommand[] = [
   tabSnapshot,
   tabTail,
   tabWait,
+  projectList,
+  projectShow,
+  projectCreate,
+  projectSwitch,
+  projectClose,
   workspaceList,
-  workspaceShow,
   workspaceCreate,
-  workspaceSwitch,
-  workspaceClose,
-  worktreeList,
-  worktreeCreate,
-  worktreeRemove,
+  workspaceRemove,
   workerRun,
   workerPrompt,
   workerSubmit,

package/src/config/loader.ts

@@ -6,11 +6,22 @@ import { getProfileConfigDir } from '../profile-paths'
 
 const CONFIG_FILENAMES = ['aimux.config.ts', 'aimux.config.js']
 
+export interface LoadedUserConfig {
+  resolved: ResolvedConfig
+  /**
+   * The file as written, before defaults are merged in. The settings screen needs
+   * this one: `resolved` has a value for every key, so it cannot tell a setting
+   * the user declared from one that merely defaulted — and only a declared
+   * setting outranks what the screen has written.
+   */
+  user: AimuxUserConfig
+}
+
 /**
- * Load the user's aimux.config.ts (or .js), merge with defaults, and return
- * a resolved config. Falls back to pure defaults if no config file exists.
+ * Load the user's aimux.config.ts (or .js) and merge it with defaults. Falls back
+ * to pure defaults if no config file exists.
  */
-export async function loadUserConfig(): Promise<ResolvedConfig> {
+export async function loadUserConfig(): Promise<LoadedUserConfig> {
   const configDir = getProfileConfigDir()
 
   for (const filename of CONFIG_FILENAMES) {
@@ -24,7 +35,7 @@ export async function loadUserConfig(): Promise<ResolvedConfig> {
       const userConfig: AimuxUserConfig = mod.default ?? mod
 
       logDebug('config.user.loaded', { path: configPath })
-      return resolveConfig(userConfig)
+      return { resolved: resolveConfig(userConfig), user: userConfig }
     } catch (error) {
       const message = error instanceof Error ? error.message : String(error)
       logDebug('config.user.error', { error: message, path: configPath })
@@ -32,5 +43,5 @@ export async function loadUserConfig(): Promise<ResolvedConfig> {
     }
   }
 
-  return resolveConfig({})
+  return { resolved: resolveConfig({}), user: {} }
 }

package/src/config.ts

@@ -1,11 +1,11 @@
 import { existsSync, mkdirSync, readFileSync, writeFileSync } from 'node:fs'
 
-import type { SplitDirection } from './state/layout-tree'
-import type { GitFileListMode, WorkspaceSnapshotV1 } from './state/types'
+import type { StoredSettings } from './settings/types'
+import type { GitFileListMode, ProjectSnapshotV1 } from './state/types'
 
 import { logDebug } from './debug/input-log'
 import { getProfileConfigDir } from './profile-paths'
-import { isWorkspaceSnapshotV1 } from './state/validation'
+import { isProjectSnapshotV1 } from './state/validation'
 import { migrateThemeId as resolveLegacyThemeId, type ThemeId, type ThemeMode } from './ui/themes'
 
 function migrateThemeId(value: unknown): ThemeId | undefined {
@@ -22,42 +22,46 @@ export function getConfigPath(): string {
   return `${getProfileConfigDir()}/aimux.json`
 }
 
+/**
+ * `visible` / `mode` / `position` / `*Ratio` are legacy placement fields, read
+ * once by `deriveBarsFromLegacy` and no longer written. They must stay
+ * optional: rejecting the whole block would silently drop the git *content*
+ * preferences (`fileListMode`, `diffModeRatio`, `treeCompaction`).
+ */
 export interface PersistedGitPane {
   diffModeRatio?: number
   fileListMode?: GitFileListMode
   treeCompaction?: boolean
   prefetchRadius?: number
-  visible: boolean
-  mode: 'embedded' | 'pane'
-  position: 'top' | 'bottom' | 'left' | 'right'
+  visible?: boolean
+  mode?: 'embedded' | 'pane'
+  position?: 'top' | 'bottom' | 'left' | 'right'
   paneRatio?: number
   embeddedRatio?: number
   ratio?: number
 }
 
+/** Legacy; still written for downgrade safety, read only as a bars fallback. */
 export interface PersistedSidebar {
   visible: boolean
   width: number
 }
 
-export interface WorktreeTemplatePane {
+export interface PersistedBarWidget {
   id: string
-  assistant: string
-  splitFrom?: string
-  direction?: SplitDirection
-  ratio?: number
-  send?: string
+  grow: number
+  visible: boolean
 }
 
-export interface WorktreeTemplateTab {
-  panes: WorktreeTemplatePane[]
+export interface PersistedBar {
+  visible: boolean
+  width: number
+  widgets: PersistedBarWidget[]
 }
 
-export interface WorktreeTemplate {
-  id: string
-  name: string
-  description?: string
-  tabs: WorktreeTemplateTab[]
+export interface PersistedBars {
+  left: PersistedBar
+  right: PersistedBar
 }
 
 export interface AimuxConfig {
@@ -67,20 +71,28 @@ export interface AimuxConfig {
   themeTransparent?: boolean
   themeMode?: ThemeMode
   gitPane?: PersistedGitPane
+  bars?: PersistedBars
   sidebar?: PersistedSidebar
-  sessionBarVisible?: boolean
-  workspaceSnapshot?: WorkspaceSnapshotV1
+  projectBarVisible?: boolean
+  projectSnapshot?: ProjectSnapshotV1
+  /**
+   * What the settings screen has written, keyed by row id. Sparse: an absent key
+   * means the user never touched that row, which is not the same as `false`.
+   * Keys this build doesn't know are kept as-is so a downgrade doesn't erase
+   * settings a newer one wrote.
+   */
+  settings?: StoredSettings
   skippedUpdateVersion?: string
   /** One-shot guard: orphan `aimux/` branches were pruned from existing repos. */
   prunedOrphanAimuxBranches?: boolean
-  worktreeTemplates?: WorktreeTemplate[]
 }
 
 function isPersistedGitPane(value: unknown): value is PersistedGitPane {
   if (typeof value !== 'object' || value === null) return false
   const v = value as Record<string, unknown>
-  const modeOk = v.mode === 'embedded' || v.mode === 'pane'
+  const modeOk = v.mode === undefined || v.mode === 'embedded' || v.mode === 'pane'
   const positionOk =
+    v.position === undefined ||
     v.position === 'top' ||
     v.position === 'bottom' ||
     v.position === 'left' ||
@@ -106,7 +118,7 @@ function isPersistedGitPane(value: unknown): value is PersistedGitPane {
       Number.isFinite(v.diffModeRatio) &&
       v.diffModeRatio > 0 &&
       v.diffModeRatio < 1)
-  const visibleOk = typeof v.visible === 'boolean'
+  const visibleOk = v.visible === undefined || typeof v.visible === 'boolean'
   const fileListModeOk =
     v.fileListMode === undefined || v.fileListMode === 'tree' || v.fileListMode === 'flat'
   const treeCompactionOk = v.treeCompaction === undefined || typeof v.treeCompaction === 'boolean'
@@ -130,81 +142,89 @@ function isPersistedGitPane(value: unknown): value is PersistedGitPane {
   ) {
     return false
   }
-  // cross-field coherence: embedded => top|bottom; pane => left|right
-  if (v.mode === 'embedded' && v.position !== 'top' && v.position !== 'bottom') return false
-  if (v.mode === 'pane' && v.position !== 'left' && v.position !== 'right') return false
   return true
 }
 
-function isRatioValid(value: unknown): boolean {
-  return typeof value === 'number' && Number.isFinite(value) && value > 0.15 && value < 0.85
-}
-
-function isWorktreeTemplateTab(value: unknown): value is WorktreeTemplateTab {
+function isPersistedBar(value: unknown): value is PersistedBar {
   if (typeof value !== 'object' || value === null) return false
   const v = value as Record<string, unknown>
-  if (!Array.isArray(v.panes) || v.panes.length === 0) return false
-  const seenIds = new Set<string>()
-  for (let i = 0; i < v.panes.length; i++) {
-    const rawPane = v.panes[i]
-    if (typeof rawPane !== 'object' || rawPane === null) return false
-    const pane = rawPane as Record<string, unknown>
-    if (typeof pane.id !== 'string' || pane.id.length === 0) return false
-    if (seenIds.has(pane.id)) return false
-    seenIds.add(pane.id)
-    if (typeof pane.assistant !== 'string' || pane.assistant.length === 0) return false
-    if (i === 0) {
-      if (pane.splitFrom !== undefined) return false
-      if (pane.direction !== undefined) return false
-      if (pane.ratio !== undefined) return false
-    } else {
-      if (typeof pane.splitFrom !== 'string' || !seenIds.has(pane.splitFrom)) return false
-      if (pane.splitFrom === pane.id) return false
-      if (pane.direction !== 'horizontal' && pane.direction !== 'vertical') return false
-      if (pane.ratio !== undefined && !isRatioValid(pane.ratio)) return false
-    }
-    if (pane.send !== undefined && typeof pane.send !== 'string') return false
-  }
-  return true
+  if (typeof v.visible !== 'boolean') return false
+  if (typeof v.width !== 'number' || !Number.isFinite(v.width) || v.width <= 0) return false
+  if (!Array.isArray(v.widgets)) return false
+  return v.widgets.every((raw) => {
+    if (typeof raw !== 'object' || raw === null) return false
+    const widget = raw as Record<string, unknown>
+    return (
+      typeof widget.id === 'string' &&
+      widget.id.length > 0 &&
+      typeof widget.grow === 'number' &&
+      Number.isFinite(widget.grow) &&
+      widget.grow > 0 &&
+      typeof widget.visible === 'boolean'
+    )
+  })
 }
 
-export function isWorktreeTemplate(value: unknown): value is WorktreeTemplate {
+export function isPersistedBars(value: unknown): value is PersistedBars {
   if (typeof value !== 'object' || value === null) return false
   const v = value as Record<string, unknown>
-  if (typeof v.id !== 'string' || v.id.length === 0) return false
-  if (typeof v.name !== 'string' || v.name.length === 0) return false
-  if (v.description !== undefined && typeof v.description !== 'string') return false
-  if (!Array.isArray(v.tabs) || v.tabs.length === 0) return false
-  for (const tab of v.tabs) {
-    if (!isWorktreeTemplateTab(tab)) return false
+  return isPersistedBar(v.left) && isPersistedBar(v.right)
+}
+
+/**
+ * One-time upgrade from the pre-bars layout (a left sidebar plus a git pane
+ * with its own mode/position). Runs whenever `bars` is absent so an existing
+ * install keeps the layout it had.
+ */
+export function deriveBarsFromLegacy(
+  sidebar: PersistedSidebar | undefined,
+  gitPane: PersistedGitPane | undefined
+): PersistedBars {
+  const gitVisible = gitPane?.visible ?? true
+  const embeddedRatio = gitPane?.embeddedRatio ?? gitPane?.ratio ?? 0.5
+  const gitGrow = Math.max(1, Math.round(embeddedRatio * 100))
+  const git = { grow: gitGrow, id: 'git', visible: gitVisible }
+  const projects = { grow: Math.max(1, 100 - gitGrow), id: 'projects', visible: true }
+
+  const left: PersistedBar = {
+    visible: sidebar?.visible ?? true,
+    widgets: gitPane?.position === 'top' ? [git, projects] : [projects, git],
+    width: sidebar?.width ?? 28,
   }
-  return true
+  const right: PersistedBar = { visible: false, widgets: [], width: 40 }
+
+  // A legacy `pane` git panel on the right was already its own right-hand
+  // column — it maps straight onto the right bar. On the left it shared the
+  // edge with the sidebar, which the single-bar model expresses as a stack.
+  if (gitPane?.mode === 'pane' && gitPane.position === 'right') {
+    left.widgets = [{ ...projects, grow: 100 }]
+    right.visible = true
+    right.widgets = [{ ...git, grow: 100 }]
+    right.width = Math.round((gitPane.paneRatio ?? gitPane.ratio ?? 0.5) * 80)
+  }
+  return { left, right }
 }
 
-export function parseWorktreeTemplates(
-  value: unknown,
-  issues: string[]
-): WorktreeTemplate[] | undefined {
-  if (value === undefined) return undefined
-  if (!Array.isArray(value)) {
-    issues.push('ignored invalid worktreeTemplates (not an array)')
-    return undefined
+/**
+ * Keeps the entries it understands and drops the rest, rather than rejecting the
+ * whole block: this record grows one independent key per setting, so one bad
+ * value has no business resetting every other one.
+ */
+function parseStoredSettings(value: unknown): { settings: StoredSettings; dropped: number } {
+  if (typeof value !== 'object' || value === null || Array.isArray(value)) {
+    return { dropped: 0, settings: {} }
   }
-  const seen = new Set<string>()
-  const valid: WorktreeTemplate[] = []
-  for (const entry of value) {
-    if (!isWorktreeTemplate(entry)) {
-      issues.push('ignored invalid worktreeTemplate entry')
-      continue
-    }
-    if (seen.has(entry.id)) {
-      issues.push(`ignored duplicate worktreeTemplate id "${entry.id}"`)
-      continue
-    }
-    seen.add(entry.id)
-    valid.push(entry)
+  const settings: StoredSettings = {}
+  let dropped = 0
+  for (const [key, entry] of Object.entries(value)) {
+    const ok =
+      typeof entry === 'boolean' ||
+      typeof entry === 'string' ||
+      (typeof entry === 'number' && Number.isFinite(entry))
+    if (ok) settings[key] = entry
+    else dropped++
   }
-  return valid.length > 0 ? valid : undefined
+  return { dropped, settings }
 }
 
 function isPersistedSidebar(value: unknown): value is PersistedSidebar {
@@ -259,13 +279,19 @@ export function loadConfigResult(): ConfigLoadResult {
       themeTransparent?: unknown
       themeMode?: unknown
       gitPane?: unknown
+      bars?: unknown
       sidebar?: unknown
       gitPanelVisible?: unknown
       gitPanelRatio?: unknown
+      projectBarVisible?: unknown
+      /** ponytail: pre-rename spelling, honoured for one release. */
       sessionBarVisible?: unknown
-      workspaceSnapshot?: unknown
+      projectSnapshot?: unknown
+      settings?: unknown
       skippedUpdateVersion?: unknown
       prunedOrphanAimuxBranches?: unknown
+      /** Removed; still detected so the doctor can say so. */
+      workspaceTemplates?: unknown
       worktreeTemplates?: unknown
     }
 
@@ -305,6 +331,11 @@ export function loadConfigResult(): ConfigLoadResult {
       issues.push('ignored invalid sidebar')
     }
 
+    const validBars = isPersistedBars(parsed.bars) ? parsed.bars : undefined
+    if (parsed.bars !== undefined && validBars === undefined) {
+      issues.push('ignored invalid bars')
+    }
+
     // Legacy migration: previous schema stored gitPanelVisible/gitPanelRatio at
     // top level. If the new `gitPane` field is absent, synthesize it from legacy
     // keys so users don't lose their toggle/ratio on upgrade.
@@ -330,17 +361,28 @@ export function loadConfigResult(): ConfigLoadResult {
       }
     }
 
-    const validSessionBarVisible =
-      typeof parsed.sessionBarVisible === 'boolean' ? parsed.sessionBarVisible : undefined
-    if (parsed.sessionBarVisible !== undefined && validSessionBarVisible === undefined) {
-      issues.push('ignored invalid sessionBarVisible')
+    // `sessionBarVisible` was the pre-rename key; without the fallback the bar
+    // would silently reset to its default on the first launch after upgrading.
+    const rawProjectBarVisible = parsed.projectBarVisible ?? parsed.sessionBarVisible
+    const validProjectBarVisible =
+      typeof rawProjectBarVisible === 'boolean' ? rawProjectBarVisible : undefined
+    if (rawProjectBarVisible !== undefined && validProjectBarVisible === undefined) {
+      issues.push('ignored invalid projectBarVisible')
+    }
+
+    if (parsed.projectSnapshot !== undefined && !isProjectSnapshotV1(parsed.projectSnapshot)) {
+      issues.push('ignored invalid projectSnapshot')
     }
 
-    if (
-      parsed.workspaceSnapshot !== undefined &&
-      !isWorkspaceSnapshotV1(parsed.workspaceSnapshot)
-    ) {
-      issues.push('ignored invalid workspaceSnapshot')
+    const storedSettings = parseStoredSettings(parsed.settings)
+    const settingsIsRecord =
+      typeof parsed.settings === 'object' &&
+      parsed.settings !== null &&
+      !Array.isArray(parsed.settings)
+    if (parsed.settings !== undefined && !settingsIsRecord) {
+      issues.push('ignored invalid settings')
+    } else if (storedSettings.dropped > 0) {
+      issues.push(`ignored ${String(storedSettings.dropped)} invalid setting(s)`)
     }
 
     const validSkippedUpdateVersion =
@@ -351,7 +393,12 @@ export function loadConfigResult(): ConfigLoadResult {
       issues.push('ignored invalid skippedUpdateVersion')
     }
 
-    const validWorktreeTemplates = parseWorktreeTemplates(parsed.worktreeTemplates, issues)
+    // Templates are gone, and an unknown key parses fine — so a config that
+    // still declares them would silently stop doing anything. The doctor is the
+    // only place that can say so.
+    if (parsed.workspaceTemplates !== undefined || parsed.worktreeTemplates !== undefined) {
+      issues.push('workspaceTemplates was removed — use a per-project setup script instead')
+    }
 
     if (issues.length > 0) {
       logDebug('config.load.validationIssue', { issues, path: configPath })
@@ -359,20 +406,21 @@ export function loadConfigResult(): ConfigLoadResult {
 
     return {
       config: {
+        bars: validBars ?? deriveBarsFromLegacy(validSidebar, validGitPane),
         customCommands: isCustomCommandsRecord(parsed.customCommands) ? parsed.customCommands : {},
         gitPane: validGitPane,
+        projectBarVisible: validProjectBarVisible,
+        projectSnapshot: isProjectSnapshotV1(parsed.projectSnapshot)
+          ? parsed.projectSnapshot
+          : undefined,
         prunedOrphanAimuxBranches: parsed.prunedOrphanAimuxBranches === true ? true : undefined,
-        sessionBarVisible: validSessionBarVisible,
+        settings: storedSettings.settings,
         sidebar: validSidebar,
         skippedUpdateVersion: validSkippedUpdateVersion,
         themeId: migrateThemeId(parsed.themeId),
         themeMode: validThemeMode,
         themeTransparent: validThemeTransparent,
         version: 2,
-        workspaceSnapshot: isWorkspaceSnapshotV1(parsed.workspaceSnapshot)
-          ? parsed.workspaceSnapshot
-          : undefined,
-        worktreeTemplates: validWorktreeTemplates,
       },
       issues,
       source: 'file',