🤖 fix: avoid task timeouts while queued

Foreground task waits now start the agent_report timeout only after the child
workspace transitions from queued → running, so queue time doesn’t count against
execution time.

Also start queued tasks only after a successful resumeStream and add a regression
test for the queued-wait behavior.

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: Iddcac5eb351ebc21e13fed886081f5fd4f1eaf90

Author: ThomasK33

src/node/services/taskService.test.ts

@@ -301,6 +301,84 @@ describe("TaskService", () => {
     expect(started?.taskStatus).toBe("running");
   }, 20_000);
 
+  test("waitForAgentReport does not time out while task is queued", async () => {
+    const config = new Config(rootDir);
+
+    const projectPath = path.join(rootDir, "repo");
+    const parentId = "parent-111";
+    const childId = "child-222";
+
+    await config.saveConfig({
+      projects: new Map([
+        [
+          projectPath,
+          {
+            workspaces: [
+              { path: path.join(projectPath, "parent"), id: parentId, name: "parent" },
+              {
+                path: path.join(projectPath, "child"),
+                id: childId,
+                name: "agent_explore_child",
+                parentWorkspaceId: parentId,
+                agentType: "explore",
+                taskStatus: "queued",
+              },
+            ],
+          },
+        ],
+      ]),
+      taskSettings: { maxParallelAgentTasks: 1, maxTaskNestingDepth: 3 },
+    });
+
+    const historyService = new HistoryService(config);
+    const partialService = new PartialService(config, historyService);
+
+    const aiService: AIService = {
+      isStreaming: mock(() => false),
+      on: mock(() => undefined),
+      off: mock(() => undefined),
+    } as unknown as AIService;
+
+    const workspaceService: WorkspaceService = {
+      sendMessage: mock(() => Promise.resolve(Ok(undefined))),
+      resumeStream: mock(() => Promise.resolve(Ok(undefined))),
+      remove: mock(() => Promise.resolve(Ok(undefined))),
+      emit: mock(() => true),
+    } 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
+    );
+
+    // Timeout is short so the test would fail if the timer started while queued.
+    const reportPromise = taskService.waitForAgentReport(childId, { timeoutMs: 50 });
+
+    // Wait longer than timeout while task is still queued.
+    await new Promise((r) => setTimeout(r, 100));
+
+    const internal = taskService as unknown as {
+      setTaskStatus: (workspaceId: string, status: "queued" | "running") => Promise<void>;
+      resolveWaiters: (taskId: string, report: { reportMarkdown: string; title?: string }) => void;
+    };
+
+    await internal.setTaskStatus(childId, "running");
+    internal.resolveWaiters(childId, { reportMarkdown: "ok" });
+
+    const report = await reportPromise;
+    expect(report.reportMarkdown).toBe("ok");
+  });
+
   test("rolls back created workspace when initial sendMessage fails", async () => {
     const config = new Config(rootDir);
     await fsPromises.mkdir(config.srcDir, { recursive: true });

src/node/services/taskService.ts

@@ -53,6 +53,12 @@ interface PendingTaskWaiter {
   cleanup: () => void;
 }
 
+interface PendingTaskStartWaiter {
+  createdAt: number;
+  start: () => void;
+  cleanup: () => void;
+}
+
 function isToolCallEndEvent(value: unknown): value is ToolCallEndEvent {
   return (
     typeof value === "object" &&
@@ -113,6 +119,7 @@ function getIsoNow(): string {
 export class TaskService {
   private readonly mutex = new AsyncMutex();
   private readonly pendingWaitersByTaskId = new Map<string, PendingTaskWaiter[]>();
+  private readonly pendingStartWaitersByTaskId = new Map<string, PendingTaskStartWaiter[]>();
   private readonly remindedAwaitingReport = new Set<string>();
 
   constructor(
@@ -416,12 +423,33 @@ export class TaskService {
 
     return new Promise<{ reportMarkdown: string; title?: string }>((resolve, reject) => {
       let timeout: ReturnType<typeof setTimeout> | null = null;
+      let startWaiter: PendingTaskStartWaiter | null = null;
       let abortListener: (() => void) | null = null;
 
+      const startReportTimeout = () => {
+        if (timeout) return;
+        timeout = setTimeout(() => {
+          entry.cleanup();
+          reject(new Error("Timed out waiting for agent_report"));
+        }, timeoutMs);
+      };
+
+      const cleanupStartWaiter = () => {
+        if (!startWaiter) return;
+        startWaiter.cleanup();
+        startWaiter = null;
+      };
+
       const entry: PendingTaskWaiter = {
         createdAt: Date.now(),
-        resolve,
-        reject,
+        resolve: (report) => {
+          entry.cleanup();
+          resolve(report);
+        },
+        reject: (error) => {
+          entry.cleanup();
+          reject(error);
+        },
         cleanup: () => {
           const current = this.pendingWaitersByTaskId.get(taskId);
           if (current) {
@@ -433,6 +461,8 @@ export class TaskService {
             }
           }
 
+          cleanupStartWaiter();
+
           if (timeout) {
             clearTimeout(timeout);
             timeout = null;
@@ -449,10 +479,43 @@ export class TaskService {
       list.push(entry);
       this.pendingWaitersByTaskId.set(taskId, list);
 
-      timeout = setTimeout(() => {
-        entry.cleanup();
-        reject(new Error("Timed out waiting for agent_report"));
-      }, timeoutMs);
+      // Don't start the execution timeout while the task is still queued.
+      // The timer starts once the child actually begins running (queued -> running).
+      const cfg = this.config.loadConfigOrDefault();
+      const taskEntry = this.findWorkspaceEntry(cfg, taskId);
+      const initialStatus = taskEntry?.workspace.taskStatus;
+      if (initialStatus === "queued") {
+        const startWaiterEntry: PendingTaskStartWaiter = {
+          createdAt: Date.now(),
+          start: startReportTimeout,
+          cleanup: () => {
+            const currentStartWaiters = this.pendingStartWaitersByTaskId.get(taskId);
+            if (currentStartWaiters) {
+              const next = currentStartWaiters.filter((w) => w !== startWaiterEntry);
+              if (next.length === 0) {
+                this.pendingStartWaitersByTaskId.delete(taskId);
+              } else {
+                this.pendingStartWaitersByTaskId.set(taskId, next);
+              }
+            }
+          },
+        };
+        startWaiter = startWaiterEntry;
+
+        const currentStartWaiters = this.pendingStartWaitersByTaskId.get(taskId) ?? [];
+        currentStartWaiters.push(startWaiterEntry);
+        this.pendingStartWaitersByTaskId.set(taskId, currentStartWaiters);
+
+        // Close the race where the task starts between the initial config read and registering the waiter.
+        const cfgAfterRegister = this.config.loadConfigOrDefault();
+        const afterEntry = this.findWorkspaceEntry(cfgAfterRegister, taskId);
+        if (afterEntry?.workspace.taskStatus !== "queued") {
+          cleanupStartWaiter();
+          startReportTimeout();
+        }
+      } else {
+        startReportTimeout();
+      }
 
       if (options?.abortSignal) {
         if (options.abortSignal.aborted) {
@@ -578,8 +641,6 @@ export class TaskService {
     for (const task of queued) {
       if (!task.id) continue;
 
-      await this.setTaskStatus(task.id, "running");
-
       // Start by resuming from the queued prompt in history.
       const model = task.taskModelString ?? defaultModel;
       const resumeResult = await this.workspaceService.resumeStream(task.id, {
@@ -589,9 +650,10 @@ export class TaskService {
 
       if (!resumeResult.success) {
         log.error("Failed to start queued task", { taskId: task.id, error: resumeResult.error });
-        // Put it back in queued to retry later.
-        await this.setTaskStatus(task.id, "queued");
+        continue;
       }
+
+      await this.setTaskStatus(task.id, "running");
     }
   }
 
@@ -612,6 +674,19 @@ export class TaskService {
     const allMetadata = await this.config.getAllWorkspaceMetadata();
     const metadata = allMetadata.find((m) => m.id === workspaceId) ?? null;
     this.workspaceService.emit("metadata", { workspaceId, metadata });
+
+    if (status === "running") {
+      const waiters = this.pendingStartWaitersByTaskId.get(workspaceId);
+      if (!waiters || waiters.length === 0) return;
+      this.pendingStartWaitersByTaskId.delete(workspaceId);
+      for (const waiter of waiters) {
+        try {
+          waiter.start();
+        } catch (error: unknown) {
+          log.error("Task start waiter callback failed", { workspaceId, error });
+        }
+      }
+    }
   }
 
   private async handleStreamEnd(event: StreamEndEvent): Promise<void> {