@brimveyn/aimux 1.21.0 → 1.22.2

package/src/cli/context.ts

@@ -1,31 +1,31 @@
-import type { SessionRecord } from '../state/types'
+import type { ProjectRecord } from '../state/types'
 import type { DaemonClient } from './client/daemon-client'
-import type { WorkspaceOrigin } from './client/workspace-resolver'
+import type { ProjectOrigin } from './client/project-resolver'
 import type { ParsedArgs } from './flags'
 
 /**
  * Per-command context handed to `CliCommand.run`. Commands lazily resolve
- * the workspace + daemon via the helpers on this object so a command that
- * only reads flags (e.g. `workspace list`) doesn't have to open a socket.
+ * the project + daemon via the helpers on this object so a command that
+ * only reads flags (e.g. `project list`) doesn't have to open a socket.
  */
 export interface CliContext {
   args: ParsedArgs
   /** Already-running daemon client, populated on first call to `daemon()`. */
   getDaemon: () => Promise<DaemonClient>
-  /** Resolved workspace, populated on first call to `workspace()`. */
-  getWorkspace: () => SessionRecord
+  /** Resolved project, populated on first call to `project()`. */
+  getProject: () => ProjectRecord
   /**
-   * Every catalogued workspace. Commands that must answer "is my worker really
-   * gone, or did the active workspace move?" need the whole catalog, not just
+   * Every catalogued project. Commands that must answer "is my worker really
+   * gone, or did the active project move?" need the whole catalog, not just
    * the resolved record. Optional so test fixtures can inject one.
    */
-  getWorkspaces?: () => SessionRecord[]
+  getProjects?: () => ProjectRecord[]
   /**
-   * Where `getWorkspace()` came from — `flag` (`--workspace`), `env`
-   * (`AIMUX_WORKSPACE`), or `active` (most recently opened session). Only
-   * `active` can drift under a command while the UI switches workspaces, so
+   * Where `getProject()` came from — `flag` (`--project`), `env`
+   * (`AIMUX_PROJECT`), or `active` (most recently opened project). Only
+   * `active` can drift under a command while the UI switches projects, so
    * commands that must not follow the UI branch on this. Optional so test
    * fixtures can build a minimal context.
    */
-  getWorkspaceOrigin?: () => WorkspaceOrigin
+  getProjectOrigin?: () => ProjectOrigin
 }

package/src/cli/flags.ts

@@ -15,8 +15,8 @@ export type DynamicCompletionSource =
   | 'git-ref'
   | 'tab'
   | 'worker'
+  | 'project'
   | 'workspace'
-  | 'worktree'
 
 /**
  * Where a flag value or positional draws its shell-completion candidates.
@@ -67,6 +67,23 @@ export function parseArgs(
 ): ParsedArgs {
   const flagByName = new Map<string, FlagSpec>()
   for (const spec of flagSpecs) flagByName.set(spec.name, spec)
+  // Deprecated aliases from the project/workspace rename. Unlike the command
+  // groups these are safe to map silently: --workspace named a project and
+  // --worktree named what is now a workspace, so each old name still points at
+  // the same object.
+  // ponytail: drop with the aimux-sessions.json fallback.
+  // Resolved against the declared specs, never against another alias —
+  // otherwise --worktree would chain through the --workspace alias onto
+  // --project, which is a different object entirely.
+  for (const [old, current] of [
+    ['workspace', 'project'],
+    ['worktree', 'workspace'],
+    ['new-worktree', 'new-workspace'],
+  ] as const) {
+    if (flagByName.has(old)) continue
+    const spec = flagSpecs.find((entry) => entry.name === current)
+    if (spec) flagByName.set(old, spec)
+  }
 
   const flags: Record<string, string | number | boolean> = {}
   const positionals: string[] = []
@@ -85,18 +102,21 @@ export function parseArgs(
       if (!spec) {
         throw new CliUsageError(`unknown flag: --${name}`)
       }
+      // Deprecated aliases resolve to the current spec, so results are always
+      // keyed by the canonical name regardless of which spelling was typed.
+      const key = spec.name
       if (spec.kind === 'boolean') {
         if (eq !== -1) {
           throw new CliUsageError(`flag --${name} does not take a value`)
         }
-        flags[name] = true
+        flags[key] = true
         continue
       }
       if (spec.kind === 'optional-string') {
         // Value binds ONLY in the `=` form (`--flag=value`). A bare `--flag`
         // must not swallow the next token (it may be a positional), so it
         // parses as boolean `true`.
-        flags[name] = eq === -1 ? true : token.slice(eq + 1)
+        flags[key] = eq === -1 ? true : token.slice(eq + 1)
         continue
       }
       const raw = eq === -1 ? argv[++i] : token.slice(eq + 1)
@@ -108,9 +128,9 @@ export function parseArgs(
         if (!Number.isFinite(parsed)) {
           throw new CliUsageError(`flag --${name} must be a number (got: ${raw})`)
         }
-        flags[name] = parsed
+        flags[key] = parsed
       } else {
-        flags[name] = raw
+        flags[key] = raw
       }
       continue
     }
@@ -129,17 +149,17 @@ export function parseArgs(
 }
 
 /**
- * Shared flag set — every command takes these. `--workspace` selects the
- * target session (by id or name); `--profile` overrides `AIMUX_PROFILE`
+ * Shared flag set — every command takes these. `--project` selects the
+ * target project (by id or name); `--profile` overrides `AIMUX_PROFILE`
  * before any runtime path is resolved; `--json` is a no-op kept for
  * consistency with future formats.
  */
 export const SHARED_FLAGS: readonly FlagSpec[] = [
   {
-    complete: { kind: 'dynamic', source: 'workspace' },
-    description: 'workspace id or name',
+    complete: { kind: 'dynamic', source: 'project' },
+    description: 'project id or name',
     kind: 'string',
-    name: 'workspace',
+    name: 'project',
   },
   {
     complete: { kind: 'none' },

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 {
@@ -64,26 +64,6 @@ export interface PersistedBars {
   right: PersistedBar
 }
 
-export interface WorktreeTemplatePane {
-  id: string
-  assistant: string
-  splitFrom?: string
-  direction?: SplitDirection
-  ratio?: number
-  send?: string
-}
-
-export interface WorktreeTemplateTab {
-  panes: WorktreeTemplatePane[]
-}
-
-export interface WorktreeTemplate {
-  id: string
-  name: string
-  description?: string
-  tabs: WorktreeTemplateTab[]
-}
-
 export interface AimuxConfig {
   version: 2
   customCommands: Record<string, string>
@@ -93,12 +73,18 @@ export interface AimuxConfig {
   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 {
@@ -198,11 +184,11 @@ export function deriveBarsFromLegacy(
   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 workspaces = { grow: Math.max(1, 100 - gitGrow), id: 'workspaces', visible: true }
+  const projects = { grow: Math.max(1, 100 - gitGrow), id: 'projects', visible: true }
 
   const left: PersistedBar = {
     visible: sidebar?.visible ?? true,
-    widgets: gitPane?.position === 'top' ? [git, workspaces] : [workspaces, git],
+    widgets: gitPane?.position === 'top' ? [git, projects] : [projects, git],
     width: sidebar?.width ?? 28,
   }
   const right: PersistedBar = { visible: false, widgets: [], width: 40 }
@@ -211,7 +197,7 @@ export function deriveBarsFromLegacy(
   // 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 = [{ ...workspaces, grow: 100 }]
+    left.widgets = [{ ...projects, grow: 100 }]
     right.visible = true
     right.widgets = [{ ...git, grow: 100 }]
     right.width = Math.round((gitPane.paneRatio ?? gitPane.ratio ?? 0.5) * 80)
@@ -219,75 +205,26 @@ export function deriveBarsFromLegacy(
   return { left, right }
 }
 
-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 {
-  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
-}
-
-export function isWorktreeTemplate(value: unknown): value is WorktreeTemplate {
-  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 true
-}
-
-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 {
@@ -346,10 +283,15 @@ export function loadConfigResult(): ConfigLoadResult {
       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
     }
 
@@ -419,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 =
@@ -440,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 })
@@ -451,18 +409,18 @@ export function loadConfigResult(): ConfigLoadResult {
         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',