🤖 fix: delete local branch on workspace delete (#1292)

This changes workspace deletion for **local worktree** workspaces to
also delete the associated **local git branch**.

- Normal delete uses `git branch -d` (safe; only deletes if merged)
- Force delete uses `git branch -D`
- Adds guardrails to avoid deleting protected branches (e.g. `main`) or
branches still checked out elsewhere

UI copy is updated (desktop + mobile) so users understand that deleting
a workspace also deletes the branch.

---

<details>
<summary>📋 Implementation Plan</summary>

# Plan: Delete workspace also deletes its git branch

## Summary (what will change)
- **Archive** remains non-destructive (metadata timestamp only).
- **Delete workspace** will remove:
  1) the git worktree directory *(existing)*
  2) the associated **local git branch** by default *(new)*

Behavior details (per decisions captured):
- **Safe by default**: normal delete uses `git branch -d <branch>` (only
deletes if git considers it merged).
- **Force delete** uses `git branch -D <branch>` (matches existing
`force: true` semantics).
- **No remote deletion**: we will not delete `origin/<branch>`.
- **SSH runtimes**: keep simplest safe behavior (directory removal only;
no explicit remote branch deletion).

**Net LoC estimate (prod code): ~80–140 LoC** (mostly `WorktreeRuntime`
+ UI copy).

## Current behavior (confirmed in repo)
- Delete call flow:
- `WorkspaceContext.removeWorkspace()` → `api.workspace.remove()` →
`workspaceService.remove()` → `runtime.deleteWorkspace()`
- `WorktreeRuntime.deleteWorkspace()` already does **best-effort branch
deletion**, but **only** when the workspace name starts with `agent_`.
- `SSHRuntime.deleteWorkspace()` deletes the remote directory only (no
explicit `git branch -d/-D`).

## Recommended approach
### 1) Backend: generalize branch deletion in
`WorktreeRuntime.deleteWorkspace`
Files:
- `src/node/runtime/WorktreeRuntime.ts`
- (optional helper) `src/node/git.ts`

Steps:
1. **Change the branch-deletion gate**
   - Today:
- `shouldDeleteBranch = !isInPlace &&
workspaceName.startsWith("agent_")`
   - Proposed:
- `shouldDeleteBranch = !isInPlace` (delete branch for all worktree
workspaces, not just `agent_*`).

2. **Add safety checks before deleting the branch** (defensive, and errs
on “skip deletion” rather than “delete the wrong thing”):
- If branch does **not** exist locally (`await
listLocalBranches(projectPath)`): skip.
- If branch is the repo’s **detected trunk**
(`detectDefaultTrunkBranch(projectPath)`) or the **current branch** in
the main worktree (`getCurrentBranch(projectPath)`): skip.
- If branch is still **checked out by another worktree** (parse `git -C
<projectPath> worktree list --porcelain` and see if any remaining
worktree reports `branch refs/heads/<name>`): skip.

3. **Deletion command**
   - Keep existing `deleteFlag` behavior:
     - `force=false` → `git branch -d "<branch>"`
     - `force=true` → `git branch -D "<branch>"`

4. **Keep deletion best-effort**
- Continue treating branch cleanup as **non-blocking** (never fail
workspace delete just because `git branch -d` failed).
- Upgrade logging so it’s clear whether we skipped due to guardrails vs
git failure.

### 2) UI: update delete UX copy to reflect branch deletion
Goal: make it obvious that “Delete” now also targets the branch.

Files / call sites to update:
- Desktop command palette: `src/browser/utils/commands/sources.ts`
(`confirm("Remove current workspace…")`)
- Archived view:
- `src/browser/components/ArchivedWorkspaces.tsx` tooltip/copy around
“Delete permanently”
- `src/browser/components/ForceDeleteModal.tsx` warning text (“Force
delete” should mention branch deletion too)
- Mobile: `mobile/src/screens/ProjectsScreen.tsx` delete confirmation +
force delete wording

Copy guidance:
- Mention **local branch** by name where feasible.
- Mention that normal delete is “safe” (may not delete branch if
unmerged) and that Force Delete is destructive.

### 3) Tests
1. **Unit tests** (`src/node/runtime/WorktreeRuntime.test.ts`)
   - Add coverage for a non-`agent_` branch:
     - Force delete (`force=true`) removes the branch.
   - Add coverage for safe delete (`force=false`) on a merged branch:
- Create branch → commit → merge into main → delete workspace → branch
removed with `-d`.
   - Add a guardrail test:
- Workspace on `main` can be deleted as a worktree, but **`main` branch
must not be deleted**.

2. **Integration test** (optional but valuable)
   - Extend `tests/ipc/removeWorkspace.test.ts` for `local` runtime:
- Create workspace branch, then remove with `{ options: { force: true }
}`, assert `git branch --list <branch>` is empty in the main repo.

<details>
<summary>Alternatives considered (not recommended for this
iteration)</summary>

- **Add a “keep branch” checkbox / option to workspace.remove**
  - Pros: avoids deleting user-provided existing branches.
- Cons: requires API/schema changes, UI affordances across desktop +
mobile, and new persistence semantics.

- **Delete only “Mux-created” branches** (e.g. track whether branch
existed at creation time)
  - Pros: safest.
- Cons: needs new metadata field + backfill semantics for existing
workspaces.

Given the explicit desire for “delete means delete” now that archiving
exists, the simplest consistent behavior is: delete branch by default,
with strong guardrails and clear UI copy.

</details>

</details>

---
_Generated with [`mux`](https://github.com/coder/mux) • Model:
`openai:gpt-5.2` • Thinking: `xhigh`_

Signed-off-by: Thomas Kosiewski <tk@coder.com>

Author: ThomasK33

mobile/src/screens/ProjectsScreen.tsx

@@ -260,7 +260,7 @@ export function ProjectsScreen(): JSX.Element {
       // Show confirmation dialog
       Alert.alert(
         "Delete Workspace?",
-        `This will permanently remove "${metadata.name}" from ${metadata.projectName}.\n\nThis action cannot be undone.`,
+        `This will permanently remove "${metadata.name}" from ${metadata.projectName} and delete the local branch "${metadata.name}".\n\nThis action cannot be undone.`,
         [
           { text: "Cancel", style: "cancel" },
           {
@@ -280,7 +280,7 @@ export function ProjectsScreen(): JSX.Element {
                   // Show force delete option
                   Alert.alert(
                     "Workspace Has Changes",
-                    `${errorMsg}\n\nForce delete will discard these changes permanently.`,
+                    `${errorMsg}\n\nForce delete will discard these changes permanently and delete the local branch "${metadata.name}".`,
                     [
                       { text: "Cancel", style: "cancel" },
                       {

src/browser/components/ArchivedWorkspaces.tsx

@@ -518,7 +518,9 @@ export const ArchivedWorkspaces: React.FC<ArchivedWorkspacesProps> = ({
               <span className="text-muted text-xs">{selectedIds.size} selected</span>
               {bulkDeleteConfirm ? (
                 <>
-                  <span className="text-muted text-xs">Delete permanently?</span>
+                  <span className="text-muted text-xs">
+                    Delete permanently (also deletes local branches)?
+                  </span>
                   <button
                     onClick={() => void handleBulkDelete()}
                     className="rounded bg-red-600 px-2 py-0.5 text-xs text-white hover:bg-red-700"
@@ -556,7 +558,9 @@ export const ArchivedWorkspaces: React.FC<ArchivedWorkspacesProps> = ({
                         <Trash2 className="h-4 w-4" />
                       </button>
                     </TooltipTrigger>
-                    <TooltipContent>Delete selected permanently</TooltipContent>
+                    <TooltipContent>
+                      Delete selected permanently (local branches too)
+                    </TooltipContent>
                   </Tooltip>
                   <button
                     onClick={() => setSelectedIds(new Set())}
@@ -680,7 +684,7 @@ export const ArchivedWorkspaces: React.FC<ArchivedWorkspacesProps> = ({
                                 <Trash2 className="h-4 w-4" />
                               </button>
                             </TooltipTrigger>
-                            <TooltipContent>Delete permanently</TooltipContent>
+                            <TooltipContent>Delete permanently (local branch too)</TooltipContent>
                           </Tooltip>
                         </div>
                       </div>

src/browser/components/ForceDeleteModal.tsx

@@ -70,7 +70,7 @@ export const ForceDeleteModal: React.FC<ForceDeleteModalProps> = ({
         <WarningBox>
           <WarningTitle>This action cannot be undone</WarningTitle>
           <WarningText>
-            Force deleting will permanently remove the workspace and{" "}
+            Force deleting will permanently remove the workspace and its local branch, and{" "}
             {error.includes("unpushed commits:")
               ? "discard the unpushed commits shown above"
               : "may discard uncommitted work or lose data"}

src/browser/utils/commands/sources.ts

@@ -153,7 +153,13 @@ export function buildCoreSources(p: BuildSourcesParams): Array<() => CommandActi
         subtitle: workspaceDisplayName,
         section: section.workspaces,
         run: async () => {
-          const ok = confirm("Remove current workspace? This cannot be undone.");
+          const branchName =
+            selectedMeta?.name ??
+            selected.namedWorkspacePath.split("/").pop() ??
+            selected.namedWorkspacePath;
+          const ok = confirm(
+            `Remove current workspace? This will delete the worktree and local branch "${branchName}". This cannot be undone.`
+          );
           if (ok) await p.onRemoveWorkspace(selected.workspaceId);
         },
       });
@@ -305,7 +311,10 @@ export function buildCoreSources(p: BuildSourcesParams): Array<() => CommandActi
               (m) => m.id === vals.workspaceId
             );
             const workspaceName = meta ? `${meta.projectName}/${meta.name}` : vals.workspaceId;
-            const ok = confirm(`Remove workspace ${workspaceName}? This cannot be undone.`);
+            const branchName = meta?.name ?? workspaceName.split("/").pop() ?? workspaceName;
+            const ok = confirm(
+              `Remove workspace ${workspaceName}? This will delete the worktree and local branch "${branchName}". This cannot be undone.`
+            );
             if (ok) {
               await p.onRemoveWorkspace(vals.workspaceId);
             }

src/node/runtime/WorktreeRuntime.test.ts

@@ -90,7 +90,7 @@ describe("WorktreeRuntime.resolvePath", () => {
 });
 
 describe("WorktreeRuntime.deleteWorkspace", () => {
-  it("deletes agent branches when removing worktrees", async () => {
+  it("deletes non-agent branches when removing worktrees (force)", async () => {
     const rootDir = await fsPromises.realpath(
       await fsPromises.mkdtemp(path.join(os.tmpdir(), "worktree-runtime-delete-"))
     );
@@ -106,7 +106,7 @@ describe("WorktreeRuntime.deleteWorkspace", () => {
       const runtime = new WorktreeRuntime(srcBaseDir);
       const initLogger = createNullInitLogger();
 
-      const branchName = "agent_explore_aaaaaaaaaa";
+      const branchName = "feature_aaaaaaaaaa";
       const createResult = await runtime.createWorkspace({
         projectPath,
         branchName,
@@ -116,16 +116,80 @@ describe("WorktreeRuntime.deleteWorkspace", () => {
       });
       expect(createResult.success).toBe(true);
       if (!createResult.success) return;
+      if (!createResult.workspacePath) {
+        throw new Error("Expected workspacePath from createWorkspace");
+      }
+      const workspacePath = createResult.workspacePath;
 
-      const before = execSync(`git branch --list "${branchName}"`, {
+      // Make the branch unmerged (so -d would fail); force delete should still delete it.
+      execSync("bash -lc 'echo \"change\" >> README.md'", {
+        cwd: workspacePath,
+        stdio: "ignore",
+      });
+      execSync("git add README.md", { cwd: workspacePath, stdio: "ignore" });
+      execSync('git commit -m "change"', { cwd: workspacePath, stdio: "ignore" });
+
+      const deleteResult = await runtime.deleteWorkspace(projectPath, branchName, true);
+      expect(deleteResult.success).toBe(true);
+
+      const after = execSync(`git branch --list "${branchName}"`, {
         cwd: projectPath,
         stdio: ["ignore", "pipe", "ignore"],
       })
         .toString()
         .trim();
-      expect(before).toContain(branchName);
+      expect(after).toBe("");
+    } finally {
+      await fsPromises.rm(rootDir, { recursive: true, force: true });
+    }
+  }, 20_000);
 
-      const deleteResult = await runtime.deleteWorkspace(projectPath, branchName, true);
+  it("deletes merged branches when removing worktrees (safe delete)", async () => {
+    const rootDir = await fsPromises.realpath(
+      await fsPromises.mkdtemp(path.join(os.tmpdir(), "worktree-runtime-delete-"))
+    );
+
+    try {
+      const projectPath = path.join(rootDir, "repo");
+      await fsPromises.mkdir(projectPath, { recursive: true });
+      initGitRepo(projectPath);
+
+      const srcBaseDir = path.join(rootDir, "src");
+      await fsPromises.mkdir(srcBaseDir, { recursive: true });
+
+      const runtime = new WorktreeRuntime(srcBaseDir);
+      const initLogger = createNullInitLogger();
+
+      const branchName = "feature_merge_aaaaaaaaaa";
+      const createResult = await runtime.createWorkspace({
+        projectPath,
+        branchName,
+        trunkBranch: "main",
+        directoryName: branchName,
+        initLogger,
+      });
+      expect(createResult.success).toBe(true);
+      if (!createResult.success) return;
+      if (!createResult.workspacePath) {
+        throw new Error("Expected workspacePath from createWorkspace");
+      }
+      const workspacePath = createResult.workspacePath;
+
+      // Commit on the workspace branch.
+      execSync("bash -lc 'echo \"merged-change\" >> README.md'", {
+        cwd: workspacePath,
+        stdio: "ignore",
+      });
+      execSync("git add README.md", { cwd: workspacePath, stdio: "ignore" });
+      execSync('git commit -m "merged-change"', {
+        cwd: workspacePath,
+        stdio: "ignore",
+      });
+
+      // Merge into main so `git branch -d` succeeds.
+      execSync(`git merge "${branchName}"`, { cwd: projectPath, stdio: "ignore" });
+
+      const deleteResult = await runtime.deleteWorkspace(projectPath, branchName, false);
       expect(deleteResult.success).toBe(true);
 
       const after = execSync(`git branch --list "${branchName}"`, {
@@ -139,4 +203,63 @@ describe("WorktreeRuntime.deleteWorkspace", () => {
       await fsPromises.rm(rootDir, { recursive: true, force: true });
     }
   }, 20_000);
+
+  it("does not delete protected branches", async () => {
+    const rootDir = await fsPromises.realpath(
+      await fsPromises.mkdtemp(path.join(os.tmpdir(), "worktree-runtime-delete-"))
+    );
+
+    try {
+      const projectPath = path.join(rootDir, "repo");
+      await fsPromises.mkdir(projectPath, { recursive: true });
+      initGitRepo(projectPath);
+
+      // Move the main worktree off main so we can add a separate worktree on main.
+      execSync("git checkout -b other", { cwd: projectPath, stdio: "ignore" });
+
+      const srcBaseDir = path.join(rootDir, "src");
+      await fsPromises.mkdir(srcBaseDir, { recursive: true });
+
+      const runtime = new WorktreeRuntime(srcBaseDir);
+      const initLogger = createNullInitLogger();
+
+      const branchName = "main";
+      const createResult = await runtime.createWorkspace({
+        projectPath,
+        branchName,
+        trunkBranch: "main",
+        directoryName: branchName,
+        initLogger,
+      });
+      expect(createResult.success).toBe(true);
+      if (!createResult.success) return;
+      if (!createResult.workspacePath) {
+        throw new Error("Expected workspacePath from createWorkspace");
+      }
+      const workspacePath = createResult.workspacePath;
+
+      const deleteResult = await runtime.deleteWorkspace(projectPath, branchName, true);
+      expect(deleteResult.success).toBe(true);
+
+      // The worktree directory should be removed.
+      let worktreeExists = true;
+      try {
+        await fsPromises.access(workspacePath);
+      } catch {
+        worktreeExists = false;
+      }
+      expect(worktreeExists).toBe(false);
+
+      // But protected branches (like main) should never be deleted.
+      const after = execSync(`git branch --list "${branchName}"`, {
+        cwd: projectPath,
+        stdio: ["ignore", "pipe", "ignore"],
+      })
+        .toString()
+        .trim();
+      expect(after).toBe("main");
+    } finally {
+      await fsPromises.rm(rootDir, { recursive: true, force: true });
+    }
+  }, 20_000);
 });