[Bug + Tested Fix] Scheduler failure leaves dangling tool/call without tool/result and discards in-flight results (Fix included in branch)

[wangpfcn]

Summary & Problem

When parallel tool execution encounters a scheduler or environmental failure (such as Win32 sandbox permission denial grantWrite or uncaught runtime exceptions), two critical issues occur in agent-loop:

1. Discarded In-Flight Results: In packages/core/agent-loop/src/tool-calls.ts, when a tool throws during prepare(), the catch handler drains running calls via await Promise.allSettled(inFlight.values()), but rethrows immediately without calling commitReady(). Sibling tools that completed successfully during the drain have their real outputs in slots discarded and falsely classified as failed.
2. Session Poisoning & Empty UI: In packages/core/agent-loop/src/agent.ts, when an exception escapes step(), toolRecovery can fail to capture events if scoped listeners are filtered by Cordis scope carrier rules, leaving the turn closed with turn/end { error } while prior tool/calls remain unanswered. This permanently poisons the session (HTTP 400 insufficient tool messages following tool_calls message on future turns) and causes the Web GUI to render no recorded result.

Relates to #4549, #2900, #1959.

---

Tested Solution & Pull Branch

I have implemented a complete, minimal, and fully-tested fix in my fork repository:

• Repository: wangpfcn/deepseek-harness
• Branch: fix/tool-scheduler-drain-and-wire-containment
• Commit: 08940dd65

Proposed Changes

1. In-Flight Preservation (packages/core/agent-loop/src/tool-calls.ts):
   • In runGroup's catch handler, call await commitReady().catch(() => {}) after Promise.allSettled(inFlight.values()) to commit all contiguous settled slots that completed successfully during the drain.
2. Dual-Layer Closure Guarantee (packages/core/agent-loop/src/agent.ts):
   • In step()'s error recovery, fallback to scanning this.session.snapshotEvents() if toolRecovery.results() is empty, guaranteeing that any pending call is observed regardless of scope carrier filtering.
   • In turn()'s finally block before writing turn/end { error }, introduce a final safety gate to ensure all unanswered tool/calls receive conservative recovery results, guaranteeing that no session log ever closes with dangling tool calls.
3. Regression Tests (packages/core/agent-loop/tests/tool-calls.spec.ts):
   • Added unit test it('preserves genuine in-flight tool results when a sibling fails during prepare') verifying that when sibling C fails during prepare(), sibling B (which was in-flight and succeeded during drain) preserves its genuine result (isError: false, content: "done-2").

Git Diff

diff --git a/packages/core/agent-loop/src/tool-calls.ts b/packages/core/agent-loop/src/tool-calls.ts
--- a/packages/core/agent-loop/src/tool-calls.ts
+++ b/packages/core/agent-loop/src/tool-calls.ts
@@ -232,6 +232,11 @@ async function runGroup(
   } catch (error: unknown) {
     schedulerFailure ??= { error }
     await Promise.allSettled(inFlight.values())
+    try {
+      await commitReady()
+    } catch {
+      // Preserve first scheduler failure over secondary commit failure
+    }
     throw schedulerFailure.error
   }

diff --git a/packages/core/agent-loop/src/agent.ts b/packages/core/agent-loop/src/agent.ts
--- a/packages/core/agent-loop/src/agent.ts
+++ b/packages/core/agent-loop/src/agent.ts
@@ -341,6 +341,11 @@ export class ReactLoopAgent implements Agent {
         } catch (error: unknown) {
           try {
+            if (toolRecovery.results().length === 0) {
+              for (const event of this.session.snapshotEvents()) {
+                toolRecovery.observe(event)
+              }
+            }
             for (const event of toolRecovery.results()) {
               this.session.append('tool/result', event.data, {
@@ -381,6 +386,18 @@ export class ReactLoopAgent implements Agent {
       this.throwError(error)
     } finally {
       try {
+        if (turnEnds?.kind === 'error') {
+          const finalRecovery = new ToolCallRecovery()
+          for (const event of this.session.snapshotEvents()) {
+            finalRecovery.observe(event)
+          }
+          for (const event of finalRecovery.results()) {
+            this.session.append('tool/result', event.data, {
+              surfaceOp: 'append',
+              ...event.sourceEventSeqs === undefined ? {} : { sourceEventSeqs: event.sourceEventSeqs },
+            })
+          }
+        }
         this.session.append('turn/end', { turn, reason: turnEnds! })
       } catch (error: unknown) {

Please review this patch and consider cherry-picking it into upstream master.