🤖 Invert architecture: Use workspace names as directories

Terminals always resolve symlinks, showing stable IDs instead of names.
Instead of managing symlinks, use workspace names as real directory names
and track stable IDs in config.

Changes:
- Workspaces created with name as directory (not stable ID)
- Rename uses `git worktree move` to rename directory + update config
- Removed all symlink creation/management code
- Both stableWorkspacePath and namedWorkspacePath now return same path
- Config stores ID mapping: workspace.id tracks stable identity

Benefits:
- Simpler code (no symlink management)
- Better UX (terminals naturally show friendly names)
- Still stable (IDs tracked in config, renames don't break identity)
- No existing users (can make breaking changes)

_Generated with `cmux`_

🤖 Fix lint errors from workspace rename changes

🤖 Block workspace rename during active streaming

Prevents race conditions when renaming while AI stream is active:
- Bash tool processes would have stale cwd references
- System message would contain incorrect workspace path
- Git worktree move could conflict with active file operations

Changes:
- Check isStreaming() before allowing rename
- Return clear error message to user
- Add integration test verifying blocking behavior

Rename succeeds immediately after stream completes.

_Generated with `cmux`_

Fix App.tsx to use correct NewWorkspaceModal props after rebase

Fix lint errors: add void to async call and workspaceMetadata dependency

Fix executeBash test to check for workspace name instead of ID

Fix gitService tests to detect default branch instead of hardcoding 'main'

🤖 Fix: path checks use workspace name for directory lookup (stable-ids arch)

- AgentSession.ensureMetadata compared against getWorkspacePath(projectPath, id)\n  but directories are name-based. Use name instead.\n- Clarify config comment about getWorkspacePath usage.\n\nGenerated with

Author: ammar-agent

src/App.tsx

@@ -149,6 +149,13 @@ function AppInner() {
   );
   const [workspaceModalOpen, setWorkspaceModalOpen] = useState(false);
   const [workspaceModalProject, setWorkspaceModalProject] = useState<string | null>(null);
+  const [workspaceModalProjectName, setWorkspaceModalProjectName] = useState<string>("");
+  const [workspaceModalBranches, setWorkspaceModalBranches] = useState<string[]>([]);
+  const [workspaceModalDefaultTrunk, setWorkspaceModalDefaultTrunk] = useState<string | undefined>(
+    undefined
+  );
+  const [workspaceModalLoadError, setWorkspaceModalLoadError] = useState<string | null>(null);
+  const workspaceModalProjectRef = useRef<string | null>(null);
   const [sidebarCollapsed, setSidebarCollapsed] = usePersistedState("sidebarCollapsed", false);
 
   const handleToggleSidebar = useCallback(() => {
@@ -166,12 +173,17 @@ function AppInner() {
     [setProjects]
   );
 
-  const { workspaceMetadata, loading: metadataLoading, createWorkspace, removeWorkspace, renameWorkspace } =
-    useWorkspaceManagement({
-      selectedWorkspace,
-      onProjectsUpdate: handleProjectsUpdate,
-      onSelectedWorkspaceUpdate: setSelectedWorkspace,
-    });
+  const {
+    workspaceMetadata,
+    loading: metadataLoading,
+    createWorkspace,
+    removeWorkspace,
+    renameWorkspace,
+  } = useWorkspaceManagement({
+    selectedWorkspace,
+    onProjectsUpdate: handleProjectsUpdate,
+    onSelectedWorkspaceUpdate: setSelectedWorkspace,
+  });
 
   // NEW: Sync workspace metadata with the stores
   const workspaceStore = useWorkspaceStoreRaw();
@@ -221,16 +233,16 @@ function AppInner() {
       }
       void window.api.window.setTitle("cmux");
     }
-  }, [selectedWorkspace]);
+  }, [selectedWorkspace, workspaceMetadata]);
 
   // Restore workspace from URL on mount (if valid)
   // This effect runs once on mount to restore from hash, which takes priority over localStorage
   const [hasRestoredFromHash, setHasRestoredFromHash] = useState(false);
-  
+
   useEffect(() => {
     // Only run once
     if (hasRestoredFromHash) return;
-    
+
     // Wait for metadata to finish loading
     if (metadataLoading) return;
 
@@ -251,18 +263,18 @@ function AppInner() {
         });
       }
     }
-    
+
     setHasRestoredFromHash(true);
   }, [metadataLoading, workspaceMetadata, hasRestoredFromHash, setSelectedWorkspace]);
 
   // Validate selected workspace exists and has all required fields
   useEffect(() => {
     // Don't validate until metadata is loaded
     if (metadataLoading) return;
-    
+
     if (selectedWorkspace) {
       const metadata = workspaceMetadata.get(selectedWorkspace.workspaceId);
-      
+
       if (!metadata) {
         // Workspace was deleted
         console.warn(
@@ -274,9 +286,7 @@ function AppInner() {
         }
       } else if (!selectedWorkspace.namedWorkspacePath && metadata.namedWorkspacePath) {
         // Old localStorage entry missing namedWorkspacePath - update it once
-        console.log(
-          `Updating workspace ${selectedWorkspace.workspaceId} with missing fields`
-        );
+        console.log(`Updating workspace ${selectedWorkspace.workspaceId} with missing fields`);
         setSelectedWorkspace({
           workspaceId: metadata.id,
           projectPath: metadata.projectPath,
@@ -287,13 +297,16 @@ function AppInner() {
     }
   }, [metadataLoading, selectedWorkspace, workspaceMetadata, setSelectedWorkspace]);
 
-  const openWorkspaceInTerminal = useCallback((workspaceId: string) => {
-    // Look up workspace metadata to get the named path (user-friendly symlink)
-    const metadata = workspaceMetadata.get(workspaceId);
-    if (metadata) {
-      void window.api.workspace.openTerminal(metadata.namedWorkspacePath);
-    }
-  }, [workspaceMetadata]);
+  const openWorkspaceInTerminal = useCallback(
+    (workspaceId: string) => {
+      // Look up workspace metadata to get the named path (user-friendly symlink)
+      const metadata = workspaceMetadata.get(workspaceId);
+      if (metadata) {
+        void window.api.workspace.openTerminal(metadata.namedWorkspacePath);
+      }
+    },
+    [workspaceMetadata]
+  );
 
   const handleRemoveProject = useCallback(
     async (path: string) => {
@@ -305,9 +318,45 @@ function AppInner() {
     [removeProject, selectedWorkspace, setSelectedWorkspace]
   );
 
-  const handleAddWorkspace = useCallback((projectPath: string) => {
+  const handleAddWorkspace = useCallback(async (projectPath: string) => {
+    const projectName = projectPath.split("/").pop() ?? projectPath.split("\\").pop() ?? "project";
+
+    workspaceModalProjectRef.current = projectPath;
     setWorkspaceModalProject(projectPath);
+    setWorkspaceModalProjectName(projectName);
+    setWorkspaceModalBranches([]);
+    setWorkspaceModalDefaultTrunk(undefined);
+    setWorkspaceModalLoadError(null);
     setWorkspaceModalOpen(true);
+
+    try {
+      const branchResult = await window.api.projects.listBranches(projectPath);
+
+      // Guard against race condition: only update state if this is still the active project
+      if (workspaceModalProjectRef.current !== projectPath) {
+        return;
+      }
+
+      const sanitizedBranches = Array.isArray(branchResult?.branches)
+        ? branchResult.branches.filter((branch): branch is string => typeof branch === "string")
+        : [];
+
+      const recommended =
+        typeof branchResult?.recommendedTrunk === "string" &&
+        sanitizedBranches.includes(branchResult.recommendedTrunk)
+          ? branchResult.recommendedTrunk
+          : sanitizedBranches[0];
+
+      setWorkspaceModalBranches(sanitizedBranches);
+      setWorkspaceModalDefaultTrunk(recommended);
+      setWorkspaceModalLoadError(null);
+    } catch (err) {
+      console.error("Failed to load branches for modal:", err);
+      const message = err instanceof Error ? err.message : "Unknown error";
+      setWorkspaceModalLoadError(
+        `Unable to load branches automatically: ${message}. You can still enter the trunk branch manually.`
+      );
+    }
   }, []);
 
   // Memoize callbacks to prevent LeftSidebar/ProjectSidebar re-renders
@@ -495,7 +544,7 @@ function AppInner() {
 
   const openNewWorkspaceFromPalette = useCallback(
     (projectPath: string) => {
-      handleAddWorkspace(projectPath);
+      void handleAddWorkspace(projectPath);
     },
     [handleAddWorkspace]
   );
@@ -682,7 +731,10 @@ function AppInner() {
                   key={selectedWorkspace.workspaceId}
                   workspaceId={selectedWorkspace.workspaceId}
                   projectName={selectedWorkspace.projectName}
-                  branch={selectedWorkspace.namedWorkspacePath?.split("/").pop() ?? selectedWorkspace.workspaceId}
+                  branch={
+                    selectedWorkspace.namedWorkspacePath?.split("/").pop() ??
+                    selectedWorkspace.workspaceId
+                  }
                   namedWorkspacePath={selectedWorkspace.namedWorkspacePath ?? ""}
                 />
               </ErrorBoundary>
@@ -703,10 +755,18 @@ function AppInner() {
         {workspaceModalOpen && workspaceModalProject && (
           <NewWorkspaceModal
             isOpen={workspaceModalOpen}
-            projectPath={workspaceModalProject}
+            projectName={workspaceModalProjectName}
+            branches={workspaceModalBranches}
+            defaultTrunkBranch={workspaceModalDefaultTrunk}
+            loadErrorMessage={workspaceModalLoadError}
             onClose={() => {
+              workspaceModalProjectRef.current = null;
               setWorkspaceModalOpen(false);
               setWorkspaceModalProject(null);
+              setWorkspaceModalProjectName("");
+              setWorkspaceModalBranches([]);
+              setWorkspaceModalDefaultTrunk(undefined);
+              setWorkspaceModalLoadError(null);
             }}
             onAdd={handleCreateWorkspace}
           />

src/config.test.ts

@@ -35,105 +35,6 @@ describe("Config", () => {
     });
   });
 
-  describe("symlink management", () => {
-    let projectPath: string;
-    let projectDir: string;
-
-    beforeEach(() => {
-      projectPath = "/fake/project";
-      const projectName = "project";
-      projectDir = path.join(config.srcDir, projectName);
-      fs.mkdirSync(projectDir, { recursive: true });
-    });
-
-    it("should create a symlink from name to ID", () => {
-      const id = "abc123def4";
-      const name = "feature-branch";
-      const idPath = path.join(projectDir, id);
-      const symlinkPath = path.join(projectDir, name);
-
-      // Create the actual ID directory
-      fs.mkdirSync(idPath);
-
-      // Create symlink
-      config.createWorkspaceSymlink(projectPath, id, name);
-
-      // Verify symlink exists and points to ID
-      expect(fs.existsSync(symlinkPath)).toBe(true);
-      const stats = fs.lstatSync(symlinkPath);
-      expect(stats.isSymbolicLink()).toBe(true);
-      expect(fs.readlinkSync(symlinkPath)).toBe(id);
-    });
-
-    it("should update a symlink when renaming", () => {
-      const id = "abc123def4";
-      const oldName = "old-name";
-      const newName = "new-name";
-      const idPath = path.join(projectDir, id);
-      const oldSymlinkPath = path.join(projectDir, oldName);
-      const newSymlinkPath = path.join(projectDir, newName);
-
-      // Create the actual ID directory and initial symlink
-      fs.mkdirSync(idPath);
-      fs.symlinkSync(id, oldSymlinkPath, "dir");
-
-      // Update symlink
-      config.updateWorkspaceSymlink(projectPath, oldName, newName, id);
-
-      // Verify old symlink removed and new one created
-      expect(fs.existsSync(oldSymlinkPath)).toBe(false);
-      expect(fs.existsSync(newSymlinkPath)).toBe(true);
-      const stats = fs.lstatSync(newSymlinkPath);
-      expect(stats.isSymbolicLink()).toBe(true);
-      expect(fs.readlinkSync(newSymlinkPath)).toBe(id);
-    });
-
-    it("should remove a symlink", () => {
-      const id = "abc123def4";
-      const name = "feature-branch";
-      const idPath = path.join(projectDir, id);
-      const symlinkPath = path.join(projectDir, name);
-
-      // Create the actual ID directory and symlink
-      fs.mkdirSync(idPath);
-      fs.symlinkSync(id, symlinkPath, "dir");
-
-      // Remove symlink
-      config.removeWorkspaceSymlink(projectPath, name);
-
-      // Verify symlink removed but ID directory still exists
-      expect(fs.existsSync(symlinkPath)).toBe(false);
-      expect(fs.existsSync(idPath)).toBe(true);
-    });
-
-    it("should handle removing non-existent symlink gracefully", () => {
-      const name = "nonexistent";
-      expect(() => {
-        config.removeWorkspaceSymlink(projectPath, name);
-      }).not.toThrow();
-    });
-
-    it("should replace existing symlink when creating", () => {
-      const id = "abc123def4";
-      const name = "feature-branch";
-      const idPath = path.join(projectDir, id);
-      const symlinkPath = path.join(projectDir, name);
-
-      // Create the actual ID directory
-      fs.mkdirSync(idPath);
-
-      // Create initial symlink to different target
-      fs.symlinkSync("different-id", symlinkPath, "dir");
-
-      // Create new symlink (should replace old one)
-      config.createWorkspaceSymlink(projectPath, id, name);
-
-      // Verify symlink now points to new ID
-      expect(fs.existsSync(symlinkPath)).toBe(true);
-      expect(fs.readlinkSync(symlinkPath)).toBe(id);
-    });
-  });
-
   describe("getAllWorkspaceMetadata with migration", () => {
     it("should migrate legacy workspace without metadata file", () => {
       const projectPath = "/fake/project";