@brimveyn/aimux 1.23.1 → 1.23.4

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@brimveyn/aimux",
-  "version": "1.23.1",
+  "version": "1.23.4",
   "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.2",
+    "@brimveyn/aimux-config": "0.10.5",
     "@opentui/core": "^0.1.90",
     "@opentui/react": "^0.1.90",
     "@resvg/resvg-wasm": "^2.6.2",

package/src/app-runtime/use-auto-commit-driver.ts

@@ -93,8 +93,13 @@ export function useAutoCommitDriver({
   const lastGitHashRef = useRef<string | null>(null)
   const gitStabilizeTimerRef = useRef<ReturnType<typeof setTimeout> | null>(null)
 
+  // `state.gitPanel`, not `state`: the payload is built from the git panel and
+  // nothing else, while `state` changes on every PTY frame. Keyed on the whole
+  // state this ran — and JSON.stringify'd the changed-file list — at the rate
+  // the assistants print.
   useEffect(() => {
     if (!configRef.current.enabled) return
+    const state = stateRef.current
     const projectId = state.currentProjectId
     if (!(projectId != null && projectId !== '')) return
     const payload = gitPayloadFromState(state)
@@ -126,7 +131,7 @@ export function useAutoCommitDriver({
         tabId: activeTab.id,
       })
     }, GIT_STABILIZATION_DEBOUNCE_MS)
-  }, [state])
+  }, [state.gitPanel, stateRef])
 
   useEffect(
     () => () => {

package/src/app-runtime/use-backend-runtime.ts

@@ -19,6 +19,9 @@ interface BackendRuntimeOptions {
   syntaxOverlayEnabled: () => boolean
 }
 
+/** Below the eye's notice on a deliberate switch; wide enough to swallow key repeat. */
+const ATTACH_SETTLE_MS = 90
+
 export interface TabRuntimeControls {
   clearIdleTimer: (tabId: string) => void
   clearStartupGrace: (tabId: string) => void
@@ -45,14 +48,28 @@ export function useBackendRuntime({
       return
     }
 
-    return attachCurrentSession({
-      attachRequestIdRef,
-      backend,
-      currentProjectId,
-      currentProjectProjectSnapshot,
-      dispatch,
-      layoutRef,
-    })
+    // Settle before attaching. An attach is a socket teardown + reconnect +
+    // handshake to the daemon, which then re-attaches every PTY of the project
+    // and classifies them — and holding `j`/`k` across the sidebar walks
+    // through projects at key-repeat rate. Firing one per keypress meant every
+    // intermediate project paid that round trip only to have its result
+    // discarded by the next. Only where the cursor comes to rest attaches.
+    let detach: (() => void) | null = null
+    const timer = setTimeout(() => {
+      detach = attachCurrentSession({
+        attachRequestIdRef,
+        backend,
+        currentProjectId,
+        currentProjectProjectSnapshot,
+        dispatch,
+        layoutRef,
+      })
+    }, ATTACH_SETTLE_MS)
+
+    return () => {
+      clearTimeout(timer)
+      detach?.()
+    }
   }, [backend, currentProjectId, currentProjectProjectSnapshot, dispatch, layoutRef])
 
   useEffect(() => {

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

@@ -73,6 +73,9 @@ export function startWorkspaceCreation(
  * conclusion. Only prefixed when a setup is actually live.
  */
 function buildWorkspacePrompt(ctx: SideEffectContext, pending: PendingWorkspaceLaunch): string {
+  // No prompt is a valid choice: the user wanted the worktree, not a task. Send
+  // nothing — not even the setup note, which would arrive as a prompt of its own.
+  if (pending.prompt.trim() === '') return ''
   const setupTab = findSetupTab(ctx.getState().tabs, pending.workspaceId)
   // No setup tab yet does not mean no setup: the workspace can land in the
   // store the same tick the user picks, and the runner only spawns on the next
@@ -95,6 +98,8 @@ function renameWorkspaceFromLaunch(
   workspace: WorkspaceRecord,
   assistant: AssistantId
 ): void {
+  // Nothing to name it after; the `wt-<project>` placeholder stands.
+  if (pending.prompt.trim() === '') return
   void renameWorkspaceFromPrompt(
     { projectId: pending.projectId, prompt: pending.prompt, provider: assistant, workspace },
     {

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

@@ -18,36 +18,29 @@ export function useWorkspaceBranchPolling(enabled: boolean): void {
   useEffect(() => {
     if (!enabled) return
 
-    let cancelled = false
     let timer: ReturnType<typeof setTimeout> | null = null
 
-    const tick = async () => {
-      const projects = appStore.getState().projects
-      await Promise.all(
-        projects.flatMap((project) =>
-          (project.workspaces ?? []).map(async (workspace) => {
-            if (workspace.path == null || workspace.path === '') return
-            const branch = await getCurrentBranch(workspace.path)
-            if (cancelled) return
-            if (branch != null && branch !== workspace.branch) {
-              dispatchGlobal({
-                patch: { branch },
-                projectId: project.id,
-                type: 'update-workspace-record',
-                workspaceId: workspace.id,
-              })
-            }
-          })
-        )
-      )
-      if (cancelled) return
-      timer = setTimeout(() => void tick(), INTERVAL_MS)
+    const tick = () => {
+      for (const project of appStore.getState().projects) {
+        for (const workspace of project.workspaces ?? []) {
+          if (workspace.path == null || workspace.path === '') continue
+          const branch = getCurrentBranch(workspace.path)
+          if (branch != null && branch !== workspace.branch) {
+            dispatchGlobal({
+              patch: { branch },
+              projectId: project.id,
+              type: 'update-workspace-record',
+              workspaceId: workspace.id,
+            })
+          }
+        }
+      }
+      timer = setTimeout(tick, INTERVAL_MS)
     }
 
-    void tick()
+    tick()
 
     return () => {
-      cancelled = true
       if (timer != null) clearTimeout(timer)
     }
   }, [enabled])

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

@@ -2,7 +2,7 @@ import { useEffect } from 'react'
 
 import type { BranchDivergence } from '../state/types'
 
-import { useAppStore } from '../state/app-store'
+import { appStore } from '../state/app-store'
 import { dispatchGlobal } from '../state/dispatch-ref'
 import { getBranchDivergence, getWorkspaceDiffStat } from './divergence'
 
@@ -14,25 +14,30 @@ const INTERVAL_MS = 4000
 // never forked, so they fall back to their own upstream — for a root checkout on
 // main that reads as "unpushed commits + dirty work". A branch with no upstream
 // makes git fail, which the poller already renders as nothing.
+//
+// Runs once when enabled; reads projects from the store on each tick so project
+// updates do NOT re-create the effect. Taking `projects` as a dependency meant
+// every workspace switch tore the loop down and fired a fresh tick — holding
+// `j` in the sidebar launched a full git fan-out per keypress (~200ms of
+// subprocesses each) and the machine spent the whole time spawning `git`.
 export function useWorkspaceDivergencePolling(enabled: boolean): void {
-  const projects = useAppStore((s) => s.projects)
-
   useEffect(() => {
     if (!enabled) return
-    // Every project, not just the current one: each dispatch replaces the whole
-    // map, so polling one project's workspaces blanks the stats of every other
-    // project's rows — which the sidebar shows all of at once.
-    // ponytail: one unbounded fan-out per tick, two `git` spawns per workspace.
-    // Batch or stagger if a machine with many projects feels it.
-    const targets = projects
-      .flatMap((project) => project.workspaces ?? [])
-      .filter((w) => w.branch != null && w.branch !== '')
-    if (targets.length === 0) return
 
     let cancelled = false
     let timer: ReturnType<typeof setTimeout> | null = null
 
     const tick = async () => {
+      // Every project, not just the current one: each dispatch replaces the
+      // whole map, so polling one project's workspaces blanks the stats of
+      // every other project's rows — which the sidebar shows all of at once.
+      // ponytail: one unbounded fan-out per tick, two `git` spawns per
+      // workspace. Batch or stagger if a machine with many projects feels it.
+      const targets = appStore
+        .getState()
+        .projects.flatMap((project) => project.workspaces ?? [])
+        .filter((w) => w.branch != null && w.branch !== '')
+
       const entries = await Promise.all(
         targets.map(async (workspace) => {
           const branch = workspace.branch
@@ -54,11 +59,15 @@ export function useWorkspaceDivergencePolling(enabled: boolean): void {
         })
       )
       if (cancelled) return
-      const next: Record<string, BranchDivergence> = {}
-      for (const entry of entries) {
-        if (entry != null) next[entry[0]] = entry[1]
+      // Only when there was something to measure: an empty dispatch on a tick
+      // that found no branches would blank rows the previous tick filled.
+      if (targets.length > 0) {
+        const next: Record<string, BranchDivergence> = {}
+        for (const entry of entries) {
+          if (entry != null) next[entry[0]] = entry[1]
+        }
+        dispatchGlobal({ divergence: next, type: 'set-workspace-divergence' })
       }
-      dispatchGlobal({ divergence: next, type: 'set-workspace-divergence' })
       timer = setTimeout(() => void tick(), INTERVAL_MS)
     }
 
@@ -68,5 +77,5 @@ export function useWorkspaceDivergencePolling(enabled: boolean): void {
       cancelled = true
       if (timer != null) clearTimeout(timer)
     }
-  }, [enabled, projects])
+  }, [enabled])
 }

package/src/ui/components/git/pane/git-pane-widget.tsx

@@ -7,10 +7,14 @@ import { usePrStatusPolling } from '../../../../git/pr-status-poller'
 import { useRepoDiscovery } from '../../../../git/use-repo-discovery'
 import { useAppStore } from '../../../../state/app-store'
 import { getActiveWorkspacePath } from '../../../../state/project-workspaces'
+import { useSettled } from '../../../hooks/use-settled'
 import { GitPanel } from '../git-panel'
 import { GitPaneHeader, type GitPaneTab } from './git-pane-header'
 import { PrChecksPanel } from './pr-checks-panel'
 
+/** Long enough to swallow key repeat, short enough to read as instant. */
+const PATH_SETTLE_MS = 150
+
 interface GitPaneWidgetProps {
   pollingEnabled: boolean
   contentWidth: number
@@ -32,7 +36,9 @@ export const GitPaneWidget = memo(function GitPaneWidget({
     currentProjectId != null && currentProjectId !== ''
       ? projects.find((s) => s.id === currentProjectId)
       : undefined
-  const projectPath = getActiveWorkspacePath(currentProject)
+  // Settled: every poller below keys off this path and fires an immediate tick
+  // when it changes, and holding `j`/`k` in the sidebar changes it per keypress.
+  const projectPath = useSettled(getActiveWorkspacePath(currentProject), PATH_SETTLE_MS)
 
   const [tab, setTab] = useState<GitPaneTab>('diff')
 

package/src/ui/components/modals/tabs/new-tab-modal.tsx

@@ -17,8 +17,12 @@ interface NewTabModalProps {
   cursorPos?: number
   editingCommand: AssistantId | null
   editBuffer: string
-  /** Chained from `<C-p>`: a shell cannot take the prompt, so Terminal is hidden. */
-  excludeTerminal: boolean
+  /**
+   * Chained from `<C-p>`: the prompt waiting for the picked assistant, `''` when
+   * the workspace was created without one, `null` when this is a plain new tab.
+   * A shell cannot take a prompt, so Terminal is hidden only when there is one.
+   */
+  pendingPrompt: string | null
 }
 
 export function NewTabModal({
@@ -26,11 +30,16 @@ export function NewTabModal({
   customCommands,
   editBuffer,
   editingCommand,
-  excludeTerminal,
   filter,
+  pendingPrompt,
   selectedIndex,
 }: NewTabModalProps) {
   const t = useTheme()
+  const excludeTerminal = pendingPrompt != null && pendingPrompt.trim() !== ''
+  const footerText =
+    pendingPrompt == null
+      ? 'Enter launches in the active workspace'
+      : `Enter launches in the new workspace${excludeTerminal ? ' and sends your prompt' : ''}`
   const options = useMemo(() => getAllAssistantOptions(customCommands), [customCommands])
   const filtered = useMemo(
     () => getNewTabAssistantOptions(customCommands, filter, excludeTerminal),
@@ -100,13 +109,7 @@ export function NewTabModal({
       selectedIndex={selectedIndex}
       emptyState={<text fg={t.textMuted}>No matching assistants.</text>}
       onHover={handleHover}
-      footer={
-        <text fg={t.textMuted}>
-          {excludeTerminal
-            ? 'Enter launches in the new workspace and sends your prompt'
-            : 'Enter launches in the active workspace'}
-        </text>
-      }
+      footer={<text fg={t.textMuted}>{footerText}</text>}
     />
   )
 }

package/src/ui/components/modals/workspace/create-workspace-modal.tsx

@@ -70,11 +70,11 @@ export function CreateWorkspaceModal({
         <box flexDirection="column">
           <TextField
             active={activeField === 'prompt'}
-            label="What do you want to work on?"
-            description="Sent to the assistant, and names the workspace and its branch."
+            label="What do you want to work on? (optional)"
+            description="Sent to the assistant, and names the workspace and its branch. Leave empty for a bare workspace."
             value={prompt}
             cursorPos={activeField === 'prompt' ? cursorPos : undefined}
-            placeholder="Describe the task..."
+            placeholder="Describe the task, or leave empty..."
             minLines={PROMPT_LINES}
           />
           {branchError != null && branchError !== '' ? (

package/src/ui/git-branch.ts

@@ -1,10 +1,31 @@
-import { $ } from 'bun'
+import { readFileSync, statSync } from 'node:fs'
+import { isAbsolute, join, resolve } from 'node:path'
 
-export async function getCurrentBranch(cwd: string): Promise<string | null> {
+/**
+ * `.git` is a directory in a normal checkout and a `gitdir: <path>` pointer
+ * file inside a worktree — which is what every aimux-created workspace is.
+ */
+function gitDirOf(cwd: string): string {
+  const dotGit = join(cwd, '.git')
+  if (statSync(dotGit).isDirectory()) return dotGit
+  const pointer = /^gitdir:\s*(.+)$/m.exec(readFileSync(dotGit, 'utf8'))?.[1]?.trim()
+  if (pointer == null || pointer === '') throw new Error('unreadable .git pointer')
+  return isAbsolute(pointer) ? pointer : resolve(cwd, pointer)
+}
+
+/**
+ * Current branch name, or null when detached (or when `cwd` is not a checkout) —
+ * the same contract as `git branch --show-current`, from one file read instead
+ * of a subprocess.
+ *
+ * The branch poller calls this for every workspace of every project every four
+ * seconds. Spawning git there cost ~35ms a tick on a 13-workspace setup; the
+ * reads cost ~0.1ms.
+ */
+export function getCurrentBranch(cwd: string): string | null {
   try {
-    const result = await $`git -C ${cwd} branch --show-current`.quiet()
-    const branch = result.text().trim()
-    return branch || null
+    const head = readFileSync(join(gitDirOf(cwd), 'HEAD'), 'utf8').trim()
+    return /^ref:\s*refs\/heads\/(.+)$/.exec(head)?.[1] ?? null
   } catch {
     return null
   }

package/src/ui/hooks/use-settled.ts

@@ -0,0 +1,22 @@
+import { useEffect, useState } from 'react'
+
+/**
+ * `value`, but only once it has stopped changing for `ms`. The first value is
+ * returned as-is, so mounting is never delayed.
+ *
+ * Everything keyed on the active workspace's path — git status, PR checks,
+ * nested-repo discovery — restarts its poller and fires an immediate tick when
+ * that path changes. Holding `j`/`k` through the sidebar changes it at
+ * key-repeat rate, so without this every keypress spawned a `git status`
+ * fan-out and a network-bound `gh pr view` that the next keypress discarded.
+ */
+export function useSettled<T>(value: T, ms: number): T {
+  const [settled, setSettled] = useState(value)
+
+  useEffect(() => {
+    const timer = setTimeout(() => setSettled(value), ms)
+    return () => clearTimeout(timer)
+  }, [value, ms])
+
+  return settled
+}

package/src/ui/root.tsx

@@ -109,7 +109,7 @@ function renderModal(
           cursorPos={modal.cursorPos}
           editingCommand={modal.type === 'new-tab' ? modal.editingCommand : null}
           editBuffer={modal.editBuffer ?? ''}
-          excludeTerminal={modal.type === 'new-tab' && modal.pendingWorkspace != null}
+          pendingPrompt={modal.type === 'new-tab' ? (modal.pendingWorkspace?.prompt ?? null) : null}
         />
       )
     case 'create-workspace':