@brimveyn/aimux 1.23.4 → 1.23.6

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@brimveyn/aimux",
-  "version": "1.23.4",
+  "version": "1.23.6",
   "description": "A terminal multiplexer for AI CLIs. Run Claude, Codex, OpenCode, Kimi side-by-side with tabbed navigation, split panes, and persistent sessions.",
   "keywords": [
     "ai",
@@ -66,7 +66,7 @@
     "bump:terminal_manager": "bun run scripts/bump-protocol.ts terminal-manager"
   },
   "dependencies": {
-    "@brimveyn/aimux-config": "0.10.5",
+    "@brimveyn/aimux-config": "0.10.7",
     "@opentui/core": "^0.1.90",
     "@opentui/react": "^0.1.90",
     "@resvg/resvg-wasm": "^2.6.2",

package/src/app-runtime/navigation-actions.ts

@@ -7,6 +7,7 @@ import { saveProjectCatalog } from '../state/project-catalog'
 import {
   filterTabsForActiveWorkspace,
   getPrimaryWorkspace,
+  getSidebarWorkspaces,
   withActiveWorkspace,
 } from '../state/project-workspaces'
 import { appReducer } from '../state/store'
@@ -103,7 +104,9 @@ function buildSidebarItems(state: AppState): SidebarItem[] {
   )
   const items: SidebarItem[] = []
   for (const project of ordered) {
-    for (const workspace of project.workspaces ?? []) {
+    // `true`, for every project: a folded one keeps exactly the row j/k would
+    // land on, and that row is on screen the moment the cursor gets there.
+    for (const workspace of getSidebarWorkspaces(project, true)) {
       items.push({ projectId: project.id, workspaceId: workspace.id })
     }
   }

package/src/app-runtime/side-effects.ts

@@ -65,10 +65,12 @@ import {
   startExistingTab,
 } from './tab-actions'
 import {
+  hibernateWorkspace,
   isForceableWorkspaceDeleteError,
   runDeleteWorkspace,
   runMoveWorkspace,
   setProjectDefaultBaseRef,
+  toggleProjectCollapsed,
 } from './workspace-actions'
 import { launchPendingWorkspace, startWorkspaceCreation } from './workspace-launch'
 
@@ -389,6 +391,9 @@ export function executeSideEffect(effect: SideEffect, ctx: SideEffectContext): v
       backend.disposeSession(effect.tabId)
       return
     }
+    case 'hibernate-workspace':
+      hibernateWorkspace(ctx, effect.workspaceId)
+      return
     case 'restart-tab':
       restartTabSession(
         backend,
@@ -586,6 +591,10 @@ export function executeSideEffect(effect: SideEffect, ctx: SideEffectContext): v
       setProjectDefaultBaseRef(ctx, effect.projectId, effect.baseRef)
       return
     }
+    case 'toggle-project-collapsed': {
+      toggleProjectCollapsed(ctx, effect.projectId)
+      return
+    }
     case 'ask-agent-for-setup-script': {
       handleAskAgentForSetupScriptEffect(ctx)
       return

package/src/app-runtime/tab-actions.ts

@@ -5,6 +5,7 @@ import { logInputDebug } from '../debug/input-log'
 import { createPrefixedId } from '../platform/id'
 import {
   assistantAcceptsPromptArg,
+  buildAssistantSessionArgs,
   getAllAssistantOptions,
   getAssistantOption,
   isCommandAvailable,
@@ -65,6 +66,10 @@ export function createTabSession(
     buffer: '',
     command: customCommand ?? option.command,
     id: createTabId(),
+    // Minted up front, before the CLI has ever run, so the very first spawn can
+    // claim it. Only for assistants that can be told their session id — a shell
+    // tab would just carry a uuid nothing reads.
+    sessionId: option.session ? crypto.randomUUID() : undefined,
     status: 'starting',
     terminalModes: createDefaultTerminalModes(),
     title: option.label,
@@ -75,7 +80,7 @@ export function createTabSession(
 /** Everything `startTabSession` needs from the side-effect context. */
 type StartTabSessionContext = Pick<
   SideEffectContext,
-  'backend' | 'clearStartupGrace' | 'dispatch' | 'startStartupGrace'
+  'backend' | 'clearStartupGrace' | 'dispatch' | 'startStartupGrace' | 'state'
 >
 
 export interface StartTabSessionOptions {
@@ -95,7 +100,7 @@ export interface StartTabSessionOptions {
 
 export function startTabSession(
   ctx: StartTabSessionContext,
-  tab: Pick<TabSession, 'id' | 'assistant' | 'title' | 'command' | 'workspaceId'>,
+  tab: Pick<TabSession, 'id' | 'assistant' | 'title' | 'command' | 'sessionId' | 'workspaceId'>,
   { autoRenameCandidate = true, cols, cwd, extraArgs, rows }: StartTabSessionOptions
 ): void {
   const { backend, clearStartupGrace, dispatch } = ctx
@@ -111,6 +116,12 @@ export function startTabSession(
   ctx.startStartupGrace(tab.id, STARTUP_GRACE_MS)
 
   const { args, executable } = parseCommand(tab.command)
+  // Ahead of `extraArgs` because that is where an initial prompt goes, and the
+  // prompt is positional — a flag after it would be read as part of it.
+  const sessionArgs =
+    tab.sessionId == null
+      ? []
+      : buildAssistantSessionArgs(tab.assistant, ctx.state.customCommands, tab.sessionId)
 
   if (!isCommandAvailable(executable)) {
     clearStartupGrace(tab.id)
@@ -123,7 +134,7 @@ export function startTabSession(
   }
 
   backend.createSession({
-    args: extraArgs ? [...args, ...extraArgs] : args,
+    args: [...args, ...sessionArgs, ...(extraArgs ?? [])],
     assistant: tab.assistant,
     autoRenameCandidate,
     cols,

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

@@ -87,6 +87,17 @@ export function setProjectDefaultBaseRef(
   ctx.dispatch({ projects, type: 'set-projects' })
 }
 
+/** Fold or unfold a project's workspace rows in the sidebar. */
+export function toggleProjectCollapsed(ctx: SideEffectContext, projectId: string): void {
+  const projects = replaceProject(ctx, projectId, (entry) => ({
+    ...entry,
+    collapsed: entry.collapsed !== true ? true : undefined,
+    updatedAt: new Date().toISOString(),
+  }))
+  saveProjectCatalog(projects)
+  ctx.dispatch({ projects, type: 'set-projects' })
+}
+
 function normalizeBranchName(branch: string | undefined): string | undefined {
   return branch?.replace(/^refs\/heads\//, '').trim()
 }
@@ -203,6 +214,50 @@ function disposeWorkspaceTabs(ctx: SideEffectContext, workspaceId: string): void
   }
 }
 
+/**
+ * Put every idle assistant tab in a workspace to sleep: kill the PTY, keep the
+ * frozen screen, resume on focus. The RAM a workspace holds is its assistant
+ * processes — several hundred MB each — and none of it is aimux's own.
+ *
+ * A tab mid-turn is never touched. The lot is deliberately partial rather than
+ * all-or-nothing: one busy tab should not veto the other three, and the toast
+ * says what stayed up so the skip is never silent.
+ *
+ * ponytail: `activity` comes from reading the assistant's screen, so it sees a
+ * turn in progress but not a background task the assistant spawned. Manual-only
+ * for exactly that reason — you know what you left running; a timer would not.
+ */
+export function hibernateWorkspace(ctx: SideEffectContext, workspaceId: string): void {
+  const tabs = ctx.state.tabs.filter(
+    (tab) => tab.workspaceId === workspaceId && tab.role !== 'setup'
+  )
+  const sleepable = tabs.filter(
+    (tab) => (tab.status === 'running' || tab.status === 'starting') && tab.activity === 'idle'
+  )
+  const busy = tabs.filter(
+    (tab) => (tab.status === 'running' || tab.status === 'starting') && tab.activity !== 'idle'
+  )
+
+  for (const tab of sleepable) {
+    ctx.clearIdleTimer(tab.id)
+    ctx.clearStartupGrace(tab.id)
+    ctx.backend.disposeSession(tab.id)
+    ctx.dispatch({ tabId: tab.id, type: 'hibernate-tab' })
+  }
+
+  if (sleepable.length === 0) {
+    toast.info(
+      busy.length > 0 ? `Nothing to hibernate — ${busy.length} tab(s) busy` : 'Nothing to hibernate'
+    )
+    return
+  }
+  toast.success(
+    busy.length > 0
+      ? `Hibernated ${sleepable.length} tab(s), skipped ${busy.length} busy`
+      : `Hibernated ${sleepable.length} tab(s)`
+  )
+}
+
 export async function runDeleteWorkspace(
   ctx: SideEffectContext,
   projectId: string,
@@ -404,7 +459,11 @@ export function removeWorkspaceRecordFromProject(
 }
 
 export function isForceableWorkspaceDeleteError(message: string): boolean {
-  return /active assistant tabs|dirty|uncommitted|modified|untracked|not clean|contains.*changes/i.test(
+  // `force delete` is the marker `removeGitWorktree` appends to every refusal
+  // git raises: matching git's own wording never worked, since a broken worktree
+  // link fatals differently ("is not a working tree", "validation failed", …)
+  // depending on which part of the link broke.
+  return /active assistant tabs|dirty|uncommitted|modified|untracked|not clean|contains.*changes|force delete/i.test(
     message
   )
 }

package/src/app.tsx

@@ -49,7 +49,11 @@ 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 {
+  runSideEffectGlobal,
+  setActiveDispatch,
+  setActiveSideEffectRunner,
+} from './state/dispatch-ref'
 import { findMostRecentProject, loadProjectCatalog } from './state/project-catalog'
 import { getActiveWorkspacePath } from './state/project-workspaces'
 import { loadSnippetCatalog, mergeConfigSnippets } from './state/snippet-catalog'
@@ -484,6 +488,19 @@ export function App({
 
   useSetupRunner(state, sideEffectCtx)
 
+  // Waking is the counterpart of hibernating, and focus is the only signal it
+  // needs: you looked at the tab, so you want it back. Keyed on the id as well
+  // as the flag so switching between two sleeping tabs wakes the second one.
+  // `restart-tab` already does the whole job — dispose, reset, respawn — and the
+  // respawn now carries `--resume`, so the conversation comes back with it.
+  const wakeTabRef = useRef(activeTab)
+  wakeTabRef.current = activeTab
+  useEffect(() => {
+    const tab = wakeTabRef.current
+    if (tab?.hibernated !== true) return
+    runSideEffectGlobal({ tab, type: 'restart-tab' })
+  }, [activeTab?.id, activeTab?.hibernated])
+
   function processKeyResult(result: KeyResult, modeId: ModeId): void {
     for (const action of result.actions) {
       dispatch(action)

package/src/git/worktree.ts

@@ -1,5 +1,6 @@
 import { $ } from 'bun'
 import { existsSync } from 'node:fs'
+import { rm } from 'node:fs/promises'
 
 import { isInsideAimuxWorktreeRoot } from '../platform/worktree-paths'
 
@@ -227,7 +228,22 @@ export async function removeGitWorktree({
     await $`git -C ${repoPath} worktree prune`.quiet().nothrow()
     return
   }
-  throw new Error(result.stderr.toString().trim() || 'failed to remove git worktree')
+  // git refuses on states it cannot repair — a half-finished removal or a moved
+  // repo leaves a directory git no longer links to ("is not a working tree"),
+  // and no retry ever fixes it, so the row was undeletable forever. Force means
+  // "delete it regardless": finish the job ourselves. The path guard above
+  // already pinned the target inside the Aimux worktree root.
+  if (force) {
+    await rm(targetPath, { force: true, recursive: true })
+    await $`git -C ${repoPath} worktree prune`.quiet().nothrow()
+    return
+  }
+  // Every refusal git can raise here is force-recoverable — the directory lives
+  // under the Aimux worktree root and nothing else owns it — so the message
+  // carries the offer, and `isForceableWorkspaceDeleteError` keys off that
+  // phrase instead of trying to enumerate git's wording.
+  const stderr = result.stderr.toString().trim() || 'failed to remove git worktree'
+  throw new Error(`${stderr} — force delete to remove it anyway`)
 }
 
 export async function listGitWorktrees(repoPath: string): Promise<GitWorktreeInfo[]> {

package/src/input/modes/types.ts

@@ -108,6 +108,7 @@ export type SideEffect =
       keepConflicts?: boolean
     }
   | { type: 'load-workspace-move-stats' }
+  | { type: 'hibernate-workspace'; workspaceId: string }
   | { type: 'toggle-transparent' }
   | { type: 'toggle-mode' }
   | { type: 'open-file-in-editor'; path: string }
@@ -116,6 +117,7 @@ export type SideEffect =
   | { type: 'stop-setup' }
   | { type: 'configure-setup-script'; projectId?: string }
   | { type: 'set-project-default-base-ref'; projectId: string; baseRef: string }
+  | { type: 'toggle-project-collapsed'; projectId: string }
   | { type: 'ask-agent-for-setup-script' }
   | { type: 'promote-setup-tab' }
   /** Toggle a checkbox, cycle an enum, run a row's action — whatever the row is. */

package/src/pty/command-registry.ts

@@ -1,4 +1,5 @@
-import { basename } from 'node:path'
+import { homedir } from 'node:os'
+import { basename, join } from 'node:path'
 
 import type { AssistantId } from '../state/types'
 
@@ -18,12 +19,41 @@ export interface AssistantModelSpec {
   buildEffortArgs?: (effort: string) => string[]
 }
 
+/**
+ * How an assistant names a resumable conversation on the command line. Same
+ * philosophy as `AssistantModelSpec`: the vendor's flag syntax lives on the
+ * assistant definition, not in a resolver.
+ *
+ * Two builders because the two directions are different flags, not one flag
+ * with two meanings — `claude --session-id <uuid>` *claims* an id for a new
+ * conversation and errors with "Session ID … is already in use" if it exists,
+ * while `claude --resume <uuid>` refuses an id that does not. An assistant that
+ * can resume but cannot be told its id up front (codex: `codex resume <id>`,
+ * with no way to fix the id at spawn) has no entry here — its id would have to
+ * be discovered after the fact, which is a different mechanism.
+ */
+export interface AssistantSessionSpec {
+  /** Args that pin a fresh conversation to `sessionId`. */
+  buildSessionArgs: (sessionId: string) => string[]
+  /** Args that reopen the conversation `sessionId` names. */
+  buildResumeArgs: (sessionId: string) => string[]
+  /**
+   * Whether the vendor has a stored conversation under this id. Asking the
+   * filesystem is what lets one spawn path serve both directions: an id with a
+   * transcript resumes, an id without one is claimed fresh. Without it, a tab
+   * you opened and never typed into would resume into "No conversation found"
+   * and exit — and an exiting PTY takes the tab with it.
+   */
+  hasConversation: (sessionId: string) => boolean
+}
+
 export interface AssistantOption {
   id: AssistantId
   label: string
   command: string
   description: string
   model?: AssistantModelSpec
+  session?: AssistantSessionSpec
   /**
    * The CLI starts an interactive session with a positional prompt argument
    * (`claude "…"`, `codex "…"`). When it does, handing the prompt over at spawn
@@ -41,6 +71,23 @@ export interface AssistantOption {
   acceptsPromptArg?: boolean
 }
 
+/**
+ * A machine that has never run `claude` has no `~/.claude/projects`, and
+ * `scanSync` reports a missing cwd by throwing ENOENT rather than yielding
+ * nothing. "No directory" and "directory without this transcript" are the same
+ * answer here — there is no conversation to resume — so the throw is folded back
+ * into the false it should have been. Without this, the very first assistant tab
+ * on a fresh install dies at spawn.
+ */
+function hasClaudeTranscript(sessionId: string): boolean {
+  const cwd = join(homedir(), '.claude', 'projects')
+  try {
+    return new Bun.Glob(`*/${sessionId}.jsonl`).scanSync({ cwd }).next().done !== true
+  } catch {
+    return false
+  }
+}
+
 const DEFAULT_SHELL =
   process.env.SHELL != null && process.env.SHELL !== '' ? process.env.SHELL : 'sh'
 const SHELL_NAME = DEFAULT_SHELL.split('/').pop() ?? 'shell'
@@ -56,6 +103,14 @@ export const ASSISTANT_OPTIONS: AssistantOption[] = [
       buildEffortArgs: (effort) => ['--effort', effort],
       buildModelArgs: (model) => ['--model', model],
     },
+    session: {
+      buildResumeArgs: (sessionId) => ['--resume', sessionId],
+      buildSessionArgs: (sessionId) => ['--session-id', sessionId],
+      // `~/.claude/projects/<cwd-slug>/<uuid>.jsonl`. Globbing the slug away
+      // beats deriving it: the uuid alone is unique, so we never have to model
+      // how the vendor mangles a path into a directory name.
+      hasConversation: (sessionId) => hasClaudeTranscript(sessionId),
+    },
   },
   {
     acceptsPromptArg: true,
@@ -149,11 +204,53 @@ export function assistantAcceptsPromptArg(
 ): boolean {
   const option = getAllAssistantOptions(customCommands).find((entry) => entry.id === assistant)
   if (option?.acceptsPromptArg !== true) return false
-  const custom = customCommands[assistant]
+  return runsVendorProgram(option, customCommands)
+}
+
+/**
+ * Whether the configured command still runs the program the assistant's flags
+ * were written for. Extra flags are fine; a wrapper script is not, because any
+ * flag we append lands on the wrapper rather than the vendor CLI.
+ */
+function runsVendorProgram(
+  option: AssistantOption,
+  customCommands: Record<string, string>
+): boolean {
+  const custom = customCommands[option.id]
   if (custom == null || custom === '') return true
   return basename(parseCommand(custom).executable) === option.command
 }
 
+/**
+ * The args that tie a spawn to `sessionId` — resume when the vendor already has
+ * a conversation under that id, claim it otherwise.
+ *
+ * One function for both directions on purpose: every spawn site (new tab,
+ * split, Ctrl+r, waking a hibernated tab) wants the same thing — "be this
+ * conversation" — and the filesystem, not the call site, is what knows whether
+ * that conversation exists yet. A caller that had to pick would get it wrong
+ * exactly once: on the tab that was opened and never typed into.
+ *
+ * Empty for an assistant with no session support, and for a custom command
+ * that already bakes in its own session flags — doubling `--resume` is an error
+ * the vendor would report at spawn, long after the useful stack is gone.
+ */
+export function buildAssistantSessionArgs(
+  assistant: AssistantId,
+  customCommands: Record<string, string>,
+  sessionId: string
+): string[] {
+  if (sessionId === '') return []
+  const option = getAllAssistantOptions(customCommands).find((entry) => entry.id === assistant)
+  if (!option?.session) return []
+  if (!runsVendorProgram(option, customCommands)) return []
+  const custom = customCommands[assistant] ?? ''
+  if (/(^|\s)(-r|--resume|--session-id|--continue|-c)(\s|$)/.test(custom)) return []
+  return option.session.hasConversation(sessionId)
+    ? option.session.buildResumeArgs(sessionId)
+    : option.session.buildSessionArgs(sessionId)
+}
+
 export function isCommandAvailable(command: string): boolean {
   return Bun.which(command) !== null
 }

package/src/settings/live.ts

@@ -5,7 +5,7 @@ import { useMemo } from 'react'
 import { AUTO_COMMIT_ENABLED, AUTO_COMMIT_TIMEOUT } from './sections/automation'
 import { AUTO_COMMIT_MODEL_PREFIX, SNIPPET_TRIGGER_CHAR } from './sections/commands'
 import { ACTIVITY_SPRITES, HARMONIZE_CLAUDE_THEME } from './sections/experimental'
-import { AI_USAGE_ENABLED, AI_USAGE_POLL_SECONDS } from './sections/status-bar'
+import { AI_USAGE_ENABLED, AI_USAGE_POLL_SECONDS, HINTS_ENABLED } from './sections/status-bar'
 import { useSettingsStore } from './settings-store'
 
 /**
@@ -88,3 +88,8 @@ export function useHarmonizeClaudeTheme(fromConfigFile: boolean | undefined): bo
   const stored = useSettingsStore((s) => s.values[HARMONIZE_CLAUDE_THEME])
   return typeof stored === 'boolean' ? stored : fromConfigFile === true
 }
+
+/** Whether the status bar draws its second row of keybinding hints. */
+export function useStatusBarHints(): boolean {
+  return useSettingsStore((s) => s.values[HINTS_ENABLED] !== false)
+}

package/src/settings/sections/status-bar.ts

@@ -2,6 +2,7 @@ import { setStatusBarSeparator, type StatusBarSeparator } from '@brimveyn/aimux-
 
 import type { SettingSection } from '../types'
 
+export const HINTS_ENABLED = 'statusBar.hints'
 export const AI_USAGE_ENABLED = 'statusBar.aiUsage.enabled'
 export const AI_USAGE_POLL_SECONDS = 'statusBar.aiUsage.pollSeconds'
 
@@ -35,6 +36,15 @@ export const STATUS_BAR_SECTION: SettingSection = {
       options: SEPARATORS,
       storage: 'settings',
     },
+    {
+      description: 'The keybinding row under the bar. Off frees a line.',
+      fallback: true,
+      fromConfig: (config) => config.statusBar?.hints,
+      id: HINTS_ENABLED,
+      kind: 'toggle',
+      label: 'Keybinding hints',
+      storage: 'settings',
+    },
     {
       description: 'Show how much of your Claude or Codex quota is left.',
       fallback: false,

package/src/state/actions.ts

@@ -153,6 +153,7 @@ export type TabAction =
   | { type: 'reorder-active-tab'; delta: number }
   | { type: 'reorder-tabs'; orderedTabIds: string[] }
   | { type: 'reset-tab-project'; tabId: string }
+  | { type: 'hibernate-tab'; tabId: string }
   | {
       type: 'rename-tab'
       tabId: string

package/src/state/project-persistence.ts

@@ -62,6 +62,7 @@ export function serializeProject(state: AppState): ProjectSnapshotV1 {
         errorMessage: tab.errorMessage,
         exitCode: tab.exitCode,
         id: tab.id,
+        sessionId: tab.sessionId,
         status: tab.status === 'disconnected' ? 'running' : tab.status,
         terminalModes: tab.terminalModes,
         title: tab.title,
@@ -129,6 +130,7 @@ export function restoreTabsFromProject(
       errorMessage: tab.errorMessage,
       exitCode: tab.exitCode,
       id: tab.id,
+      sessionId: tab.sessionId,
       status: forceDisconnected ? getDisconnectedStatus(tab.status) : tab.status,
       terminalModes: tab.terminalModes,
       title: tab.title,

package/src/state/project-workspaces.ts

@@ -293,13 +293,13 @@ export function findWorkspace(
   return undefined
 }
 
+/** The workspace a project's cursor sits on: its active one, else the checkout. */
 export function getActiveWorkspace(
   project: ProjectRecord | undefined
 ): WorkspaceRecord | undefined {
-  if (!(project?.workspaces?.length != null && project?.workspaces?.length !== 0)) return undefined
   return (
-    project.workspaces.find((workspace) => workspace.id === project.activeWorkspaceId) ??
-    project.workspaces[0]
+    project?.workspaces?.find((workspace) => workspace.id === project.activeWorkspaceId) ??
+    getPrimaryWorkspace(project?.workspaces)
   )
 }
 
@@ -390,3 +390,23 @@ export function orderTabsByWorkspace(
     })
     .map((entry) => entry.tab)
 }
+
+/**
+ * The workspace rows a folded project still shows: just the one the cursor is
+ * on, so folding never hides the row you are standing on — and, for a project
+ * you are not in, nothing at all.
+ *
+ * Sidebar navigation calls this with `isCurrent: true` for every project: the
+ * moment j/k crosses into one it *is* current, and a project whose rows all
+ * vanished from the item list would be unreachable by keyboard.
+ */
+export function getSidebarWorkspaces(
+  project: ProjectRecord,
+  isCurrent: boolean
+): WorkspaceRecord[] {
+  const workspaces = project.workspaces ?? []
+  if (project.collapsed !== true) return workspaces
+  if (!isCurrent) return []
+  const active = getActiveWorkspace(project)
+  return active ? [active] : []
+}

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

@@ -531,6 +531,7 @@ export function reduceTabState(state: AppState, action: AppAction): AppState | n
             buffer: '',
             errorMessage: undefined,
             exitCode: undefined,
+            hibernated: undefined,
             status: 'starting',
             terminalModes: createDefaultTerminalModes(),
             viewport: undefined,
@@ -538,6 +539,20 @@ export function reduceTabState(state: AppState, action: AppAction): AppState | n
         },
         action.tabId
       )
+    case 'hibernate-tab':
+      // Deliberately keeps `buffer` and `viewport`: the frozen screen is the
+      // whole point — you should still see what the assistant last said. That is
+      // the one thing separating this from `reset-tab-project`, which wipes both
+      // because it is about to draw a live PTY over them.
+      return {
+        ...state,
+        tabs: updateTab(state.tabs, action.tabId, (tab) => ({
+          ...tab,
+          activity: 'idle',
+          hibernated: true,
+          status: 'disconnected',
+        })),
+      }
     case 'append-tab-buffer':
       return {
         ...state,

package/src/state/types.ts

@@ -42,8 +42,6 @@ export interface ProjectStatus {
   waiting: boolean
 }
 
-export const IDLE_PROJECT_STATUS: ProjectStatus = { waiting: false, working: false }
-
 /**
  * A workspace's status, as the sidebar draws it. `working`/`waiting` mirror
  * `ProjectStatus` one level down; `done` is a latch — an assistant here
@@ -153,6 +151,8 @@ export interface PersistedTabSnapshot {
   assistant: AssistantId
   title: string
   command: string
+  /** Optional and additive: an older build ignores it and spawns fresh. */
+  sessionId?: string
   status: Exclude<LegacyPersistedTabStatus, 'disconnected'>
   buffer: string
   viewport?: TerminalSnapshot
@@ -226,6 +226,12 @@ export interface ProjectRecord {
    * answers. Unset means the repo's default branch.
    */
   defaultBaseRef?: string
+  /**
+   * Folded in the sidebar: the project's workspace rows are hidden, bar the one
+   * the cursor is on. Persisted, because a fold you have to redo on every start
+   * is worse than no fold at all.
+   */
+  collapsed?: boolean
 }
 
 export interface ProjectBarState {
@@ -242,6 +248,25 @@ export interface TabSession {
   viewport?: TerminalSnapshot
   terminalModes: TerminalModeState
   command: string
+  /**
+   * Names the assistant conversation this tab owns, so a respawn reopens it
+   * instead of starting over. Minted when the tab is created and handed to the
+   * CLI at spawn — we pick the id rather than discover it afterwards, because
+   * discovery cannot tell two tabs sharing a cwd apart.
+   *
+   * Absent on tabs created before this existed, and on assistants with no
+   * session support; both spawn exactly as they always did.
+   */
+  sessionId?: string
+  /**
+   * Deliberately put to sleep: the PTY is gone, the frozen viewport stays, and
+   * focusing the tab resumes it. Distinct from the `disconnected` it rides on —
+   * that also means "restored from a snapshot after a restart" — and only used
+   * to tell the two apart in the sidebar glyph, the pane overlay, and the wake.
+   * Ephemeral — never persisted, never on the wire: a restart turns every tab
+   * disconnected anyway, and Ctrl+r resumes them just the same.
+   */
+  hibernated?: boolean
   errorMessage?: string
   exitCode?: number
   workspaceId?: string

package/src/state/validation.ts

@@ -181,7 +181,8 @@ export function isProjectRecord(value: unknown): value is ProjectRecord {
     (value.workspaces === undefined ||
       (Array.isArray(value.workspaces) && value.workspaces.every(isWorkspaceRecord))) &&
     (value.activeWorkspaceId === undefined || isString(value.activeWorkspaceId)) &&
-    (value.defaultBaseRef === undefined || isString(value.defaultBaseRef))
+    (value.defaultBaseRef === undefined || isString(value.defaultBaseRef)) &&
+    (value.collapsed === undefined || isBoolean(value.collapsed))
   )
 }
 

package/src/ui/components/layout/bar-footer.tsx

@@ -0,0 +1,74 @@
+import type { MouseEvent as OtuiMouseEvent } from '@opentui/core'
+
+import { useCallback } from 'react'
+
+import { dispatchGlobal } from '../../../state/dispatch-ref'
+import { useTheme } from '../../theme'
+
+/**
+ * U+2699, not the nerd-font gear: its Emoji_Presentation is No, so a conforming
+ * terminal draws it text-style in one cell and no font has to be installed for
+ * the one button that opens the settings.
+ */
+const SETTINGS_GLYPH = '⚙'
+/**
+ * U+25A4, chosen on the same rule as the gear above: one cell, text presentation,
+ * present in the base fonts. A ▁▄█ mini bar chart reads better but is three cells
+ * wide, which pushes this row past a narrow sidebar.
+ */
+const STATS_GLYPH = '▤'
+const SETTINGS_LABEL = `${SETTINGS_GLYPH} Settings`
+const STATS_LABEL = `${STATS_GLYPH} Stats`
+/** The two entries and the gap between them, so a renamed label re-measures itself. */
+const FOOTER_GAP = 2
+const FOOTER_FULL_WIDTH = SETTINGS_LABEL.length + FOOTER_GAP + STATS_LABEL.length
+/** The row's own left and right padding. */
+const FOOTER_PAD = 2
+
+/**
+ * The bar's bottom bar: settings and stats, pinned under every widget in the
+ * column rather than living inside whichever widget happens to be last. These
+ * are the only full-screen views the panes step aside for that a mouse can
+ * reach at all, so they need a slot that is on screen whenever the bar is.
+ */
+export function BarFooter({ contentWidth }: { contentWidth: number }) {
+  const t = useTheme()
+
+  const handleOpenSettings = useCallback((e: OtuiMouseEvent) => {
+    e.stopPropagation()
+    e.preventDefault()
+    dispatchGlobal({ type: 'enter-settings' })
+  }, [])
+
+  const handleOpenStats = useCallback((e: OtuiMouseEvent) => {
+    e.stopPropagation()
+    e.preventDefault()
+    dispatchGlobal({ type: 'enter-stats' })
+  }, [])
+
+  // The bar clamps down to 18 columns, narrower than both labels together, so
+  // below that the second entry drops to its glyph rather than being sliced
+  // mid-word by the overflow.
+  const statsLabel = contentWidth - FOOTER_PAD >= FOOTER_FULL_WIDTH ? STATS_LABEL : STATS_GLYPH
+
+  return (
+    <box flexDirection="column" flexShrink={0}>
+      <box flexShrink={0}>
+        <text fg={t.border} selectable={false} wrapMode="none">
+          {'─'.repeat(Math.max(1, contentWidth))}
+        </text>
+      </box>
+      {/* Each entry is its own <text>, with a spacer box between them: one string
+          holding both would make the whole footer a single click target. */}
+      <box flexDirection="row" flexShrink={0} paddingLeft={1} paddingRight={1}>
+        <text fg={t.textMuted} selectable={false} wrapMode="none" onMouseDown={handleOpenSettings}>
+          {SETTINGS_LABEL}
+        </text>
+        <box width={FOOTER_GAP} flexShrink={1} />
+        <text fg={t.textMuted} selectable={false} wrapMode="none" onMouseDown={handleOpenStats}>
+          {statsLabel}
+        </text>
+      </box>
+    </box>
+  )
+}

package/src/ui/components/layout/bar.tsx

@@ -11,6 +11,7 @@ import { useTheme } from '../../theme'
 import { WIDGET_RENDERERS } from '../../widgets/registry'
 import { buildBarContextMenu, buildWidgetContextMenu } from '../../widgets/widget-context-menu'
 import { ContextMenuBox } from '../overlays/context-menu/context-menu-box'
+import { BarFooter } from './bar-footer'
 
 export interface BarBoundaryResizeInfo {
   containerStart: number
@@ -119,6 +120,7 @@ export function Bar({
       {side === 'right' ? edge : null}
       <box width={contentWidth} flexGrow={1} flexDirection="column" overflow="hidden">
         {body}
+        {side === 'left' ? <BarFooter contentWidth={contentWidth} /> : null}
       </box>
       {side === 'left' ? edge : null}
     </ContextMenuBox>

package/src/ui/components/layout/sidebar/project-list.tsx

@@ -6,13 +6,15 @@ import type {
 
 import { memo, type ReactNode, useCallback, useMemo, useRef, useState } from 'react'
 
-import type { ProjectRecord, ProjectStatus } from '../../../../state/types'
+import type { ProjectRecord } from '../../../../state/types'
 
 import { useAppStore } from '../../../../state/app-store'
 import { dispatchGlobal, runSideEffectGlobal } from '../../../../state/dispatch-ref'
-import { getPrimaryWorkspace } from '../../../../state/project-workspaces'
-// eslint-disable-next-line no-duplicate-imports
-import { IDLE_PROJECT_STATUS } from '../../../../state/types'
+import {
+  getActiveWorkspace,
+  getPrimaryWorkspace,
+  getSidebarWorkspaces,
+} from '../../../../state/project-workspaces'
 import { moveIdToInsertIndex, orderProjectsForDisplay } from '../../../project-ordering'
 import { useBaseTheme, useTheme } from '../../../theme'
 import { truncate } from '../../../truncate'
@@ -31,25 +33,9 @@ const RULE = '─'
 /** Heavier than the chrome rules, so the drop preview never reads as a border. */
 const DROP_BAR = '━'
 const HEADER_TITLE = 'Projects'
-/**
- * U+2699, not the nerd-font gear: its Emoji_Presentation is No, so a conforming
- * terminal draws it text-style in one cell and no font has to be installed for
- * the one button that opens the settings.
- */
-const SETTINGS_GLYPH = '⚙'
-/**
- * U+25A4, chosen on the same rule as the gear above: one cell, text presentation,
- * present in the base fonts. A ▁▄█ mini bar chart reads better but is three cells
- * wide, which pushes this row past a narrow sidebar.
- */
-const STATS_GLYPH = '▤'
-const SETTINGS_LABEL = `${SETTINGS_GLYPH} Settings`
-const STATS_LABEL = `${STATS_GLYPH} Stats`
-/** The two entries and the gap between them, so a renamed label re-measures itself. */
-const FOOTER_GAP = 2
-const FOOTER_FULL_WIDTH = SETTINGS_LABEL.length + FOOTER_GAP + STATS_LABEL.length
-/** The row's own left and right padding. */
-const FOOTER_PAD = 2
+/** Same pair the git panel folds its directories with, so the gesture reads once. */
+const COLLAPSED_GLYPH = '▸ '
+const EXPANDED_GLYPH = '▾ '
 
 interface DragState {
   id: string
@@ -61,7 +47,6 @@ export function ProjectList({ contentWidth }: ProjectListProps) {
   const t = useTheme()
   const projects = useAppStore((s) => s.projects)
   const currentProjectId = useAppStore((s) => s.currentProjectId)
-  const statusMap = useAppStore((s) => s.projectStatuses)
 
   // The drag lives in a ref because mouse events can arrive before React has
   // committed the state they set — reading `draggingId` out of a handler
@@ -90,11 +75,7 @@ export function ProjectList({ contentWidth }: ProjectListProps) {
   // The cursor is always on a workspace row now, so there is one id to scroll
   // to instead of two — otherwise it visually "disappears" off-screen when a
   // key press crosses a project boundary.
-  const rawActiveWorkspaceId = currentProject?.activeWorkspaceId
-  const activeWorkspaceId =
-    rawActiveWorkspaceId != null && rawActiveWorkspaceId !== ''
-      ? rawActiveWorkspaceId
-      : getPrimaryWorkspace(currentProject?.workspaces)?.id
+  const activeWorkspaceId = getActiveWorkspace(currentProject)?.id
   const activeRowId =
     activeWorkspaceId != null && activeWorkspaceId !== '' ? `sidebar-wt-${activeWorkspaceId}` : null
 
@@ -187,28 +168,7 @@ export function ProjectList({ contentWidth }: ProjectListProps) {
     dispatchGlobal({ returnToProjectPicker: false, type: 'open-create-project-modal' })
   }, [])
 
-  // The settings screen's only mouse-reachable way in. It lives here because this
-  // header is on screen whenever the left bar is, and because the `+` beside it
-  // already taught the same gesture.
-  const handleOpenSettings = useCallback((e: OtuiMouseEvent) => {
-    e.stopPropagation()
-    e.preventDefault()
-    dispatchGlobal({ type: 'enter-settings' })
-  }, [])
-
-  // Stats sits beside it for the same reason, and because the two are the only
-  // full-screen views the panes step aside for that a mouse can reach at all.
-  const handleOpenStats = useCallback((e: OtuiMouseEvent) => {
-    e.stopPropagation()
-    e.preventDefault()
-    dispatchGlobal({ type: 'enter-stats' })
-  }, [])
-
   const rule = RULE.repeat(Math.max(1, contentWidth))
-  // The bar clamps down to 18 columns, narrower than both labels together, so
-  // below that the second entry drops to its glyph rather than being sliced
-  // mid-word by the overflow.
-  const statsLabel = contentWidth - FOOTER_PAD >= FOOTER_FULL_WIDTH ? STATS_LABEL : STATS_GLYPH
 
   return (
     // Drag and release are handled here, not on the row that started them:
@@ -253,15 +213,11 @@ export function ProjectList({ contentWidth }: ProjectListProps) {
           for (const [index, project] of ordered.entries()) {
             const projectIndex = index + 1
             const isCurrentProject = project.id === currentProjectId
-            const workspaces = project.workspaces ?? []
             // Every workspace gets a row, the checkout included. Folding it into
             // the project row made one row mean two things — a project you
             // switch to and a workspace you run tabs in — and left the checkout
             // the only workspace with no branch and no churn on screen.
-            const activeWorkspaceId =
-              project.activeWorkspaceId != null && project.activeWorkspaceId !== ''
-                ? project.activeWorkspaceId
-                : getPrimaryWorkspace(workspaces)?.id
+            const activeWorkspaceId = getActiveWorkspace(project)?.id
             rows.push(
               // Every project already had a blank line above it, which doubles
               // as the gap under the header. The drop bar is drawn *in* that
@@ -280,13 +236,12 @@ export function ProjectList({ contentWidth }: ProjectListProps) {
                 project={project}
                 inCurrentGroup={isCurrentProject}
                 projectIndex={projectIndex}
-                status={statusMap[project.id] ?? IDLE_PROJECT_STATUS}
                 dragging={draggingId === project.id}
                 contentWidth={contentWidth}
                 onDragStart={handleRowDragStart}
               />
             )
-            for (const workspace of workspaces) {
+            for (const workspace of getSidebarWorkspaces(project, isCurrentProject)) {
               rows.push(
                 <WorkspaceRow
                   key={`wt:${workspace.id}`}
@@ -313,22 +268,6 @@ export function ProjectList({ contentWidth }: ProjectListProps) {
           return rows
         })()}
       </scrollbox>
-      <box flexShrink={0}>
-        <text fg={t.border} selectable={false} wrapMode="none">
-          {rule}
-        </text>
-      </box>
-      {/* Each entry is its own <text>, with a spacer box between them: one string
-          holding both would make the whole footer a single click target. */}
-      <box flexDirection="row" flexShrink={0} paddingLeft={1} paddingRight={1}>
-        <text fg={t.textMuted} selectable={false} wrapMode="none" onMouseDown={handleOpenSettings}>
-          {SETTINGS_LABEL}
-        </text>
-        <box width={FOOTER_GAP} flexShrink={1} />
-        <text fg={t.textMuted} selectable={false} wrapMode="none" onMouseDown={handleOpenStats}>
-          {statsLabel}
-        </text>
-      </box>
     </box>
   )
 }
@@ -370,7 +309,6 @@ interface ProjectRowProps {
   inCurrentGroup: boolean
   /** 1-based index in the visible order, so the "+" can switch projects first. */
   projectIndex: number
-  status: ProjectStatus
   dragging: boolean
   contentWidth: number
   /** Only the gesture's start lives here — the list owns drag and release. */
@@ -384,25 +322,11 @@ const ProjectRow = memo(function ProjectRow({
   onDragStart,
   project,
   projectIndex,
-  status,
 }: ProjectRowProps) {
   const t = useTheme()
   // Selection highlight must stay opaque in transparent mode — otherwise the
   // cursor row visually disappears against the see-through chrome.
   const base = useBaseTheme()
-  // State belongs on the workspace rows: they say *which* one is working or
-  // waiting, and this heading can only say "somewhere below". So the heading
-  // speaks only when none of its workspaces can — a tab whose workspace this
-  // client doesn't know, which today means a daemon still running a pre-v18
-  // protocol. Without that fallback the sidebar would go silent instead of
-  // degrading.
-  const workspacesSpeak = useAppStore((s) =>
-    (project.workspaces ?? []).some((workspace) => {
-      const activity = s.workspaceActivity[workspace.id]
-      return activity !== undefined && (activity.working || activity.waiting || activity.done)
-    })
-  )
-  const showWaiting = status.waiting && !workspacesSpeak
   // Only the drag highlight is "selected"-strength here. A heading that lights
   // up like a cursor row is what made the project look like a workspace.
   let bgColor: string | undefined
@@ -411,7 +335,6 @@ const ProjectRow = memo(function ProjectRow({
   } else if (inCurrentGroup) {
     bgColor = base.backgroundPanel
   }
-  const waitingColor = t.warning
   const currentProjectId = useAppStore((s) => s.currentProjectId)
 
   const handleMouseDown = useCallback(
@@ -422,6 +345,16 @@ const ProjectRow = memo(function ProjectRow({
     },
     [onDragStart, project.id]
   )
+  // stopPropagation keeps the row's own mousedown from starting a drag, so the
+  // release never falls through to switching project — same trick as the "+".
+  const handleToggleCollapsed = useCallback(
+    (e: OtuiMouseEvent) => {
+      e.preventDefault()
+      e.stopPropagation()
+      runSideEffectGlobal({ projectId: project.id, type: 'toggle-project-collapsed' })
+    },
+    [project.id]
+  )
   const handleNewWorkspace = useCallback(
     (e: OtuiMouseEvent) => {
       e.preventDefault()
@@ -457,17 +390,11 @@ const ProjectRow = memo(function ProjectRow({
     [project.id, project.name]
   )
 
-  // Neutral muted marker, and a question when a workspace of this project needs
-  // an answer. No progress indicator: a heading can only say "somewhere below",
-  // and the row that actually knows is one line down. Keeping a glyph in the slot
-  // avoids name shifts when the question comes and goes — which is also why the
-  // gap after it is part of the glyph.
-  let leadingGlyph = '• '
-  let leadingColor = t.textMuted
-  if (showWaiting) {
-    leadingGlyph = '? '
-    leadingColor = waitingColor
-  }
+  // The slot used to carry a status marker, which only ever said "somewhere
+  // below" — the workspace rows one line down say it precisely. It now carries
+  // the fold arrow instead, and the trailing space is part of the glyph so the
+  // name never shifts.
+  const leadingGlyph = project.collapsed === true ? COLLAPSED_GLYPH : EXPANDED_GLYPH
 
   // No branch line: the repo checkout is not somewhere aimux works, so naming
   // it under every project only ever read as "you are on main".
@@ -485,7 +412,12 @@ const ProjectRow = memo(function ProjectRow({
       onMouseDown={handleMouseDown}
     >
       <box flexDirection="row" alignItems="center">
-        <text fg={leadingColor} selectable={false} wrapMode="none">
+        <text
+          fg={t.textMuted}
+          selectable={false}
+          wrapMode="none"
+          onMouseDown={handleToggleCollapsed}
+        >
           {leadingGlyph}
         </text>
         <FlashLabelBadge rowKey={`ws:${project.id}`} />

package/src/ui/components/layout/sidebar/workspace-row.tsx

@@ -62,6 +62,10 @@ export const WorkspaceRow = memo(function WorkspaceRow({
   // Only the working case animates, so the timer is off for every other row —
   // and off entirely when a sprite is drawing this row instead.
   const spinner = useBusySpinner(activity.working && sprite === null)
+  // A primitive, so the selector stays referentially stable across renders.
+  const hasSleepingTabs = useAppStore((s) =>
+    s.tabs.some((tab) => tab.workspaceId === workspace.id && tab.hibernated === true)
+  )
 
   const handleMouseDown = useCallback(
     (event: OtuiMouseEvent) => {
@@ -102,6 +106,10 @@ export const WorkspaceRow = memo(function WorkspaceRow({
           }),
       ],
     ]
+    entries.push([
+      'Hibernate',
+      () => runSideEffectGlobal({ type: 'hibernate-workspace', workspaceId: workspace.id }),
+    ])
     if (workspace.source !== 'primary') {
       entries.push([
         'Remove workspace',
@@ -184,6 +192,12 @@ export const WorkspaceRow = memo(function WorkspaceRow({
   } else if (activity.done) {
     statusGlyph = '● '
     statusColor = t.success
+  } else if (hasSleepingTabs) {
+    // Last, because anything else is news and this is the absence of it. Without
+    // a marker a hibernated workspace is indistinguishable from an idle one, and
+    // you would not know which rows still hold a running assistant.
+    statusGlyph = 'z '
+    statusColor = t.textMuted
   }
 
   return (

package/src/ui/components/layout/status-bar.tsx

@@ -7,6 +7,7 @@ import {
 import type { AppState } from '../../../state/types'
 
 import { version as APP_VERSION } from '../../../../package.json'
+import { useStatusBarHints } from '../../../settings/live'
 import { useAIUsageStore } from '../../../state/ai-usage-store'
 import { useAppStore } from '../../../state/app-store'
 import { useKeymap } from '../../keymap-context'
@@ -124,6 +125,7 @@ export function StatusBar() {
   const modeColor = getModeColor(state.focusMode, t)
   const ambient = composeAmbient(model.right, model.help)
   const aiEnabled = useAIUsageStore((s) => s.enabled)
+  const showHints = useStatusBarHints()
 
   const glyphs = SEPARATOR_GLYPHS[getStatusBarSeparator()]
 
@@ -137,7 +139,7 @@ export function StatusBar() {
 
   return (
     <box
-      height={2}
+      height={showHints ? 2 : 1}
       flexShrink={0}
       overflow="hidden"
       flexDirection="column"
@@ -201,20 +203,22 @@ export function StatusBar() {
       </box>
 
       {/* Row 2 — ambient hints */}
-      <box
-        height={1}
-        flexShrink={0}
-        flexDirection="row"
-        paddingLeft={ROW2_INDENT}
-        paddingRight={1}
-        overflow="hidden"
-      >
-        {ambient !== '' ? (
-          <text fg={t.textMuted} wrapMode="none" selectable={false}>
-            {ambient}
-          </text>
-        ) : null}
-      </box>
+      {showHints ? (
+        <box
+          height={1}
+          flexShrink={0}
+          flexDirection="row"
+          paddingLeft={ROW2_INDENT}
+          paddingRight={1}
+          overflow="hidden"
+        >
+          {ambient !== '' ? (
+            <text fg={t.textMuted} wrapMode="none" selectable={false}>
+              {ambient}
+            </text>
+          ) : null}
+        </box>
+      ) : null}
     </box>
   )
 }

package/src/ui/components/layout/terminal-pane.tsx

@@ -573,7 +573,11 @@ export function TerminalPane({
         // re-introducing the shifted-content / dead-row bug.
         <box position="absolute" bottom={0} left={0} backgroundColor={editorBg}>
           {tab?.status === 'disconnected' ? (
-            <text fg={t.warning}>Restored snapshot. Press Ctrl+r to restart this project.</text>
+            <text fg={t.warning}>
+              {tab.hibernated === true
+                ? 'Hibernated. Resuming…'
+                : 'Restored snapshot. Press Ctrl+r to restart this tab.'}
+            </text>
           ) : null}
           {tab?.errorMessage != null && tab?.errorMessage !== '' ? (
             <text fg={t.error}>{tab.errorMessage}</text>