@brimveyn/aimux 1.22.6 → 1.22.7

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@brimveyn/aimux",
-  "version": "1.22.6",
+  "version": "1.22.7",
   "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",

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

@@ -1,7 +1,6 @@
 import { isAutoCommitEnabled } from '@brimveyn/aimux-config'
 
 import type { SideEffect } from '../input/modes/types'
-import type { AssistantId, PendingWorkspaceLaunch } from '../state/types'
 import type { SideEffectContext } from './side-effect-context'
 
 import { loadConfig, saveConfig } from '../config'
@@ -9,7 +8,6 @@ import { logInputDebug } from '../debug/input-log'
 import { enqueueGitOp } from '../git/command-queue'
 import { countDirtyFiles } from '../git/move-workspace'
 import { getCurrentBranch, getDefaultBranch, listLocalBranches } from '../git/worktree'
-import { assistantAcceptsPromptArg } from '../pty/command-registry'
 import { allLeafIds, getGroupIdForTab } from '../state/layout-tree'
 import { saveCurrentProject } from '../state/project-save'
 import { getActiveWorkspace, getActiveWorkspacePath } from '../state/project-workspaces'
@@ -39,7 +37,6 @@ import {
   handleSwitchProjectEffect,
   restartTabSession,
 } from './project-actions'
-import { injectPromptWhenReady } from './prompt-injection'
 import { getSelectedAssistantOption, getSelectedProject, getSelectedSnippet } from './selection'
 import {
   changeSelectedSetting,
@@ -48,7 +45,6 @@ import {
   resetSelectedSetting,
 } from './settings-actions'
 import {
-  findSetupTab,
   handleAskAgentForSetupScriptEffect,
   handleConfigureSetupScriptEffect,
   handlePromoteSetupTabEffect,
@@ -64,17 +60,16 @@ import {
   confirmSplitSelection,
   createTabSession,
   executeSplitPane,
-  launchAssistant,
+  launchWithPrompt,
   startExistingTab,
 } from './tab-actions'
 import {
-  createAimuxTempWorkspace,
   isForceableWorkspaceDeleteError,
   runDeleteWorkspace,
   runMoveWorkspace,
   setProjectDefaultBaseRef,
 } from './workspace-actions'
-import { placeholderWorkspaceName, renameWorkspaceFromPrompt } from './workspace-naming'
+import { launchPendingWorkspace, startWorkspaceCreation } from './workspace-launch'
 
 function handleProjectSelection(ctx: SideEffectContext): void {
   const { backend, dispatch, state } = ctx
@@ -214,79 +209,6 @@ function hoistBranch(branches: string[], first: string | undefined): string[] {
   return [first, ...branches.filter((branch) => branch !== first)]
 }
 
-/**
- * Setup runs concurrently with the agent by design, so say so rather than
- * letting the agent run tests against a half-installed tree and draw the wrong
- * conclusion. Only prefixed when a setup is actually live.
- */
-function buildWorkspacePrompt(ctx: SideEffectContext, pending: PendingWorkspaceLaunch): string {
-  const setupRunning = findSetupTab(ctx.getState().tabs, pending.workspaceId)?.status === 'running'
-  if (!setupRunning) return pending.prompt
-  return `Note: a setup script is currently installing this workspace's dependencies in the background. Wait for it to finish before running builds, tests, or anything that reads installed dependencies.\n\n${pending.prompt}`
-}
-
-/**
- * Name the workspace after what its prompt describes, using the assistant the
- * user just picked. Background work that must never block or fail the launch.
- *
- * Always `pending.prompt`, never the setup-annotated variant built for the
- * agent — the note is guidance, not part of what the user asked for.
- */
-function renameWorkspaceFromLaunch(
-  ctx: SideEffectContext,
-  pending: PendingWorkspaceLaunch,
-  assistant: AssistantId
-): void {
-  const workspace = ctx
-    .getState()
-    .projects.find((entry) => entry.id === pending.projectId)
-    ?.workspaces?.find((entry) => entry.id === pending.workspaceId)
-  if (!workspace) return
-
-  void renameWorkspaceFromPrompt(
-    { projectId: pending.projectId, prompt: pending.prompt, provider: assistant, workspace },
-    {
-      applyName: (projectId, workspaceId, patch) =>
-        ctx.dispatch({ patch, projectId, type: 'update-workspace-record', workspaceId }),
-    }
-  )
-}
-
-/**
- * The `<C-p>` flow: create a workspace in the current project, then chain into
- * the new-tab modal rather than leaving the user in an empty workspace.
- */
-async function createWorkspaceFromModal(
-  ctx: SideEffectContext,
-  projectId: string,
-  params: {
-    prompt: string
-    baseRef?: string
-  }
-): Promise<void> {
-  // A name derived locally from the prompt, so the sidebar reads right from the
-  // first frame. The model-generated one replaces it a few seconds later.
-  // The branch is left to `createAimuxTempWorkspace`, which suffixes it with a
-  // timestamp: two workspaces started from the same prompt must not collide on
-  // the branch name before the model has had a chance to distinguish them.
-  const workspace = await createAimuxTempWorkspace(
-    ctx,
-    projectId,
-    placeholderWorkspaceName(params.prompt),
-    undefined,
-    params.baseRef
-  )
-  // Undefined means the create was rejected (e.g. branch already checked out);
-  // the modal stays open showing the error.
-  if (!workspace) return
-
-  ctx.dispatch({ type: 'close-modal' })
-  ctx.dispatch({
-    pendingWorkspace: { projectId, prompt: params.prompt, workspaceId: workspace.id },
-    type: 'open-new-tab-modal',
-  })
-}
-
 export function executeSideEffect(effect: SideEffect, ctx: SideEffectContext): void {
   const { backend, dispatch, state } = ctx
 
@@ -313,47 +235,16 @@ export function executeSideEffect(effect: SideEffect, ctx: SideEffectContext): v
     }
     case 'launch-selected-assistant': {
       const assistant = getSelectedAssistantOption(state).id
-      // Chained from `<C-p>`: pin the tab to the workspace just created, hand it
-      // the prompt, and name the workspace with the assistant the user picked.
-      // Otherwise the tab lands in the project's active workspace, which
-      // launchAssistant resolves itself.
-      const pending = state.modal.type === 'new-tab' ? state.modal.pendingWorkspace : undefined
-      // Normalized to '' so "is there a prompt" is one comparison rather than a
-      // null check repeated at each decision below.
-      const prompt = pending
-        ? buildWorkspacePrompt(ctx, pending)
-        : ((state.modal.type === 'new-tab' ? state.modal.pendingPrompt : undefined) ?? '')
-
-      // Hand the prompt to the CLI at spawn where the CLI takes one. Pasting it
-      // into a live TUI works — it is what this flow did — but it means polling
-      // for readiness, probing the screen, and retrying. An argv slot has none of
-      // those failure modes.
-      const atSpawn = prompt !== '' && assistantAcceptsPromptArg(assistant, state.customCommands)
-      logInputDebug('app.launchSelectedAssistant', {
-        assistant,
-        chained: pending != null,
-        modal: state.modal.type,
-        promptAtSpawn: atSpawn,
-        promptLength: prompt.length,
-      })
-
-      const tabId = launchAssistant(
-        ctx,
-        assistant,
-        pending?.workspaceId,
-        atSpawn ? [prompt] : undefined
-      )
-      // Delivery is decided and done here, chained or not: two call sites meant
-      // the prompt could be built twice, from two different reads of the store.
-      if (prompt !== '' && !atSpawn) {
-        void injectPromptWhenReady({
-          backend: ctx.backend,
-          getState: ctx.getState,
-          prompt,
-          tabId,
-        })
+      const newTab = state.modal.type === 'new-tab' ? state.modal : undefined
+      // Chained from `<C-p>`: the tab is pinned to the workspace being cut, and
+      // waits for it. Otherwise it lands in the project's active workspace,
+      // which launchAssistant resolves itself.
+      if (newTab?.pendingWorkspace) {
+        launchPendingWorkspace(ctx, assistant, newTab.pendingWorkspace)
+        return
       }
-      if (pending) renameWorkspaceFromLaunch(ctx, pending, assistant)
+      // Normalized to '' so "is there a prompt" stays one comparison.
+      launchWithPrompt(ctx, assistant, newTab?.pendingPrompt ?? '', undefined)
       return
     }
     case 'edit-selected-assistant': {
@@ -389,18 +280,10 @@ export function executeSideEffect(effect: SideEffect, ctx: SideEffectContext): v
       const projectId = state.currentProjectId
       if (!(projectId != null && projectId !== '')) return
       const { baseRef, prompt } = state.modal
-      void (async () => {
-        try {
-          await enqueueGitOp(async () =>
-            createWorkspaceFromModal(ctx, projectId, {
-              baseRef: baseRef !== '' ? baseRef : undefined,
-              prompt,
-            })
-          )
-        } catch (error) {
-          toast.error(error instanceof Error ? error.message : String(error))
-        }
-      })()
+      startWorkspaceCreation(ctx, projectId, {
+        baseRef: baseRef !== '' ? baseRef : undefined,
+        prompt,
+      })
       return
     }
     case 'confirm-selected-project': {

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

@@ -4,6 +4,7 @@ import type { SideEffectContext } from './side-effect-context'
 import { logInputDebug } from '../debug/input-log'
 import { createPrefixedId } from '../platform/id'
 import {
+  assistantAcceptsPromptArg,
   getAllAssistantOptions,
   getAssistantOption,
   isCommandAvailable,
@@ -20,6 +21,7 @@ import {
 } from '../state/layout-tree'
 import { getActiveWorkspace, getCurrentProject } from '../state/project-workspaces'
 import { createDefaultTerminalModes } from '../state/terminal-modes'
+import { injectPromptWhenReady } from './prompt-injection'
 import { getSelectedAssistantOption } from './selection'
 
 /**
@@ -171,6 +173,40 @@ export function launchAssistant(
   return tab.id
 }
 
+/**
+ * Spawn the assistant and get `prompt` in front of it.
+ *
+ * Handed over at spawn where the CLI takes one. Pasting it into a live TUI
+ * works — it is what the `<C-p>` flow did — but it means polling for readiness,
+ * probing the screen, and retrying. An argv slot has none of those failure
+ * modes. Deciding it here means the prompt cannot be built twice, from two
+ * different reads of the store.
+ */
+export function launchWithPrompt(
+  ctx: SideEffectContext,
+  assistant: AssistantId,
+  prompt: string,
+  workspaceId: string | undefined
+): void {
+  const atSpawn = prompt !== '' && assistantAcceptsPromptArg(assistant, ctx.state.customCommands)
+  logInputDebug('app.launchSelectedAssistant', {
+    assistant,
+    chained: workspaceId != null,
+    promptAtSpawn: atSpawn,
+    promptLength: prompt.length,
+  })
+
+  const tabId = launchAssistant(ctx, assistant, workspaceId, atSpawn ? [prompt] : undefined)
+  if (prompt !== '' && !atSpawn) {
+    void injectPromptWhenReady({
+      backend: ctx.backend,
+      getState: ctx.getState,
+      prompt,
+      tabId,
+    })
+  }
+}
+
 export function getTabProjectPath(
   ctx: SideEffectContext,
   tab: Pick<TabSession, 'workspaceId'>

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

@@ -94,14 +94,27 @@ function normalizeBranchName(branch: string | undefined): string | undefined {
 export async function createAimuxTempWorkspace(
   ctx: SideEffectContext,
   projectId: string,
-  requestedName?: string,
-  requestedBranchName?: string,
-  requestedBaseRef?: string,
-  sourceWorkspaceId?: string
+  options: {
+    name?: string
+    branchName?: string
+    baseRef?: string
+    sourceWorkspaceId?: string
+    /**
+     * Pre-allocated by callers that must name the workspace before git is done
+     * cutting it — the `<C-p>` chain pins a tab to it while it is still being
+     * created.
+     */
+    workspaceId?: string
+  } = {}
 ): Promise<WorkspaceRecord | undefined> {
+  const {
+    baseRef: requestedBaseRef,
+    branchName: requestedBranchName,
+    name: requestedName,
+  } = options
   const project = ctx.state.projects.find((entry) => entry.id === projectId)
   const source =
-    project?.workspaces?.find((entry) => entry.id === sourceWorkspaceId) ??
+    project?.workspaces?.find((entry) => entry.id === options.sourceWorkspaceId) ??
     getActiveWorkspace(project)
   const sourcePath = source?.path ?? getActiveWorkspacePath(project)
   if (!project || !(sourcePath != null && sourcePath !== '')) return undefined
@@ -111,7 +124,7 @@ export async function createAimuxTempWorkspace(
   const repoRoot = (await getMainWorktreeRoot(sourcePath)) ?? source?.repoRoot ?? sourcePath
   const baseBranch = (await getCurrentBranch(sourcePath)) ?? source?.branch ?? 'HEAD'
   const baseRef = requestedBaseRef ?? baseBranch
-  const workspaceId = createPrefixedId('workspace')
+  const workspaceId = options.workspaceId ?? createPrefixedId('workspace')
   const trimmedName = requestedName?.trim()
   const workspaceName =
     trimmedName != null && trimmedName !== ''

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

@@ -0,0 +1,135 @@
+import type { AssistantId, PendingWorkspaceLaunch, WorkspaceRecord } from '../state/types'
+import type { SideEffectContext } from './side-effect-context'
+
+import { enqueueGitOp } from '../git/command-queue'
+import { createPrefixedId } from '../platform/id'
+import { hasSetupScript } from '../state/project-data'
+import { findWorkspace } from '../state/project-workspaces'
+import { toast } from '../state/toast-store'
+import { findSetupTab } from './setup-actions'
+import { launchWithPrompt } from './tab-actions'
+import { createAimuxTempWorkspace } from './workspace-actions'
+import { placeholderWorkspaceName, renameWorkspaceFromPrompt } from './workspace-naming'
+
+/**
+ * The `<C-p>` worktree being cut while its assistant picker is already open.
+ * A barrier, not a value: what the launch needs to know — did the worktree
+ * land — is read back from the store, which is the only thing that can still
+ * be true a tick later.
+ *
+ * Single-slot: only one create-workspace modal can be open, so only one chain
+ * can ever be in flight.
+ */
+let pendingWorkspaceCreate: Promise<void> | null = null
+
+/**
+ * The `<C-p>` flow: chain into the new-tab modal *now* and cut the worktree in
+ * the background. `git fetch` + `worktree add` take seconds, and the next
+ * question — which assistant — does not depend on either, so making the user
+ * watch a frozen modal buys nothing. `launchPendingWorkspace` waits this out,
+ * so the tab still lands in a finished workspace.
+ */
+export function startWorkspaceCreation(
+  ctx: SideEffectContext,
+  projectId: string,
+  params: {
+    prompt: string
+    baseRef?: string
+  }
+): void {
+  // Allocated here rather than by the create: the picker below pins its tab to
+  // this workspace before git has produced anything to pin to.
+  const workspaceId = createPrefixedId('workspace')
+  pendingWorkspaceCreate = (async () => {
+    try {
+      await enqueueGitOp(async () =>
+        // A name derived locally from the prompt, so the sidebar reads right from
+        // the first frame. The model-generated one replaces it a few seconds later.
+        // The branch is left to `createAimuxTempWorkspace`, which suffixes it with
+        // a timestamp: two workspaces started from the same prompt must not
+        // collide on the branch name before the model has distinguished them.
+        createAimuxTempWorkspace(ctx, projectId, {
+          baseRef: params.baseRef,
+          name: placeholderWorkspaceName(params.prompt),
+          workspaceId,
+        })
+      )
+    } catch (error) {
+      // The modal that would have shown this inline is already gone, so the
+      // toast is the only channel left. The launch reads the missing record.
+      toast.error(error instanceof Error ? error.message : String(error))
+    }
+  })()
+  ctx.dispatch({ type: 'close-modal' })
+  ctx.dispatch({
+    pendingWorkspace: { projectId, prompt: params.prompt, workspaceId },
+    type: 'open-new-tab-modal',
+  })
+}
+
+/**
+ * Setup runs concurrently with the agent by design, so say so rather than
+ * letting the agent run tests against a half-installed tree and draw the wrong
+ * conclusion. Only prefixed when a setup is actually live.
+ */
+function buildWorkspacePrompt(ctx: SideEffectContext, pending: PendingWorkspaceLaunch): string {
+  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
+  // render. A project with a script is about to run it, so say so.
+  const setupRunning = setupTab ? setupTab.status === 'running' : hasSetupScript(pending.projectId)
+  if (!setupRunning) return pending.prompt
+  return `Note: a setup script is currently installing this workspace's dependencies in the background. Wait for it to finish before running builds, tests, or anything that reads installed dependencies.\n\n${pending.prompt}`
+}
+
+/**
+ * Name the workspace after what its prompt describes, using the assistant the
+ * user just picked. Background work that must never block or fail the launch.
+ *
+ * Always `pending.prompt`, never the setup-annotated variant built for the
+ * agent — the note is guidance, not part of what the user asked for.
+ */
+function renameWorkspaceFromLaunch(
+  ctx: SideEffectContext,
+  pending: PendingWorkspaceLaunch,
+  workspace: WorkspaceRecord,
+  assistant: AssistantId
+): void {
+  void renameWorkspaceFromPrompt(
+    { projectId: pending.projectId, prompt: pending.prompt, provider: assistant, workspace },
+    {
+      applyName: (projectId, workspaceId, patch) =>
+        ctx.dispatch({ patch, projectId, type: 'update-workspace-record', workspaceId }),
+    }
+  )
+}
+
+/**
+ * Pin the tab to the workspace `<C-p>` is cutting, hand it the prompt, and name
+ * the workspace after what it describes.
+ *
+ * Waits for the worktree first: spawning early would drop the tab in the
+ * project checkout instead, since that is what an unresolvable workspace id
+ * falls back to.
+ */
+export function launchPendingWorkspace(
+  ctx: SideEffectContext,
+  assistant: AssistantId,
+  pending: PendingWorkspaceLaunch
+): void {
+  const creating = pendingWorkspaceCreate
+  pendingWorkspaceCreate = null
+  void (async () => {
+    await creating
+    // Read the store again: the record landed after `ctx.state` was captured,
+    // and its absence is how a failed create says "do not spawn".
+    const fresh = { ...ctx, state: ctx.getState() }
+    const found = findWorkspace(fresh.state.projects, pending.workspaceId)
+    if (!found) {
+      toast.error('Workspace creation failed — no tab was opened')
+      return
+    }
+    launchWithPrompt(fresh, assistant, buildWorkspacePrompt(fresh, pending), pending.workspaceId)
+    renameWorkspaceFromLaunch(fresh, pending, found.workspace, assistant)
+  })()
+}

package/src/git/pr-status.ts

@@ -145,7 +145,7 @@ export function parsePrView(raw: unknown): PrStatusResult {
   }
 }
 
-export type PrAction = 'merge' | null
+export type PrAction = 'cleanup' | 'merge' | null
 
 export interface PrActionState {
   label: string
@@ -160,7 +160,11 @@ export interface PrActionState {
  * offer an action for still gets an honest label rather than a dead button.
  */
 export function prActionState(pr: PrSummary, checks: PrCheck[]): PrActionState {
-  if (pr.state === 'MERGED') return { action: null, label: 'Merged', tone: 'neutral' }
+  // Merged is the one terminal state with something left to do: the workspace
+  // that carried the branch is now dead weight. The row offers the removal
+  // right where the merge happened; whether it's actually removable (not the
+  // primary workspace) is the caller's call, not the PR's.
+  if (pr.state === 'MERGED') return { action: 'cleanup', label: 'Merged', tone: 'ok' }
   if (pr.state === 'CLOSED') return { action: null, label: 'Closed', tone: 'blocked' }
   if (pr.isDraft) return { action: null, label: 'Draft', tone: 'neutral' }
   if (pr.mergeable === 'CONFLICTING') {
@@ -182,6 +186,28 @@ export function prActionState(pr: PrSummary, checks: PrCheck[]): PrActionState {
   return { action: null, label: 'Checking…', tone: 'neutral' }
 }
 
+export type PrCleanupKind = 'branch' | 'worktree' | null
+
+/**
+ * What "clean up" means for a merged PR, which depends on where its branch
+ * lives. A linked workspace is disposable, so it goes. The repo checkout is not
+ * — the equivalent is leaving the merged branch for the one it landed on, which
+ * the PR names, so a PR into `develop` doesn't drop you on `main`.
+ *
+ * `gh pr view` resolves the PR from the checked-out branch, so a PR on screen
+ * means we're on its head — but a base already equal to it has nowhere to go.
+ */
+export function prCleanupKind(
+  action: PrAction,
+  pr: Pick<PrSummary, 'base' | 'head'>,
+  workspaceIsRemovable: boolean
+): PrCleanupKind {
+  if (action !== 'cleanup') return null
+  if (workspaceIsRemovable) return 'worktree'
+  if (pr.base === '' || pr.base === pr.head) return null
+  return 'branch'
+}
+
 export interface ClampedBody {
   text: string
   truncated: boolean

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

@@ -9,22 +9,24 @@ import { getBranchDivergence, getWorkspaceDiffStat } from './divergence'
 const INTERVAL_MS = 4000
 
 // Polls per-workspace base divergence for the current project while enabled and
-// dispatches it into workspaceDivergence. Only workspaces that record a baseRef
-// (the aimux-created ones) are measured; the primary and externally-discovered
-// workspaces have no recorded base and are left out.
+// dispatches it into workspaceDivergence. aimux-created workspaces are measured
+// against the ref they forked from; the primary and externally-discovered ones
+// 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.
 export function useWorkspaceDivergencePolling(enabled: boolean): void {
-  const currentProjectId = useAppStore((s) => s.currentProjectId)
   const projects = useAppStore((s) => s.projects)
 
   useEffect(() => {
     if (!enabled) return
-    const project =
-      currentProjectId != null && currentProjectId !== ''
-        ? projects.find((s) => s.id === currentProjectId)
-        : undefined
-    const targets = (project?.workspaces ?? []).filter(
-      (w) => w.baseRef != null && w.baseRef !== '' && w.branch != null && w.branch !== ''
-    )
+    // 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
@@ -33,9 +35,14 @@ export function useWorkspaceDivergencePolling(enabled: boolean): void {
     const tick = async () => {
       const entries = await Promise.all(
         targets.map(async (workspace) => {
-          const base = workspace.baseRef
           const branch = workspace.branch
-          if (base == null || branch == null) return null
+          if (branch == null) return null
+          // `<branch>@{upstream}` rather than a bare `@{upstream}`: the latter
+          // resolves against the repo root's HEAD, which is not this workspace.
+          const base =
+            workspace.baseRef != null && workspace.baseRef !== ''
+              ? workspace.baseRef
+              : `${branch}@{upstream}`
           // Commits come from the repo root (comparing two refs); lines come
           // from the workspace itself, so uncommitted work is counted too.
           const [divergence, stat] = await Promise.all([
@@ -61,5 +68,5 @@ export function useWorkspaceDivergencePolling(enabled: boolean): void {
       cancelled = true
       if (timer != null) clearTimeout(timer)
     }
-  }, [enabled, currentProjectId, projects])
+  }, [enabled, projects])
 }

package/src/git/worktree.ts

@@ -181,6 +181,15 @@ export async function pruneGitWorktrees(repoPath: string): Promise<void> {
   await $`git -C ${repoPath} worktree prune`.quiet().nothrow()
 }
 
+// Switch a checkout to an existing branch. Throws git's own message rather than
+// a paraphrase: "local changes would be overwritten" is the one thing the user
+// needs to read, and no wording of ours beats it.
+export async function checkoutBranch(cwd: string, branch: string): Promise<void> {
+  const result = await $`git -C ${cwd} checkout ${branch}`.quiet().nothrow()
+  if (result.exitCode === 0) return
+  throw new Error(result.stderr.toString().trim() || `failed to check out ${branch}`)
+}
+
 // Drop every `aimux/` branch left behind by deleted temp worktrees. git refuses
 // to delete branches still checked out in a live worktree, so this only removes
 // true orphans. Returns the number of branches removed.

package/src/ui/components/git/pane/pr-state-row.tsx

@@ -1,10 +1,15 @@
 import { memo, useCallback, useState } from 'react'
 
+import { enqueueGitOp } from '../../../../git/command-queue'
 import { approveAndMergePr } from '../../../../git/pr-merge'
-import { type PrActionState, prActionState } from '../../../../git/pr-status'
+import { type PrActionState, prActionState, prCleanupKind } from '../../../../git/pr-status'
 import { refreshPrStatus } from '../../../../git/pr-status-poller'
+import { checkoutBranch } from '../../../../git/worktree'
 import { openUrl } from '../../../../platform/open-url'
+import { useAppStore } from '../../../../state/app-store'
+import { runSideEffectGlobal } from '../../../../state/dispatch-ref'
 import { usePrStatusStore } from '../../../../state/pr-status-store'
+import { getActiveWorkspace } from '../../../../state/project-workspaces'
 import { toast } from '../../../../state/toast-store'
 import { useBusySpinner } from '../../../hooks/use-busy-spinner'
 import { type ResolvedTuiTheme, useTheme, useTransparent } from '../../../theme'
@@ -22,18 +27,62 @@ export const PrStateRow = memo(function PrStateRow({ projectPath }: { projectPat
   const transparent = useTransparent()
   const bg = transparent ? undefined : t.backgroundElement
   const result = usePrStatusStore((s) => s.result)
+  const currentProjectId = useAppStore((s) => s.currentProjectId)
+  const projects = useAppStore((s) => s.projects)
   const [confirming, setConfirming] = useState(false)
   const [merging, setMerging] = useState(false)
   const spinner = useBusySpinner(merging)
 
   const pr = result?.kind === 'ok' ? result.pr : null
+  const status = result?.kind === 'ok' ? prActionState(result.pr, result.checks) : null
   const prUrl = pr?.url ?? ''
 
+  // The PR is polled against the active workspace's path, so its branch is this
+  // workspace's branch — which is what makes offering the removal here honest.
+  const project = projects.find((entry) => entry.id === currentProjectId)
+  const workspace = getActiveWorkspace(project)
+  const projectId = project?.id ?? null
+  const removableWorkspaceId =
+    workspace !== undefined && workspace.source !== 'primary' ? workspace.id : null
+
+  const base = pr?.base ?? ''
+  const cleanupKind =
+    pr === null ? null : prCleanupKind(status?.action ?? null, pr, removableWorkspaceId !== null)
+
   const openPr = useCallback(() => openUrl(prUrl), [prUrl])
   const askConfirm = useCallback(() => setConfirming(true), [])
   const cancel = useCallback(() => setConfirming(false), [])
   const confirm = useCallback(() => {
     setConfirming(false)
+    if (cleanupKind === 'worktree') {
+      if (projectId === null || removableWorkspaceId === null) return
+      // closeTabs (not force) mirrors the sidebar's "Remove workspace": the
+      // workspace's tabs are disposed, but a dirty worktree still re-prompts for
+      // an explicit force-delete instead of silently discarding work.
+      runSideEffectGlobal({
+        closeTabs: true,
+        projectId,
+        type: 'delete-workspace',
+        workspaceId: removableWorkspaceId,
+      })
+      return
+    }
+    if (cleanupKind === 'branch') {
+      void (async () => {
+        try {
+          // Queued like every other mutating git op: the pollers read this same
+          // checkout, and a checkout mid-status is how you get a torn panel.
+          await enqueueGitOp(async () => checkoutBranch(projectPath, base))
+        } catch (error) {
+          toast.error(error instanceof Error ? error.message : String(error))
+          return
+        }
+        // The branch poller would catch up within its tick; refreshing here
+        // retires the row now instead of leaving a merged PR sitting on screen.
+        await refreshPrStatus(projectPath)
+      })()
+      return
+    }
     setMerging(true)
     void (async () => {
       const merged = await approveAndMergePr(projectPath)
@@ -42,14 +91,18 @@ export const PrStateRow = memo(function PrStateRow({ projectPath }: { projectPat
       else toast.error(merged.message)
       await refreshPrStatus(projectPath)
     })()
-  }, [projectPath])
+  }, [base, cleanupKind, projectId, projectPath, removableWorkspaceId])
 
   // Nothing known yet (or nothing to show): stay out of the layout entirely and
   // appear only once a fetch reports a PR.
-  if (result?.kind !== 'ok' || pr === null) return null
-  const status = prActionState(pr, result.checks)
+  if (result?.kind !== 'ok' || pr === null || status === null) return null
+  const showAction = cleanupKind !== null || status.action === 'merge'
   let label = status.label
-  if (confirming) label = 'Merge this PR?'
+  if (confirming) {
+    if (cleanupKind === 'worktree') label = 'Remove this worktree?'
+    else if (cleanupKind === 'branch') label = `Switch to ${base}?`
+    else label = 'Merge this PR?'
+  }
   if (merging) label = `${spinner} merging…`
 
   return (
@@ -82,10 +135,10 @@ export const PrStateRow = memo(function PrStateRow({ projectPath }: { projectPat
           </text>
         </box>
       ) : null}
-      {status.action === 'merge' && !confirming && !merging ? (
+      {showAction && !confirming && !merging ? (
         <box flexShrink={0}>
           <text selectable={false} fg={t.primary} bg={bg} wrapMode="none" onMouseDown={askConfirm}>
-            <strong>Merge</strong>
+            <strong>{cleanupKind === null ? 'Merge' : 'Clean up'}</strong>
           </text>
         </box>
       ) : null}

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

@@ -13,7 +13,7 @@ import { dispatchGlobal, runSideEffectGlobal } from '../../../../state/dispatch-
 import { getPrimaryWorkspace } from '../../../../state/project-workspaces'
 // eslint-disable-next-line no-duplicate-imports
 import { IDLE_PROJECT_STATUS } from '../../../../state/types'
-import { moveIdToIdPosition, orderProjectsForDisplay } from '../../../project-ordering'
+import { moveIdToInsertIndex, orderProjectsForDisplay } from '../../../project-ordering'
 import { useBaseTheme, useTheme } from '../../../theme'
 import { truncate } from '../../../truncate'
 import { FlashLabelBadge } from '../../flash/flash-label-badge'
@@ -28,6 +28,8 @@ interface ProjectListProps {
 const COLUMN_CONTENT_OPTIONS = { flexDirection: 'column' as const, gap: 0 }
 
 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
@@ -36,12 +38,10 @@ const HEADER_TITLE = 'Projects'
  */
 const SETTINGS_GLYPH = '⚙'
 
-function arraysEqual(a: string[], b: string[]): boolean {
-  if (a.length !== b.length) return false
-  for (let i = 0; i < a.length; i++) {
-    if (a[i] !== b[i]) return false
-  }
-  return true
+interface DragState {
+  id: string
+  /** Gap the drop would land in, or null while the pointer is off the list. */
+  dropIndex: number | null
 }
 
 export function ProjectList({ contentWidth }: ProjectListProps) {
@@ -50,10 +50,18 @@ export function ProjectList({ contentWidth }: ProjectListProps) {
   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
+  // closure saw `null` for the whole gesture. The two state copies below exist
+  // only so the row highlight and the drop bar redraw.
+  const dragRef = useRef<DragState | null>(null)
   const [draggingId, setDraggingId] = useState<string | null>(null)
-  const [dragOrder, setDragOrder] = useState<string[] | null>(null)
-  const lastSwapWithRef = useRef<string | null>(null)
-  const rowRefs = useRef(new Map<string, BoxRenderable>())
+  // Where the drop would land, as a gap index (0 = above the first project,
+  // projects.length = below the last). The list itself never moves while
+  // dragging — only this bar does, so rows can't slide out from under the
+  // pointer and make the drag oscillate.
+  const [dropIndex, setDropIndex] = useState<number | null>(null)
+  const gapRefs = useRef(new Map<number, BoxRenderable>())
   const scrollRef = useRef<ScrollBoxRenderable | null>(null)
 
   const ordered = useMemo(() => orderProjectsForDisplay(projects), [projects])
@@ -83,58 +91,64 @@ export function ProjectList({ contentWidth }: ProjectListProps) {
     visible: true,
   })
 
-  const setRowRef = useCallback((id: string, ref: BoxRenderable | null): void => {
-    if (ref) rowRefs.current.set(id, ref)
-    else rowRefs.current.delete(id)
+  const setGapRef = useCallback((index: number, ref: BoxRenderable | null): void => {
+    if (ref) gapRefs.current.set(index, ref)
+    else gapRefs.current.delete(index)
   }, [])
 
-  const findRowAtY = useCallback((y: number): string | null => {
-    for (const [id, ref] of rowRefs.current) {
-      if (y >= ref.y && y < ref.y + ref.height) return id
+  // The gaps *are* the insertion points, so the nearest one to the pointer is
+  // the drop slot — no row-height arithmetic, which matters because a workspace
+  // row is one line or two depending on whether it has a branch.
+  const findDropIndex = useCallback((event: OtuiMouseEvent): number | null => {
+    const box = scrollRef.current
+    if (box && (event.x < box.x || event.x >= box.x + box.width)) return null
+    let best: number | null = null
+    let bestDistance = Number.POSITIVE_INFINITY
+    for (const [index, ref] of gapRefs.current) {
+      const distance = Math.abs(event.y - ref.y)
+      if (distance < bestDistance) {
+        bestDistance = distance
+        best = index
+      }
     }
-    return null
+    return best
   }, [])
 
-  const handleRowDragStart = useCallback(
-    (id: string) => {
-      setDraggingId(id)
-      setDragOrder(baselineOrder)
-      lastSwapWithRef.current = null
-    },
-    [baselineOrder]
-  )
+  const handleRowDragStart = useCallback((id: string) => {
+    dragRef.current = { dropIndex: null, id }
+    setDraggingId(id)
+    setDropIndex(null)
+  }, [])
 
-  const handleRowDrag = useCallback(
+  const handleDrag = useCallback(
     (event: OtuiMouseEvent) => {
-      if (!(draggingId != null && draggingId !== '')) return
-      const hit = findRowAtY(event.y)
-      if (hit === null) {
-        lastSwapWithRef.current = null
-        return
-      }
-      if (hit === draggingId) {
-        lastSwapWithRef.current = null
-        return
-      }
-      if (hit === lastSwapWithRef.current) return
-      setDragOrder((prev) => (prev ? moveIdToIdPosition(prev, draggingId, hit) : prev))
-      lastSwapWithRef.current = hit
+      const drag = dragRef.current
+      if (!drag) return
+      drag.dropIndex = findDropIndex(event)
+      setDropIndex(drag.dropIndex)
     },
-    [draggingId, findRowAtY]
+    [findDropIndex]
   )
 
+  // Bound to both `up` and `drag-end`: a plain click only ever sends `up`,
+  // while a released drag sends `drag-end` first. Clearing the ref makes the
+  // second one a no-op, so either order does the same thing once.
   const commitDrop = useCallback(() => {
-    const source = draggingId
-    const finalOrder = dragOrder
+    const drag = dragRef.current
+    dragRef.current = null
     setDraggingId(null)
-    setDragOrder(null)
-    lastSwapWithRef.current = null
+    setDropIndex(null)
 
-    if (source == null || source === '' || !finalOrder) return
+    if (!drag) return
+    const source = drag.id
 
-    const changed = !arraysEqual(finalOrder, baselineOrder)
-    if (changed) {
-      dispatchGlobal({ orderedIds: finalOrder, type: 'reorder-projects' })
+    if (drag.dropIndex !== null) {
+      const nextOrder = moveIdToInsertIndex(baselineOrder, source, drag.dropIndex)
+      // Identity means the drop landed back where it started — a released drag,
+      // not a click, so it must not fall through to switching project.
+      if (nextOrder !== baselineOrder) {
+        dispatchGlobal({ orderedIds: nextOrder, type: 'reorder-projects' })
+      }
       return
     }
 
@@ -152,13 +166,7 @@ export function ProjectList({ contentWidth }: ProjectListProps) {
         workspaceId: sourcePrimaryId,
       })
     }
-  }, [baselineOrder, dragOrder, draggingId, ordered])
-
-  const cancelDrag = useCallback(() => {
-    setDraggingId(null)
-    setDragOrder(null)
-    lastSwapWithRef.current = null
-  }, [])
+  }, [baselineOrder, ordered])
 
   const handleNewProject = useCallback((e: OtuiMouseEvent) => {
     e.stopPropagation()
@@ -175,17 +183,22 @@ export function ProjectList({ contentWidth }: ProjectListProps) {
     dispatchGlobal({ type: 'enter-settings' })
   }, [])
 
-  const visibleProjects =
-    dragOrder !== null
-      ? dragOrder
-          .map((id) => ordered.find((s) => s.id === id))
-          .filter((s): s is ProjectRecord => !!s)
-      : ordered
-
   const rule = RULE.repeat(Math.max(1, contentWidth))
 
   return (
-    <box flexDirection="column" flexGrow={1} flexShrink={1} overflow="hidden">
+    // Drag and release are handled here, not on the row that started them:
+    // opentui captures the pointer at the first drag event, wherever it lands,
+    // and a one-line heading is left the moment the pointer moves down. Any row
+    // that captures is a descendant of this box, so the events bubble here.
+    <box
+      flexDirection="column"
+      flexGrow={1}
+      flexShrink={1}
+      overflow="hidden"
+      onMouseDrag={handleDrag}
+      onMouseUp={commitDrop}
+      onMouseDragEnd={commitDrop}
+    >
       <box flexShrink={0}>
         <text fg={t.border} selectable={false} wrapMode="none">
           {rule}
@@ -212,8 +225,8 @@ export function ProjectList({ contentWidth }: ProjectListProps) {
           // one of its workspaces. One map, one React keypath per visible row;
           // transitions are a single atomic reconciliation.
           const rows: ReactNode[] = []
-          for (const project of visibleProjects) {
-            const projectIndex = baselineOrder.indexOf(project.id) + 1
+          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
@@ -224,6 +237,18 @@ export function ProjectList({ contentWidth }: ProjectListProps) {
               project.activeWorkspaceId != null && project.activeWorkspaceId !== ''
                 ? project.activeWorkspaceId
                 : getPrimaryWorkspace(workspaces)?.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
+              // line, so previewing a slot never shifts a single row.
+              <DropGap
+                key={`gap:${project.id}`}
+                index={index}
+                active={dropIndex === index}
+                contentWidth={contentWidth}
+                setGapRef={setGapRef}
+              />
+            )
             rows.push(
               <ProjectRow
                 key={`ws:${project.id}`}
@@ -233,15 +258,7 @@ export function ProjectList({ contentWidth }: ProjectListProps) {
                 status={statusMap[project.id] ?? IDLE_PROJECT_STATUS}
                 dragging={draggingId === project.id}
                 contentWidth={contentWidth}
-                // Every project gets a blank line above it, which doubles as
-                // the gap under the header — one rule instead of a spacer row
-                // that would shift the list every time the header changes.
-                marginTop={1}
-                setRowRef={setRowRef}
                 onDragStart={handleRowDragStart}
-                onDrag={handleRowDrag}
-                onDrop={commitDrop}
-                onDragCancel={cancelDrag}
               />
             )
             for (const workspace of workspaces) {
@@ -258,6 +275,16 @@ export function ProjectList({ contentWidth }: ProjectListProps) {
               )
             }
           }
+          // Trailing slot, so "after the last project" is reachable.
+          rows.push(
+            <DropGap
+              key="gap:end"
+              index={ordered.length}
+              active={dropIndex === ordered.length}
+              contentWidth={contentWidth}
+              setGapRef={setGapRef}
+            />
+          )
           return rows
         })()}
       </scrollbox>
@@ -275,6 +302,32 @@ export function ProjectList({ contentWidth }: ProjectListProps) {
   )
 }
 
+interface DropGapProps {
+  /** Insertion slot this gap stands for: 0 is above the first project. */
+  index: number
+  active: boolean
+  contentWidth: number
+  setGapRef: (index: number, ref: BoxRenderable | null) => void
+}
+
+/** The one-line gap above a project — blank, or the drop preview mid-drag. */
+function DropGap({ active, contentWidth, index, setGapRef }: DropGapProps) {
+  const t = useTheme()
+  const handleRef = useCallback(
+    (r: BoxRenderable | null) => setGapRef(index, r),
+    [setGapRef, index]
+  )
+  return (
+    <box ref={handleRef} flexShrink={0} height={1}>
+      {active ? (
+        <text fg={t.primary} selectable={false} wrapMode="none">
+          {DROP_BAR.repeat(Math.max(1, contentWidth))}
+        </text>
+      ) : null}
+    </box>
+  )
+}
+
 interface ProjectRowProps {
   project: ProjectRecord
   /**
@@ -289,27 +342,17 @@ interface ProjectRowProps {
   status: ProjectStatus
   dragging: boolean
   contentWidth: number
-  /** Vertical spacing above this row — used to separate project blocks. */
-  marginTop: number
-  setRowRef: (id: string, ref: BoxRenderable | null) => void
+  /** Only the gesture's start lives here — the list owns drag and release. */
   onDragStart: (id: string) => void
-  onDrag: (event: OtuiMouseEvent) => void
-  onDrop: () => void
-  onDragCancel: () => void
 }
 
 const ProjectRow = memo(function ProjectRow({
   contentWidth,
   dragging,
   inCurrentGroup,
-  marginTop,
-  onDrag,
-  onDragCancel,
   onDragStart,
-  onDrop,
   project,
   projectIndex,
-  setRowRef,
   status,
 }: ProjectRowProps) {
   const t = useTheme()
@@ -340,10 +383,6 @@ const ProjectRow = memo(function ProjectRow({
   const waitingColor = t.warning
   const currentProjectId = useAppStore((s) => s.currentProjectId)
 
-  const handleRef = useCallback(
-    (r: BoxRenderable | null) => setRowRef(project.id, r),
-    [setRowRef, project.id]
-  )
   const handleMouseDown = useCallback(
     (e: OtuiMouseEvent) => {
       e.preventDefault()
@@ -352,13 +391,6 @@ const ProjectRow = memo(function ProjectRow({
     },
     [onDragStart, project.id]
   )
-  const handleMouseUp = useCallback(
-    (e: OtuiMouseEvent) => {
-      e.preventDefault()
-      onDrop()
-    },
-    [onDrop]
-  )
   const handleNewWorkspace = useCallback(
     (e: OtuiMouseEvent) => {
       e.preventDefault()
@@ -412,19 +444,14 @@ const ProjectRow = memo(function ProjectRow({
 
   return (
     <ContextMenuBox
-      ref={handleRef}
       id={`sidebar-ws-${project.id}`}
       flexDirection="column"
       flexShrink={0}
-      marginTop={marginTop}
       paddingLeft={1}
       paddingRight={1}
       backgroundColor={bgColor}
       rightClickMenu={rightClickMenu}
       onMouseDown={handleMouseDown}
-      onMouseDrag={onDrag}
-      onMouseUp={handleMouseUp}
-      onMouseDragEnd={onDragCancel}
     >
       <box flexDirection="row" alignItems="center">
         <text fg={leadingColor} selectable={false} wrapMode="none">

package/src/ui/components/overlays/ai-usage/ai-usage-indicator.tsx

@@ -1,4 +1,4 @@
-import type { AIUsageTool, ResolvedTuiTheme } from '@brimveyn/aimux-config'
+import type { AIUsageTool } from '@brimveyn/aimux-config'
 
 import { useCallback } from 'react'
 
@@ -6,7 +6,11 @@ import { useAIUsageStore } from '../../../../state/ai-usage-store'
 import { dispatchGlobal } from '../../../../state/dispatch-ref'
 import { useTheme } from '../../../theme'
 
-const DOT = '●'
+/** nf-cod-claude / nf-cod-openai. Needs a nerd font, like the status bar separators. */
+const ICON: Record<AIUsageTool, string> = {
+  claude: '\u{ec82}',
+  codex: '\u{ec81}',
+}
 
 function formatTokens(total: number): string {
   if (total >= 1_000_000) return `${(total / 1_000_000).toFixed(1)}M`
@@ -14,12 +18,6 @@ function formatTokens(total: number): string {
   return String(total)
 }
 
-function pickDotColor(t: ResolvedTuiTheme, percent: number): string {
-  if (percent >= 85) return t.error
-  if (percent >= 60) return t.warning
-  return t.success
-}
-
 export function AIUsageIndicator() {
   const t = useTheme()
   const enabled = useAIUsageStore((s) => s.enabled)
@@ -59,35 +57,20 @@ export function AIUsageIndicator() {
         if (snap.error != null && snap.error !== '' && !(snap.stale === true)) {
           return (
             <box key={tool} flexDirection="row">
-              <text fg={t.error} selectable={false}>
-                {DOT}
-              </text>
-            </box>
-          )
-        }
-
-        if (snap.percent !== null) {
-          const p = Math.round(snap.percent)
-          const color = pickDotColor(t, snap.percent)
-          return (
-            <box key={tool} flexDirection="row">
-              <text fg={color} selectable={false}>
-                {DOT}
-              </text>
               <text fg={t.text} selectable={false}>
-                {` ${p}%`}
+                {ICON[tool]}
               </text>
             </box>
           )
         }
 
+        const value =
+          snap.percent !== null ? `${Math.round(snap.percent)}%` : formatTokens(snap.tokens.total)
+
         return (
           <box key={tool} flexDirection="row">
-            <text fg={t.textMuted} selectable={false}>
-              {DOT}
-            </text>
-            <text fg={t.textMuted} selectable={false}>
-              {` ${formatTokens(snap.tokens.total)}`}
+            <text fg={t.text} selectable={false}>
+              {`${ICON[tool]} ${value}`}
             </text>
           </box>
         )

package/src/ui/project-ordering.ts

@@ -13,6 +13,24 @@ export function orderProjectsForDisplay(projects: ProjectRecord[]): ProjectRecor
   })
 }
 
+/**
+ * Move `moveId` into the gap `insertIndex` — 0 is before the first id,
+ * `ids.length` is after the last, matching the drop bars drawn between rows.
+ * Returns the input array itself when the move changes nothing, so callers can
+ * skip the dispatch with a reference check.
+ */
+export function moveIdToInsertIndex(ids: string[], moveId: string, insertIndex: number): string[] {
+  const from = ids.indexOf(moveId)
+  if (from < 0) return ids
+  // Removing the id first shifts every later gap down by one.
+  const to = insertIndex > from ? insertIndex - 1 : insertIndex
+  if (to === from) return ids
+  const next = [...ids]
+  next.splice(from, 1)
+  next.splice(to, 0, moveId)
+  return next
+}
+
 /**
  * Move `moveId` to the slot currently held by `intoPositionOfId`, shifting the
  * displaced id in the opposite direction. Pure; returns a new array. Returns