fix: dedupe restarted descendant session counts

Takhoffman · Takhoffman · commit c541cde0f66e · 2026-03-24T16:52:50.000-05:00
diff --git a/src/agents/openclaw-tools.sessions.test.ts b/src/agents/openclaw-tools.sessions.test.ts
@@ -998,6 +998,76 @@ describe("sessions tools", () => {
     expect(details.text).toContain("active (waiting on 1 child)");
   });
 
+  it("subagents list does not double-count restarted descendants on one child session", async () => {
+    resetSubagentRegistryForTests();
+    const now = Date.now();
+    const parentKey = "agent:main:subagent:orchestrator-restarted-child";
+    const childKey = `${parentKey}:subagent:worker`;
+    addSubagentRunForTests({
+      runId: "run-orchestrator-ended-restarted",
+      childSessionKey: parentKey,
+      requesterSessionKey: "agent:main:main",
+      requesterDisplayKey: "main",
+      task: "orchestrate restarted child worker",
+      cleanup: "keep",
+      createdAt: now - 5 * 60_000,
+      startedAt: now - 5 * 60_000,
+      endedAt: now - 4 * 60_000,
+      outcome: { status: "ok" },
+    });
+    addSubagentRunForTests({
+      runId: "run-restarted-child-stale",
+      childSessionKey: childKey,
+      requesterSessionKey: parentKey,
+      requesterDisplayKey: parentKey,
+      task: "stale child run",
+      cleanup: "keep",
+      createdAt: now - 90_000,
+      startedAt: now - 90_000,
+      endedAt: now - 70_000,
+      cleanupCompletedAt: undefined,
+      outcome: { status: "ok" },
+    });
+    addSubagentRunForTests({
+      runId: "run-restarted-child-current",
+      childSessionKey: childKey,
+      requesterSessionKey: parentKey,
+      requesterDisplayKey: parentKey,
+      task: "current child run",
+      cleanup: "keep",
+      createdAt: now - 60_000,
+      startedAt: now - 60_000,
+    });
+
+    const tool = createOpenClawTools({
+      agentSessionKey: "agent:main:main",
+    }).find((candidate) => candidate.name === "subagents");
+    expect(tool).toBeDefined();
+    if (!tool) {
+      throw new Error("missing subagents tool");
+    }
+
+    const result = await tool.execute("call-subagents-list-restarted-child", { action: "list" });
+    const details = result.details as {
+      status?: string;
+      active?: Array<{ runId?: string; status?: string; pendingDescendants?: number }>;
+      text?: string;
+    };
+
+    expect(details.status).toBe("ok");
+    expect(details.active).toEqual(
+      expect.arrayContaining([
+        expect.objectContaining({
+          runId: "run-orchestrator-ended-restarted",
+          status: "active (waiting on 1 child)",
+          pendingDescendants: 1,
+        }),
+      ]),
+    );
+    expect(details.text).toContain("active (waiting on 1 child)");
+    expect(details.text).not.toContain("active (waiting on 2 children)");
+  });
+
   it("subagents list dedupes stale rows for the same child session", async () => {
     resetSubagentRegistryForTests();
     const now = Date.now();
diff --git a/src/agents/subagent-registry-queries.test.ts b/src/agents/subagent-registry-queries.test.ts
@@ -115,6 +115,35 @@ describe("subagent registry query regressions", () => {
     expect(countPendingDescendantRunsFromRuns(runs, middleSessionKey)).toBe(1);
   });
 
+  it("dedupes restarted descendant rows for the same child session when counting pending work", () => {
+    const parentSessionKey = "agent:main:subagent:parent-dedupe";
+    const childSessionKey = `${parentSessionKey}:subagent:worker`;
+    const runs = toRunMap([
+      makeRun({
+        runId: "run-child-stale",
+        childSessionKey,
+        requesterSessionKey: parentSessionKey,
+        createdAt: 100,
+        endedAt: 150,
+        cleanupCompletedAt: undefined,
+      }),
+      makeRun({
+        runId: "run-child-current",
+        childSessionKey,
+        requesterSessionKey: parentSessionKey,
+        createdAt: 200,
+      }),
+      makeRun({
+        runId: "run-grandchild-current",
+        childSessionKey: `${childSessionKey}:subagent:leaf`,
+        requesterSessionKey: childSessionKey,
+        createdAt: 210,
+      }),
+    ]);
+
+    expect(countPendingDescendantRunsFromRuns(runs, parentSessionKey)).toBe(2);
+  });
+
   it("regression excluding current run, countPendingDescendantRunsExcludingRun keeps sibling gating intact", () => {
     // Regression guard: excluding the currently announcing run must not hide sibling pending work.
     const runs = toRunMap([
diff --git a/src/agents/subagent-registry-queries.ts b/src/agents/subagent-registry-queries.ts
@@ -176,10 +176,18 @@ function forEachDescendantRun(
     if (!requester) {
       continue;
     }
+    const latestByChildSessionKey = new Map<string, [string, SubagentRunRecord]>();
     for (const [runId, entry] of runs.entries()) {
       if (entry.requesterSessionKey !== requester) {
         continue;
       }
+      const childKey = entry.childSessionKey.trim();
+      const existing = latestByChildSessionKey.get(childKey);
+      if (!existing || entry.createdAt > existing[1].createdAt) {
+        latestByChildSessionKey.set(childKey, [runId, entry]);
+      }
+    }
+    for (const [runId, entry] of latestByChildSessionKey.values()) {
       visitor(runId, entry);
       const childKey = entry.childSessionKey.trim();
       if (!childKey || visited.has(childKey)) {
