@brimveyn/aimux 1.22.5 → 1.22.7

package/src/auto-rename/title-runner.ts

@@ -1,4 +1,5 @@
 import { buildHeadlessInvocation, type HeadlessInvocation } from '../auto-commit/headless-commands'
+import { foldDiacritics } from '../platform/worktree-paths'
 import { clampTitle } from './title-format'
 
 export type TitleSpawnFn = (
@@ -16,6 +17,33 @@ export type TitleResult =
   | { status: 'failed' }
   | { status: 'unavailable' }
 
+/**
+ * A workspace needs two different names from one request: a tab title in the
+ * user's own language, and a branch name — which is read by git, by reviewers
+ * and by CI, so it follows the repo's conventions instead: English, a
+ * conventional-commit type, kebab-case. `branch` is null when the model gave
+ * nothing that qualifies; the caller keeps the branch it already has.
+ */
+export type NamingResult =
+  | { status: 'ok'; title: string; branch: string | null }
+  | { status: 'failed' }
+  | { status: 'unavailable' }
+
+/** Conventional-commit types a generated branch may use; anything else is refused. */
+const BRANCH_TYPES = new Set([
+  'build',
+  'chore',
+  'ci',
+  'docs',
+  'feat',
+  'fix',
+  'perf',
+  'refactor',
+  'style',
+  'test',
+])
+const BRANCH_SUBJECT_WORDS = 5
+
 export function buildTitlePrompt(firstPrompt: string): string {
   return [
     'Create a concise tab title for the user request below.',
@@ -26,15 +54,56 @@ export function buildTitlePrompt(firstPrompt: string): string {
   ].join('\n')
 }
 
-export function sanitizeGeneratedTitle(raw: string): string | null {
-  const first = raw
+export function buildWorkspaceNamingPrompt(firstPrompt: string): string {
+  return [
+    'Name a workspace for the user request below.',
+    'Return exactly two lines and nothing else.',
+    'Line 1 — a tab title: 2 to 6 words, at most 48 characters, in the same language as the request.',
+    'Line 2 — a git branch named <type>/<subject>, always in English whatever the language of the request.',
+    '<type> is one of: feat, fix, refactor, perf, docs, test, chore, ci, style, build.',
+    '<subject> is 2 to 5 lowercase words joined by hyphens, naming what changes rather than restating the request.',
+    'Example line 2: fix/scroll-drift-on-resize',
+    'No quotes, no labels, no numbering, no markdown, no ending punctuation.',
+    '',
+    firstPrompt.slice(0, 8_000),
+  ].join('\n')
+}
+
+function nonEmptyLines(raw: string): string[] {
+  return raw
     .split(/\r?\n/u)
     .map((line) => line.trim())
-    .find(Boolean)
-  if (first == null || first === '') return null
+    .filter(Boolean)
+}
+
+/** Strip the wrappers a model reaches for even when told not to: labels, list markers, quotes. */
+function unwrapLine(line: string, label: RegExp): string {
+  return line
+    .replace(label, '')
+    .replace(/^(?:\d+[.)]|[-*])\s*/u, '')
+    .replaceAll(/^["'`“”‘’]+|["'`“”‘’]+$/gu, '')
+}
 
-  const unlabelled = first.replace(/^TITLE\s*:\s*/iu, '').replaceAll(/^["'“”‘’]+|["'“”‘’]+$/gu, '')
-  return clampTitle(unlabelled)
+export function sanitizeGeneratedTitle(raw: string): string | null {
+  const first = nonEmptyLines(raw)[0]
+  if (first == null) return null
+  return clampTitle(unwrapLine(first, /^TITLE\s*:\s*/iu))
+}
+
+export function sanitizeGeneratedBranch(raw: string): string | null {
+  const line = unwrapLine(raw.trim(), /^BRANCH\s*:\s*/iu)
+  const slash = line.indexOf('/')
+  if (slash < 0) return null
+  const type = line.slice(0, slash).trim().toLowerCase()
+  if (!BRANCH_TYPES.has(type)) return null
+  // Whole words only: a mid-word cut ("...-bran") names nothing.
+  const subject = foldDiacritics(line.slice(slash + 1))
+    .toLowerCase()
+    .split(/[^a-z0-9]+/u)
+    .filter(Boolean)
+    .slice(0, BRANCH_SUBJECT_WORDS)
+    .join('-')
+  return subject === '' ? null : `${type}/${subject}`
 }
 
 function executableOnPath(executable: string): boolean {
@@ -46,7 +115,7 @@ function executableOnPath(executable: string): boolean {
   }
 }
 
-export async function generateTabTitle(options: {
+export interface NamingOptions {
   provider: string
   model?: string
   firstPrompt: string
@@ -54,12 +123,13 @@ export async function generateTabTitle(options: {
   signal: AbortSignal
   spawn?: TitleSpawnFn
   isExecutableAvailable?: (executable: string) => boolean
-}): Promise<TitleResult> {
-  const invocation = buildHeadlessInvocation(
-    options.provider,
-    buildTitlePrompt(options.firstPrompt),
-    options.model
-  )
+}
+
+async function runNamingModel(
+  options: NamingOptions,
+  prompt: string
+): Promise<{ status: 'ok'; stdout: string } | { status: 'failed' } | { status: 'unavailable' }> {
+  const invocation = buildHeadlessInvocation(options.provider, prompt, options.model)
   if (!invocation) return { status: 'unavailable' }
 
   // A caller-supplied spawn does not go through PATH, so only probe it for the
@@ -72,13 +142,33 @@ export async function generateTabTitle(options: {
   try {
     const result = await (options.spawn ?? defaultSpawn)(invocation, signal)
     if (!result || result.exitCode !== 0 || signal.aborted) return { status: 'failed' }
-    const title = sanitizeGeneratedTitle(result.stdout)
-    return title == null ? { status: 'failed' } : { status: 'ok', title }
+    return { status: 'ok', stdout: result.stdout }
   } catch {
     return { status: 'failed' }
   }
 }
 
+export async function generateTabTitle(options: NamingOptions): Promise<TitleResult> {
+  const run = await runNamingModel(options, buildTitlePrompt(options.firstPrompt))
+  if (run.status !== 'ok') return run
+  const title = sanitizeGeneratedTitle(run.stdout)
+  return title == null ? { status: 'failed' } : { status: 'ok', title }
+}
+
+/** One model call for both names — a workspace must not wait on two. */
+export async function generateWorkspaceNaming(options: NamingOptions): Promise<NamingResult> {
+  const run = await runNamingModel(options, buildWorkspaceNamingPrompt(options.firstPrompt))
+  if (run.status !== 'ok') return run
+  const [titleLine, branchLine] = nonEmptyLines(run.stdout)
+  const title = titleLine == null ? null : sanitizeGeneratedTitle(titleLine)
+  if (title == null) return { status: 'failed' }
+  return {
+    branch: branchLine == null ? null : sanitizeGeneratedBranch(branchLine),
+    status: 'ok',
+    title,
+  }
+}
+
 async function defaultSpawn(
   invocation: HeadlessInvocation,
   signal: AbortSignal

package/src/cli/commands/workspace/create-core.ts

@@ -2,6 +2,7 @@ import type { ProjectRecord, WorkspaceRecord } from '../../../state/types'
 import type { DaemonClient } from '../../client/daemon-client'
 
 import { createGitWorktree, removeGitWorktree, resolveGitRef } from '../../../git/worktree'
+import { copyWorktreeFiles } from '../../../git/worktree-files'
 import { IPC_CAPABILITY_WORKSPACE_LIFECYCLE_EVENTS } from '../../../ipc/protocol'
 import { createPrefixedId } from '../../../platform/id'
 import {
@@ -10,7 +11,7 @@ import {
   makeWorktreePath,
   pruneEmptyWorktreeParent,
 } from '../../../platform/worktree-paths'
-import { shouldRefreshBase } from '../../../settings/flags'
+import { shouldRefreshBase, worktreeCopyPatterns } from '../../../settings/flags'
 
 export interface CreateWorkspaceParams {
   /** Base ref for the branch (callers default to 'HEAD'). */
@@ -84,6 +85,7 @@ export async function createProjectWorkspace(
     await pruneEmptyWorktreeParent(targetPath)
     throw error
   }
+  await copyWorktreeFiles(primary.repoRoot, targetPath, worktreeCopyPatterns())
 
   const now = new Date().toISOString()
   const record: WorkspaceRecord = {

package/src/git/pr-status-poller.ts

@@ -15,14 +15,16 @@ interface Options {
 
 /** One-shot refetch, for when an action we took just invalidated the state. */
 export async function refreshPrStatus(projectPath: string): Promise<void> {
-  prStatusStore.getState().setResult(await collectPrStatus(projectPath))
+  prStatusStore.getState().setResult(projectPath, await collectPrStatus(projectPath))
 }
 
 export function usePrStatusPolling({ enabled, projectPath }: Options): void {
   useEffect(() => {
     if (!enabled || !(projectPath != null && projectPath !== '')) return
 
-    prStatusStore.getState().reset()
+    // Show what we last knew about this path while the fetch runs in the
+    // background, rather than blanking the row on every workspace switch.
+    prStatusStore.getState().selectPath(projectPath)
 
     let cancelled = false
     let timer: ReturnType<typeof setTimeout> | null = null
@@ -36,7 +38,7 @@ export function usePrStatusPolling({ enabled, projectPath }: Options): void {
     const tick = async () => {
       const result = await collectPrStatus(projectPath)
       if (cancelled) return
-      prStatusStore.getState().setResult(result)
+      prStatusStore.getState().setResult(projectPath, result)
       if (result.kind === 'error') {
         delay = Math.min(delay * 2, MAX_INTERVAL_MS)
       } else if (result.kind === 'ok' && result.checks.some((c) => c.state === 'pending')) {

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-files.ts

@@ -0,0 +1,51 @@
+import { Glob } from 'bun'
+import { existsSync } from 'node:fs'
+import { cp, mkdir } from 'node:fs/promises'
+import { dirname, join } from 'node:path'
+
+import { logDebug } from '../debug/input-log'
+
+/**
+ * Seed a fresh worktree with the untracked local files it needs to run.
+ *
+ * A worktree checkout holds tracked files and nothing else, so every ignored
+ * local file — `.env` above all — is missing the moment the workspace opens.
+ * The setup script can recreate some of them from a template; it cannot invent
+ * the secrets, which is why they are copied from the main checkout instead.
+ *
+ * ponytail: the patterns are matched against the whole checkout, gitignore and
+ * all — a recursive pattern walks `node_modules` too. Feeding the scan the ignore
+ * rules is the upgrade path if that ever costs anything noticeable.
+ *
+ * Best-effort by design: a pattern that matches nothing, or a file that cannot
+ * be read, must not take the workspace down with it. Nothing is ever
+ * overwritten — a match that already exists in the new worktree is tracked
+ * content, and clobbering it would dirty the workspace before its first commit.
+ */
+export async function copyWorktreeFiles(
+  repoPath: string,
+  targetPath: string,
+  patterns: readonly string[]
+): Promise<void> {
+  for (const pattern of patterns) {
+    try {
+      const matches = new Glob(pattern).scan({ cwd: repoPath, dot: true, onlyFiles: true })
+      for await (const relative of matches) {
+        const to = join(targetPath, relative)
+        if (existsSync(to)) continue
+        await mkdir(dirname(to), { recursive: true })
+        await cp(join(repoPath, relative), to)
+      }
+    } catch (error) {
+      // A workspace without its .env still opens; a workspace that failed to be
+      // created does not. Logged rather than swallowed outright: a file that
+      // silently never arrives is otherwise indistinguishable from one the
+      // pattern never matched.
+      logDebug('worktree.seed.error', {
+        error: error instanceof Error ? error.message : String(error),
+        pattern,
+        repoPath,
+      })
+    }
+  }
+}

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/platform/worktree-paths.ts

@@ -21,8 +21,13 @@ export function getAimuxWorktreeRoot(): string {
   return root != null && root !== '' ? root : defaultWorktreeRoot()
 }
 
+/** `améliorer` → `ameliorer`, so accents slug as letters instead of separators. */
+export function foldDiacritics(input: string): string {
+  return input.normalize('NFD').replaceAll(/\p{Diacritic}/gu, '')
+}
+
 export function sanitizePathSegment(input: string, maxLength = MAX_SLUG_LENGTH): string {
-  const sanitized = input
+  const sanitized = foldDiacritics(input)
     .trim()
     .replaceAll(/[^A-Za-z0-9._-]+/g, '-')
     .replaceAll(/\.\.+/g, '-')

package/src/settings/flags.ts

@@ -1,5 +1,5 @@
 import { loadConfig } from '../config'
-import { FETCH_BASE } from './sections/git'
+import { COPY_FILES, COPY_FILES_DEFAULT, FETCH_BASE } from './sections/git'
 
 /**
  * Settings read outside the screen, off the file rather than the store.
@@ -13,3 +13,13 @@ import { FETCH_BASE } from './sections/git'
 export function shouldRefreshBase(): boolean {
   return loadConfig().settings?.[FETCH_BASE] !== false
 }
+
+/** Untracked files a new workspace is seeded with, as globs relative to the repo. */
+export function worktreeCopyPatterns(): string[] {
+  const value = loadConfig().settings?.[COPY_FILES]
+  // Only an explicit empty string disables it; an untouched setting gets `.env`.
+  return String(value ?? COPY_FILES_DEFAULT)
+    .split(',')
+    .map((pattern) => pattern.trim())
+    .filter((pattern) => pattern !== '')
+}

package/src/settings/sections/git.ts

@@ -6,6 +6,8 @@ import type { SettingSection, SettingValue } from '../types'
 import { dispatchGlobal, runSideEffectGlobal } from '../../state/dispatch-ref'
 
 export const FETCH_BASE = 'git.fetchBase'
+export const COPY_FILES = 'git.worktreeCopyFiles'
+export const COPY_FILES_DEFAULT = '.env'
 
 function isFileListMode(value: SettingValue): value is GitFileListMode {
   return value === 'tree' || value === 'flat'
@@ -93,6 +95,18 @@ export const GIT_SECTION: SettingSection = {
       label: 'Refresh the base branch',
       storage: 'settings',
     },
+    {
+      // No `apply`, same reason as the row above: `worktreeCopyPatterns` reads
+      // this off the file so `aimux workspace create` honours it too.
+      description:
+        'Untracked files copied into each new workspace. Globs from the repo root: **/.env for nested ones.',
+      fallback: COPY_FILES_DEFAULT,
+      id: COPY_FILES,
+      kind: 'text',
+      label: 'Seed new workspaces with',
+      placeholder: 'nothing',
+      storage: 'settings',
+    },
     {
       apply: (value) => setMultiRepoConfig({ ...getMultiRepoConfig(), enabled: value === true }),
       description: 'Aggregate the status of git repos nested under the project.',

package/src/state/pr-status-store.ts

@@ -5,34 +5,38 @@ import type { PrStatusResult } from '../git/pr-status'
 
 export interface PrStatusState {
   result: PrStatusResult | null
+  /** Last result seen per project path, so a workspace switch shows its own
+   * previous state instead of blanking while the background fetch runs. */
+  byPath: Record<string, PrStatusResult>
   /** True once a fetch failed but we are still showing the previous good result. */
   stale: boolean
-  setResult: (result: PrStatusResult) => void
-  reset: () => void
+  setResult: (path: string, result: PrStatusResult) => void
+  /** Point the row at a project path, showing whatever we last knew about it. */
+  selectPath: (path: string) => void
 }
 
 export const prStatusStore = createStore<PrStatusState>((set) => ({
-  reset: () => set({ result: null, stale: false }),
+  byPath: {},
   result: null,
-  setResult: (result: PrStatusResult) =>
+  selectPath: (path: string) =>
+    set((state) => ({ result: state.byPath[path] ?? null, stale: false })),
+  setResult: (path: string, result: PrStatusResult) =>
     set((state) => {
       // A transient `gh` failure shouldn't blank a PR we already resolved — keep
       // the last good snapshot and mark it stale instead (same contract as
       // ai-usage-store's setSnapshot).
       if (result.kind === 'error' && state.result?.kind === 'ok') return { stale: true }
-      return { result, stale: false }
+      return { byPath: { ...state.byPath, [path]: result }, result, stale: false }
     }),
   stale: false,
 }))
 
 /**
- * The PR state row occupies its band both while the first fetch is in flight
- * and once it resolved to a PR — anything else (no PR, no gh, error) gives the
- * row back. Shared so the header and the row itself can never disagree and
- * shift the layout under the user.
+ * The PR state row only occupies its band once we know there is a PR — an
+ * unknown or resolved-to-nothing state gives the row back. Shared so the header
+ * and the row itself can never disagree and shift the layout under the user.
  */
-export const selectPrRowVisible = (state: PrStatusState): boolean =>
-  state.result === null || state.result.kind === 'ok'
+export const selectPrRowVisible = (state: PrStatusState): boolean => state.result?.kind === 'ok'
 
 export function usePrStatusStore<T>(selector: (state: PrStatusState) => T): T {
   return useStore(prStatusStore, selector)

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,23 +91,18 @@ export const PrStateRow = memo(function PrStateRow({ projectPath }: { projectPat
       else toast.error(merged.message)
       await refreshPrStatus(projectPath)
     })()
-  }, [projectPath])
+  }, [base, cleanupKind, projectId, projectPath, removableWorkspaceId])
 
-  // First fetch still in flight: hold the band empty so the tabs below don't
-  // jump a row once the PR lands.
-  if (result === null) {
-    return (
-      <box backgroundColor={bg} paddingLeft={1} paddingRight={1}>
-        <text selectable={false} bg={bg} wrapMode="none">
-          {' '}
-        </text>
-      </box>
-    )
-  }
-  if (result.kind !== 'ok' || pr === null) return null
-  const status = prActionState(pr, result.checks)
+  // 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 || 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 (
@@ -91,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}