@brimveyn/aimux 1.21.0 → 1.22.2

package/src/daemon/session-manager.ts

@@ -1,10 +1,10 @@
 import { EventEmitter } from 'node:events'
 
 import type {
+  ProjectSnapshotV1,
   TabSession,
   TerminalModeState,
   TerminalSnapshot,
-  WorkspaceSnapshotV1,
 } from '../state/types'
 
 import { logDebug } from '../debug/input-log'
@@ -12,110 +12,110 @@ import { SessionRegistry } from './session-registry'
 
 interface SessionManagerEvents {
   render: [
-    sessionId: string,
+    projectId: string,
     tabId: string,
     viewport: TerminalSnapshot,
     terminalModes: TerminalModeState,
   ]
-  exit: [sessionId: string, tabId: string, exitCode: number]
-  error: [sessionId: string, tabId: string, message: string]
+  exit: [projectId: string, tabId: string, exitCode: number]
+  error: [projectId: string, tabId: string, message: string]
 }
 
 export class SessionManager extends EventEmitter<SessionManagerEvents> {
   private registries = new Map<string, SessionRegistry>()
 
-  private getOrCreateRegistry(sessionId: string): SessionRegistry {
-    const existing = this.registries.get(sessionId)
+  private getOrCreateRegistry(projectId: string): SessionRegistry {
+    const existing = this.registries.get(projectId)
     if (existing) {
       return existing
     }
 
     const registry = new SessionRegistry()
     registry.on('render', (tabId, viewport, terminalModes) => {
-      this.emit('render', sessionId, tabId, viewport, terminalModes)
+      this.emit('render', projectId, tabId, viewport, terminalModes)
     })
     registry.on('exit', (tabId, exitCode) => {
-      this.emit('exit', sessionId, tabId, exitCode)
+      this.emit('exit', projectId, tabId, exitCode)
     })
     registry.on('error', (tabId, message) => {
-      this.emit('error', sessionId, tabId, message)
+      this.emit('error', projectId, tabId, message)
     })
-    this.registries.set(sessionId, registry)
+    this.registries.set(projectId, registry)
     return registry
   }
 
-  attachSession(sessionId: string, snapshot?: WorkspaceSnapshotV1) {
+  attachSession(projectId: string, snapshot?: ProjectSnapshotV1) {
     logDebug('daemon.sessionManager.attachSession', {
       hasSnapshot: !!snapshot,
-      sessionId,
+      projectId,
       snapshotTabs: snapshot?.tabs.length ?? 0,
     })
-    return this.getOrCreateRegistry(sessionId).attachFromSnapshot(snapshot)
+    return this.getOrCreateRegistry(projectId).attachFromSnapshot(snapshot)
   }
 
-  createTab(sessionId: string, options: Parameters<SessionRegistry['createSession']>[0]): void {
+  createTab(projectId: string, options: Parameters<SessionRegistry['createSession']>[0]): void {
     logDebug('daemon.sessionManager.createTab', {
       command: options.command,
-      sessionId,
+      projectId,
       tabId: options.tabId,
       title: options.title,
     })
-    this.getOrCreateRegistry(sessionId).createSession(options)
+    this.getOrCreateRegistry(projectId).createSession(options)
   }
 
-  write(sessionId: string, tabId: string, data: string): void {
-    this.getOrCreateRegistry(sessionId).write(tabId, data)
+  write(projectId: string, tabId: string, data: string): void {
+    this.getOrCreateRegistry(projectId).write(tabId, data)
   }
 
   updateTabMetadata(
-    sessionId: string,
+    projectId: string,
     tabId: string,
     patch: { title?: string; autoRenameStatus?: 'eligible' | 'attempted' }
   ): void {
-    this.getOrCreateRegistry(sessionId).updateTabMetadata(tabId, patch)
+    this.getOrCreateRegistry(projectId).updateTabMetadata(tabId, patch)
   }
 
-  resize(sessionId: string, cols: number, rows: number, options?: { sync?: boolean }): void {
-    this.getOrCreateRegistry(sessionId).resizeAll(cols, rows, options)
+  resize(projectId: string, cols: number, rows: number, options?: { sync?: boolean }): void {
+    this.getOrCreateRegistry(projectId).resizeAll(cols, rows, options)
   }
 
   resizeTab(
-    sessionId: string,
+    projectId: string,
     tabId: string,
     cols: number,
     rows: number,
     options?: { sync?: boolean }
   ): void {
-    this.getOrCreateRegistry(sessionId).resizeTab(tabId, cols, rows, options)
+    this.getOrCreateRegistry(projectId).resizeTab(tabId, cols, rows, options)
   }
 
-  scroll(sessionId: string, tabId: string, deltaLines: number): void {
-    this.getOrCreateRegistry(sessionId).scrollViewport(tabId, deltaLines)
+  scroll(projectId: string, tabId: string, deltaLines: number): void {
+    this.getOrCreateRegistry(projectId).scrollViewport(tabId, deltaLines)
   }
 
-  scrollToBottom(sessionId: string, tabId: string): void {
-    this.getOrCreateRegistry(sessionId).scrollViewportToBottom(tabId)
+  scrollToBottom(projectId: string, tabId: string): void {
+    this.getOrCreateRegistry(projectId).scrollViewportToBottom(tabId)
   }
 
-  setActiveTab(sessionId: string, tabId: string | null): void {
-    this.getOrCreateRegistry(sessionId).setActiveTab(tabId)
+  setActiveTab(projectId: string, tabId: string | null): void {
+    this.getOrCreateRegistry(projectId).setActiveTab(tabId)
   }
 
-  closeTab(sessionId: string, tabId: string): void {
-    this.getOrCreateRegistry(sessionId).closeTab(tabId)
+  closeTab(projectId: string, tabId: string): void {
+    this.getOrCreateRegistry(projectId).closeTab(tabId)
   }
 
-  disposeSession(sessionId: string): void {
+  disposeSession(projectId: string): void {
     logDebug('daemon.sessionManager.disposeSession', {
-      hadRegistry: this.registries.has(sessionId),
-      sessionId,
+      hadRegistry: this.registries.has(projectId),
+      projectId,
     })
-    const registry = this.registries.get(sessionId)
+    const registry = this.registries.get(projectId)
     if (!registry) {
       return
     }
     registry.disposeAll()
-    this.registries.delete(sessionId)
+    this.registries.delete(projectId)
   }
 
   disposeAll(): void {
@@ -143,7 +143,7 @@ export class SessionManager extends EventEmitter<SessionManagerEvents> {
     return [...this.registries.keys()]
   }
 
-  listTabs(sessionId: string): TabSession[] {
-    return this.registries.get(sessionId)?.listTabs() ?? []
+  listTabs(projectId: string): TabSession[] {
+    return this.registries.get(projectId)?.listTabs() ?? []
   }
 }

package/src/daemon/session-registry.ts

@@ -1,10 +1,10 @@
 import { EventEmitter } from 'node:events'
 
 import type {
+  ProjectSnapshotV1,
   TabSession,
   TerminalModeState,
   TerminalSnapshot,
-  WorkspaceSnapshotV1,
 } from '../state/types'
 
 import { logDebug } from '../debug/input-log'
@@ -12,8 +12,8 @@ import { PtyManager } from '../pty/pty-manager'
 import {
   normalizeGroupedTabOrder,
   restoreLayoutTrees,
-  restoreTabsFromWorkspace,
-} from '../state/session-persistence'
+  restoreTabsFromProject,
+} from '../state/project-persistence'
 import { createDefaultTerminalModes } from '../state/terminal-modes'
 
 interface SessionRegistryEvents {
@@ -65,7 +65,7 @@ export class SessionRegistry extends EventEmitter<SessionRegistryEvents> {
     })
   }
 
-  attachFromSnapshot(snapshot: WorkspaceSnapshotV1 | undefined): {
+  attachFromSnapshot(snapshot: ProjectSnapshotV1 | undefined): {
     tabs: TabSession[]
     activeTabId: string | null
   } {
@@ -75,7 +75,7 @@ export class SessionRegistry extends EventEmitter<SessionRegistryEvents> {
       snapshotTabs: snapshot?.tabs.length ?? 0,
     })
     if (this.tabs.size === 0 && snapshot) {
-      const restoredTabs = restoreTabsFromWorkspace(snapshot)
+      const restoredTabs = restoreTabsFromProject(snapshot)
       for (const tab of restoredTabs) {
         this.tabs.set(tab.id, tab)
       }
@@ -93,7 +93,7 @@ export class SessionRegistry extends EventEmitter<SessionRegistryEvents> {
             existing.title = persisted.title
             existing.autoRenameStatus = persisted.autoRenameStatus
           }
-          existing.worktreeId = persisted.worktreeId
+          existing.workspaceId = persisted.workspaceId
           existing.workerName = persisted.workerName
         }
       }
@@ -116,10 +116,10 @@ export class SessionRegistry extends EventEmitter<SessionRegistryEvents> {
       .map((persistedTab) => this.tabs.get(persistedTab.id))
       .filter((tab): tab is TabSession => tab !== undefined)
     // The registry — not the snapshot — is the source of truth for *which*
-    // tabs exist. A tab spawned by a sibling CLI after this workspace's
+    // tabs exist. A tab spawned by a sibling CLI after this project's
     // snapshot was last persisted lives in `this.tabs` but is absent from
     // `snapshot.tabs`; ordering by the snapshot alone would silently drop it
-    // from the attach result, so the UI would render an empty/stale workspace
+    // from the attach result, so the UI would render an empty/stale project
     // on switch. Append any live tab the snapshot doesn't mention (in
     // registry order) so membership stays authoritative while the snapshot
     // still supplies ordering + layout for the tabs it captured.
@@ -151,12 +151,12 @@ export class SessionRegistry extends EventEmitter<SessionRegistryEvents> {
     env?: Record<string, string>
     autoRenameStatus?: 'eligible' | 'attempted'
     /**
-     * Worktree this tab belongs to (for UI grouping). Stored on the
+     * Workspace this tab belongs to (for UI grouping). Stored on the
      * TabSession so an attach-time replay surfaces it inside the right
-     * worktree column. Optional — tabs not bound to a worktree are valid.
+     * workspace column. Optional — tabs not bound to a workspace are valid.
      */
-    worktreeId?: string
-    /** Workspace-scoped orchestration handle; does not affect PTY behavior. */
+    workspaceId?: string
+    /** Project-scoped orchestration handle; does not affect PTY behavior. */
     workerName?: string
   }): void {
     logDebug('daemon.registry.createSession', {
@@ -179,7 +179,7 @@ export class SessionRegistry extends EventEmitter<SessionRegistryEvents> {
         terminalModes: createDefaultTerminalModes(),
         title: options.title,
         workerName: options.workerName,
-        worktreeId: options.worktreeId,
+        workspaceId: options.workspaceId,
       })
     } else {
       existing.status = 'starting'
@@ -192,7 +192,7 @@ export class SessionRegistry extends EventEmitter<SessionRegistryEvents> {
       existing.title = options.title
       existing.command = [options.command, ...(options.args ?? [])].join(' ')
       existing.autoRenameStatus = options.autoRenameStatus
-      if (options.worktreeId !== undefined) existing.worktreeId = options.worktreeId
+      if (options.workspaceId !== undefined) existing.workspaceId = options.workspaceId
       if (options.workerName !== undefined) existing.workerName = options.workerName
     }
 

package/src/git/divergence.ts

@@ -16,7 +16,7 @@ export function parseDivergenceCount(output: string): BranchDivergence | undefin
   }
 }
 
-// Commits a worktree branch is ahead/behind the ref it forked from. Returns
+// Commits a workspace branch is ahead/behind the ref it forked from. Returns
 // undefined when the refs can't be compared (missing ref, not a repo, …) so
 // callers can simply render nothing.
 export async function getBranchDivergence(
@@ -32,8 +32,39 @@ export async function getBranchDivergence(
   return parseDivergenceCount(result.text())
 }
 
+// Parses `git diff --shortstat`, e.g.
+// " 7 files changed, 149 insertions(+), 629 deletions(-)". Either side may be
+// absent (a pure addition reports no deletions line at all).
+export function parseShortstat(output: string): { added: number; removed: number } | undefined {
+  const trimmed = output.trim()
+  if (trimmed === '') return undefined
+  const added = /(\d+) insertions?\(\+\)/.exec(trimmed)
+  const removed = /(\d+) deletions?\(-\)/.exec(trimmed)
+  if (!added && !removed) return undefined
+  return {
+    added: Number.parseInt(added?.[1] ?? '0', 10),
+    removed: Number.parseInt(removed?.[1] ?? '0', 10),
+  }
+}
+
+/**
+ * Lines a workspace has changed since it forked, measured from the merge base
+ * to the *working tree* — so commits, staged and unstaged work all count. That
+ * is the number the sidebar shows, and it is what a squash-move would land.
+ */
+export async function getWorkspaceDiffStat(
+  workspacePath: string,
+  baseRef: string
+): Promise<{ added: number; removed: number } | undefined> {
+  const mergeBase = await getMergeBase(workspacePath, baseRef)
+  if (mergeBase == null) return undefined
+  const result = await $`git -C ${workspacePath} diff --shortstat ${mergeBase}`.quiet().nothrow()
+  if (result.exitCode !== 0) return undefined
+  return parseShortstat(result.text())
+}
+
 // Fork point: the most recent commit shared by baseRef and ref. Diffing the
-// working tree against this shows everything the worktree changed since it
+// working tree against this shows everything the workspace changed since it
 // branched off (commits + staged + unstaged) — i.e. what a squash-move lands.
 export async function getMergeBase(
   repoPath: string,

package/src/git/git-poller.ts

@@ -13,7 +13,7 @@ interface Options {
   enabled: boolean
   projectPath: string | undefined
   headOffset: number
-  // When set, diff the working tree against this ref (worktree fork point for
+  // When set, diff the working tree against this ref (workspace fork point for
   // review-vs-base) instead of HEAD/HEAD~N.
   compareRef?: string
 }

package/src/git/git-status.ts

@@ -199,7 +199,7 @@ async function annotateUntrackedCounts(cwd: string, files: GitFileEntry[]): Prom
 
 interface CollectOptions {
   headOffset?: number
-  // Explicit ref to diff the working tree against (e.g. a worktree's fork
+  // Explicit ref to diff the working tree against (e.g. a workspace's fork
   // point). Takes precedence over headOffset when set.
   compareRef?: string
 }
@@ -266,7 +266,7 @@ async function collectAgainstHistorical(
 }
 
 // Diffs the working tree against an arbitrary ref (a HEAD~N commit, or a
-// worktree's fork point for review-vs-base), surfacing changed files as a
+// workspace's fork point for review-vs-base), surfacing changed files as a
 // single `historical` section plus any untracked files.
 async function collectAgainstRef(cwd: string, ref: string): Promise<GitCollectResult> {
   const [statusResult, nameStatus, numstat, untrackedStatus] = await Promise.all([

package/src/git/{move-worktree.ts → move-workspace.ts}

@@ -1,6 +1,6 @@
 import { $ } from 'bun'
 
-export interface MoveWorktreeOptions {
+export interface MoveWorkspaceOptions {
   sourcePath: string
   sourceBranch: string
   targetPath: string
@@ -10,7 +10,7 @@ export interface MoveWorktreeOptions {
   keepConflicts?: boolean
 }
 
-export type MoveWorktreeResult =
+export type MoveWorkspaceResult =
   | { kind: 'ok'; filesChanged: number; stashedTarget: boolean }
   /** Target dirty/untracked files would be overwritten by the move; nothing was touched. */
   | { kind: 'needs-stash'; files: string[] }
@@ -76,8 +76,8 @@ function parseOverwrittenFiles(output: string): string[] {
   return files
 }
 
-// Squashes everything a source worktree changed since its fork point into the
-// target worktree's working tree (staged, uncommitted) — committed work plus
+// Squashes everything a source workspace changed since its fork point into the
+// target workspace's working tree (staged, uncommitted) — committed work plus
 // any uncommitted/untracked changes. The source is left exactly as it was; the
 // caller decides whether to delete it. The target may be dirty as long as its
 // local changes don't overlap the incoming ones: on overlap the move stops
@@ -85,7 +85,7 @@ function parseOverwrittenFiles(output: string): string[] {
 // conflict nothing is kept — target reset, source restored — unless
 // keepConflicts is set, in which case the conflicted squash state is left in
 // the target for manual resolution.
-export async function moveWorktree(opts: MoveWorktreeOptions): Promise<MoveWorktreeResult> {
+export async function moveWorkspace(opts: MoveWorkspaceOptions): Promise<MoveWorkspaceResult> {
   const { sourceBranch, sourcePath, targetPath } = opts
   try {
     const headResult = await $`git -C ${sourcePath} rev-parse HEAD`.quiet().nothrow()

package/src/git/pr-status.ts

@@ -213,7 +213,7 @@ export async function collectPrStatus(cwd: string): Promise<PrStatusResult> {
   if (!result.ok) {
     // `gh` exits non-zero for every "there is simply nothing to show" case too:
     // no PR on the branch, no GitHub remote, or a directory that isn't a repo
-    // at all (aimux sessions can point anywhere). None of those is an error.
+    // at all (aimux projects can point anywhere). None of those is an error.
     const stderr = result.stderr.toLowerCase()
     if (NOT_AN_ERROR.some((needle) => stderr.includes(needle))) return { kind: 'no-pr' }
     return { kind: 'error', message: (result.error ?? 'gh failed').slice(0, 200) }

package/src/git/repo-discovery.ts

@@ -79,7 +79,7 @@ const cache = new Map<string, CacheEntry>()
 /**
  * Cached variant. The cache key is `projectPath` + `maxDepth`: a depth change
  * invalidates the entry. The cache persists until `invalidateRepoCache()` or
- * process exit — discovery is one-shot per session per depth setting.
+ * process exit — discovery is one-shot per project per depth setting.
  */
 export async function discoverRepos(projectPath: string, maxDepth = 1): Promise<DiscoveredRepo[]> {
   const existing = cache.get(projectPath)

package/src/git/use-repo-discovery.ts

@@ -5,7 +5,7 @@ import { dispatchGlobal } from '../state/dispatch-ref'
 import { discoverRepos } from './repo-discovery'
 
 /**
- * Discover nested git repos inside `projectPath` once per session and push
+ * Discover nested git repos inside `projectPath` once per project and push
  * the result into state. No-op when the multi-repo config flag is off.
  */
 export function useRepoDiscovery(projectPath: string | undefined): void {

package/src/git/workspace-branch-poller.ts

@@ -0,0 +1,54 @@
+import { useEffect } from 'react'
+
+import { appStore } from '../state/app-store'
+import { dispatchGlobal } from '../state/dispatch-ref'
+import { getCurrentBranch } from '../ui/git-branch'
+
+const INTERVAL_MS = 4000
+
+// Single source of truth for "what git branch is each workspace on right now".
+// Polls every known workspace's path and dispatches update-workspace-record
+// when the live branch differs from the stored one. Components read
+// `workspace.branch` from state — no per-component polling, no flickers.
+//
+// Runs once when enabled; reads projects from the store on each tick so
+// project updates do NOT re-create the effect (which would otherwise feedback
+// off our own dispatches).
+export function useWorkspaceBranchPolling(enabled: boolean): void {
+  useEffect(() => {
+    if (!enabled) return
+
+    let cancelled = false
+    let timer: ReturnType<typeof setTimeout> | null = null
+
+    const tick = async () => {
+      const projects = appStore.getState().projects
+      await Promise.all(
+        projects.flatMap((project) =>
+          (project.workspaces ?? []).map(async (workspace) => {
+            if (workspace.path == null || workspace.path === '') return
+            const branch = await getCurrentBranch(workspace.path)
+            if (cancelled) return
+            if (branch != null && branch !== workspace.branch) {
+              dispatchGlobal({
+                patch: { branch },
+                projectId: project.id,
+                type: 'update-workspace-record',
+                workspaceId: workspace.id,
+              })
+            }
+          })
+        )
+      )
+      if (cancelled) return
+      timer = setTimeout(() => void tick(), INTERVAL_MS)
+    }
+
+    void tick()
+
+    return () => {
+      cancelled = true
+      if (timer != null) clearTimeout(timer)
+    }
+  }, [enabled])
+}

package/src/git/workspace-divergence-poller.ts

@@ -0,0 +1,65 @@
+import { useEffect } from 'react'
+
+import type { BranchDivergence } from '../state/types'
+
+import { useAppStore } from '../state/app-store'
+import { dispatchGlobal } from '../state/dispatch-ref'
+import { getBranchDivergence, getWorkspaceDiffStat } from './divergence'
+
+const INTERVAL_MS = 4000
+
+// Polls per-workspace base divergence for the current project while enabled and
+// dispatches it into workspaceDivergence. Only workspaces that record a baseRef
+// (the aimux-created ones) are measured; the primary and externally-discovered
+// workspaces have no recorded base and are left out.
+export function useWorkspaceDivergencePolling(enabled: boolean): void {
+  const currentProjectId = useAppStore((s) => s.currentProjectId)
+  const projects = useAppStore((s) => s.projects)
+
+  useEffect(() => {
+    if (!enabled) return
+    const project =
+      currentProjectId != null && currentProjectId !== ''
+        ? projects.find((s) => s.id === currentProjectId)
+        : undefined
+    const targets = (project?.workspaces ?? []).filter(
+      (w) => w.baseRef != null && w.baseRef !== '' && w.branch != null && w.branch !== ''
+    )
+    if (targets.length === 0) return
+
+    let cancelled = false
+    let timer: ReturnType<typeof setTimeout> | null = null
+
+    const tick = async () => {
+      const entries = await Promise.all(
+        targets.map(async (workspace) => {
+          const base = workspace.baseRef
+          const branch = workspace.branch
+          if (base == null || branch == null) return null
+          // Commits come from the repo root (comparing two refs); lines come
+          // from the workspace itself, so uncommitted work is counted too.
+          const [divergence, stat] = await Promise.all([
+            getBranchDivergence(workspace.repoRoot, base, branch),
+            getWorkspaceDiffStat(workspace.path, base),
+          ])
+          if (divergence == null) return null
+          return [workspace.id, { ...divergence, ...stat }] as const
+        })
+      )
+      if (cancelled) return
+      const next: Record<string, BranchDivergence> = {}
+      for (const entry of entries) {
+        if (entry != null) next[entry[0]] = entry[1]
+      }
+      dispatchGlobal({ divergence: next, type: 'set-workspace-divergence' })
+      timer = setTimeout(() => void tick(), INTERVAL_MS)
+    }
+
+    void tick()
+
+    return () => {
+      cancelled = true
+      if (timer != null) clearTimeout(timer)
+    }
+  }, [enabled, currentProjectId, projects])
+}

package/src/git/worktree.ts

@@ -69,6 +69,35 @@ export async function resolveGitRef(repoPath: string, ref: string): Promise<stri
   return result.text().trim() || undefined
 }
 
+// The branch a new workspace forks from unless the user picks another base.
+// `origin/HEAD` is the only authoritative answer; it is missing on repos cloned
+// with --no-checkout or created locally, hence the name probes behind it.
+export async function getDefaultBranch(repoPath: string): Promise<string | undefined> {
+  const head = await $`git -C ${repoPath} symbolic-ref --short refs/remotes/origin/HEAD`
+    .quiet()
+    .nothrow()
+  if (head.exitCode === 0) {
+    const ref = head.text().trim()
+    const short = ref.startsWith('origin/') ? ref.slice('origin/'.length) : ref
+    if (short !== '') return short
+  }
+  const locals = await listLocalBranches(repoPath)
+  return ['main', 'master'].find((name) => locals.includes(name))
+}
+
+// Rename a local branch. Returns false (without throwing) when git refuses —
+// the target name already exists, most likely — so a failed rename leaves the
+// workspace on the branch it was created with instead of losing it.
+export async function renameGitBranch(
+  repoPath: string,
+  from: string,
+  to: string
+): Promise<boolean> {
+  if (from === '' || to === '' || from === to) return false
+  const result = await $`git -C ${repoPath} branch -m ${from} ${to}`.quiet().nothrow()
+  return result.exitCode === 0
+}
+
 export async function createGitWorktree({
   baseRef,
   branchName,

package/src/index.tsx

@@ -5,7 +5,7 @@
 const command = process.argv[2]
 
 // Shell completion. First branch and cheapest: it loads the CLI registry and
-// nothing else — no daemon client, no session backend, no renderer.
+// nothing else — no daemon client, no project backend, no renderer.
 if (command === '__complete') {
   const { runComplete } = await import('./cli/completion/entry')
   process.exit(await runComplete(process.argv.slice(3)))
@@ -19,7 +19,7 @@ if (command === 'completion') {
 // CLI control plane (docs/reference/cli.md). Branch BEFORE the UI bootstrap so
 // `aimux tab list` from a non-TTY shell never spins up the React renderer.
 // Dynamic import keeps the CLI code out of the UI's cold-start cost.
-const CLI_GROUPS = new Set(['tab', 'workspace', 'worktree', 'worker'])
+const CLI_GROUPS = new Set(['tab', 'project', 'workspace', 'worker'])
 if (typeof command === 'string' && CLI_GROUPS.has(command)) {
   const { runCli } = await import('./cli')
   process.exit(await runCli(process.argv.slice(2)))
@@ -96,7 +96,7 @@ const [
   import('./session-backend/bootstrap'),
   import('./cli/completion/install'),
 ])
-const resolvedConfig = await loadUserConfig()
+const { resolved: resolvedConfig, user: userConfig } = await loadUserConfig()
 
 // First launch (and after every upgrade): drop the shell completion script in
 // the conventional location for $SHELL. Silent and best-effort — it writes one
@@ -154,4 +154,4 @@ const backend = await createSessionBackend({
 })
 logDebug('index.backendReady', { backend: backend.constructor.name, runtimeProfile })
 
-root.render(<App backend={backend} resolvedConfig={resolvedConfig} />)
+root.render(<App backend={backend} resolvedConfig={resolvedConfig} userConfig={userConfig} />)

package/src/input/keymap/help-entries.ts

@@ -11,15 +11,17 @@ export const HELP_MODE_LABELS: { modeId: ModeId; label: string }[] = [
   { label: 'Navigation', modeId: 'navigation' },
   { label: 'Terminal input', modeId: 'terminal-input' },
   { label: 'Git mode', modeId: 'git-mode' },
+  { label: 'Settings', modeId: 'settings' },
   { label: 'Git commit', modeId: 'modal.git-commit' },
   { label: 'New tab', modeId: 'modal.new-tab.command-edit' },
   { label: 'New tab — command', modeId: 'modal.new-tab.command-edit' },
-  { label: 'Workspace picker', modeId: 'modal.session-picker.filtering' },
-  { label: 'Workspace picker — filter', modeId: 'modal.session-picker.filtering' },
-  { label: 'Workspace name', modeId: 'modal.session-name' },
-  { label: 'Create workspace', modeId: 'modal.create-session' },
+  { label: 'Project picker', modeId: 'modal.project-picker.filtering' },
+  { label: 'Project picker — filter', modeId: 'modal.project-picker.filtering' },
+  { label: 'Project name', modeId: 'modal.project-name' },
+  { label: 'Create project', modeId: 'modal.create-project' },
+  { label: 'Create workspace', modeId: 'modal.create-workspace' },
   { label: 'Rename tab', modeId: 'modal.rename-tab' },
-  { label: 'Rename worktree', modeId: 'modal.rename-worktree' },
+  { label: 'Rename workspace', modeId: 'modal.rename-workspace' },
   { label: 'Snippet picker', modeId: 'modal.snippet-picker.filtering' },
   { label: 'Snippet picker — filter', modeId: 'modal.snippet-picker.filtering' },
   { label: 'Snippet editor', modeId: 'modal.snippet-editor' },