🤖 fix: rollback failed task spawns

If persisting the queued prompt or starting the child stream fails, remove the
newly-created task workspace from config and best-effort delete its worktree +
session dir to avoid orphaned descendants blocking future task creation.

Add a regression test for the sendMessage failure path.

Signed-off-by: Thomas Kosiewski <tk@coder.com>

---
_Generated with `codex cli` • Model: `gpt-5.2` • Thinking: `xhigh`_
<!-- mux-attribution: model=gpt-5.2 thinking=xhigh -->

Change-Id: I77552838252872e4d80f26b8259f8892831ceb59

Author: ThomasK33

src/node/services/taskService.test.ts

@@ -301,6 +301,123 @@ describe("TaskService", () => {
     expect(started?.taskStatus).toBe("running");
   }, 20_000);
 
+  test("rolls back created workspace when initial sendMessage fails", async () => {
+    const config = new Config(rootDir);
+    await fsPromises.mkdir(config.srcDir, { recursive: true });
+
+    const configWithStableId = config as unknown as { generateStableId: () => string };
+    configWithStableId.generateStableId = () => "aaaaaaaaaa";
+
+    const projectPath = path.join(rootDir, "repo");
+    await fsPromises.mkdir(projectPath, { recursive: true });
+    initGitRepo(projectPath);
+
+    const runtimeConfig = { type: "worktree" as const, srcBaseDir: config.srcDir };
+    const runtime = createRuntime(runtimeConfig, { projectPath });
+    const initLogger = createNullInitLogger();
+
+    const parentName = "parent";
+    const parentCreate = await runtime.createWorkspace({
+      projectPath,
+      branchName: parentName,
+      trunkBranch: "main",
+      directoryName: parentName,
+      initLogger,
+    });
+    expect(parentCreate.success).toBe(true);
+
+    const parentId = "1111111111";
+    const parentPath = runtime.getWorkspacePath(projectPath, parentName);
+
+    await config.saveConfig({
+      projects: new Map([
+        [
+          projectPath,
+          {
+            workspaces: [
+              {
+                path: parentPath,
+                id: parentId,
+                name: parentName,
+                createdAt: new Date().toISOString(),
+                runtimeConfig,
+              },
+            ],
+          },
+        ],
+      ]),
+      taskSettings: { maxParallelAgentTasks: 3, maxTaskNestingDepth: 3 },
+    });
+
+    const historyService = new HistoryService(config);
+    const partialService = new PartialService(config, historyService);
+
+    const aiService: AIService = {
+      isStreaming: mock(() => false),
+      getWorkspaceMetadata: mock(
+        async (workspaceId: string): Promise<Result<WorkspaceMetadata>> => {
+          const all = await config.getAllWorkspaceMetadata();
+          const found = all.find((m) => m.id === workspaceId);
+          return found ? Ok(found) : Err("not found");
+        }
+      ),
+      on: mock(() => undefined),
+      off: mock(() => undefined),
+    } as unknown as AIService;
+
+    const sendMessage = mock(() => Promise.resolve(Err("send failed")));
+    const resumeStream = mock(() => Promise.resolve(Ok(undefined)));
+    const remove = mock(() => Promise.resolve(Ok(undefined)));
+    const emit = mock(() => true);
+
+    const workspaceService: WorkspaceService = {
+      sendMessage,
+      resumeStream,
+      remove,
+      emit,
+    } as unknown as WorkspaceService;
+
+    const initStateManager: InitStateManager = {
+      startInit: mock(() => undefined),
+      appendOutput: mock(() => undefined),
+      endInit: mock(() => Promise.resolve()),
+    } as unknown as InitStateManager;
+
+    const taskService = new TaskService(
+      config,
+      historyService,
+      partialService,
+      aiService,
+      workspaceService,
+      initStateManager
+    );
+
+    const created = await taskService.create({
+      parentWorkspaceId: parentId,
+      kind: "agent",
+      agentType: "explore",
+      prompt: "do the thing",
+    });
+
+    expect(created.success).toBe(false);
+
+    const postCfg = config.loadConfigOrDefault();
+    const stillExists = Array.from(postCfg.projects.values())
+      .flatMap((p) => p.workspaces)
+      .some((w) => w.id === "aaaaaaaaaa");
+    expect(stillExists).toBe(false);
+
+    const workspaceName = "agent_explore_aaaaaaaaaa";
+    const workspacePath = runtime.getWorkspacePath(projectPath, workspaceName);
+    let workspacePathExists = true;
+    try {
+      await fsPromises.access(workspacePath);
+    } catch {
+      workspacePathExists = false;
+    }
+    expect(workspacePathExists).toBe(false);
+  }, 20_000);
+
   test("agent_report posts report to parent, finalizes pending task tool output, and triggers cleanup", async () => {
     const config = new Config(rootDir);
 

src/node/services/taskService.ts

@@ -1,4 +1,5 @@
 import assert from "node:assert/strict";
+import * as fsPromises from "fs/promises";
 
 import { AsyncMutex } from "@/node/utils/concurrency/asyncMutex";
 import type { Config, Workspace as WorkspaceConfigEntry } from "@/node/config";
@@ -334,6 +335,7 @@ export class TaskService {
 
       const appendResult = await this.historyService.appendToHistory(taskId, userMessage);
       if (!appendResult.success) {
+        await this.rollbackFailedTaskCreate(runtime, parentMeta.projectPath, workspaceName, taskId);
         return Err(`Task.create: failed to persist queued prompt (${appendResult.error})`);
       }
 
@@ -353,12 +355,56 @@ export class TaskService {
         typeof sendResult.error === "string"
           ? sendResult.error
           : formatSendMessageError(sendResult.error).message;
+      await this.rollbackFailedTaskCreate(runtime, parentMeta.projectPath, workspaceName, taskId);
       return Err(message);
     }
 
     return Ok({ taskId, kind: "agent", status: "running" });
   }
 
+  private async rollbackFailedTaskCreate(
+    runtime: ReturnType<typeof createRuntime>,
+    projectPath: string,
+    workspaceName: string,
+    taskId: string
+  ): Promise<void> {
+    try {
+      await this.config.removeWorkspace(taskId);
+    } catch (error: unknown) {
+      log.error("Task.create rollback: failed to remove workspace from config", {
+        taskId,
+        error: error instanceof Error ? error.message : String(error),
+      });
+    }
+
+    this.workspaceService.emit("metadata", { workspaceId: taskId, metadata: null });
+
+    try {
+      const deleteResult = await runtime.deleteWorkspace(projectPath, workspaceName, true);
+      if (!deleteResult.success) {
+        log.error("Task.create rollback: failed to delete workspace", {
+          taskId,
+          error: deleteResult.error,
+        });
+      }
+    } catch (error: unknown) {
+      log.error("Task.create rollback: runtime.deleteWorkspace threw", {
+        taskId,
+        error: error instanceof Error ? error.message : String(error),
+      });
+    }
+
+    try {
+      const sessionDir = this.config.getSessionDir(taskId);
+      await fsPromises.rm(sessionDir, { recursive: true, force: true });
+    } catch (error: unknown) {
+      log.error("Task.create rollback: failed to remove session directory", {
+        taskId,
+        error: error instanceof Error ? error.message : String(error),
+      });
+    }
+  }
+
   waitForAgentReport(
     taskId: string,
     options?: { timeoutMs?: number; abortSignal?: AbortSignal }