🤖 fix: persist runtimeConfig when forking local workspaces (#1863)

## Summary

Fix local workspace fork creating corrupt worktree workspaces by
persisting `runtimeConfig` in `config.addWorkspace()`, then simplify the
codebase by removing redundant inline fallbacks.

## Background

PR #1721 (commit 4238ff4) added fork support for local (project-dir)
workspaces. The `LocalRuntime.forkWorkspace()` was correctly implemented
to return the project path, and `workspaceService.fork()` correctly
assembled the `FrontendWorkspaceMetadata` with `runtimeConfig:
forkedRuntimeConfig`.

However, when `config.addWorkspace()` stored the forked workspace entry,
it **discarded the runtimeConfig field**:

```typescript
const workspaceEntry: Workspace = {
  path: workspacePath,
  id: metadata.id,
  name: metadata.name,
  createdAt: metadata.createdAt,
  // runtimeConfig was missing!
};
```

On subsequent config loads, `getAllWorkspaceMetadata()` would see no
`runtimeConfig` and apply `DEFAULT_RUNTIME_CONFIG` (type: "worktree"
with srcBaseDir), causing the forked workspace to be treated as a
worktree runtime. This created "corrupt worktree" errors because
WorktreeRuntime operations would fail on directories that were never set
up as git worktrees.

## Implementation

### Commit 1: Fix runtimeConfig persistence
One-line fix: include `runtimeConfig: metadata.runtimeConfig` in the
workspace entry when calling `addWorkspace()`.

### Commit 2: Remove redundant fallbacks
The config layer already guarantees every `WorkspaceMetadata` has a
`runtimeConfig` (via `DEFAULT_RUNTIME_CONFIG` applied in
`getAllWorkspaceMetadata()`). This commit removes 13 inline `?? { type:
"local", srcBaseDir }` fallbacks across 5 service files that were:

- **Redundant**: The metadata type already includes runtimeConfig
- **Inconsistent**: Inline fallbacks used `type: "local"` while the
canonical default is `type: "worktree"`
- **Bug-masking**: Silently substituting values instead of surfacing
issues

Files cleaned up:
- `workspaceService.ts` (5 locations)
- `agentSession.ts` (5 locations)
- `aiService.ts`, `terminalService.ts`,
`workspaceMcpOverridesService.ts` (1 each)

### Commit 3: Fix namedWorkspacePath persistence (Codex review feedback)
`config.addWorkspace()` was hardcoding worktree-style paths
(`~/.mux/src/...`) even for local workspaces. After app restart, this
caused Open-in-Editor and path display to use the wrong directory.

Fix: use `namedWorkspacePath` from the metadata if provided (which is
computed runtime-aware by `Runtime.getWorkspacePath()`), falling back to
worktree-style path only for legacy callers.

## Validation

- Integration tests for fork persistence:
- Creates local workspace → forks → verifies runtimeConfig survives
reload
- Verifies `namedWorkspacePath` is the project path (not
`~/.mux/src/...`) after reload
- `make typecheck` passes
- `make static-check` passes
- `TEST_INTEGRATION=1 bun x jest tests/ipc/forkWorkspace.test.ts` - all
9 tests pass

---

_Generated with `mux` · Model: `anthropic:claude-sonnet-4-20250514`_

<!-- mux-attribution: model=anthropic:claude-sonnet-4-20250514 -->

Author: ammar-agent

src/node/config.ts

@@ -762,7 +762,10 @@ export class Config {
    * @param projectPath Absolute path to the project
    * @param metadata Workspace metadata to save
    */
-  async addWorkspace(projectPath: string, metadata: WorkspaceMetadata): Promise<void> {
+  async addWorkspace(
+    projectPath: string,
+    metadata: WorkspaceMetadata & { namedWorkspacePath?: string }
+  ): Promise<void> {
     await this.editConfig((config) => {
       let project = config.projects.get(projectPath);
 
@@ -774,15 +777,17 @@ export class Config {
       // Check if workspace already exists (by ID)
       const existingIndex = project.workspaces.findIndex((w) => w.id === metadata.id);
 
-      // Compute workspace path - this is only for legacy config migration
-      // New code should use Runtime.getWorkspacePath() directly
+      // Use provided namedWorkspacePath if available (runtime-aware),
+      // otherwise fall back to worktree-style path for legacy compatibility
       const projectName = this.getProjectName(projectPath);
-      const workspacePath = path.join(this.srcDir, projectName, metadata.name);
+      const workspacePath =
+        metadata.namedWorkspacePath ?? path.join(this.srcDir, projectName, metadata.name);
       const workspaceEntry: Workspace = {
         path: workspacePath,
         id: metadata.id,
         name: metadata.name,
         createdAt: metadata.createdAt,
+        runtimeConfig: metadata.runtimeConfig,
       };
 
       if (existingIndex >= 0) {

src/node/services/agentSession.ts

@@ -345,10 +345,10 @@ export class AgentSession {
       const expectedPath = isInPlace
         ? metadata.projectPath
         : (() => {
-            const runtime = createRuntime(
-              metadata.runtimeConfig ?? { type: "local", srcBaseDir: this.config.srcDir },
-              { projectPath: metadata.projectPath, workspaceName: metadata.name }
-            );
+            const runtime = createRuntime(metadata.runtimeConfig, {
+              projectPath: metadata.projectPath,
+              workspaceName: metadata.name,
+            });
             return runtime.getWorkspacePath(metadata.projectPath, metadata.name);
           })();
       assert(
@@ -1272,14 +1272,7 @@ export class AgentSession {
 
         return attachments;
       }
-      const runtime = createRuntimeForWorkspace({
-        runtimeConfig: metadataResult.data.runtimeConfig ?? {
-          type: "local",
-          srcBaseDir: this.config.srcDir,
-        },
-        projectPath: metadataResult.data.projectPath,
-        name: metadataResult.data.name,
-      });
+      const runtime = createRuntimeForWorkspace(metadataResult.data);
 
       const attachments = await AttachmentService.generatePostCompactionAttachments(
         metadataResult.data.name,
@@ -1343,14 +1336,7 @@ export class AgentSession {
 
       return attachments;
     }
-    const runtime = createRuntimeForWorkspace({
-      runtimeConfig: metadataResult.data.runtimeConfig ?? {
-        type: "local",
-        srcBaseDir: this.config.srcDir,
-      },
-      projectPath: metadataResult.data.projectPath,
-      name: metadataResult.data.name,
-    });
+    const runtime = createRuntimeForWorkspace(metadataResult.data);
 
     const attachments = await AttachmentService.generatePostCompactionAttachments(
       metadataResult.data.name,
@@ -1399,11 +1385,7 @@ export class AgentSession {
     }
 
     const metadata = metadataResult.data;
-    const runtime = createRuntimeForWorkspace({
-      runtimeConfig: metadata.runtimeConfig ?? { type: "local", srcBaseDir: this.config.srcDir },
-      projectPath: metadata.projectPath,
-      name: metadata.name,
-    });
+    const runtime = createRuntimeForWorkspace(metadata);
     const workspacePath = runtime.getWorkspacePath(metadata.projectPath, metadata.name);
 
     const materialized = await materializeFileAtMentions(messageText, {
@@ -1467,10 +1449,10 @@ export class AgentSession {
     }
 
     const metadata = metadataResult.data;
-    const runtime = createRuntime(
-      metadata.runtimeConfig ?? { type: "local", srcBaseDir: this.config.srcDir },
-      { projectPath: metadata.projectPath, workspaceName: metadata.name }
-    );
+    const runtime = createRuntime(metadata.runtimeConfig, {
+      projectPath: metadata.projectPath,
+      workspaceName: metadata.name,
+    });
 
     // In-place workspaces (CLI/benchmarks) have projectPath === name.
     // Use the path directly instead of reconstructing via getWorkspacePath.

src/node/services/aiService.ts

@@ -1159,10 +1159,10 @@ export class AIService extends EventEmitter {
       }
 
       // Get workspace path - handle both worktree and in-place modes
-      const runtime = createRuntime(
-        metadata.runtimeConfig ?? { type: "local", srcBaseDir: this.config.srcDir },
-        { projectPath: metadata.projectPath, workspaceName: metadata.name }
-      );
+      const runtime = createRuntime(metadata.runtimeConfig, {
+        projectPath: metadata.projectPath,
+        workspaceName: metadata.name,
+      });
       // In-place workspaces (CLI/benchmarks) have projectPath === name
       // Use path directly instead of reconstructing via getWorkspacePath
       const isInPlace = metadata.projectPath === metadata.name;

src/node/services/terminalService.ts

@@ -85,10 +85,10 @@ export class TerminalService {
       }
 
       // 2. Create runtime (pass workspace info for Docker container name derivation)
-      const runtime = createRuntime(
-        workspaceMetadata.runtimeConfig ?? { type: "local", srcBaseDir: this.config.srcDir },
-        { projectPath: workspaceMetadata.projectPath, workspaceName: workspaceMetadata.name }
-      );
+      const runtime = createRuntime(workspaceMetadata.runtimeConfig, {
+        projectPath: workspaceMetadata.projectPath,
+        workspaceName: workspaceMetadata.name,
+      });
 
       // 3. Compute workspace path
       const workspacePath = runtime.getWorkspacePath(

src/node/services/workspaceMcpOverridesService.ts

@@ -166,11 +166,7 @@ export class WorkspaceMcpOverridesService {
   }> {
     const metadata = await this.getWorkspaceMetadata(workspaceId);
 
-    const runtime = createRuntimeForWorkspace({
-      runtimeConfig: metadata.runtimeConfig ?? { type: "local", srcBaseDir: this.config.srcDir },
-      projectPath: metadata.projectPath,
-      name: metadata.name,
-    });
+    const runtime = createRuntimeForWorkspace(metadata);
 
     // In-place workspaces (CLI/benchmarks) store the workspace path directly by setting
     // metadata.projectPath === metadata.name.

src/node/services/workspaceService.ts

@@ -836,10 +836,10 @@ export class WorkspaceService extends EventEmitter {
         const metadata = metadataResult.data;
         const projectPath = metadata.projectPath;
 
-        const runtime = createRuntime(
-          metadata.runtimeConfig ?? { type: "local", srcBaseDir: this.config.srcDir },
-          { projectPath, workspaceName: metadata.name }
-        );
+        const runtime = createRuntime(metadata.runtimeConfig, {
+          projectPath,
+          workspaceName: metadata.name,
+        });
 
         // Delete workspace from runtime first - if this fails with force=false, we abort
         // and keep workspace in config so user can retry. This prevents orphaned directories.
@@ -1018,10 +1018,10 @@ export class WorkspaceService extends EventEmitter {
       }
       const { projectPath } = workspace;
 
-      const runtime = createRuntime(
-        oldMetadata.runtimeConfig ?? { type: "local", srcBaseDir: this.config.srcDir },
-        { projectPath, workspaceName: oldName }
-      );
+      const runtime = createRuntime(oldMetadata.runtimeConfig, {
+        projectPath,
+        workspaceName: oldName,
+      });
 
       const renameResult = await runtime.renameWorkspace(projectPath, oldName, newName);
 
@@ -1502,10 +1502,7 @@ export class WorkspaceService extends EventEmitter {
       const foundProjectPath = sourceMetadata.projectPath;
       const projectName = sourceMetadata.projectName;
 
-      const sourceRuntimeConfig = sourceMetadata.runtimeConfig ?? {
-        type: "local",
-        srcBaseDir: this.config.srcDir,
-      };
+      const sourceRuntimeConfig = sourceMetadata.runtimeConfig;
 
       // Block fork for remote runtimes - creates broken workspaces
       // Sub-agent task spawning uses a different code path (TaskService.create)
@@ -2348,16 +2345,7 @@ export class WorkspaceService extends EventEmitter {
       return { paths: [] };
     }
 
-    const runtimeConfig = metadata.runtimeConfig ?? {
-      type: "local" as const,
-      srcBaseDir: this.config.srcDir,
-    };
-
-    const runtime = createRuntimeForWorkspace({
-      runtimeConfig,
-      projectPath: metadata.projectPath,
-      name: metadata.name,
-    });
+    const runtime = createRuntimeForWorkspace(metadata);
     const isInPlace = metadata.projectPath === metadata.name;
     const workspacePath = isInPlace
       ? metadata.projectPath
@@ -2474,11 +2462,7 @@ export class WorkspaceService extends EventEmitter {
       using tempDir = new DisposableTempDir("mux-ipc-bash");
 
       // Create runtime and compute workspace path
-      const runtimeConfig = metadata.runtimeConfig ?? {
-        type: "local" as const,
-        srcBaseDir: this.config.srcDir,
-      };
-      const runtime = createRuntime(runtimeConfig, {
+      const runtime = createRuntime(metadata.runtimeConfig, {
         projectPath: metadata.projectPath,
         workspaceName: metadata.name,
       });

tests/ipc/forkWorkspace.test.ts

@@ -502,4 +502,65 @@ describeIntegration("Workspace fork", () => {
     },
     15000
   );
+
+  test.concurrent(
+    "should persist local runtimeConfig through config reload after fork",
+    async () => {
+      const env = await createTestEnvironment();
+      const tempGitRepo = await createTempGitRepo();
+
+      try {
+        // Create source workspace with LocalRuntime (project-dir mode)
+        const localRuntimeConfig = { type: "local" as const };
+
+        const client = resolveOrpcClient(env);
+        const createResult = await client.workspace.create({
+          projectPath: tempGitRepo,
+          branchName: "local-persist-test",
+          trunkBranch: "main",
+          runtimeConfig: localRuntimeConfig,
+        });
+        expect(createResult.success).toBe(true);
+        if (!createResult.success) return;
+        const sourceWorkspaceId = createResult.metadata.id;
+
+        // Fork the local workspace
+        const forkResult = await client.workspace.fork({
+          sourceWorkspaceId,
+          newName: "local-persist-forked",
+        });
+        expect(forkResult.success).toBe(true);
+        if (!forkResult.success) return;
+        const forkedWorkspaceId = forkResult.metadata.id;
+
+        // Verify forked workspace has local runtimeConfig immediately
+        expect(forkResult.metadata.runtimeConfig.type).toBe("local");
+        expect("srcBaseDir" in forkResult.metadata.runtimeConfig).toBe(false);
+
+        // BUG REPRO: Reload config and verify runtimeConfig persisted correctly
+        // This simulates what happens after app restart or when getAllWorkspaceMetadata is called
+        const workspaces = await client.workspace.list();
+        const forkedWorkspace = workspaces.find((w: { id: string }) => w.id === forkedWorkspaceId);
+
+        // This is the critical assertion that would fail before the fix:
+        // After reload, the workspace should still have type: "local" without srcBaseDir
+        expect(forkedWorkspace).toBeDefined();
+        expect(forkedWorkspace!.runtimeConfig.type).toBe("local");
+        expect("srcBaseDir" in forkedWorkspace!.runtimeConfig).toBe(false);
+
+        // Verify namedWorkspacePath is the project path (not ~/.mux/src/...) for local workspaces
+        // This ensures Open-in-Editor and path display work correctly after reload
+        expect(forkedWorkspace!.namedWorkspacePath).toBe(tempGitRepo);
+        expect(forkResult.metadata.namedWorkspacePath).toBe(tempGitRepo);
+
+        // Cleanup
+        await client.workspace.remove({ workspaceId: sourceWorkspaceId });
+        await client.workspace.remove({ workspaceId: forkedWorkspaceId });
+      } finally {
+        await cleanupTestEnvironment(env);
+        await cleanupTempGitRepo(tempGitRepo);
+      }
+    },
+    15000
+  );
 });