Add stable workspace IDs

Workspaces now use stable, unique IDs (10 hex chars) instead of deriving IDs from paths. This simplifies workspace renames from 150 lines of complex migration logic to ~60 lines of metadata updates.

**Stable ID Generation:**
- Generate at workspace creation: `crypto.randomBytes(5).toString('hex')`
- Separate `id` (stable, immutable) from `name` (mutable, user-facing)
- Add symlinks for UX: `~/.cmux/src/<project>/<name>` → `<id>`

**Type System:**
- `WorkspaceMetadata`: Backend type with stable ID, no path field
- `WorkspaceMetadataWithPaths`: Frontend type with computed paths
- IPC layer enriches metadata with `stableWorkspacePath` and `namedWorkspacePath`

**Workspace Operations:**
- Create: Generate stable ID before creating worktree
- Rename: Update metadata + symlink only (ID unchanged, ~60 lines)
- Remove: Clean up worktree, session data, and symlinks

**Frontend Integration:**
- Build `pathToMetadata` map for lookups (handles both stable and legacy)
- Use map lookups instead of parsing workspace IDs from paths
- Support both new stable-ID workspaces and legacy name-based workspaces

```
~/.cmux/src/cmux/a1b2c3d4e5/          # Worktree (stable ID)
~/.cmux/src/cmux/feature-branch → a1b2c3d4e5  # Symlink
~/.cmux/sessions/a1b2c3d4e5/          # Session data

~/.cmux/src/cmux/stable-ids/          # Worktree
~/.cmux/sessions/cmux-stable-ids/     # Session data
```

- **Instant renames**: No file moves, just metadata update
- **Simpler code**: Removed 90 lines of complex migration/rollback logic
- **Better UX**: Symlinks let users navigate by readable names
- **Stable references**: Chat history, config stay valid across renames
- **Future-proof**: Enables workspace aliases, templates, cross-project refs

- ✅ 511 unit tests pass
- ✅ 8 rename integration tests pass
- ✅ 5 remove integration tests pass
- ✅ 13 E2E tests pass
- ✅ 9 new config unit tests

Fix stuck loading state for deleted/invalid workspaces

When a workspace is deleted or doesn't exist:
- Previously: selectedWorkspace persisted in localStorage, causing eternal "Loading workspace..."
- Now: Validate workspace exists on mount and clear invalid selection

Added validation effect that:
- Checks if selected workspace ID exists in workspaceMetadata
- Clears selection if workspace was deleted
- Also clears URL hash to prevent re-selection on reload

Fixes edge cases:
- Workspace deleted while app was closed
- URL with invalid workspace ID (#workspace=invalid-id)
- Workspace removed from another instance

Remove rename blocking during streaming

With stable IDs, workspace rename no longer requires moving files or
changing workspace ID. Rename only updates:
- metadata.name (display name)
- Symlink (~/.cmux/src/project/name → workspaceId)

Session directory (~/.cmux/sessions/workspaceId) remains unchanged,
so active streams can continue writing safely.

Changes:
- Remove isStreaming check from WORKSPACE_RENAME handler
- Remove "should block rename during active stream" test
- Simplifies UX: no more "Press Esc first" error

Benefits:
- Users can organize workspaces without interrupting work
- One less artificial limitation
- Cleaner, simpler code (-38 lines)

Fix integration test race condition with AI SDK dynamic imports

Integration tests were failing in CI with:
"Failed to create model: ReferenceError: You are trying to `import` a
file outside of the scope of the test code."

This only occurred when multiple tests ran concurrently in CI, not locally.

AI SDK providers use dynamic imports for lazy loading (to optimize startup
time from 6-13s → 3-6s). Under high concurrency in CI (8 workers × 11 test
files × concurrent tests within files), Jest/Bun's module resolution has a
race condition where multiple simultaneous dynamic imports of the same
module can fail.

Preload AI SDK providers once during test setup, similar to how we preload
tokenizer modules. This ensures subsequent dynamic imports hit the module
cache instead of racing.

- Added `preloadAISDKProviders()` function to aiService.ts
- Called during `setupWorkspace()` alongside `loadTokenizerModules()`
- Preserves lazy loading in production (startup optimization)
- Eliminates race condition in concurrent test environment

- ✅ Tests pass locally with concurrent execution
- ✅ No impact on production startup time (preload only in tests)
- ✅ No changes to test behavior, only timing/reliability

Fixes the flaky integration test failures in PR #259.

Fix formatting

Refactor: eliminate pathToMetadata code smell

1. Rename type: WorkspaceMetadataWithPaths → FrontendWorkspaceMetadata
2. sortedWorkspacesByProject returns metadata arrays directly
3. Removed duplicate pathToMetadata maps from App.tsx and ProjectSidebar
4. WorkspaceListItem accepts metadata object (6 props → 1)
5. Updated keyboard navigation to work with metadata

- Net: -23 lines (removed duplicate logic)
- Clearer data flow: pass data, not lookup maps
- Simpler component API: metadata object vs 6 props

16 files changed, 124 insertions(+), 147 deletions(-)

Fix lint errors: remove unused imports and params

Author: ammar-agent

src/App.tsx

@@ -6,6 +6,7 @@ import { GlobalFonts } from "./styles/fonts";
 import { GlobalScrollbars } from "./styles/scrollbars";
 import type { ProjectConfig } from "./config";
 import type { WorkspaceSelection } from "./components/ProjectSidebar";
+import type { FrontendWorkspaceMetadata } from "./types/workspace";
 import { LeftSidebar } from "./components/LeftSidebar";
 import NewWorkspaceModal from "./components/NewWorkspaceModal";
 import { AIView } from "./components/AIView";
@@ -148,13 +149,6 @@ 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(() => {
@@ -237,27 +231,36 @@ function AppInner() {
       const metadata = Array.from(workspaceMetadata.values()).find((ws) => ws.id === workspaceId);
 
       if (metadata) {
-        // Find project for this workspace
-        for (const [projectPath, projectConfig] of projects.entries()) {
-          const workspace = (projectConfig.workspaces ?? []).find(
-            (ws) => ws.path === metadata.workspacePath
-          );
-          if (workspace) {
-            setSelectedWorkspace({
-              workspaceId: metadata.id,
-              projectPath,
-              projectName: metadata.projectName,
-              workspacePath: metadata.workspacePath,
-            });
-            break;
-          }
-        }
+        // Find project for this workspace (metadata now includes projectPath)
+        setSelectedWorkspace({
+          workspaceId: metadata.id,
+          projectPath: metadata.projectPath,
+          projectName: metadata.projectName,
+          workspacePath: metadata.stableWorkspacePath,
+        });
       }
     }
     // Only run on mount
     // eslint-disable-next-line react-hooks/exhaustive-deps
   }, []);
 
+  // Validate selected workspace exists (clear if workspace was deleted)
+  useEffect(() => {
+    if (selectedWorkspace && workspaceMetadata.size > 0) {
+      const exists = workspaceMetadata.has(selectedWorkspace.workspaceId);
+      if (!exists) {
+        console.warn(
+          `Workspace ${selectedWorkspace.workspaceId} no longer exists, clearing selection`
+        );
+        setSelectedWorkspace(null);
+        // Also clear URL hash if present
+        if (window.location.hash) {
+          window.history.replaceState(null, "", window.location.pathname);
+        }
+      }
+    }
+  }, [selectedWorkspace, workspaceMetadata, setSelectedWorkspace]);
+
   const openWorkspaceInTerminal = useCallback((workspacePath: string) => {
     void window.api.workspace.openTerminal(workspacePath);
   }, []);
@@ -272,45 +275,9 @@ function AppInner() {
     [removeProject, selectedWorkspace, setSelectedWorkspace]
   );
 
-  const handleAddWorkspace = useCallback(async (projectPath: string) => {
-    const projectName = projectPath.split("/").pop() ?? projectPath.split("\\").pop() ?? "project";
-
-    workspaceModalProjectRef.current = projectPath;
+  const handleAddWorkspace = useCallback((projectPath: string) => {
     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
@@ -364,24 +331,32 @@ function AppInner() {
   const workspaceRecency = useWorkspaceRecency();
 
   // Sort workspaces by recency (most recent first)
+  // Returns Map<projectPath, FrontendWorkspaceMetadata[]> for direct component use
   // Use stable reference to prevent sidebar re-renders when sort order hasn't changed
   const sortedWorkspacesByProject = useStableReference(
     () => {
-      const result = new Map<string, ProjectConfig["workspaces"]>();
+      // Build path-to-metadata lookup map internally
+      const pathToMetadata = new Map<string, FrontendWorkspaceMetadata>();
+      for (const metadata of workspaceMetadata.values()) {
+        pathToMetadata.set(metadata.stableWorkspacePath, metadata);
+        pathToMetadata.set(metadata.namedWorkspacePath, metadata);
+      }
+
+      const result = new Map<string, FrontendWorkspaceMetadata[]>();
       for (const [projectPath, config] of projects) {
-        result.set(
-          projectPath,
-          (config.workspaces ?? []).slice().sort((a, b) => {
-            const aMeta = workspaceMetadata.get(a.path);
-            const bMeta = workspaceMetadata.get(b.path);
-            if (!aMeta || !bMeta) return 0;
-
-            // Get timestamp of most recent user message (0 if never used)
-            const aTimestamp = workspaceRecency[aMeta.id] ?? 0;
-            const bTimestamp = workspaceRecency[bMeta.id] ?? 0;
-            return bTimestamp - aTimestamp;
-          })
-        );
+        // Transform Workspace[] to FrontendWorkspaceMetadata[] and filter nulls
+        const metadataList = config.workspaces
+          .map((ws) => pathToMetadata.get(ws.path))
+          .filter((meta): meta is FrontendWorkspaceMetadata => meta !== undefined);
+
+        // Sort by recency
+        metadataList.sort((a, b) => {
+          const aTimestamp = workspaceRecency[a.id] ?? 0;
+          const bTimestamp = workspaceRecency[b.id] ?? 0;
+          return bTimestamp - aTimestamp;
+        });
+
+        result.set(projectPath, metadataList);
       }
       return result;
     },
@@ -390,7 +365,7 @@ function AppInner() {
       if (
         !compareMaps(prev, next, (a, b) => {
           if (a.length !== b.length) return false;
-          return a.every((workspace, i) => workspace.path === b[i].path);
+          return a.every((metadata, i) => metadata.id === b[i].id);
         })
       ) {
         return false;
@@ -410,7 +385,7 @@ function AppInner() {
 
       // Find current workspace index in sorted list
       const currentIndex = sortedWorkspaces.findIndex(
-        (ws) => ws.path === selectedWorkspace.workspacePath
+        (metadata) => metadata.id === selectedWorkspace.workspaceId
       );
       if (currentIndex === -1) return;
 
@@ -422,20 +397,17 @@ function AppInner() {
         targetIndex = currentIndex === 0 ? sortedWorkspaces.length - 1 : currentIndex - 1;
       }
 
-      const targetWorkspace = sortedWorkspaces[targetIndex];
-      if (!targetWorkspace) return;
-
-      const metadata = workspaceMetadata.get(targetWorkspace.path);
-      if (!metadata) return;
+      const targetMetadata = sortedWorkspaces[targetIndex];
+      if (!targetMetadata) return;
 
       setSelectedWorkspace({
         projectPath: selectedWorkspace.projectPath,
         projectName: selectedWorkspace.projectName,
-        workspacePath: targetWorkspace.path,
-        workspaceId: metadata.id,
+        workspacePath: targetMetadata.stableWorkspacePath,
+        workspaceId: targetMetadata.id,
       });
     },
-    [selectedWorkspace, sortedWorkspacesByProject, workspaceMetadata, setSelectedWorkspace]
+    [selectedWorkspace, sortedWorkspacesByProject, setSelectedWorkspace]
   );
 
   // Register command sources with registry
@@ -495,7 +467,7 @@ function AppInner() {
 
   const openNewWorkspaceFromPalette = useCallback(
     (projectPath: string) => {
-      void handleAddWorkspace(projectPath);
+      handleAddWorkspace(projectPath);
     },
     [handleAddWorkspace]
   );
@@ -679,19 +651,15 @@ function AppInner() {
         />
         <MainContent>
           <ContentArea>
-            {selectedWorkspace?.workspacePath ? (
+            {selectedWorkspace ? (
               <ErrorBoundary
-                workspaceInfo={`${selectedWorkspace.projectName}/${selectedWorkspace.workspacePath?.split("/").pop() ?? selectedWorkspace.workspaceId ?? "unknown"}`}
+                workspaceInfo={`${selectedWorkspace.projectName}/${selectedWorkspace.workspacePath.split("/").pop() ?? ""}`}
               >
                 <AIView
                   key={selectedWorkspace.workspaceId}
                   workspaceId={selectedWorkspace.workspaceId}
                   projectName={selectedWorkspace.projectName}
-                  branch={
-                    selectedWorkspace.workspacePath?.split("/").pop() ??
-                    selectedWorkspace.workspaceId ??
-                    ""
-                  }
+                  branch={selectedWorkspace.workspacePath.split("/").pop() ?? ""}
                   workspacePath={selectedWorkspace.workspacePath}
                 />
               </ErrorBoundary>
@@ -712,18 +680,10 @@ function AppInner() {
         {workspaceModalOpen && workspaceModalProject && (
           <NewWorkspaceModal
             isOpen={workspaceModalOpen}
-            projectName={workspaceModalProjectName}
-            branches={workspaceModalBranches}
-            defaultTrunkBranch={workspaceModalDefaultTrunk}
-            loadErrorMessage={workspaceModalLoadError}
+            projectPath={workspaceModalProject}
             onClose={() => {
-              workspaceModalProjectRef.current = null;
               setWorkspaceModalOpen(false);
               setWorkspaceModalProject(null);
-              setWorkspaceModalProjectName("");
-              setWorkspaceModalBranches([]);
-              setWorkspaceModalDefaultTrunk(undefined);
-              setWorkspaceModalLoadError(null);
             }}
             onAdd={handleCreateWorkspace}
           />

src/components/LeftSidebar.tsx

@@ -1,7 +1,7 @@
 import React from "react";
 import styled from "@emotion/styled";
 import type { ProjectConfig } from "@/config";
-import type { WorkspaceMetadata } from "@/types/workspace";
+import type { FrontendWorkspaceMetadata } from "@/types/workspace";
 import type { WorkspaceSelection } from "./ProjectSidebar";
 import type { Secret } from "@/types/secrets";
 import ProjectSidebar from "./ProjectSidebar";
@@ -21,7 +21,7 @@ const LeftSidebarContainer = styled.div<{ collapsed?: boolean }>`
 
 interface LeftSidebarProps {
   projects: Map<string, ProjectConfig>;
-  workspaceMetadata: Map<string, WorkspaceMetadata>;
+  workspaceMetadata: Map<string, FrontendWorkspaceMetadata>;
   selectedWorkspace: WorkspaceSelection | null;
   onSelectWorkspace: (selection: WorkspaceSelection) => void;
   onAddProject: () => void;
@@ -41,7 +41,7 @@ interface LeftSidebarProps {
   onToggleCollapsed: () => void;
   onGetSecrets: (projectPath: string) => Promise<Secret[]>;
   onUpdateSecrets: (projectPath: string, secrets: Secret[]) => Promise<void>;
-  sortedWorkspacesByProject: Map<string, ProjectConfig["workspaces"]>;
+  sortedWorkspacesByProject: Map<string, FrontendWorkspaceMetadata[]>;
 }
 
 export function LeftSidebar(props: LeftSidebarProps) {

src/components/ProjectSidebar.tsx

@@ -2,8 +2,8 @@ import React, { useState, useEffect, useCallback, useRef } from "react";
 import { createPortal } from "react-dom";
 import styled from "@emotion/styled";
 import { css } from "@emotion/react";
-import type { ProjectConfig, Workspace } from "@/config";
-import type { WorkspaceMetadata } from "@/types/workspace";
+import type { ProjectConfig } from "@/config";
+import type { FrontendWorkspaceMetadata } from "@/types/workspace";
 import { usePersistedState } from "@/hooks/usePersistedState";
 import { DndProvider } from "react-dnd";
 import { HTML5Backend, getEmptyImage } from "react-dnd-html5-backend";
@@ -471,7 +471,7 @@ const ProjectDragLayer: React.FC = () => {
 
 interface ProjectSidebarProps {
   projects: Map<string, ProjectConfig>;
-  workspaceMetadata: Map<string, WorkspaceMetadata>;
+  workspaceMetadata: Map<string, FrontendWorkspaceMetadata>;
   selectedWorkspace: WorkspaceSelection | null;
   onSelectWorkspace: (selection: WorkspaceSelection) => void;
   onAddProject: () => void;
@@ -491,12 +491,11 @@ interface ProjectSidebarProps {
   onToggleCollapsed: () => void;
   onGetSecrets: (projectPath: string) => Promise<Secret[]>;
   onUpdateSecrets: (projectPath: string, secrets: Secret[]) => Promise<void>;
-  sortedWorkspacesByProject: Map<string, Workspace[]>;
+  sortedWorkspacesByProject: Map<string, FrontendWorkspaceMetadata[]>;
 }
 
 const ProjectSidebarInner: React.FC<ProjectSidebarProps> = ({
   projects,
-  workspaceMetadata,
   selectedWorkspace,
   onSelectWorkspace,
   onAddProject,
@@ -820,23 +819,13 @@ const ProjectSidebarInner: React.FC<ProjectSidebarProps> = ({
                                   ` (${formatKeybind(KEYBINDS.NEW_WORKSPACE)})`}
                               </AddWorkspaceBtn>
                             </WorkspaceHeader>
-                            {(
-                              sortedWorkspacesByProject.get(projectPath) ??
-                              config.workspaces ??
-                              []
-                            ).map((workspace) => {
-                              const metadata = workspaceMetadata.get(workspace.path);
-                              if (!metadata) return null;
-
-                              const workspaceId = metadata.id;
-                              const isSelected =
-                                selectedWorkspace?.workspacePath === workspace.path;
+                            {sortedWorkspacesByProject.get(projectPath)?.map((metadata) => {
+                              const isSelected = selectedWorkspace?.workspaceId === metadata.id;
 
                               return (
                                 <WorkspaceListItem
-                                  key={workspace.path}
-                                  workspaceId={workspaceId}
-                                  workspacePath={workspace.path}
+                                  key={metadata.id}
+                                  metadata={metadata}
                                   projectPath={projectPath}
                                   projectName={projectName}
                                   isSelected={isSelected}