🤖 fix: register foreground task promise before startTask

Address Codex review comment: foreground tasks now register their
pending completion promise BEFORE calling startTask, ensuring that
if startTask fails early (e.g., sendMessage returns an error),
handleTaskFailure can find and reject the promise, preventing the
parent stream from hanging indefinitely.

Added test case to verify this behavior.

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

Author: ThomasK33

src/node/services/taskService.test.ts

@@ -406,6 +406,56 @@ describe("TaskService", () => {
     ).rejects.toThrow(/Maximum task nesting depth/);
   });
 
+  it("rejects foreground task promise when startTask fails early", async () => {
+    // This test verifies that foreground tasks properly reject their promise
+    // when sendMessage fails, instead of leaving the parent stream hanging.
+    const config = new FakeConfig();
+    const parent = createWorkspaceMetadata("parent");
+    config.addWorkspace(parent);
+
+    const aiService = new FakeAIService();
+    aiService.setWorkspaceMetadata(parent);
+
+    const workspaceService = new FakeWorkspaceService(config, aiService);
+    const historyService = new FakeHistoryService();
+    const partialService = new FakePartialService();
+
+    // Make sendMessage fail
+    workspaceService.sendMessageResult = Err({
+      type: "unknown",
+      raw: "simulated sendMessage failure",
+    });
+
+    const taskService = new TaskService(
+      config as unknown as Config,
+      workspaceService as unknown as WorkspaceService,
+      historyService as unknown as HistoryService,
+      partialService as unknown as PartialService,
+      aiService as unknown as AIService
+    );
+
+    // Foreground task (runInBackground: false) should reject when startTask fails
+    let error: Error | null = null;
+    try {
+      await taskService.createTask({
+        parentWorkspaceId: "parent",
+        agentType: "research",
+        prompt: "will fail",
+        runInBackground: false,
+        parentToolCallId: "tool_call_1",
+      });
+    } catch (e) {
+      error = e as Error;
+    }
+
+    expect(error).not.toBeNull();
+    expect(error?.message).toBe("simulated sendMessage failure");
+
+    // Verify task state is set to failed
+    const taskState = config.getWorkspaceTaskState("task_1");
+    expect(taskState?.taskStatus).toBe("failed");
+  });
+
   it("queues tasks when maxParallelAgentTasks reached and inherits parent runtime", async () => {
     const config = new FakeConfig();
     config.setTaskSettings({ maxParallelAgentTasks: 1 });

src/node/services/taskService.ts

@@ -234,6 +234,16 @@ export class TaskService extends EventEmitter {
 
     this.emit("task-created", { taskId, parentWorkspaceId });
 
+    // For foreground tasks, register the pending completion BEFORE starting the task.
+    // This ensures that if startTask fails synchronously, handleTaskFailure can find
+    // and reject the promise, preventing the parent stream from hanging indefinitely.
+    let completionPromise: Promise<CreateTaskResult> | undefined;
+    if (!runInBackground) {
+      completionPromise = new Promise<CreateTaskResult>((resolve, reject) => {
+        this.pendingCompletions.set(taskId, { resolve, reject });
+      });
+    }
+
     if (shouldQueue) {
       // Add to queue
       this.taskQueue.push({ taskId, options });
@@ -252,10 +262,8 @@ export class TaskService extends EventEmitter {
       };
     }
 
-    // Wait for completion
-    return new Promise<CreateTaskResult>((resolve, reject) => {
-      this.pendingCompletions.set(taskId, { resolve, reject });
-    });
+    // Wait for completion (promise was registered before startTask to handle early failures)
+    return completionPromise!;
   }
 
   /**