@brimveyn/aimux 1.21.0 → 1.22.2

package/src/state/reducers/tab-state.ts

@@ -1,4 +1,5 @@
-import type { AppAction, AppState, TabSession } from '../types'
+import type { AppAction } from '../actions'
+import type { AppState, TabSession } from '../types'
 
 import {
   allLeafIds,
@@ -14,12 +15,13 @@ import {
   setSplitRatio,
   splitNode,
 } from '../layout-tree'
-import { normalizeGroupedTabOrder } from '../session-persistence'
+import { normalizeGroupedTabOrder } from '../project-persistence'
 import {
-  filterTabsForActiveWorktree,
-  orderTabsByWorktree,
-  withActiveWorktree,
-} from '../session-worktrees'
+  clearWorkspaceDone,
+  filterTabsForActiveWorkspace,
+  orderTabsByWorkspace,
+  withActiveWorkspace,
+} from '../project-workspaces'
 import { createDefaultTerminalModes } from '../terminal-modes'
 
 const MAX_BUFFER_LENGTH = 50_000
@@ -197,47 +199,61 @@ function getActiveIndex(state: AppState): number {
   return state.tabs.findIndex((tab) => tab.id === state.activeTabId)
 }
 
-function getCurrentSession(state: AppState) {
-  return state.currentSessionId != null && state.currentSessionId !== ''
-    ? state.sessions.find((session) => session.id === state.currentSessionId)
+function getCurrentProject(state: AppState) {
+  return state.currentProjectId != null && state.currentProjectId !== ''
+    ? state.projects.find((project) => project.id === state.currentProjectId)
     : undefined
 }
 
-function withActiveTabWorktree(
+function withActiveTabWorkspace(
   state: AppState,
   tabId: string | null,
   opts?: { onlyIfMissing?: boolean }
 ): AppState {
-  if (
-    tabId == null ||
-    tabId === '' ||
-    !(state.currentSessionId != null && state.currentSessionId !== '')
-  )
-    return state
-  const tab = state.tabs.find((entry) => entry.id === tabId)
-  if (!(tab?.worktreeId != null && tab?.worktreeId !== '')) return state
-  const worktreeId = tab.worktreeId
-  // When `onlyIfMissing` is set, we leave the session's worktree alone if it
-  // already points at a known worktree. Used by `hydrate-workspace` so that
-  // a backend re-attach after a user-initiated worktree switch (j/k cycling)
-  // doesn't clobber the freshly chosen worktree by re-syncing from the
+  if (tabId == null || tabId === '') return state
+  // Opening the tab is reading its notification, whatever else this helper
+  // decides about the workspace. Every path that makes a tab the active one
+  // goes through here.
+  const seen = { ...state, tabs: clearTabUnseen(state.tabs, tabId) }
+  if (!(seen.currentProjectId != null && seen.currentProjectId !== '')) return seen
+  const tab = seen.tabs.find((entry) => entry.id === tabId)
+  if (!(tab?.workspaceId != null && tab?.workspaceId !== '')) return seen
+  const workspaceId = tab.workspaceId
+  // Opening one of a workspace's tabs is seeing that workspace, so it drops the
+  // finished-a-turn tick — otherwise a background tab finishing in the workspace
+  // you are already in leaves a ✓ that only a workspace switch could clear.
+  const workspaceActivity = clearWorkspaceDone(seen.workspaceActivity, workspaceId)
+  // When `onlyIfMissing` is set, we leave the project's workspace alone if it
+  // already points at a known workspace. Used by `hydrate-project` so that
+  // a backend re-attach after a user-initiated workspace switch (j/k cycling)
+  // doesn't clobber the freshly chosen workspace by re-syncing from the
   // restored active tab.
   if (opts?.onlyIfMissing === true) {
-    const session = state.sessions.find((entry) => entry.id === state.currentSessionId)
-    const hasValidWorktree =
-      session?.activeWorktreeId != null &&
-      session.activeWorktreeId !== '' &&
-      (session.worktrees?.some((w) => w.id === session.activeWorktreeId) ?? false)
-    if (hasValidWorktree) return state
+    const project = seen.projects.find((entry) => entry.id === seen.currentProjectId)
+    const hasValidWorkspace =
+      project?.activeWorkspaceId != null &&
+      project.activeWorkspaceId !== '' &&
+      (project.workspaces?.some((w) => w.id === project.activeWorkspaceId) ?? false)
+    if (hasValidWorkspace) return { ...seen, workspaceActivity }
   }
   return {
-    ...state,
-    sessions: state.sessions.map((session) =>
-      session.id === state.currentSessionId ? withActiveWorktree(session, worktreeId) : session
+    ...seen,
+    projects: seen.projects.map((project) =>
+      project.id === seen.currentProjectId ? withActiveWorkspace(project, workspaceId) : project
     ),
+    workspaceActivity,
   }
 }
 
+/**
+ * Drop one tab's unseen mark. Returns the same array when it holds none, so a
+ * caller can run it on every activation without re-rendering the tab list.
+ */
+function clearTabUnseen(tabs: TabSession[], tabId: string): TabSession[] {
+  if (!tabs.some((tab) => tab.id === tabId && tab.unseen === true)) return tabs
+  return tabs.map((tab) => (tab.id === tabId ? { ...tab, unseen: undefined } : tab))
+}
+
 function closeTabAtIndex(state: AppState, indexToClose: number): AppState {
   if (indexToClose < 0 || indexToClose >= state.tabs.length) {
     return state
@@ -262,7 +278,12 @@ function closeTabAtIndex(state: AppState, indexToClose: number): AppState {
           getAdjacentLeaf(groupTree, closingTabId, 'down') ??
           getAdjacentLeaf(groupTree, closingTabId, 'up'))
         : null
-    nextActiveTabId = layoutNeighbor ?? tabs[indexToClose]?.id ?? tabs[indexToClose - 1]?.id ?? null
+    // Positional fallbacks must skip hidden tabs: landing `activeTabId` on one
+    // would render a pane the user cannot see in any tab bar.
+    const positional = [tabs[indexToClose], tabs[indexToClose - 1]].find(
+      (tab) => tab !== undefined && tab.hidden !== true
+    )
+    nextActiveTabId = layoutNeighbor ?? positional?.id ?? null
   } else {
     nextActiveTabId = tabs.find((tab) => tab.id === state.activeTabId)?.id ?? null
   }
@@ -292,7 +313,7 @@ function closeTabAtIndex(state: AppState, indexToClose: number): AppState {
     }
   }
 
-  return withActiveTabWorktree(
+  return withActiveTabWorkspace(
     {
       ...state,
       activeTabId: nextActiveTabId,
@@ -309,35 +330,41 @@ export function reduceTabState(state: AppState, action: AppAction): AppState | n
   switch (action.type) {
     case 'add-tab': {
       const newTab = { ...action.tab, activity: action.tab.activity ?? 'idle' }
-      return withActiveTabWorktree(
+      // A hidden tab is chrome-invisible, so adding it must be invisible too:
+      // no focus steal, no modal dismissal, and — critically — no workspace
+      // re-sync, which would teleport a user sitting on another workspace.
+      if (newTab.hidden === true) {
+        return { ...state, tabs: [...state.tabs, newTab] }
+      }
+      return withActiveTabWorkspace(
         {
           ...state,
           activeTabId: newTab.id,
           focusMode: 'navigation',
-          modal: { editBuffer: null, selectedIndex: 0, sessionTargetId: null, type: null },
+          modal: { editBuffer: null, projectTargetId: null, selectedIndex: 0, type: null },
           tabs: [...state.tabs, newTab],
         },
         newTab.id
       )
     }
-    case 'hydrate-workspace': {
-      // The session's activeWorktreeId may have just been switched by the
+    case 'hydrate-project': {
+      // The project's activeWorkspaceId may have just been switched by the
       // user (j/k cycle, sidebar click) before the backend attached. Honor
-      // that choice by only considering tabs visible in that worktree —
+      // that choice by only considering tabs visible in that workspace —
       // otherwise we'd land the active tab on whatever the backend picked
-      // (typically the worktree we *last* persisted, not the current one).
-      const currentSession =
-        state.currentSessionId != null && state.currentSessionId !== ''
-          ? state.sessions.find((s) => s.id === state.currentSessionId)
+      // (typically the workspace we *last* persisted, not the current one).
+      const currentProject =
+        state.currentProjectId != null && state.currentProjectId !== ''
+          ? state.projects.find((s) => s.id === state.currentProjectId)
           : undefined
-      const visibleForWorktree = filterTabsForActiveWorktree(action.tabs, currentSession)
-      const visibleIds = new Set(visibleForWorktree.map((t) => t.id))
+      const visibleForWorkspace = filterTabsForActiveWorkspace(action.tabs, currentProject)
+      const visibleIds = new Set(visibleForWorkspace.map((t) => t.id))
       const hydratedActiveTabId =
         action.activeTabId != null &&
         action.activeTabId !== '' &&
         visibleIds.has(action.activeTabId)
           ? action.activeTabId
-          : (visibleForWorktree[0]?.id ?? null)
+          : (visibleForWorkspace[0]?.id ?? null)
       const tabIds = new Set(action.tabs.map((t) => t.id))
 
       // Restore from new multi-tree format or migrate from legacy single tree
@@ -368,7 +395,7 @@ export function reduceTabState(state: AppState, action: AppAction): AppState | n
         }
       }
 
-      return withActiveTabWorktree(
+      return withActiveTabWorkspace(
         {
           ...state,
           activeTabId: hydratedActiveTabId,
@@ -389,24 +416,24 @@ export function reduceTabState(state: AppState, action: AppAction): AppState | n
     case 'close-active-tab':
       return closeTabAtIndex(state, getActiveIndex(state))
     case 'set-active-tab':
-      return withActiveTabWorktree({ ...state, activeTabId: action.tabId }, action.tabId)
+      return withActiveTabWorkspace({ ...state, activeTabId: action.tabId }, action.tabId)
     case 'move-active-tab': {
       if (state.tabs.length === 0) {
         return state
       }
-      const session = getCurrentSession(state)
-      const visibleTabs = filterTabsForActiveWorktree(state.tabs, session)
+      const project = getCurrentProject(state)
+      const visibleTabs = filterTabsForActiveWorkspace(state.tabs, project)
       if (visibleTabs.length === 0) {
         return state
       }
-      const orderedTabs = orderTabsByWorktree(visibleTabs, session)
+      const orderedTabs = orderTabsByWorkspace(visibleTabs, project)
       const currentIndex = orderedTabs.findIndex((tab) => tab.id === state.activeTabId)
       const safeIndex = currentIndex === -1 ? 0 : currentIndex
       const nextIndex = (safeIndex + action.delta + orderedTabs.length) % orderedTabs.length
       const nextTabId = orderedTabs[nextIndex]?.id
       return nextTabId == null || nextTabId === '' || nextTabId === state.activeTabId
         ? state
-        : withActiveTabWorktree({ ...state, activeTabId: nextTabId }, nextTabId)
+        : withActiveTabWorkspace({ ...state, activeTabId: nextTabId }, nextTabId)
     }
     case 'reorder-active-tab': {
       const activeIndex = getActiveIndex(state)
@@ -436,8 +463,14 @@ export function reduceTabState(state: AppState, action: AppAction): AppState | n
         return { ...state, tabs }
       }
 
-      // Standalone tab reorder
-      const nextIndex = activeIndex + action.delta
+      // Standalone tab reorder. Step over hidden tabs rather than swapping with
+      // one: the swap would look like a dead keypress and shuffle the hidden
+      // tab out of its append-order slot.
+      let nextIndex = activeIndex + action.delta
+      const step = action.delta < 0 ? -1 : 1
+      while (state.tabs[nextIndex]?.hidden === true) {
+        nextIndex += step
+      }
       if (nextIndex < 0 || nextIndex >= state.tabs.length) {
         return state
       }
@@ -473,7 +506,7 @@ export function reduceTabState(state: AppState, action: AppAction): AppState | n
       // Drag-and-drop reorder of the visible tab strip. `orderedTabIds` is the
       // flattened new order of the currently-visible tabs (group members already
       // expanded into contiguous runs). We only rewrite the slots those tabs
-      // occupy in `state.tabs`, leaving tabs from other worktrees anchored in
+      // occupy in `state.tabs`, leaving tabs from other workspaces anchored in
       // place. Because group members arrive contiguous, splits stay intact.
       const visibleSet = new Set(action.orderedTabIds)
       const byId = new Map(state.tabs.map((tab) => [tab.id, tab]))
@@ -486,8 +519,8 @@ export function reduceTabState(state: AppState, action: AppAction): AppState | n
       })
       return { ...state, tabs }
     }
-    case 'reset-tab-session':
-      return withActiveTabWorktree(
+    case 'reset-tab-project':
+      return withActiveTabWorkspace(
         {
           ...state,
           activeTabId: action.tabId,
@@ -527,7 +560,20 @@ export function reduceTabState(state: AppState, action: AppAction): AppState | n
     case 'set-tab-activity':
       return {
         ...state,
-        tabs: updateTab(state.tabs, action.tabId, (tab) => ({ ...tab, activity: action.activity })),
+        tabs: updateTab(state.tabs, action.tabId, (tab) => ({
+          ...tab,
+          activity: action.activity,
+          // Back to work: whatever it wanted to tell you is out of date.
+          unseen:
+            action.activity === 'working' || action.activity === 'waiting-input'
+              ? undefined
+              : tab.unseen,
+        })),
+      }
+    case 'mark-tab-unseen':
+      return {
+        ...state,
+        tabs: updateTab(state.tabs, action.tabId, (tab) => ({ ...tab, unseen: true })),
       }
     case 'set-tab-error':
       return {
@@ -555,6 +601,7 @@ export function reduceTabState(state: AppState, action: AppAction): AppState | n
         tabs: updateTab(state.tabs, action.tabId, (tab) => ({
           ...tab,
           autoRenameStatus: action.autoRenameStatus ?? tab.autoRenameStatus,
+          hidden: action.hidden ?? tab.hidden,
           title: action.title ?? tab.title,
         })),
       }
@@ -590,7 +637,7 @@ export function reduceTabState(state: AppState, action: AppAction): AppState | n
       }
       const tabs = [...state.tabs.slice(0, insertIndex), newTab, ...state.tabs.slice(insertIndex)]
 
-      return withActiveTabWorktree(
+      return withActiveTabWorkspace(
         {
           ...state,
           activeTabId: newTab.id,
@@ -621,7 +668,7 @@ export function reduceTabState(state: AppState, action: AppAction): AppState | n
       if (!(neighbor != null && neighbor !== '')) {
         return state
       }
-      return withActiveTabWorktree({ ...state, activeTabId: neighbor }, neighbor)
+      return withActiveTabWorkspace({ ...state, activeTabId: neighbor }, neighbor)
     }
     case 'resize-pane': {
       const resizeGroupId = getGroupIdForTab(state.tabGroupMap, action.tabId)

package/src/state/reducers/ui-state.ts

@@ -1,4 +1,5 @@
-import type { AppAction, AppState, BarSide, BarState, BarWidget } from '../types'
+import type { AppAction } from '../actions'
+import type { AppState, BarSide, BarState, BarWidget } from '../types'
 
 import {
   boundaryDeltaFromRatio,
@@ -99,10 +100,10 @@ export function reduceUIState(state: AppState, action: AppAction): AppState | nu
         return state
       }
       return { ...state, pendingChords: action.chords }
-    case 'toggle-session-bar':
+    case 'toggle-project-bar':
       return {
         ...state,
-        sessionBar: { ...state.sessionBar, visible: !state.sessionBar.visible },
+        projectBar: { ...state.projectBar, visible: !state.projectBar.visible },
       }
     default:
       return null

package/src/state/selectors.ts

@@ -1,38 +1,39 @@
-import type { AssistantOption } from '../pty/command-registry'
-import type { AssistantId, SessionRecord, SnippetRecord, WorktreeRecord } from './types'
+import type { ProjectRecord, SnippetRecord, WorkspaceRecord } from './types'
+
+import { type AssistantOption, getAllAssistantOptions } from '../pty/command-registry'
 
 export interface BaseRefOption {
-  /** Git ref the new worktree is forked from. */
+  /** Git ref the new workspace is forked from. */
   ref: string
   label: string
-  kind: 'worktree' | 'branch'
-  /** Worktree name, for the 'worktree' kind. */
+  kind: 'workspace' | 'branch'
+  /** Workspace name, for the 'workspace' kind. */
   detail?: string
 }
 
 /**
- * Ordered, filtered base-ref candidates for the worktree-create "Base" picker:
- * branches checked out in the session's worktrees first (labelled with the
- * worktree name), then the remaining local branches. A branch already surfaced
- * via a worktree is not repeated. Throwaway `aimux/` branches are skipped unless
- * a live worktree is on them — `git worktree remove` leaves the branch behind,
- * so deleted temp worktrees would otherwise haunt the list as orphan branches.
+ * Ordered, filtered base-ref candidates for the workspace-create "Base" picker:
+ * branches checked out in the project's workspaces first (labelled with the
+ * workspace name), then the remaining local branches. A branch already surfaced
+ * via a workspace is not repeated. Throwaway `aimux/` branches are skipped unless
+ * a live workspace is on them — `git worktree remove` leaves the branch behind,
+ * so deleted temp workspaces would otherwise haunt the list as orphan branches.
  */
 export function buildBaseRefOptions(
-  worktrees: WorktreeRecord[],
+  workspaces: WorkspaceRecord[],
   localBranches: string[],
   query: string
 ): BaseRefOption[] {
   const seen = new Set<string>()
   const options: BaseRefOption[] = []
-  for (const worktree of worktrees) {
-    if (worktree.branch == null || worktree.branch === '' || seen.has(worktree.branch)) continue
-    seen.add(worktree.branch)
+  for (const workspace of workspaces) {
+    if (workspace.branch == null || workspace.branch === '' || seen.has(workspace.branch)) continue
+    seen.add(workspace.branch)
     options.push({
-      detail: worktree.name,
-      kind: 'worktree',
-      label: worktree.branch,
-      ref: worktree.branch,
+      detail: workspace.name,
+      kind: 'workspace',
+      label: workspace.branch,
+      ref: workspace.branch,
     })
   }
   for (const branch of localBranches) {
@@ -45,16 +46,6 @@ export function buildBaseRefOptions(
   return options.filter((option) => option.label.toLowerCase().includes(trimmed))
 }
 
-/**
- * 0 when the template picker should NOT show the "None" fallback (no assistant
- * was picked — typical for the template shortcut path), 1 otherwise. Shared
- * by the modal reducer, the side-effect that resolves templateId, and the
- * picker UI so the three stay in sync.
- */
-export function getTemplateNoneOffset(selectedAssistantId: AssistantId | null): 0 | 1 {
-  return selectedAssistantId == null ? 0 : 1
-}
-
 export function filterAssistants(
   options: AssistantOption[],
   filter: string | null
@@ -66,18 +57,39 @@ export function filterAssistants(
   )
 }
 
-export function filterSessions(sessions: SessionRecord[], filter: string | null): SessionRecord[] {
+/**
+ * Assistants offered by the new-tab picker. One source of truth on purpose: the
+ * modal renders this list while `launch-selected-assistant` indexes into it, so
+ * a divergence launches the row above or below the one the user highlighted.
+ *
+ * Chained from `<C-p>`, the prompt is pasted into the assistant and drives the
+ * workspace's name — neither of which a plain shell can do — so Terminal is not
+ * offered there. A bare `<C-n>` still lists it.
+ */
+export function getNewTabAssistantOptions(
+  customCommands: Record<string, string>,
+  filter: string | null,
+  excludeTerminal: boolean
+): AssistantOption[] {
+  const all = getAllAssistantOptions(customCommands)
+  return filterAssistants(
+    excludeTerminal ? all.filter((option) => option.id !== 'terminal') : all,
+    filter
+  )
+}
+
+export function filterProjects(projects: ProjectRecord[], filter: string | null): ProjectRecord[] {
   if (!(filter != null && filter !== '')) {
-    return sessions
+    return projects
   }
 
   const lower = filter.toLowerCase()
-  return sessions.filter(
-    (session) =>
-      session.name.toLowerCase().includes(lower) ||
-      (session.projectPath != null &&
-        session.projectPath !== '' &&
-        session.projectPath.toLowerCase().includes(lower))
+  return projects.filter(
+    (project) =>
+      project.name.toLowerCase().includes(lower) ||
+      (project.projectPath != null &&
+        project.projectPath !== '' &&
+        project.projectPath.toLowerCase().includes(lower))
   )
 }
 

package/src/state/store.ts

@@ -1,4 +1,4 @@
-import type { WorktreeTemplate } from '../config'
+import type { AppAction } from './actions'
 
 import { clampBarWidth, KNOWN_WIDGET_IDS } from './bars'
 import { reduceAutoCommit } from './reducers/auto-commit-state'
@@ -6,19 +6,19 @@ import { emptyGitMode, reduceGitModeState } from './reducers/git-mode-state'
 import { emptyGitPanel, reduceGitPanelState } from './reducers/git-panel-state'
 import { emptyModal, reduceModalState } from './reducers/modal-state'
 import { reduceMultiRepoState } from './reducers/multi-repo-state'
-import { reduceSessionState } from './reducers/session-state'
+import { reduceProjectState } from './reducers/project-state'
+import { emptySettingsUI, reduceSettingsState } from './reducers/settings-state'
 import { reduceTabState } from './reducers/tab-state'
 import { reduceUIState } from './reducers/ui-state'
 import { filterSnippets } from './selectors'
 import {
-  type AppAction,
   type AppState,
   type BarsState,
   EMPTY_AUTO_COMMIT_STATE,
   EMPTY_MULTI_REPO_STATE,
   type GitModeState,
   type GitPaneState,
-  type SessionRecord,
+  type ProjectRecord,
   type SnippetRecord,
 } from './types'
 
@@ -29,8 +29,7 @@ export interface InitialStateOverrides {
   gitMode?: Partial<GitModeState>
   gitPane?: Partial<GitPaneState>
   bars?: BarsState
-  sessionBarVisible?: boolean
-  worktreeTemplates?: WorktreeTemplate[]
+  projectBarVisible?: boolean
 }
 
 const DEFAULT_GIT_PANE: GitPaneState = {
@@ -46,14 +45,26 @@ export const DEFAULT_BARS: BarsState = {
   left: {
     visible: true,
     widgets: [
-      { grow: 50, id: 'workspaces', visible: true },
+      { grow: 50, id: 'projects', visible: true },
       { grow: 50, id: 'git', visible: true },
+      // Opt-in: reachable via the bar's right-click menu ("Show Setup"). Present
+      // here so sanitizeBars places it rather than treating it as corruption.
+      { grow: 50, id: 'setup', visible: false },
     ],
     width: 28,
   },
   right: { visible: false, widgets: [], width: 40 },
 }
 
+/**
+ * Persisted widget ids from before the project/workspace rename. Without this
+ * the old id is simply unknown, so the widget is pruned, the bar renders empty
+ * and the emptied layout is written straight back to aimux.json.
+ *
+ * ponytail: drop with the other rename shims.
+ */
+const LEGACY_WIDGET_IDS: Record<string, string> = { workspaces: 'projects' }
+
 /**
  * Drop widget ids this build cannot render (config written by a newer or
  * patched version) and normalise widths — the only place unknown ids can enter.
@@ -62,63 +73,82 @@ function sanitizeBars(bars: BarsState): BarsState {
   const sanitizeBar = (bar: BarsState[keyof BarsState]): BarsState[keyof BarsState] => ({
     ...bar,
     widgets: bar.widgets
+      .map((widget) => ({ ...widget, id: LEGACY_WIDGET_IDS[widget.id] ?? widget.id }))
       .filter((widget) => (KNOWN_WIDGET_IDS as readonly string[]).includes(widget.id))
       .map((widget) => ({ ...widget, grow: Math.max(1, Math.round(widget.grow)) })),
     width: clampBarWidth(bar.width),
   })
-  return { left: sanitizeBar(bars.left), right: sanitizeBar(bars.right) }
+  const sanitized: BarsState = { left: sanitizeBar(bars.left), right: sanitizeBar(bars.right) }
+
+  // A widget can only ever be moved between bars or hidden, never deleted, so
+  // one that is in neither bar means the persisted layout was corrupted —
+  // which is exactly what the pre-rename `workspaces` id did to older files
+  // before LEGACY_WIDGET_IDS existed. Put it back where it ships by default,
+  // otherwise the bar renders empty forever and re-saves that emptiness.
+  for (const side of ['left', 'right'] as const) {
+    for (const fallback of DEFAULT_BARS[side].widgets) {
+      const present =
+        sanitized.left.widgets.some((w) => w.id === fallback.id) ||
+        sanitized.right.widgets.some((w) => w.id === fallback.id)
+      if (!present) {
+        sanitized[side] = { ...sanitized[side], widgets: [...sanitized[side].widgets, fallback] }
+      }
+    }
+  }
+  return sanitized
 }
 
 export function createInitialState(
   customCommands: Record<string, string> = {},
-  sessions: SessionRecord[] = [],
+  projects: ProjectRecord[] = [],
   snippets: SnippetRecord[] = [],
-  showSessionPicker = false,
+  showProjectPicker = false,
   overrides: InitialStateOverrides = {}
 ): AppState {
   return {
     activeTabId: null,
     autoCommit: EMPTY_AUTO_COMMIT_STATE,
     bars: sanitizeBars(overrides.bars ?? DEFAULT_BARS),
-    currentSessionId: null,
+    currentProjectId: null,
     customCommands,
-    focusMode: showSessionPicker ? 'command-edit' : 'navigation',
+    focusMode: showProjectPicker ? 'command-edit' : 'navigation',
     gitMode: { ...emptyGitMode(), ...overrides.gitMode },
     gitPane: { ...DEFAULT_GIT_PANE, ...overrides.gitPane },
     gitPanel: emptyGitPanel(),
-    lastActiveTabByWorktree: {},
+    lastActiveTabByWorkspace: {},
     layout: {
       terminalCols: DEFAULT_TERMINAL_COLS,
       terminalRows: DEFAULT_TERMINAL_ROWS,
     },
     layoutTrees: {},
-    modal: showSessionPicker
+    modal: showProjectPicker
       ? {
           cursorPos: 0,
           editBuffer: '',
+          projectTargetId: null,
           selectedIndex: 0,
-          sessionTargetId: null,
-          type: 'session-picker',
+          type: 'project-picker',
         }
       : emptyModal(),
     multiRepo: EMPTY_MULTI_REPO_STATE,
     pendingChords: null,
-    sessionBar: {
-      visible: overrides.sessionBarVisible ?? true,
+    projectBar: {
+      visible: overrides.projectBarVisible ?? true,
     },
-    sessions,
-    sessionStatuses: {},
+    projects,
+    projectStatuses: {},
+    settings: emptySettingsUI(),
     snippets,
     tabGroupMap: {},
     tabs: [],
-    worktreeDivergence: {},
-    worktreeTemplates: overrides.worktreeTemplates ?? [],
+    workspaceActivity: {},
+    workspaceDivergence: {},
   }
 }
 
 export function appReducer(state: AppState, action: AppAction): AppState {
-  const sessionState = reduceSessionState(state, action)
-  if (sessionState) return sessionState
+  const projectState = reduceProjectState(state, action)
+  if (projectState) return projectState
 
   const tabState = reduceTabState(state, action)
   if (tabState) return tabState
@@ -141,6 +171,9 @@ export function appReducer(state: AppState, action: AppAction): AppState {
   const multiRepoState = reduceMultiRepoState(state, action)
   if (multiRepoState) return multiRepoState
 
+  const settingsState = reduceSettingsState(state, action)
+  if (settingsState) return settingsState
+
   switch (action.type) {
     case 'set-snippets':
       return { ...state, snippets: action.snippets }