🤖 fix: redeliver saved reports for 'reported' tasks on restart

Address Codex review comment: if Mux crashes after saving a task's
report (taskStatus='reported') but before delivering it to the parent
workspace, the report would be lost on restart.

Now:
- getActiveAgentTaskWorkspaces() includes 'reported' tasks
- rehydrateTasks() calls redeliverSavedReport() for reported tasks
- hasActiveDescendantTasks() filters out reported tasks so they don't
  block parent stream resumption

Added test case to verify restart redelivery of saved reports.

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

Author: ThomasK33

src/node/config.ts

@@ -653,11 +653,15 @@ export class Config {
     for (const [_projectPath, projectConfig] of config.projects) {
       for (const workspace of projectConfig.workspaces) {
         if (workspace.taskState && workspace.id) {
-          // Include queued, running, and awaiting_report tasks
+          // Include queued, running, awaiting_report, and reported tasks.
+          // "reported" tasks need rehydration too: if Mux crashed after saving
+          // the report but before injecting it into the parent, we need to
+          // re-deliver the saved report on restart.
           if (
             workspace.taskState.taskStatus === "queued" ||
             workspace.taskState.taskStatus === "running" ||
-            workspace.taskState.taskStatus === "awaiting_report"
+            workspace.taskState.taskStatus === "awaiting_report" ||
+            workspace.taskState.taskStatus === "reported"
           ) {
             result.push({
               workspaceId: workspace.id,

src/node/services/taskService.test.ts

@@ -144,10 +144,12 @@ class FakeConfig {
     const result: Array<{ workspaceId: string; taskState: TaskState }> = [];
     for (const [workspaceId, taskState] of this.taskStateById.entries()) {
       if (!taskState) continue;
+      // Include "reported" tasks for restart redelivery
       if (
         taskState.taskStatus === "queued" ||
         taskState.taskStatus === "running" ||
-        taskState.taskStatus === "awaiting_report"
+        taskState.taskStatus === "awaiting_report" ||
+        taskState.taskStatus === "reported"
       ) {
         result.push({ workspaceId, taskState });
       }
@@ -824,6 +826,51 @@ describe("TaskService", () => {
     ]);
   });
 
+  it("redelivers saved report for 'reported' tasks on restart", async () => {
+    // This tests the scenario where Mux crashed after saving taskStatus="reported"
+    // but before delivering the report to the parent workspace.
+    const config = new FakeConfig();
+
+    const parent = createWorkspaceMetadata("parent");
+    const reportedTask = createWorkspaceMetadata("task_reported", { parentWorkspaceId: "parent" });
+    config.addWorkspace(parent);
+    config.addWorkspace(reportedTask);
+
+    // Task was marked as reported with saved report content
+    await config.setWorkspaceTaskState("task_reported", {
+      taskStatus: "reported",
+      agentType: "research",
+      parentWorkspaceId: "parent",
+      prompt: "research prompt",
+      reportMarkdown: "This is the saved report content",
+      reportTitle: "Saved Report",
+      reportedAt: new Date().toISOString(),
+    });
+
+    const aiService = new FakeAIService();
+    const workspaceService = new FakeWorkspaceService(config, aiService);
+    const historyService = new FakeHistoryService();
+    const partialService = new FakePartialService();
+
+    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
+    );
+
+    await taskService.rehydrateTasks();
+
+    // The saved report should be re-delivered to the parent
+    expect(workspaceService.appendedMessages).toHaveLength(1);
+    expect(workspaceService.appendedMessages[0]?.workspaceId).toBe("parent");
+    const msg = workspaceService.appendedMessages[0]?.message;
+    const textPart = msg?.parts.find((p) => p.type === "text");
+    assert(textPart?.type === "text", "expected text part");
+    expect(textPart.text).toContain("This is the saved report content");
+  });
+
   it("does not remove a completed task workspace until its subtree is gone", async () => {
     const config = new FakeConfig();
     const parent = createWorkspaceMetadata("task_parent");

src/node/services/taskService.ts

@@ -472,6 +472,43 @@ export class TaskService extends EventEmitter {
     }
   }
 
+  /**
+   * Re-deliver a saved report from a "reported" task on restart.
+   * This handles the case where Mux crashed after saving taskStatus="reported"
+   * but before delivering the report to the parent workspace.
+   */
+  private async redeliverSavedReport(taskId: string, taskState: TaskState): Promise<void> {
+    assert(taskState.reportMarkdown, "Cannot redeliver report without reportMarkdown");
+
+    const report = {
+      reportMarkdown: taskState.reportMarkdown,
+      title: taskState.reportTitle,
+    };
+
+    // Re-post the report to the parent workspace history (idempotent from user perspective)
+    await this.postReportToParent(taskId, taskState, report);
+
+    // If this was a foreground task, re-inject the tool output
+    if (taskState.parentToolCallId) {
+      const toolOutput: TaskToolResult = {
+        status: "completed",
+        taskId,
+        reportMarkdown: report.reportMarkdown,
+        reportTitle: report.title,
+      };
+      const injected = await this.injectToolOutputToParent(
+        taskState.parentWorkspaceId,
+        taskState.parentToolCallId,
+        toolOutput
+      );
+      if (injected) {
+        await this.maybeResumeParentStream(taskState.parentWorkspaceId);
+      }
+    }
+
+    log.debug(`Re-delivered saved report for task ${taskId}`);
+  }
+
   /**
    * Inject task tool output into the parent workspace's pending tool call.
    * Persists the output into partial.json or chat.jsonl and emits a synthetic
@@ -952,6 +989,15 @@ export class TaskService extends EventEmitter {
         } catch (error) {
           log.error(`Failed to send reminder to task ${workspaceId}:`, error);
         }
+      } else if (taskState.taskStatus === "reported") {
+        // Task already reported but may not have delivered to parent before crash.
+        // Re-deliver the saved report to ensure parent gets the result.
+        if (taskState.reportMarkdown) {
+          log.debug(`Re-delivering saved report for task ${workspaceId}`);
+          await this.redeliverSavedReport(workspaceId, taskState);
+        } else {
+          log.warn(`Task ${workspaceId} marked as reported but has no saved report`);
+        }
       }
     }
 
@@ -1036,7 +1082,13 @@ export class TaskService extends EventEmitter {
 
   private async hasActiveDescendantTasks(parentWorkspaceId: string): Promise<boolean> {
     const activeTasks = this.config.getActiveAgentTaskWorkspaces();
-    if (activeTasks.length === 0) {
+    // Filter out "reported" tasks - they're done and shouldn't block parent resumption.
+    // We still include them in getActiveAgentTaskWorkspaces for restart redelivery,
+    // but they shouldn't count as "active" for the purpose of blocking resumption.
+    const trulyActiveTasks = activeTasks.filter(
+      ({ taskState }) => taskState.taskStatus !== "reported"
+    );
+    if (trulyActiveTasks.length === 0) {
       return false;
     }
 
@@ -1046,7 +1098,7 @@ export class TaskService extends EventEmitter {
       parentMap.set(meta.id, meta.parentWorkspaceId);
     }
 
-    for (const { workspaceId } of activeTasks) {
+    for (const { workspaceId } of trulyActiveTasks) {
       let current: string | undefined = workspaceId;
       while (current) {
         const parent = parentMap.get(current);