@brimveyn/aimux 1.20.4 → 1.22.0

package/src/pty/assistant-status-detector.ts

@@ -5,7 +5,7 @@
  * (https://github.com/ogulcancelik/herdr, MIT). Rule tables trace back to
  * `src/detect.rs` in that repo.
  *
- * The detector classifies a terminal session as `working`, `waiting-input`,
+ * The detector classifies a terminal project as `working`, `waiting-input`,
  * or `idle`. Built-in CLIs (claude, codex, opencode, grok, kimi) have dedicated
  * classify* functions. Custom CLIs fall back to a generic heuristic that
  * (a) recognises common shells as always-idle and (b) uses pane-tail change
@@ -51,6 +51,13 @@ export class AssistantStatusDetector {
     if (!viewport) return this.remember(tabId, '', now, 'idle')
 
     const tail = extractTailText(viewport, TAIL_LINE_COUNT)
+    // Whole visible screen. Claude's Ctrl+T todo overlay pushes the spinner
+    // status line above the 10-line tail, so "is it working" has to look at
+    // the full frame. "Is it waiting on me" stays tail-scoped.
+    // ponytail: a scrolled-away pane falls back to `viewport.tailLines`, capped
+    // at SNAPSHOT_TAIL_LINE_COUNT (10) — the overlay still hides the spinner
+    // there. Raise that constant if it bites; it grows every render payload.
+    const screen = extractTailText(viewport, viewport.lines.length)
     const prev = this.entries.get(tabId)
     const changedAt = prev && prev.tail === tail ? prev.changedAt : now
     const haystack = tail.toLowerCase()
@@ -59,7 +66,7 @@ export class AssistantStatusDetector {
       return this.remember(tabId, tail, changedAt, 'idle')
     }
 
-    const perCli = classifyBuiltin(assistant, haystack, tail)
+    const perCli = classifyBuiltin(assistant, haystack, tail, screen)
     if (perCli) return this.remember(tabId, tail, changedAt, perCli)
 
     const generic = classifyGeneric(haystack, changedAt, now)
@@ -129,11 +136,12 @@ function extractTailText(viewport: TerminalSnapshot, lineCount: number): string
 function classifyBuiltin(
   assistant: AssistantId,
   haystack: string,
-  rawTail: string
+  rawTail: string,
+  rawScreen: string
 ): TabActivity | null {
   switch (assistant) {
     case 'claude':
-      return classifyClaude(haystack, rawTail)
+      return classifyClaude(haystack, rawScreen)
     case 'codex':
       return classifyCodex(haystack)
     case 'opencode':
@@ -147,7 +155,15 @@ function classifyBuiltin(
   }
 }
 
-function classifyClaude(haystack: string, rawTail: string): TabActivity {
+/**
+ * `haystack` is the lowercased 10-line tail, `rawScreen` the whole visible
+ * frame. Prompts always land at the bottom, so waiting-input stays on the tail
+ * — widening it would let a "Do you want…" from the transcript above fake a
+ * pending question. Working markers get the full frame: with the Ctrl+T todo
+ * overlay open, Claude drops the `esc to interrupt` hint entirely and the
+ * spinner line sits above however many todos are listed.
+ */
+function classifyClaude(haystack: string, rawScreen: string): TabActivity {
   if (
     haystack.includes('do you want') ||
     haystack.includes('would you like') ||
@@ -157,15 +173,16 @@ function classifyClaude(haystack: string, rawTail: string): TabActivity {
   ) {
     return 'waiting-input'
   }
+  const screen = rawScreen.toLowerCase()
   if (
-    haystack.includes('esc/ctrl+c to interrupt') ||
-    haystack.includes('esc to interrupt') ||
-    haystack.includes('ctrl+c to interrupt') ||
-    haystack.includes('esc interrupt')
+    screen.includes('esc/ctrl+c to interrupt') ||
+    screen.includes('esc to interrupt') ||
+    screen.includes('ctrl+c to interrupt') ||
+    screen.includes('esc interrupt')
   ) {
     return 'working'
   }
-  if (hasClaudeSpinner(rawTail)) return 'working'
+  if (hasClaudeSpinner(rawScreen)) return 'working'
   return 'idle'
 }
 
@@ -174,8 +191,16 @@ function classifyClaude(haystack: string, rawTail: string): TabActivity {
 // separators Claude scatters mid-line through its header/footer (e.g.
 // `Opus 4.7 … · Claude Max`, `… · ← for agents`), which would otherwise pair
 // with a stray `...` placeholder and mark an idle home screen as working.
-function hasClaudeSpinner(rawTail: string): boolean {
-  for (const line of rawTail.split('\n')) {
+//
+// The ellipsis is also what separates a live status line (`✱ Flowing… (3s · …)`)
+// from a finished one left in the transcript (`✱ Sautéed for 10s`) — that's why
+// scanning the whole screen instead of the tail doesn't resurrect past turns.
+// ponytail: a spinner line frozen mid-`…` (interrupted turn) would pin the pane
+// to `working` until it scrolls off. Chosen failure direction — a false
+// `working` notifies nobody, a false `idle` fires a turn-complete. Cross-check
+// against screen-text velocity (the `(3s` timer ticks) if it ever shows up.
+function hasClaudeSpinner(rawText: string): boolean {
+  for (const line of rawText.split('\n')) {
     const trimmed = line.trimStart()
     const first = trimmed[0]
     if (first == null || !CLAUDE_SPINNER_GLYPH_SET.has(first)) continue
@@ -275,8 +300,8 @@ function classifyKimi(haystack: string, rawTail: string): TabActivity {
     haystack.includes('apply these edits?') ||
     haystack.includes('stop this task?') ||
     haystack.includes('ready to build with this plan?') ||
-    haystack.includes('approve for session') ||
-    haystack.includes('approve for this session') ||
+    haystack.includes('approve for project') ||
+    haystack.includes('approve for this project') ||
     haystack.includes('type feedback') ||
     haystack.includes('waiting for authorization') ||
     haystack.includes('sign in to kimi') ||
@@ -297,7 +322,7 @@ function classifyKimi(haystack: string, rawTail: string): TabActivity {
 
   // Agent actively streaming / calling tools.
   // Anchor thinking on ellipsis so the footer model suffix "thinking" alone
-  // (e.g. "kimi-k2 thinking") does not mark an idle session as working.
+  // (e.g. "kimi-k2 thinking") does not mark an idle project as working.
   if (
     haystack.includes('working...') ||
     haystack.includes('working…') ||

package/src/pty/command-registry.ts

@@ -1,3 +1,5 @@
+import { basename } from 'node:path'
+
 import type { AssistantId } from '../state/types'
 
 /**
@@ -22,6 +24,21 @@ export interface AssistantOption {
   command: string
   description: string
   model?: AssistantModelSpec
+  /**
+   * The CLI starts an interactive session with a positional prompt argument
+   * (`claude "…"`, `codex "…"`). When it does, handing the prompt over at spawn
+   * beats pasting it into the running TUI afterwards: no readiness poll, no
+   * screen probe, no retries.
+   *
+   * Absent means "unknown or not supported" and the caller falls back to
+   * `injectPromptWhenReady`. `opencode`'s positional is a project path and its
+   * `run` subcommand is non-interactive, so it stays on the fallback.
+   *
+   * ponytail: a boolean, because both CLIs that support it are positional.
+   * Promote to a builder — as `AssistantModelSpec` already does for flags — when
+   * a `--prompt <x>`-shaped one shows up.
+   */
+  acceptsPromptArg?: boolean
 }
 
 const DEFAULT_SHELL =
@@ -30,6 +47,7 @@ const SHELL_NAME = DEFAULT_SHELL.split('/').pop() ?? 'shell'
 
 export const ASSISTANT_OPTIONS: AssistantOption[] = [
   {
+    acceptsPromptArg: true,
     command: 'claude',
     description: 'Anthropic Claude CLI',
     id: 'claude',
@@ -40,6 +58,7 @@ export const ASSISTANT_OPTIONS: AssistantOption[] = [
     },
   },
   {
+    acceptsPromptArg: true,
     command: 'codex',
     description: 'OpenAI Codex CLI',
     id: 'codex',
@@ -116,12 +135,73 @@ export function getAllAssistantOptions(customCommands: Record<string, string>):
   return [...ASSISTANT_OPTIONS, ...customOptions]
 }
 
+/**
+ * Whether this assistant can take the initial prompt as a spawn argument.
+ *
+ * A custom command counts only while it still runs the same program — extra
+ * flags are fine, a wrapper is not. A wrapper that forgets `"$@"` would swallow
+ * the prompt with no error anywhere, and pasting works for any command, so the
+ * unrecognised executable falls back rather than gambling.
+ */
+export function assistantAcceptsPromptArg(
+  assistant: AssistantId,
+  customCommands: Record<string, string>
+): boolean {
+  const option = getAllAssistantOptions(customCommands).find((entry) => entry.id === assistant)
+  if (option?.acceptsPromptArg !== true) return false
+  const custom = customCommands[assistant]
+  if (custom == null || custom === '') return true
+  return basename(parseCommand(custom).executable) === option.command
+}
+
 export function isCommandAvailable(command: string): boolean {
   return Bun.which(command) !== null
 }
 
+/**
+ * Minimal POSIX shell-word splitter — respects single/double quotes and
+ * backslash escapes so values like `code --user-data-dir "/tmp/foo bar"` or a
+ * script path under a `$HOME` containing a space tokenize correctly.
+ * Does not expand variables or globs.
+ */
+export function shellSplit(input: string): string[] {
+  const out: string[] = []
+  let current = ''
+  let inSingle = false
+  let inDouble = false
+  let hasToken = false
+  for (let i = 0; i < input.length; i++) {
+    const c = input[i] ?? ''
+    if (!inSingle && !inDouble && /\s/.test(c)) {
+      if (hasToken) {
+        out.push(current)
+        current = ''
+        hasToken = false
+      }
+      continue
+    }
+    hasToken = true
+    if (c === "'" && !inDouble) {
+      inSingle = !inSingle
+    } else if (c === '"' && !inSingle) {
+      inDouble = !inDouble
+    } else if (c === '\\' && !inSingle && i + 1 < input.length) {
+      current += input[++i]
+    } else {
+      current += c
+    }
+  }
+  if (hasToken) out.push(current)
+  return out
+}
+
+/** Wrap a value so `shellSplit` (and a real shell) return it as one word. */
+export function shellQuote(value: string): string {
+  return `'${value.replaceAll("'", `'\\''`)}'`
+}
+
 export function parseCommand(commandString: string): { executable: string; args: string[] } {
-  const parts = commandString.trim().split(/\s+/).filter(Boolean)
+  const parts = shellSplit(commandString.trim())
   return { args: parts.slice(1), executable: parts[0] ?? '' }
 }
 

package/src/restart-terminal-manager.ts

@@ -21,7 +21,7 @@ export async function runRestartTerminalManager(): Promise<number> {
   const managerPid = await findTerminalManagerPid()
   if (managerPid !== null) {
     process.stdout.write(
-      `WARNING: killing terminal-manager (pid ${managerPid}) will kill live sessions.\n`
+      `WARNING: killing terminal-manager (pid ${managerPid}) will kill live projects.\n`
     )
     await killProcess(managerPid)
     process.stdout.write('Terminal-manager stopped.\n')

package/src/services/ai-usage/provider.ts

@@ -6,7 +6,14 @@ import { fetchClaudeUsage } from './adapters/claude'
 import { fetchCodexUsage } from './adapters/codex'
 import { loadCachedSnapshot, saveCachedSnapshot } from './cache'
 
-const DEFAULT_POLL_SECONDS = 60
+/**
+ * Claude's OAuth usage endpoint drops a caller polling faster than this into a
+ * punitive rate-limit bucket, which shows up as an indicator that stops updating
+ * rather than as an error. So it is the floor as well as the default, and it is
+ * not per-tool: one interval drives every tool in the list, and a Codex-only
+ * setup loses nothing measurable by refreshing a quota bar every three minutes.
+ */
+const MIN_POLL_SECONDS = 180
 const DEFAULT_TOOLS: AIUsageTool[] = ['claude', 'codex']
 
 export interface AIUsageServiceHandle {
@@ -28,7 +35,7 @@ export function startAIUsageService(
   onUpdate: (snap: UsageSnapshot) => void
 ): AIUsageServiceHandle {
   const tools = config.tools && config.tools.length > 0 ? config.tools : DEFAULT_TOOLS
-  const pollMs = Math.max(5, config.pollSeconds ?? DEFAULT_POLL_SECONDS) * 1000
+  const pollMs = Math.max(MIN_POLL_SECONDS, config.pollSeconds ?? MIN_POLL_SECONDS) * 1000
 
   let stopped = false
   let timer: ReturnType<typeof setTimeout> | null = null

package/src/services/ai-usage/spawn.ts

@@ -10,9 +10,11 @@ const DEFAULT_TIMEOUT_MS = 15_000
 export async function runCli(
   command: string,
   args: string[],
-  timeoutMs: number = DEFAULT_TIMEOUT_MS
+  timeoutMs: number = DEFAULT_TIMEOUT_MS,
+  cwd?: string
 ): Promise<CliResult> {
   const proc = Bun.spawn([command, ...args], {
+    cwd,
     stderr: 'pipe',
     stdin: 'ignore',
     stdout: 'pipe',

package/src/session-backend/bootstrap.ts

@@ -106,7 +106,7 @@ export async function probeDaemonProtocolCompatibility(
     const helloRequestId = crypto.randomUUID()
     const attachRequestId = crypto.randomUUID()
     const disposeRequestId = crypto.randomUUID()
-    const probeSessionId = `probe-${crypto.randomUUID()}`
+    const probeProjectId = `probe-${crypto.randomUUID()}`
     let daemonProcessVersion: string | undefined
     let daemonCapabilities: readonly string[] = []
     let daemonManagerSelectedVersion: number | undefined
@@ -167,9 +167,9 @@ export async function probeDaemonProtocolCompatibility(
                 id: attachRequestId,
                 payload: {
                   cols: 80,
+                  projectId: probeProjectId,
                   protocolVersion: message.payload.selectedVersion,
                   rows: 24,
-                  sessionId: probeSessionId,
                 },
                 type: 'attach',
               })
@@ -311,7 +311,7 @@ export async function createSessionBackend(opts?: {
     // Ring 3: prefer hot-reexec over the legacy stopTM+restart path when
     // the running daemon advertises `hotReexec` and the operator has opted
     // in via AIMUX_HOT_REEXEC=1. The terminal-manager and every PTY stay
-    // alive; the daemon binary swaps under them — no session-loss prompt.
+    // alive; the daemon binary swaps under them — no project-loss prompt.
     const reexecEnabled = process.env.AIMUX_HOT_REEXEC === '1'
     const daemonSupportsReexec =
       handshake.capabilities?.includes(IPC_CAPABILITY_HOT_REEXEC) ?? false
@@ -363,7 +363,7 @@ export async function createSessionBackend(opts?: {
 
     // We're about to kill the terminal-manager and every PTY — warn the UI
     // now so the user isn't surprised. The hot-reexec branch above never
-    // reaches this point, so the callback fires only when sessions really
+    // reaches this point, so the callback fires only when projects really
     // do die.
     await opts?.onBreakingUpdateRequired?.()
 

package/src/session-backend/local-session-backend.ts

@@ -2,11 +2,11 @@ import { EventEmitter } from 'node:events'
 
 import type {
   AssistantId,
+  ProjectSnapshotV1,
   TerminalModeState,
   TerminalSnapshot,
-  WorkspaceSnapshotV1,
 } from '../state/types'
-import type { ResizeOptions, SessionBackend, SessionBackendEvents } from './types'
+import type { ProjectBackendEvents, ResizeOptions, SessionBackend } from './types'
 
 import {
   type AutoRenameConfigSnapshot,
@@ -24,11 +24,11 @@ import {
 } from '../state/layout-resize'
 
 export class LocalSessionBackend
-  extends EventEmitter<SessionBackendEvents>
+  extends EventEmitter<ProjectBackendEvents>
   implements SessionBackend
 {
   private readonly sessionManager = new SessionManager()
-  private currentSessionId: string | null = null
+  private currentProjectId: string | null = null
   private readonly statusLoop: ReturnType<typeof runStatusDetectionLoop>
   /**
    * Per-tab snapshot gate. While `false`, render events from the underlying
@@ -36,8 +36,8 @@ export class LocalSessionBackend
    * the UI. The frontend lifts the gate once `usePaneSizeReport` has reported
    * the *actual* rendered pane size via `resizeTab({ confirmedFromMeasurement })`,
    * so the first snapshot the UI ever paints is sized against the real box —
-   * never against the open-loop chrome estimate used at session create / attach.
-   * A tab without an entry here is treated as ready (legacy paths, sessions
+   * never against the open-loop chrome estimate used at project create / attach.
+   * A tab without an entry here is treated as ready (legacy paths, projects
    * not subject to the gate). See plan: il-y-a-eu-stateful-boot.md.
    */
   private readonly paneReady = new Map<string, boolean>()
@@ -59,89 +59,92 @@ export class LocalSessionBackend
       updateTab: (tabId, patch) => {
         const found = this.findTab(tabId)
         if (!found) return
-        this.sessionManager.updateTabMetadata(found.sessionId, tabId, patch)
-        if (found.sessionId === this.currentSessionId) {
-          this.emit('tabMetadataUpdated', found.sessionId, tabId, patch)
+        this.sessionManager.updateTabMetadata(found.projectId, tabId, patch)
+        if (found.projectId === this.currentProjectId) {
+          this.emit('tabMetadataUpdated', found.projectId, tabId, patch)
         }
       },
     })
-    this.sessionManager.on('render', (sessionId, tabId, viewport, terminalModes) => {
-      if (sessionId !== this.currentSessionId) return
+    this.sessionManager.on('render', (projectId, tabId, viewport, terminalModes) => {
+      if (projectId !== this.currentProjectId) return
       if (this.paneReady.get(tabId) === false) {
         this.pendingRender.set(tabId, { terminalModes, viewport })
         return
       }
       this.emit('render', tabId, viewport, terminalModes)
     })
-    this.sessionManager.on('exit', (sessionId, tabId, exitCode) => {
-      if (sessionId === this.currentSessionId) {
+    this.sessionManager.on('exit', (projectId, tabId, exitCode) => {
+      if (projectId === this.currentProjectId) {
         this.emit('exit', tabId, exitCode)
       }
     })
-    this.sessionManager.on('error', (sessionId, tabId, message) => {
-      if (sessionId === this.currentSessionId) {
+    this.sessionManager.on('error', (projectId, tabId, message) => {
+      if (projectId === this.currentProjectId) {
         this.emit('error', tabId, message)
       }
     })
     this.statusLoop = runStatusDetectionLoop({
-      listSessions: () => this.sessionManager.listSessionIds(),
-      listTabs: (sessionId) => this.sessionManager.listTabs(sessionId),
-      onSessionStatus: (sessionId, status) => {
-        this.emit('sessionActivity', sessionId, status)
+      listProjects: () => this.sessionManager.listSessionIds(),
+      listTabs: (projectId) => this.sessionManager.listTabs(projectId),
+      onProjectStatus: (projectId, status) => {
+        this.emit('projectActivity', projectId, status)
       },
-      onTabStatus: (tabId, status, sessionId) => {
-        if (sessionId === this.currentSessionId) {
-          this.emit('tabActivity', tabId, status)
+      onTabStatus: (tabId, status, projectId, workspaceId) => {
+        if (projectId === this.currentProjectId) {
+          this.emit('tabActivity', tabId, status, workspaceId)
         }
       },
+      onTurnComplete: (tabId, projectId, _idleMs, workspaceId) => {
+        this.emit('tabTurnComplete', tabId, projectId, workspaceId)
+      },
     })
   }
 
   async attach(options: {
-    sessionId: string
+    projectId: string
     cols: number
     rows: number
-    workspaceSnapshot?: WorkspaceSnapshotV1
+    projectSnapshot?: ProjectSnapshotV1
   }) {
     logDebug('backend.local.attach', {
       cols: options.cols,
+      projectId: options.projectId,
       rows: options.rows,
-      sessionId: options.sessionId,
-      snapshotTabs: options.workspaceSnapshot?.tabs.length ?? 0,
+      snapshotTabs: options.projectSnapshot?.tabs.length ?? 0,
     })
-    this.currentSessionId = options.sessionId
-    const trees = getSnapshotTrees(options.workspaceSnapshot)
+    this.currentProjectId = options.projectId
+    const trees = getSnapshotTrees(options.projectSnapshot)
     const splitTrees = trees.filter((t) => t.type === 'split')
     if (splitTrees.length > 0) {
       const bounds = createTerminalBounds(options.cols, options.rows)
       forEachSplitPaneRect(splitTrees, bounds, (tabId, rect) => {
         const size = toTerminalContentSize(rect)
         this.gatePaneRender(tabId)
-        this.sessionManager.resizeTab(options.sessionId, tabId, size.cols, size.rows)
+        this.sessionManager.resizeTab(options.projectId, tabId, size.cols, size.rows)
       })
     } else {
-      this.sessionManager.resize(options.sessionId, options.cols, options.rows)
+      this.sessionManager.resize(options.projectId, options.cols, options.rows)
     }
     const attachResult = this.sessionManager.attachSession(
-      options.sessionId,
-      options.workspaceSnapshot
+      options.projectId,
+      options.projectSnapshot
     )
     for (const tab of attachResult.tabs) {
       this.gatePaneRender(tab.id)
       this.autoRename.register(tab)
     }
     // Run a synchronous classification pass so every tab's activity and the
-    // session-status snapshot are available to embed in the reply — mirrors
+    // project-status snapshot are available to embed in the reply — mirrors
     // the remote backend's behavior and keeps hydrate dispatches atomic on
     // the client side.
-    this.statusLoop.classifyNow(options.sessionId, this.sessionManager.listTabs(options.sessionId))
+    this.statusLoop.classifyNow(options.projectId, this.sessionManager.listTabs(options.projectId))
     const tabsWithActivity = attachResult.tabs.map((tab) => ({
       ...tab,
       activity: this.statusLoop.getTabStatus(tab.id) ?? tab.activity,
     }))
     return {
       activeTabId: attachResult.activeTabId,
-      initialSessionStatuses: this.statusLoop.snapshotSessions(),
+      initialProjectStatuses: this.statusLoop.snapshotProjects(),
       tabs: tabsWithActivity,
     }
   }
@@ -155,18 +158,18 @@ export class LocalSessionBackend
     cols: number
     rows: number
     cwd?: string
-    worktreeId?: string
+    workspaceId?: string
     autoRenameCandidate?: boolean
   }): void {
-    if (!(this.currentSessionId != null && this.currentSessionId !== '')) {
-      logDebug('backend.local.skipCreateWithoutSession', { tabId: options.tabId })
+    if (!(this.currentProjectId != null && this.currentProjectId !== '')) {
+      logDebug('backend.local.skipCreateWithoutProject', { tabId: options.tabId })
       return
     }
     logDebug('backend.local.createSession', {
-      sessionId: this.currentSessionId,
+      projectId: this.currentProjectId,
       tabId: options.tabId,
       title: options.title,
-      worktreeId: options.worktreeId ?? null,
+      workspaceId: options.workspaceId ?? null,
     })
     this.gatePaneRender(options.tabId)
     const autoRenameStatus = initialAutoRenameStatus(
@@ -174,7 +177,7 @@ export class LocalSessionBackend
       options.assistant,
       options.autoRenameCandidate === true
     )
-    this.sessionManager.createTab(this.currentSessionId, { ...options, autoRenameStatus })
+    this.sessionManager.createTab(this.currentProjectId, { ...options, autoRenameStatus })
     const tab = this.findTab(options.tabId)?.tab
     if (tab) this.autoRename.register(tab)
   }
@@ -197,17 +200,17 @@ export class LocalSessionBackend
   }
 
   write(tabId: string, input: string): void {
-    if (!(this.currentSessionId != null && this.currentSessionId !== '')) {
-      logDebug('backend.local.skipWriteWithoutSession', { inputLength: input.length, tabId })
+    if (!(this.currentProjectId != null && this.currentProjectId !== '')) {
+      logDebug('backend.local.skipWriteWithoutProject', { inputLength: input.length, tabId })
       return
     }
     logDebug('backend.local.write', {
       inputLength: input.length,
-      sessionId: this.currentSessionId,
+      projectId: this.currentProjectId,
       tabId,
     })
     this.autoRename.observeWrite(tabId, input)
-    this.sessionManager.write(this.currentSessionId, tabId, input)
+    this.sessionManager.write(this.currentProjectId, tabId, input)
   }
 
   renameTab(tabId: string, title: string): void {
@@ -215,80 +218,80 @@ export class LocalSessionBackend
     if (!found) return
     this.autoRename.manualRename(tabId)
     const patch = { autoRenameStatus: 'attempted' as const, title }
-    this.sessionManager.updateTabMetadata(found.sessionId, tabId, patch)
-    if (found.sessionId === this.currentSessionId) {
-      this.emit('tabMetadataUpdated', found.sessionId, tabId, patch)
+    this.sessionManager.updateTabMetadata(found.projectId, tabId, patch)
+    if (found.projectId === this.currentProjectId) {
+      this.emit('tabMetadataUpdated', found.projectId, tabId, patch)
     }
   }
 
   scrollViewport(tabId: string, deltaLines: number): void {
-    if (!(this.currentSessionId != null && this.currentSessionId !== '')) return
-    this.sessionManager.scroll(this.currentSessionId, tabId, deltaLines)
+    if (!(this.currentProjectId != null && this.currentProjectId !== '')) return
+    this.sessionManager.scroll(this.currentProjectId, tabId, deltaLines)
   }
 
   scrollViewportToBottom(tabId: string): void {
-    if (!(this.currentSessionId != null && this.currentSessionId !== '')) return
-    this.sessionManager.scrollToBottom(this.currentSessionId, tabId)
+    if (!(this.currentProjectId != null && this.currentProjectId !== '')) return
+    this.sessionManager.scrollToBottom(this.currentProjectId, tabId)
   }
 
   setActiveTab(tabId: string | null): void {
-    if (!(this.currentSessionId != null && this.currentSessionId !== '')) return
-    logDebug('backend.local.setActiveTab', { sessionId: this.currentSessionId, tabId })
-    this.sessionManager.setActiveTab(this.currentSessionId, tabId)
+    if (!(this.currentProjectId != null && this.currentProjectId !== '')) return
+    logDebug('backend.local.setActiveTab', { projectId: this.currentProjectId, tabId })
+    this.sessionManager.setActiveTab(this.currentProjectId, tabId)
   }
 
   resizeAll(cols: number, rows: number, options?: ResizeOptions): void {
-    if (!(this.currentSessionId != null && this.currentSessionId !== '')) return
-    this.sessionManager.resize(this.currentSessionId, cols, rows, options)
+    if (!(this.currentProjectId != null && this.currentProjectId !== '')) return
+    this.sessionManager.resize(this.currentProjectId, cols, rows, options)
   }
 
   resizeTab(tabId: string, cols: number, rows: number, options?: ResizeOptions): void {
-    if (!(this.currentSessionId != null && this.currentSessionId !== '')) return
-    this.sessionManager.resizeTab(this.currentSessionId, tabId, cols, rows, options)
+    if (!(this.currentProjectId != null && this.currentProjectId !== '')) return
+    this.sessionManager.resizeTab(this.currentProjectId, tabId, cols, rows, options)
     if (options?.confirmedFromMeasurement === true) {
       this.releasePaneRender(tabId)
     }
   }
 
   disposeSession(tabId: string): void {
-    if (!(this.currentSessionId != null && this.currentSessionId !== '')) return
-    logDebug('backend.local.disposeSession', { sessionId: this.currentSessionId, tabId })
+    if (!(this.currentProjectId != null && this.currentProjectId !== '')) return
+    logDebug('backend.local.disposeSession', { projectId: this.currentProjectId, tabId })
     this.paneReady.delete(tabId)
     this.pendingRender.delete(tabId)
     this.autoRename.unregister(tabId)
-    this.sessionManager.closeTab(this.currentSessionId, tabId)
+    this.sessionManager.closeTab(this.currentProjectId, tabId)
   }
 
   disposeAll(): void {
-    if (!(this.currentSessionId != null && this.currentSessionId !== '')) return
-    logDebug('backend.local.disposeAll', { sessionId: this.currentSessionId })
+    if (!(this.currentProjectId != null && this.currentProjectId !== '')) return
+    logDebug('backend.local.disposeAll', { projectId: this.currentProjectId })
     this.paneReady.clear()
     this.pendingRender.clear()
-    for (const tab of this.sessionManager.listTabs(this.currentSessionId)) {
+    for (const tab of this.sessionManager.listTabs(this.currentProjectId)) {
       this.autoRename.unregister(tab.id)
     }
-    this.sessionManager.disposeSession(this.currentSessionId)
+    this.sessionManager.disposeSession(this.currentProjectId)
   }
 
   destroy(keepSessions = true): void {
-    logDebug('backend.local.destroy', { keepSessions, sessionId: this.currentSessionId })
-    if (!keepSessions && this.currentSessionId != null && this.currentSessionId !== '') {
-      this.sessionManager.disposeSession(this.currentSessionId)
+    logDebug('backend.local.destroy', { keepSessions, projectId: this.currentProjectId })
+    if (!keepSessions && this.currentProjectId != null && this.currentProjectId !== '') {
+      this.sessionManager.disposeSession(this.currentProjectId)
     }
     this.statusLoop.stop()
-    this.currentSessionId = null
+    this.currentProjectId = null
   }
 
-  announceWorkspaceSwitched(_sessionId: string): void {
+  announceProjectSwitched(_projectId: string): void {
     // No daemon on the local backend, so there's no CLI to notify.
   }
 
   private findTab(
     tabId: string
-  ): { sessionId: string; tab: ReturnType<SessionManager['listTabs']>[number] } | null {
-    for (const sessionId of this.sessionManager.listSessionIds()) {
-      const tab = this.sessionManager.listTabs(sessionId).find((entry) => entry.id === tabId)
-      if (tab) return { sessionId, tab }
+  ): { projectId: string; tab: ReturnType<SessionManager['listTabs']>[number] } | null {
+    for (const projectId of this.sessionManager.listSessionIds()) {
+      const tab = this.sessionManager.listTabs(projectId).find((entry) => entry.id === tabId)
+      if (tab) return { projectId, tab }
     }
     return null
   }