@brimveyn/aimux 1.20.4 → 1.22.0

package/src/app-runtime/workspace-activity.ts

@@ -0,0 +1,138 @@
+/**
+ * Per-workspace activity, and the notification sound that goes with it.
+ *
+ * The store only holds tabs for the project the client is attached to, but the
+ * daemon broadcasts every tab's status with its `workspaceId` (v18). So the
+ * table of "which tab is doing what" lives here, module-owned, and only the
+ * aggregate per workspace is dispatched into `AppState.workspaceActivity` —
+ * which is what the sidebar draws for every project, current or not.
+ *
+ * Both notification sounds are triggered from here so the glyph and the sound
+ * can never disagree about what happened:
+ *   - a tab entering `waiting-input` (the agent is asking something),
+ *   - a tab completing a turn (the daemon's settled end-of-turn signal).
+ * Neither fires for the tab you are looking at.
+ */
+import type { TabActivity } from '../state/types'
+
+import { playNotificationSound } from '../settings/sections/notifications'
+import { appStore } from '../state/app-store'
+import { dispatchGlobal } from '../state/dispatch-ref'
+
+interface Entry {
+  status: TabActivity
+  workspaceId: string | undefined
+  /**
+   * Whether this client has seen the tab do something since the last turn it
+   * announced. The daemon's end-of-turn timer is per-process: restart it (an
+   * update, `restart-daemon`) and every surviving idle PTY produces a
+   * turn-complete a settle window later. Requiring an observed `working` /
+   * `waiting-input` first is what keeps that restart from ticking every
+   * workspace and ringing.
+   */
+  armed: boolean
+}
+
+// A tab in another project never sends this client its `tabExit`, so an entry
+// here can outlive its PTY. The daemon emits a final `idle` for a tab it stops
+// seeing (the tick cleanup in `assistant-status-detection-loop.ts`), which is
+// what keeps a tab that died mid-turn from pinning a spinner to a workspace
+// row forever; the entry itself is left behind, contributing nothing.
+const entries = new Map<string, Entry>()
+
+/** The two flags a set of tabs adds up to. Pure, and the reason it is exported. */
+export function aggregate(statuses: readonly TabActivity[]): {
+  working: boolean
+  waiting: boolean
+} {
+  return {
+    waiting: statuses.includes('waiting-input'),
+    working: statuses.includes('working'),
+  }
+}
+
+function publish(workspaceId: string | undefined): void {
+  if (workspaceId == null || workspaceId === '') return
+  const statuses: TabActivity[] = []
+  for (const entry of entries.values()) {
+    if (entry.workspaceId === workspaceId) statuses.push(entry.status)
+  }
+  const { waiting, working } = aggregate(statuses)
+  dispatchGlobal({ type: 'set-workspace-activity', waiting, working, workspaceId })
+}
+
+/** True when this tab is the one on screen — no sound, no unseen-tick, for it. */
+function isBeingWatched(tabId: string): boolean {
+  return appStore.getState().activeTabId === tabId
+}
+
+export function recordTabStatus(
+  tabId: string,
+  status: TabActivity,
+  workspaceId: string | undefined,
+  options?: { silent?: boolean }
+): void {
+  const previous = entries.get(tabId)
+  const armed = status === 'working' || status === 'waiting-input' || (previous?.armed ?? false)
+  // An event that carries no workspace does not mean the tab lost one. A tab
+  // created before the daemon recorded workspaces has none in its registry,
+  // but the client's own snapshot does — and the attach seeded us with it, so
+  // keep it rather than blanking the row on the next status change.
+  const known = workspaceId ?? previous?.workspaceId
+  entries.set(tabId, { armed, status, workspaceId: known })
+  // A tab can be reassigned to another workspace (workspace move); the one it
+  // left has one tab fewer and has to be recomputed too.
+  if (previous && previous.workspaceId !== known) publish(previous.workspaceId)
+  publish(known)
+
+  if (
+    options?.silent !== true &&
+    status === 'waiting-input' &&
+    previous?.status !== 'waiting-input' &&
+    !isBeingWatched(tabId)
+  ) {
+    playNotificationSound()
+  }
+}
+
+/**
+ * Seed from the tabs an attach handed us, so a workspace whose agent has been
+ * waiting since before this client started says so on the first paint instead
+ * of waiting for a transition that already happened. Silent by definition:
+ * nothing here is news.
+ */
+export function seedTabActivity(
+  tabs: readonly { id: string; activity?: TabActivity; workspaceId?: string }[]
+): void {
+  for (const tab of tabs) {
+    recordTabStatus(tab.id, tab.activity ?? 'idle', tab.workspaceId, { silent: true })
+  }
+}
+
+export function recordTurnComplete(tabId: string, workspaceId: string | undefined): void {
+  const entry = entries.get(tabId)
+  // Nothing observed since the last turn — this is a restarted daemon
+  // re-announcing the end of a turn that ended before we were listening.
+  if (entry?.armed !== true) return
+  entry.armed = false
+  if (isBeingWatched(tabId)) return
+  if (workspaceId != null && workspaceId !== '') {
+    dispatchGlobal({ type: 'mark-workspace-done', workspaceId })
+  }
+  // The workspace tick says where to look; this says which tab rang. A no-op
+  // for a tab this client doesn't hold — its workspace row is the answer there.
+  dispatchGlobal({ tabId, type: 'mark-tab-unseen' })
+  playNotificationSound()
+}
+
+export function forgetTabActivity(tabId: string): void {
+  const entry = entries.get(tabId)
+  if (!entry) return
+  entries.delete(tabId)
+  publish(entry.workspaceId)
+}
+
+/** Test seam: drop every remembered tab. */
+export function resetWorkspaceActivity(): void {
+  entries.clear()
+}

package/src/app-runtime/workspace-naming.ts

@@ -0,0 +1,90 @@
+// Names a workspace after the prompt that created it.
+//
+// Two stages, because a model call takes seconds and workspace creation must
+// not wait on the network: a local heuristic name is applied at creation, then
+// the generated one replaces it in place when it arrives. The heuristic result
+// is not a stopgap to be embarrassed about — when no headless CLI is installed
+// it is the final name, and it is still derived from what the user asked for.
+
+import type { AssistantId, WorkspaceRecord } from '../state/types'
+
+import { heuristicTitle } from '../auto-rename/heuristic-title'
+import { generateTabTitle, type TitleSpawnFn } from '../auto-rename/title-runner'
+import { renameGitBranch } from '../git/worktree'
+import { sanitizePathSegment } from '../platform/worktree-paths'
+
+/** Model naming is best-effort background work; it must never outlive the app. */
+const NAMING_TIMEOUT_MS = 30_000
+
+export const BRANCH_PREFIX = 'aimux/'
+const BRANCH_SLUG_MAX = 40
+
+export function branchNameFor(name: string): string {
+  return `${BRANCH_PREFIX}${sanitizePathSegment(name, BRANCH_SLUG_MAX).toLowerCase()}`
+}
+
+/**
+ * The name a workspace carries until the model answers. Undefined when the
+ * prompt yields nothing usable, which lets `createAimuxTempWorkspace` fall back
+ * to its own `wt-<project>` default.
+ */
+export function placeholderWorkspaceName(prompt: string): string | undefined {
+  return heuristicTitle(prompt) ?? undefined
+}
+
+export interface WorkspaceNamingTarget {
+  projectId: string
+  workspace: WorkspaceRecord
+  prompt: string
+  /** Provider used for the naming call — the assistant the user just picked. */
+  provider: AssistantId
+}
+
+export interface WorkspaceNamingDeps {
+  applyName: (projectId: string, workspaceId: string, patch: Partial<WorkspaceRecord>) => void
+  renameBranch?: (repoRoot: string, from: string, to: string) => Promise<boolean>
+  spawn?: TitleSpawnFn
+  signal?: AbortSignal
+}
+
+/**
+ * Replace a workspace's placeholder name and branch with ones generated from
+ * the prompt. Silent on every failure: a missing CLI, a timeout or a branch
+ * collision all leave the placeholder standing, which is a perfectly usable
+ * outcome and not worth a toast.
+ *
+ * ponytail: fixed timeout, no model override. Read `autoRename.models` here if
+ * anyone wants naming on a cheaper model than the tab's assistant.
+ */
+export async function renameWorkspaceFromPrompt(
+  target: WorkspaceNamingTarget,
+  deps: WorkspaceNamingDeps
+): Promise<void> {
+  const result = await generateTabTitle({
+    firstPrompt: target.prompt,
+    provider: target.provider,
+    signal: deps.signal ?? new AbortController().signal,
+    spawn: deps.spawn,
+    timeoutMs: NAMING_TIMEOUT_MS,
+  })
+  if (result.status !== 'ok') return
+
+  const { workspace } = target
+  if (result.title === workspace.name) return
+
+  const branch = branchNameFor(result.title)
+  const rename = deps.renameBranch ?? renameGitBranch
+  // Renamed from inside the workspace, not the main checkout: the branch is
+  // that worktree's current branch, which is the form git always accepts.
+  // Renaming first means a refusal (the name is taken) leaves the record
+  // pointing at the branch that actually exists.
+  const branchRenamed =
+    workspace.branch != null && workspace.branch !== '' && branch !== workspace.branch
+      ? await rename(workspace.path, workspace.branch, branch)
+      : false
+
+  deps.applyName(target.projectId, workspace.id, {
+    name: result.title,
+    ...(branchRenamed ? { branch } : null),
+  })
+}

package/src/app.tsx

@@ -1,4 +1,5 @@
 import {
+  type AimuxUserConfig,
   type ResolvedConfig,
   setAutoCommitEnabled,
   setExternalEditorConfig,
@@ -8,20 +9,23 @@ import {
 import { useKeyboard, useRenderer, useTerminalDimensions } from '@opentui/react'
 import { useCallback, useEffect, useLayoutEffect, useMemo, useRef, useState } from 'react'
 
+import type { SideEffectContext } from './app-runtime/side-effect-context'
 import type { KeyChord } from './input/keymap/key-chord'
 import type { TrieBinding } from './input/keymap/trie'
 import type { KeyResult, ModeContext, ModeId } from './input/modes/types'
 import type { TerminalContentOrigin } from './input/raw-input-handler'
 import type { SessionBackend } from './session-backend/types'
 
-import { executeSideEffect, type SideEffectContext } from './app-runtime/side-effects'
+import { setActiveMeasure } from './app-runtime/measure-ref'
+import { executeSideEffect } from './app-runtime/side-effects'
 import { useAutoCommitDriver } from './app-runtime/use-auto-commit-driver'
 import { useBackendRuntime } from './app-runtime/use-backend-runtime'
 import { useDirectorySearch } from './app-runtime/use-directory-search'
 import { useMouseHandlers } from './app-runtime/use-mouse-handlers'
+import { useProjectAutosave } from './app-runtime/use-project-autosave'
 import { useRendererBindings } from './app-runtime/use-renderer-bindings'
+import { useSetupRunner } from './app-runtime/use-setup-runner'
 import { useTerminalResize } from './app-runtime/use-terminal-resize'
-import { useWorkspaceAutosave } from './app-runtime/use-workspace-autosave'
 import { loadConfig, saveConfig } from './config'
 import { enqueueGitOp } from './git/command-queue'
 import { pruneOrphanAimuxBranches } from './git/worktree'
@@ -34,11 +38,19 @@ import { highlightSnapshot, warmClaudeSyntaxOverlay } from './integrations/claud
 import { ensureClaudeSettingsThemePref, syncClaudeTheme } from './integrations/claude-theme-sync'
 import { getProfileConfigDir, getProfileName } from './profile-paths'
 import { startAIUsageService } from './services/ai-usage/provider'
+import {
+  useAIUsageConfig,
+  useAutoCommitConfig,
+  useHarmonizeClaudeTheme,
+  useSnippetTriggerChar,
+} from './settings/live'
+import { ALL_SETTING_ROWS } from './settings/sections'
+import { hydrateSettings } from './settings/settings-store'
 import { aiUsageStore } from './state/ai-usage-store'
 import { appStore, useAppStore } from './state/app-store'
 import { setActiveDispatch, setActiveSideEffectRunner } from './state/dispatch-ref'
-import { findMostRecentSession, loadSessionCatalog } from './state/session-catalog'
-import { getSessionProjectPath } from './state/session-worktrees'
+import { findMostRecentProject, loadProjectCatalog } from './state/project-catalog'
+import { getActiveWorkspacePath } from './state/project-workspaces'
 import { loadSnippetCatalog, mergeConfigSnippets } from './state/snippet-catalog'
 import { createInitialState } from './state/store'
 import { toast } from './state/toast-store'
@@ -59,14 +71,16 @@ import {
   isNewerVersion,
 } from './update/version-check'
 
-const WORKSPACE_SAVE_DEBOUNCE_MS = 250
+const PROJECT_SAVE_DEBOUNCE_MS = 250
 
 export function App({
   backend,
   resolvedConfig,
+  userConfig,
 }: {
   backend: SessionBackend
   resolvedConfig: ResolvedConfig
+  userConfig: AimuxUserConfig
 }) {
   // Publish the auto-commit enabled flag before any children render so
   // actions (which live outside React) can read it synchronously.
@@ -104,72 +118,42 @@ export function App({
   // selector reads. We discard the value — the store is the source of truth.
   useState(() => {
     const json = loadConfig()
-    const sessionBarVisible =
-      resolvedConfig.sessionBar?.initialVisible ?? json.sessionBarVisible ?? true
-    const sidebarOverrides = json.sidebar
-
+    const projectBarVisible =
+      resolvedConfig.projectBar?.initialVisible ?? json.projectBarVisible ?? true
     // Merge config-file gitPane (persisted prefs) with user's resolved gitPane
     // (programmatic config). User config wins; file provides persisted prior state.
     const userGitPane = resolvedConfig.gitPane
-    const fileListMode = userGitPane?.initialFileListMode ?? json.gitPane?.fileListMode ?? 'tree'
-    const diffModeRatio = userGitPane?.initialDiffModeRatio ?? json.gitPane?.diffModeRatio ?? 0.35
-    const treeCompaction =
-      userGitPane?.initialTreeCompaction ?? json.gitPane?.treeCompaction ?? true
-    const prefetchRadius = userGitPane?.prefetchRadius ?? json.gitPane?.prefetchRadius ?? 5
-    const persistedPaneRatio = json.gitPane?.paneRatio ?? json.gitPane?.ratio ?? 0.5
-    const persistedEmbeddedRatio = json.gitPane?.embeddedRatio ?? json.gitPane?.ratio ?? 0.5
     const gitPaneOverrides = {
-      ...json.gitPane,
-      diffModeRatio,
-      embeddedRatio:
-        userGitPane?.initialMode === 'embedded' && userGitPane?.initialRatio !== undefined
-          ? userGitPane.initialRatio
-          : persistedEmbeddedRatio,
-      fileListMode,
-      paneRatio:
-        userGitPane?.initialMode === 'pane' && userGitPane?.initialRatio !== undefined
-          ? userGitPane.initialRatio
-          : persistedPaneRatio,
-      prefetchRadius,
-      treeCompaction,
-      ...(userGitPane?.initialVisible !== undefined ? { visible: userGitPane.initialVisible } : {}),
-      ...(userGitPane?.initialMode !== undefined ? { mode: userGitPane.initialMode } : {}),
-      ...(userGitPane?.initialPosition !== undefined
-        ? { position: userGitPane.initialPosition }
-        : {}),
-      ...(userGitPane?.initialDiffModeRatio !== undefined
-        ? { diffModeRatio: userGitPane.initialDiffModeRatio }
-        : {}),
+      diffModeRatio: userGitPane?.initialDiffModeRatio ?? json.gitPane?.diffModeRatio ?? 0.35,
+      fileListMode: userGitPane?.initialFileListMode ?? json.gitPane?.fileListMode ?? 'tree',
+      prefetchRadius: userGitPane?.prefetchRadius ?? json.gitPane?.prefetchRadius ?? 5,
+      treeCompaction: userGitPane?.initialTreeCompaction ?? json.gitPane?.treeCompaction ?? true,
       ...(userGitPane?.path !== undefined ? { path: userGitPane.path } : {}),
       ...(userGitPane?.diffCount !== undefined ? { diffCount: userGitPane.diffCount } : {}),
     }
 
-    const sessionCatalog = loadSessionCatalog()
+    const projectCatalog = loadProjectCatalog()
     const mergedSnippets = mergeConfigSnippets(loadSnippetCatalog(), resolvedConfig.snippets)
     const initial = createInitialState(
       json.customCommands,
-      sessionCatalog,
+      projectCatalog,
       mergedSnippets,
-      sessionCatalog.length === 0,
+      projectCatalog.length === 0,
       {
+        bars: json.bars,
         gitPane: gitPaneOverrides,
-        sessionBarVisible,
-        sidebar: sidebarOverrides,
-        worktreeTemplates:
-          resolvedConfig.worktreeTemplates.length > 0
-            ? resolvedConfig.worktreeTemplates
-            : json.worktreeTemplates,
+        projectBarVisible,
       }
     )
     // Replace the module-level default with the fully-resolved initial state.
     // Preserves the dispatch baked into the store by app-store.ts.
     appStore.setState(initial)
-    const mostRecent = findMostRecentSession(sessionCatalog)
+    const mostRecent = findMostRecentProject(projectCatalog)
     if (mostRecent) {
       appStore.getState().dispatch({
-        sessionId: mostRecent.id,
-        type: 'load-session',
-        workspaceSnapshot: mostRecent.workspaceSnapshot,
+        projectId: mostRecent.id,
+        projectSnapshot: mostRecent.projectSnapshot,
+        type: 'load-project',
       })
     }
     return null
@@ -182,6 +166,15 @@ export function App({
   const state = useAppStore((s) => s)
   const dispatch = state.dispatch
 
+  // Config the settings screen can change under us. The resolved config file is
+  // the baseline each of these falls back to.
+  const autoCommitConfig = useAutoCommitConfig(resolvedConfig.autoCommit)
+  const aiUsageConfig = useAIUsageConfig(resolvedConfig.statusBar?.aiUsage)
+  const harmonizeClaudeTheme = useHarmonizeClaudeTheme(
+    resolvedConfig.theme?.beta?.harmonizeClaudeTheme
+  )
+  const snippetTriggerChar = useSnippetTriggerChar(resolvedConfig.snippetTriggerChar)
+
   useLayoutEffect(() => {
     setActiveDispatch(dispatch)
     return () => {
@@ -190,14 +183,26 @@ export function App({
     }
   }, [dispatch])
 
+  // Replays what the settings screen has written on top of the config file (the
+  // setters at the top of this component are its baseline). Deliberately after
+  // the effect above and never during render: a row applies its value through
+  // whatever owns it, and some of those owners are reached by dispatching.
+  // Layout effect, so it lands before the first paint.
+  useLayoutEffect(() => {
+    hydrateSettings(ALL_SETTING_ROWS, userConfig)
+    // Once per launch: the config file is read at startup and does not change
+    // under us, and every later write goes through `writeRow`.
+    // eslint-disable-next-line react-hooks/exhaustive-deps
+  }, [])
+
   useEffect(() => {
-    if (!(resolvedConfig.theme?.beta?.harmonizeClaudeTheme === true)) return
+    if (!harmonizeClaudeTheme) return
     ensureClaudeSettingsThemePref()
     syncClaudeTheme(getCurrentTheme(), getCurrentMode())
     return subscribeThemeChanges((resolved, mode) => {
       syncClaudeTheme(resolved, mode)
     })
-  }, [resolvedConfig.theme?.beta?.harmonizeClaudeTheme])
+  }, [harmonizeClaudeTheme])
 
   useEffect(() => {
     // Opt-in via `integrations.claudeHooks` in aimux.config.ts. When enabled,
@@ -210,13 +215,12 @@ export function App({
   }, [resolvedConfig.integrations.claudeHooks])
 
   useEffect(() => {
-    const aiUsage = resolvedConfig.statusBar?.aiUsage
-    if (!(aiUsage?.enabled === true)) {
+    if (!(aiUsageConfig.enabled === true)) {
       aiUsageStore.getState().setEnabled(false)
       return
     }
     aiUsageStore.getState().setEnabled(true)
-    const handle = startAIUsageService(aiUsage, (snap) => {
+    const handle = startAIUsageService(aiUsageConfig, (snap) => {
       aiUsageStore.getState().setSnapshot(snap)
     })
     return () => {
@@ -224,7 +228,9 @@ export function App({
       aiUsageStore.getState().clear()
       aiUsageStore.getState().setEnabled(false)
     }
-  }, [resolvedConfig.statusBar?.aiUsage])
+    // Memoized by `useAIUsageConfig`, so toggling the indicator restarts the
+    // service and nothing else does.
+  }, [aiUsageConfig])
 
   useEffect(() => {
     if (process.env.AIMUX_DISABLE_UPDATE_CHECK === '1') return
@@ -254,16 +260,16 @@ export function App({
   }, [])
 
   useEffect(() => {
-    // One-shot cleanup: prune `aimux/` branches orphaned by temp worktrees that
+    // One-shot cleanup: prune `aimux/` branches orphaned by temp workspaces that
     // were deleted before delete-time branch cleanup existed. Gated by a config
     // flag so it runs once per machine. All git calls are best-effort (nothrow)
-    // and git protects branches still checked out in a live worktree.
+    // and git protects branches still checked out in a live workspace.
     if (loadConfig().prunedOrphanAimuxBranches === true) return
     void (async () => {
       const repoRoots = new Set<string>()
-      for (const session of loadSessionCatalog()) {
-        for (const worktree of session.worktrees ?? []) {
-          if (worktree.repoRoot !== '') repoRoots.add(worktree.repoRoot)
+      for (const project of loadProjectCatalog()) {
+        for (const workspace of project.workspaces ?? []) {
+          if (workspace.repoRoot !== '') repoRoots.add(workspace.repoRoot)
         }
       }
       let removed = 0
@@ -282,15 +288,15 @@ export function App({
   // still the bootstrap default, and useBackendRuntime's attach effect would
   // then hand 80x24 to the backend, resizing the daemon-persisted PTYs (or
   // newly-spawned ones) to the wrong size and stranding the assistant's
-  // already-drawn content in the top-left until a workspace switch.
+  // already-drawn content in the top-left until a project switch.
   const layoutRef = useRef(state.layout)
   const activeTab = useMemo(
     () => state.tabs.find((tab) => tab.id === state.activeTabId),
     [state.activeTabId, state.tabs]
   )
-  const currentSession = useMemo(
-    () => state.sessions.find((session) => session.id === state.currentSessionId),
-    [state.currentSessionId, state.sessions]
+  const currentProject = useMemo(
+    () => state.projects.find((project) => project.id === state.currentProjectId),
+    [state.currentProjectId, state.projects]
   )
   const activeMouseForwardingEnabled = activeTab?.terminalModes.mouseTrackingMode !== 'none'
   const activeLocalScrollbackEnabled =
@@ -311,11 +317,11 @@ export function App({
   snippetsRef.current = state.snippets
   const branchRef = useRef(state.gitPanel.branch)
   branchRef.current = state.gitPanel.branch
-  const triggerCharRef = useRef(resolvedConfig.snippetTriggerChar)
-  triggerCharRef.current = resolvedConfig.snippetTriggerChar
+  const triggerCharRef = useRef(snippetTriggerChar)
+  triggerCharRef.current = snippetTriggerChar
 
   const contentOriginRef = useRef<TerminalContentOrigin>({ cols: 0, rows: 0, x: 0, y: 0 })
-  const currentSessionWorkspaceSnapshot = currentSession?.workspaceSnapshot
+  const currentProjectProjectSnapshot = currentProject?.projectSnapshot
 
   // Must run before useBackendRuntime so its open-loop terminalSize seeds
   // layoutRef before the attach effect reads it. See the comment on layoutRef.
@@ -329,6 +335,15 @@ export function App({
   })
   layoutRef.current = { terminalCols: terminalSize.cols, terminalRows: terminalSize.rows }
 
+  // Reaches the setup widget, which hosts its own PTY outside root.tsx's pane
+  // tree and so never sees the onMeasure prop chain.
+  useLayoutEffect(() => {
+    setActiveMeasure(terminalSize.onMeasure)
+    return () => {
+      setActiveMeasure(null)
+    }
+  }, [terminalSize.onMeasure])
+
   const syntaxOverlayFlag = resolvedConfig.theme?.beta?.experimentalSyntaxHighlight === true
   const syntaxOverlayFlagRef = useRef(syntaxOverlayFlag)
   syntaxOverlayFlagRef.current = syntaxOverlayFlag
@@ -363,18 +378,20 @@ export function App({
   const { clearIdleTimer, clearStartupGrace, startStartupGrace } = useBackendRuntime({
     activeTabId: state.activeTabId,
     backend,
-    currentSessionId: state.currentSessionId,
-    currentSessionWorkspaceSnapshot,
+    currentProjectId: state.currentProjectId,
+    currentProjectProjectSnapshot,
     dispatch,
     layoutRef,
     resizingRef,
     syntaxOverlayEnabled,
   })
 
-  useWorkspaceAutosave(state, WORKSPACE_SAVE_DEBOUNCE_MS)
+  useProjectAutosave(state, PROJECT_SAVE_DEBOUNCE_MS)
   useDirectorySearch(state.modal, dispatch)
   useAutoCommitDriver({
-    config: resolvedConfig.autoCommit,
+    // Through the settings screen, so a change lands without a restart. The
+    // resolved config is the baseline it falls back to.
+    config: autoCommitConfig,
     dispatch,
     getProfileConfigRoot: getProfileConfigDir,
     state,
@@ -382,13 +399,12 @@ export function App({
   })
 
   const {
-    handleEmbeddedGitResizeStart,
-    handleGitPaneResizeStart,
+    handleBarBoundaryResizeStart,
+    handleBarResizeStart,
     handlePaneActivate,
     handleSeparatorDrag,
     handleSeparatorDragEnd,
     handleSeparatorDragStart,
-    handleSidebarResizeStart,
     handleSplitResize,
     handleTerminalClick,
     handleTerminalDrag,
@@ -443,9 +459,9 @@ export function App({
     clearIdleTimer,
     clearStartupGrace,
     dispatch,
-    getCurrentSessionProjectPath: () => {
-      if (!(state.currentSessionId != null && state.currentSessionId !== '')) return
-      return getSessionProjectPath(state.sessions.find((s) => s.id === state.currentSessionId))
+    getCurrentProjectProjectPath: () => {
+      if (!(state.currentProjectId != null && state.currentProjectId !== '')) return
+      return getActiveWorkspacePath(state.projects.find((s) => s.id === state.currentProjectId))
     },
     // Read straight from the store, not stateRef. stateRef is only refreshed
     // on render, so within a single JS turn (a click handler that dispatches
@@ -459,6 +475,8 @@ export function App({
     themeId,
   }
 
+  useSetupRunner(state, sideEffectCtx)
+
   function processKeyResult(result: KeyResult, modeId: ModeId): void {
     for (const action of result.actions) {
       dispatch(action)
@@ -515,12 +533,12 @@ export function App({
       dispatch({ tabId: target.tabId, type: 'set-active-tab' })
       return
     }
-    if (target.kind === 'workspace' || target.kind === 'worktree') {
+    if (target.kind === 'project' || target.kind === 'workspace') {
       executeSideEffect(
         {
-          index: target.sessionIndex,
-          type: 'switch-session-by-index',
-          worktreeId: target.worktreeId,
+          index: target.projectIndex,
+          type: 'switch-project-by-index',
+          workspaceId: target.workspaceId,
         },
         sideEffectCtx
       )
@@ -563,12 +581,11 @@ export function App({
         onTerminalMouseUp={handleTerminalMouseUp}
         onPaneActivate={handlePaneActivate}
         onSplitResize={handleSplitResize}
-        onEmbeddedGitResizeStart={handleEmbeddedGitResizeStart}
-        onGitPaneResizeStart={handleGitPaneResizeStart}
+        onBarBoundaryResizeStart={handleBarBoundaryResizeStart}
+        onBarResizeStart={handleBarResizeStart}
         onSeparatorDragStart={handleSeparatorDragStart}
         onSeparatorDrag={handleSeparatorDrag}
         onSeparatorDragEnd={handleSeparatorDragEnd}
-        onSidebarResizeStart={handleSidebarResizeStart}
         onMeasure={terminalSize.onMeasure}
         terminalCols={terminalSize.cols}
         terminalRows={terminalSize.rows}

package/src/cli/client/daemon-client.ts

@@ -205,10 +205,10 @@ export class DaemonClient {
     return response.payload
   }
 
-  async listTabs(sessionId: string): Promise<ListTabsResult> {
+  async listTabs(projectId: string): Promise<ListTabsResult> {
     const response = await this.send({
       id: crypto.randomUUID(),
-      payload: { sessionId },
+      payload: { projectId },
       type: 'listTabs',
     })
     if (response.type !== 'listTabsResult') {