@brimveyn/aimux 1.21.0 → 1.22.2

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

@@ -13,12 +13,25 @@ export async function runCli(
   timeoutMs: number = DEFAULT_TIMEOUT_MS,
   cwd?: string
 ): Promise<CliResult> {
-  const proc = Bun.spawn([command, ...args], {
-    cwd,
-    stderr: 'pipe',
-    stdin: 'ignore',
-    stdout: 'pipe',
-  })
+  let proc: Bun.Subprocess<'ignore', 'pipe', 'pipe'>
+  try {
+    proc = Bun.spawn([command, ...args], {
+      cwd,
+      stderr: 'pipe',
+      stdin: 'ignore',
+      stdout: 'pipe',
+    })
+  } catch (error) {
+    // posix_spawn throws — synchronously — for a missing binary AND for a cwd
+    // that no longer exists (a deleted project dir or a pruned worktree), and
+    // it names the binary in both. Uncaught, that took the whole app down.
+    return {
+      error: `${command}: ${String(error)}`.slice(0, 200),
+      ok: false,
+      stderr: '',
+      stdout: '',
+    }
+  }
 
   const timeout = setTimeout(() => {
     try {

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
   }