🤖 fix: resume awaiting_report tasks on restart

TaskService.initialize now resumes leaf tasks stuck in taskStatus=awaiting_report so they can emit agent_report after a crash/restart.

Also harden the taskService tests by disabling commit signing in the temp repos to avoid hangs when developers have global commit.gpgsign enabled.

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

Author: ThomasK33

src/node/services/taskService.test.ts

@@ -20,6 +20,8 @@ function initGitRepo(projectPath: string): void {
   execSync("git init -b main", { cwd: projectPath, stdio: "ignore" });
   execSync('git config user.email "test@example.com"', { cwd: projectPath, stdio: "ignore" });
   execSync('git config user.name "test"', { cwd: projectPath, stdio: "ignore" });
+  // Ensure tests don't hang when developers have global commit signing enabled.
+  execSync("git config commit.gpgsign false", { cwd: projectPath, stdio: "ignore" });
   execSync("bash -lc 'echo \"hello\" > README.md'", { cwd: projectPath, stdio: "ignore" });
   execSync("git add README.md", { cwd: projectPath, stdio: "ignore" });
   execSync('git commit -m "init"', { cwd: projectPath, stdio: "ignore" });
@@ -301,6 +303,78 @@ describe("TaskService", () => {
     expect(started?.taskStatus).toBe("running");
   }, 20_000);
 
+  test("initialize resumes awaiting_report tasks after restart", 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: "awaiting_report",
+              },
+            ],
+          },
+        ],
+      ]),
+      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 resumeStream = mock(() => Promise.resolve(Ok(undefined)));
+
+    const workspaceService: WorkspaceService = {
+      sendMessage: mock(() => Promise.resolve(Ok(undefined))),
+      resumeStream,
+      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
+    );
+
+    await taskService.initialize();
+
+    expect(resumeStream).toHaveBeenCalledWith(
+      childId,
+      expect.objectContaining({
+        toolPolicy: [{ regex_match: "^agent_report$", action: "require" }],
+      })
+    );
+  });
+
   test("waitForAgentReport does not time out while task is queued", async () => {
     const config = new Config(rootDir);
 

src/node/services/taskService.ts

@@ -150,10 +150,46 @@ export class TaskService {
     await this.maybeStartQueuedTasks();
 
     const config = this.config.loadConfigOrDefault();
+    const awaitingReportTasks = this.listAgentTaskWorkspaces(config).filter(
+      (t) => t.taskStatus === "awaiting_report"
+    );
     const runningTasks = this.listAgentTaskWorkspaces(config).filter(
       (t) => t.taskStatus === "running"
     );
 
+    for (const task of awaitingReportTasks) {
+      if (!task.id) continue;
+
+      // Avoid resuming a task while it still has active descendants (it shouldn't report yet).
+      const hasActiveDescendants = this.hasActiveDescendantAgentTasks(config, task.id);
+      if (hasActiveDescendants) {
+        continue;
+      }
+
+      // Restart-safety: if this task stream ends again without agent_report, fall back immediately.
+      this.remindedAwaitingReport.add(task.id);
+
+      const model = task.taskModelString ?? defaultModel;
+      const resumeResult = await this.workspaceService.resumeStream(task.id, {
+        model,
+        thinkingLevel: task.taskThinkingLevel,
+        toolPolicy: [{ regex_match: "^agent_report$", action: "require" }],
+        additionalSystemInstructions:
+          "This task is awaiting its final agent_report. Call agent_report exactly once now.",
+      });
+      if (!resumeResult.success) {
+        log.error("Failed to resume awaiting_report task on startup", {
+          taskId: task.id,
+          error: resumeResult.error,
+        });
+
+        await this.fallbackReportMissingAgentReport({
+          projectPath: task.projectPath,
+          workspace: task,
+        });
+      }
+    }
+
     for (const task of runningTasks) {
       if (!task.id) continue;
       // Best-effort: if mux restarted mid-stream, nudge the agent to continue and report.