🤖 fix: prevent race condition between rename and streaming

Added renamingWorkspaces set to track workspaces being renamed.
- sendMessage and resumeStream now check this flag and return error
- Both AI-generated rename and user-initiated rename set the flag
- Flag is cleared in finally blocks to ensure cleanup

This prevents a race where:
1. Stream ends, rename starts
2. Auto-resume or user triggers new stream
3. Stream uses old paths while rename is changing them

_Generated with mux_

Author: ibetitsmike

src/node/services/workspaceService.ts

@@ -81,6 +81,8 @@ export class WorkspaceService extends EventEmitter {
     string,
     { chat: () => void; metadata: () => void }
   >();
+  // Tracks workspaces currently being renamed to prevent streaming during rename
+  private readonly renamingWorkspaces = new Set<string>();
 
   constructor(
     private readonly config: Config,
@@ -688,37 +690,44 @@ export class WorkspaceService extends EventEmitter {
       // Wait for the stream to complete before renaming (rename is blocked during streaming)
       await this.waitForStreamComplete(workspaceId);
 
-      // Attempt to rename with collision retry (same logic as workspace creation)
-      let finalName = aiGeneratedName;
-      for (let attempt = 0; attempt <= MAX_WORKSPACE_NAME_COLLISION_RETRIES; attempt++) {
-        const renameResult = await this.rename(workspaceId, finalName);
+      // Mark workspace as renaming to block new streams during the rename operation
+      this.renamingWorkspaces.add(workspaceId);
+      try {
+        // Attempt to rename with collision retry (same logic as workspace creation)
+        let finalName = aiGeneratedName;
+        for (let attempt = 0; attempt <= MAX_WORKSPACE_NAME_COLLISION_RETRIES; attempt++) {
+          const renameResult = await this.rename(workspaceId, finalName);
+
+          if (renameResult.success) {
+            log.info("Successfully renamed workspace to AI-generated name", {
+              workspaceId,
+              oldName: currentName,
+              newName: finalName,
+            });
+            return;
+          }
 
-        if (renameResult.success) {
-          log.info("Successfully renamed workspace to AI-generated name", {
+          // If collision and not last attempt, retry with suffix
+          if (
+            renameResult.error?.includes("already exists") &&
+            attempt < MAX_WORKSPACE_NAME_COLLISION_RETRIES
+          ) {
+            log.debug(`Workspace name collision for "${finalName}", retrying with suffix`);
+            finalName = appendCollisionSuffix(aiGeneratedName);
+            continue;
+          }
+
+          // Non-collision error or out of retries - keep placeholder name
+          log.info("Failed to rename workspace to AI-generated name", {
             workspaceId,
-            oldName: currentName,
-            newName: finalName,
+            aiGeneratedName: finalName,
+            error: renameResult.error,
           });
           return;
         }
-
-        // If collision and not last attempt, retry with suffix
-        if (
-          renameResult.error?.includes("already exists") &&
-          attempt < MAX_WORKSPACE_NAME_COLLISION_RETRIES
-        ) {
-          log.debug(`Workspace name collision for "${finalName}", retrying with suffix`);
-          finalName = appendCollisionSuffix(aiGeneratedName);
-          continue;
-        }
-
-        // Non-collision error or out of retries - keep placeholder name
-        log.info("Failed to rename workspace to AI-generated name", {
-          workspaceId,
-          aiGeneratedName: finalName,
-          error: renameResult.error,
-        });
-        return;
+      } finally {
+        // Always clear renaming flag, even on error
+        this.renamingWorkspaces.delete(workspaceId);
       }
     } catch (error) {
       const errorMessage = error instanceof Error ? error.message : String(error);
@@ -891,6 +900,9 @@ export class WorkspaceService extends EventEmitter {
         return Err(validation.error ?? "Invalid workspace name");
       }
 
+      // Mark workspace as renaming to block new streams during the rename operation
+      this.renamingWorkspaces.add(workspaceId);
+
       const metadataResult = await this.aiService.getWorkspaceMetadata(workspaceId);
       if (!metadataResult.success) {
         return Err(`Failed to get workspace metadata: ${metadataResult.error}`);
@@ -958,6 +970,9 @@ export class WorkspaceService extends EventEmitter {
     } catch (error) {
       const message = error instanceof Error ? error.message : String(error);
       return Err(`Failed to rename workspace: ${message}`);
+    } finally {
+      // Always clear renaming flag, even on error
+      this.renamingWorkspaces.delete(workspaceId);
     }
   }
 
@@ -1102,6 +1117,15 @@ export class WorkspaceService extends EventEmitter {
     });
 
     try {
+      // Block streaming while workspace is being renamed to prevent path conflicts
+      if (this.renamingWorkspaces.has(workspaceId)) {
+        log.debug("sendMessage blocked: workspace is being renamed", { workspaceId });
+        return Err({
+          type: "unknown",
+          raw: "Workspace is being renamed. Please wait and try again.",
+        });
+      }
+
       const session = this.getOrCreateSession(workspaceId);
       void this.updateRecencyTimestamp(workspaceId);
 
@@ -1144,6 +1168,15 @@ export class WorkspaceService extends EventEmitter {
     options: SendMessageOptions | undefined = { model: "claude-3-5-sonnet-latest" }
   ): Promise<Result<void, SendMessageError>> {
     try {
+      // Block streaming while workspace is being renamed to prevent path conflicts
+      if (this.renamingWorkspaces.has(workspaceId)) {
+        log.debug("resumeStream blocked: workspace is being renamed", { workspaceId });
+        return Err({
+          type: "unknown",
+          raw: "Workspace is being renamed. Please wait and try again.",
+        });
+      }
+
       const session = this.getOrCreateSession(workspaceId);
       const result = await session.resumeStream(options);
       if (!result.success) {