🤖 fix: finalize task tool calls from history

Finalize pending task tool calls before appending the synthetic report message so
restart scenarios can update history-only tool parts and emit tool-call-end.

Add a regression test for the history-only 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: I2e95fa8815f0d33bf1548fde44d7edd9d339e2d6

Author: ThomasK33

src/node/services/taskService.test.ts

@@ -469,6 +469,187 @@ describe("TaskService", () => {
     expect(emit).toHaveBeenCalled();
   });
 
+  test("agent_report finalizes pending task tool output from history when parent has no partial", 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: "running",
+              },
+            ],
+          },
+        ],
+      ]),
+      taskSettings: { maxParallelAgentTasks: 3, maxTaskNestingDepth: 3 },
+    });
+
+    const historyService = new HistoryService(config);
+    const partialService = new PartialService(config, historyService);
+
+    // Restart scenario: parent has no partial.json, only history containing the pending tool call.
+    const parentHistoryMessage = createMuxMessage(
+      "assistant-parent-history",
+      "assistant",
+      "Waiting on subagent…",
+      { timestamp: Date.now() },
+      [
+        {
+          type: "dynamic-tool",
+          toolCallId: "task-call-1",
+          toolName: "task",
+          input: { subagent_type: "explore", prompt: "do the thing" },
+          state: "input-available",
+        },
+      ]
+    );
+    const appendParentHistory = await historyService.appendToHistory(
+      parentId,
+      parentHistoryMessage
+    );
+    expect(appendParentHistory.success).toBe(true);
+
+    const childPartial = createMuxMessage(
+      "assistant-child-partial",
+      "assistant",
+      "",
+      { timestamp: Date.now() },
+      [
+        {
+          type: "dynamic-tool",
+          toolCallId: "agent-report-call-1",
+          toolName: "agent_report",
+          input: { reportMarkdown: "Hello from child", title: "Result" },
+          state: "output-available",
+          output: { success: true },
+        },
+      ]
+    );
+    const writeChildPartial = await partialService.writePartial(childId, childPartial);
+    expect(writeChildPartial.success).toBe(true);
+
+    const aiService: AIService = {
+      isStreaming: mock(() => false),
+      on: mock(() => undefined),
+      off: mock(() => undefined),
+    } as unknown as AIService;
+
+    const sendMessage = mock(() => Promise.resolve(Ok(undefined)));
+    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 internal = taskService as unknown as {
+      handleAgentReport: (event: {
+        type: "tool-call-end";
+        workspaceId: string;
+        toolName: string;
+      }) => Promise<void>;
+    };
+    await internal.handleAgentReport({
+      type: "tool-call-end",
+      workspaceId: childId,
+      toolName: "agent_report",
+    });
+
+    const parentPartial = await partialService.readPartial(parentId);
+    expect(parentPartial).toBeNull();
+
+    const parentHistory = await historyService.getHistory(parentId);
+    expect(parentHistory.success).toBe(true);
+    if (parentHistory.success) {
+      const msg = parentHistory.data.find((m) => m.id === "assistant-parent-history") ?? null;
+      expect(msg).not.toBeNull();
+      if (msg) {
+        const toolPart = msg.parts.find(
+          (p) =>
+            p &&
+            typeof p === "object" &&
+            "type" in p &&
+            (p as { type?: unknown }).type === "dynamic-tool"
+        ) as unknown as
+          | {
+              toolName: string;
+              state: string;
+              output?: unknown;
+            }
+          | undefined;
+        expect(toolPart?.toolName).toBe("task");
+        expect(toolPart?.state).toBe("output-available");
+        expect(toolPart?.output && typeof toolPart.output === "object").toBe(true);
+        expect(JSON.stringify(toolPart?.output)).toContain("Hello from child");
+      }
+
+      const combined = parentHistory.data
+        .filter((m) => m.role === "assistant")
+        .flatMap((m) => m.parts)
+        .map((p) =>
+          p &&
+          typeof p === "object" &&
+          "type" in p &&
+          (p as { type?: unknown }).type === "text" &&
+          "text" in p
+            ? (p as { text?: unknown }).text
+            : ""
+        )
+        .join("");
+      expect(combined).toContain("Hello from child");
+    }
+
+    const emitCalls = (emit as unknown as { mock: { calls: Array<[string, unknown]> } }).mock.calls;
+    const hasTaskToolCallEnd = emitCalls.some((call) => {
+      const [eventName, payload] = call;
+      if (eventName !== "chat") return false;
+      if (!payload || typeof payload !== "object") return false;
+      const maybePayload = payload as { workspaceId?: unknown; message?: unknown };
+      if (maybePayload.workspaceId !== parentId) return false;
+      const message = maybePayload.message;
+      if (!message || typeof message !== "object") return false;
+      const maybeMessage = message as { type?: unknown; toolName?: unknown };
+      return maybeMessage.type === "tool-call-end" && maybeMessage.toolName === "task";
+    });
+    expect(hasTaskToolCallEnd).toBe(true);
+
+    expect(remove).toHaveBeenCalled();
+    expect(resumeStream).toHaveBeenCalled();
+  });
+
   test("missing agent_report triggers one reminder, then posts fallback output and cleans up", async () => {
     const config = new Config(rootDir);
 

src/node/services/taskService.ts

@@ -832,6 +832,9 @@ export class TaskService {
     const titlePrefix = report.title ? `${report.title}` : `Subagent (${agentType}) report`;
     const markdown = `### ${titlePrefix}\n\n${report.reportMarkdown}`;
 
+    // Restart-safe: if the parent has a pending task tool call in partial/history, finalize it with the report.
+    await this.tryFinalizePendingTaskToolCall(parentWorkspaceId, report, agentType);
+
     const messageId = `assistant-${Date.now()}-${Math.random().toString(36).substring(2, 11)}`;
     const reportMessage = createMuxMessage(messageId, "assistant", markdown, {
       timestamp: Date.now(),
@@ -855,9 +858,6 @@ export class TaskService {
       workspaceId: parentWorkspaceId,
       message: { ...reportMessage, type: "message" },
     });
-
-    // Restart-safe: if the parent has a pending task tool call in partial/history, finalize it with the report.
-    await this.tryFinalizePendingTaskToolCall(parentWorkspaceId, report, agentType);
   }
 
   private async tryFinalizePendingTaskToolCall(