🤖 Remove ipcMain coupling with git worktrees

Problem: ipcMain directly imported and called git worktree functions
(removeWorktree, pruneWorktrees), breaking the Runtime abstraction:
- Created leaky abstraction with if (type !== 'ssh') checks
- Exposed LocalRuntime implementation details (worktrees) to business logic
- Inconsistent - some ops went through Runtime, others bypassed it

Key insight: Worktrees are an internal concept of LocalRuntime. SSHRuntime
uses plain directories. The Runtime interface should never expose
worktree-specific operations.

Solution: Make LocalRuntime.deleteWorkspace() fully idempotent and
self-sufficient:

1. LocalRuntime.deleteWorkspace() now:
   - Checks if directory exists before attempting deletion
   - Prunes stale git records when directory is already gone
   - Handles 'not a working tree' errors gracefully by auto-pruning
   - Returns success for already-deleted workspaces (idempotent)

2. ipcMain cleanup paths now use runtime.deleteWorkspace():
   - Line 608: Fork cleanup now calls runtime.deleteWorkspace(force=true)
   - Lines 1067-1078: Removed manual pruning logic entirely

3. Removed git imports from ipcMain:
   - Deleted removeWorktree and pruneWorktrees imports
   - Only kept branch query operations (getCurrentBranch, etc.)

Benefits:
✅ Proper encapsulation - Worktree concerns stay in LocalRuntime
✅ No leaky abstractions - Removed if (type !== 'ssh') check from ipcMain
✅ Consistent - All workspace mutations go through Runtime interface
✅ Idempotent - deleteWorkspace() succeeds on already-deleted workspaces
✅ Zero Runtime interface changes - Solution internal to LocalRuntime

Result: Clean architecture, no git coupling in ipcMain, all tests pass.

_Generated with `cmux`_

Author: ammar-agent

src/runtime/LocalRuntime.ts

@@ -478,6 +478,18 @@ export class LocalRuntime implements Runtime {
     // Compute workspace path using the canonical method
     const deletedPath = this.getWorkspacePath(projectPath, workspaceName);
 
+    // Check if directory exists - if not, operation is idempotent
+    if (!fs.existsSync(deletedPath)) {
+      // Directory already gone - prune stale git records (best effort)
+      try {
+        using pruneProc = execAsync(`git -C "${projectPath}" worktree prune`);
+        await pruneProc.result;
+      } catch {
+        // Ignore prune errors - directory is already deleted, which is the goal
+      }
+      return { success: true, deletedPath };
+    }
+
     try {
       // Use git worktree remove to delete the worktree
       // This updates git's internal worktree metadata correctly
@@ -492,6 +504,25 @@ export class LocalRuntime implements Runtime {
     } catch (error) {
       const message = getErrorMessage(error);
 
+      // Check if the error is due to missing/stale worktree
+      const normalizedError = message.toLowerCase();
+      const looksLikeMissingWorktree =
+        normalizedError.includes("not a working tree") ||
+        normalizedError.includes("does not exist") ||
+        normalizedError.includes("no such file");
+
+      if (looksLikeMissingWorktree) {
+        // Worktree records are stale - prune them
+        try {
+          using pruneProc = execAsync(`git -C "${projectPath}" worktree prune`);
+          await pruneProc.result;
+        } catch {
+          // Ignore prune errors
+        }
+        // Treat as success - workspace is gone (idempotent)
+        return { success: true, deletedPath };
+      }
+
       // If force is enabled and git worktree remove failed, fall back to rm -rf
       // This handles edge cases like submodules where git refuses to delete
       if (force) {

src/services/ipcMain.ts

@@ -10,8 +10,6 @@ import {
   listLocalBranches,
   detectDefaultTrunkBranch,
   getCurrentBranch,
-  removeWorktree,
-  pruneWorktrees,
 } from "@/git";
 import { AIService } from "@/services/aiService";
 import { HistoryService } from "@/services/historyService";
@@ -604,13 +602,14 @@ export class IpcMain {
             }
           } catch (copyError) {
             // If copy fails, clean up everything we created
-            // 1. Remove the workspace
-            await removeWorktree(foundProjectPath, newWorkspacePath);
+            // 1. Remove the workspace using Runtime abstraction
+            const cleanupRuntime = createRuntime({ type: "local", srcBaseDir: this.config.srcDir });
+            await cleanupRuntime.deleteWorkspace(foundProjectPath, newName, true);
             // 2. Remove the session directory (may contain partial copies)
             try {
               await fsPromises.rm(newSessionDir, { recursive: true, force: true });
             } catch (cleanupError) {
-              // Log but don't fail - worktree cleanup is more important
+              // Log but don't fail - workspace cleanup is more important
               log.error(`Failed to clean up session dir ${newSessionDir}:`, cleanupError);
             }
             const message = copyError instanceof Error ? copyError.message : String(copyError);
@@ -1053,34 +1052,12 @@ export class IpcMain {
         metadata.runtimeConfig ?? { type: "local", srcBaseDir: this.config.srcDir }
       );
 
-      // Delegate deletion to runtime - it handles all path computation and existence checks
+      // Delegate deletion to runtime - it handles all path computation, existence checks, and pruning
       const deleteResult = await runtime.deleteWorkspace(projectPath, metadata.name, options.force);
 
       if (!deleteResult.success) {
-        const errorMessage = deleteResult.error;
-        const normalizedError = errorMessage.toLowerCase();
-        const looksLikeMissingWorktree =
-          normalizedError.includes("not a working tree") ||
-          normalizedError.includes("does not exist") ||
-          normalizedError.includes("no such file");
-
-        if (looksLikeMissingWorktree) {
-          // Worktree is already gone or stale - prune git records if this is a local worktree
-          if (metadata.runtimeConfig?.type !== "ssh") {
-            const pruneResult = await pruneWorktrees(projectPath);
-            if (!pruneResult.success) {
-              log.info(
-                `Failed to prune stale worktrees for ${projectPath} after deleteWorkspace error: ${
-                  pruneResult.error ?? "unknown error"
-                }`
-              );
-            }
-          }
-          // Treat missing workspace as success (idempotent operation)
-        } else {
-          // Real error (e.g., dirty workspace without force) - return it
-          return { success: false, error: deleteResult.error };
-        }
+        // Real error (e.g., dirty workspace without force) - return it
+        return { success: false, error: deleteResult.error };
       }
 
       // Remove the workspace from AI service