Fail leftover exec dispose without skipping sibling teardown

Author: TheGreatAxios

CHANGELOG.md

@@ -20,6 +20,9 @@ parallel copies under `docs/` or `scripts/notes/`. At cut time: rename
   exits 1; SIGINT, SIGTERM, and SIGHUP still exit 128+n.
 - Persist close_agent surfaces leftover-child dispose failure so a worker
   that survives reap is not reported as a successful shutdown.
+- Leftover exec dispose is reported as a failed run (stderr + status failed), and
+  parent toolset dispose finishes remaining workers and posix teardown before
+  surfacing leftover-child failure.
 
 ## [0.3.18] - 2026-09-08
 

src/agent/fleet-verbs-mount.test.ts

@@ -122,6 +122,58 @@ describe("primary fleet verb mount", () => {
     await expect(toolset.dispose()).rejects.toThrow(/still live after 2000ms reap/);
   });
 
+  test("createAgentToolset dispose closes remaining retained workers after the first leftover", async () => {
+    const cwd = mkdtempSync(join(tmpdir(), "corbits-fleet-mount-"));
+    const { createAgentToolset } = await import("./tools.js");
+    const permissionGate = {
+      check: async () => ({ allowed: true }),
+      getSkipPermissions: () => false,
+    } as never;
+    const sessions = createSubAgentSessionStore();
+    const first = sessions.start({
+      description: "d1",
+      agentId: "a",
+      brief: "b",
+      retained: true,
+    });
+    const second = sessions.start({
+      description: "d2",
+      agentId: "a",
+      brief: "b",
+      retained: true,
+    });
+    let firstCloseCalls = 0;
+    let secondCloseCalls = 0;
+    sessions.registerClose(first.id, async () => {
+      firstCloseCalls += 1;
+      throw new Error("1 shell child process still live after 2000ms reap");
+    });
+    sessions.registerClose(second.id, async () => {
+      secondCloseCalls += 1;
+    });
+    sessions.complete(first.id, "done", { agentRetained: true });
+    sessions.complete(second.id, "done", { agentRetained: true });
+
+    const toolset = await createAgentToolset({
+      cwd,
+      permissionGate,
+      onOperatorGate: async () => ({ kind: "option", index: 0 }),
+      subAgent: {
+        provider: {
+          providerName: "test",
+          baseURL: "http://127.0.0.1:0",
+          model: "test-model",
+        },
+        getWorkdirBase: () => cwd,
+        sessions,
+      },
+    });
+
+    await expect(toolset.dispose()).rejects.toThrow(/still live after 2000ms reap/);
+    expect(firstCloseCalls).toBe(1);
+    expect(secondCloseCalls).toBe(1);
+  });
+
   test("createAgentToolset dispose rejects when a retained running persist worker leaves children", async () => {
     const cwd = mkdtempSync(join(tmpdir(), "corbits-fleet-mount-"));
     const { createAgentToolset } = await import("./tools.js");

src/agent/tools.ts

@@ -95,6 +95,13 @@ export const ASK_OPERATOR_OPTION_MAX_CHARS = 48;
 /** Cap on the ask_operator question (UTF-16 code units). */
 export const ASK_OPERATOR_QUESTION_MAX_CHARS = 160;
 
+function rethrowToolsetDisposeFailures(failures: unknown[]): void {
+  const first = failures[0];
+  if (first === undefined) return;
+  if (failures.length === 1) throw first;
+  throw new AggregateError(failures, "toolset leftover dispose failed");
+}
+
 const SubmitOutputArgs = type({
   "summary?": "string",
   "step?": "string",
@@ -943,11 +950,20 @@ export async function createAgentToolset(args: AgentToolsetArgs): Promise<AgentT
     disposed = true;
     mcpAbortController.abort(new Error("MCP toolset disposed"));
     disposal = (async () => {
+      const failures: unknown[] = [];
       const fleetSessions = fleetSessionsForDispose;
       if (fleetSessions !== undefined) {
-        await fleetSessions.cancelAll("parent session closed");
+        try {
+          await fleetSessions.cancelAll("parent session closed");
+        } catch (err: unknown) {
+          failures.push(err);
+        }
         for (const session of [...fleetSessions.list()].reverse()) {
-          await fleetSessions.closeOne(session.id, DEFAULT_CLOSE_DEADLINE_MS);
+          try {
+            await fleetSessions.closeOne(session.id, DEFAULT_CLOSE_DEADLINE_MS);
+          } catch (err: unknown) {
+            failures.push(err);
+          }
         }
       }
       await Promise.allSettled([...inFlightConnections.values()]);
@@ -958,8 +974,13 @@ export async function createAgentToolset(args: AgentToolsetArgs): Promise<AgentT
         [...connectedClients.values()].map((client) => client.close().catch(() => undefined)),
       );
       connectedClients.clear();
-      await posixTools.dispose();
+      try {
+        await posixTools.dispose();
+      } catch (err: unknown) {
+        failures.push(err);
+      }
       await disposeWebSearchClients();
+      rethrowToolsetDisposeFailures(failures);
     })();
     return disposal;
   };

src/exec/runner.ts

@@ -888,11 +888,13 @@ export async function runExec(config: Config): Promise<ExecResult> {
     try {
       await disposeExecRuntime({ agent, toolset, subAgentSessions });
     } catch (err: unknown) {
-      logger.debug("disposeExecRuntime failed: {error}", {
-        error: formatCaughtError(err),
-      });
-      if (result !== undefined && result.exitCode === 0) {
+      const message = formatCaughtError(err);
+      logger.error("runtime dispose failed: {error}", { error: message });
+      stderr.write(`Error: runtime dispose failed: ${message}\n`);
+      if (result !== undefined) {
         result.exitCode = 1;
+        result.status = "failed";
+        result.error = `runtime dispose failed: ${message}`;
       }
     }
     clearActiveDisposeHost();

src/subagent/retain-salvage.test.ts

@@ -17,14 +17,11 @@ describe("retained session lifecycle", () => {
     // agentRetained:false, exactly as its real call site does whenever
     // result.agentRetained isn't true.
     store.complete(s.id, "Stopped: deadline\n\nPartial work...", { agentRetained: false });
-    const after = store.get(s.id);
-    console.log("lifecycleStatus:", after?.lifecycleStatus, "retained:", after?.retained);
     const outcome = store.resumeOne(s.id, "more");
-    console.log("resumeOne outcome:", JSON.stringify(outcome));
     expect(outcome.ok).toBe(false);
   });
 
-  test("cancelAll does not close retained completed sessions", async () => {
+  test("cancelAll closes salvaged retained completed sessions", async () => {
     const store = createSubAgentSessionStore({ maxCompleted: 5 });
     const s = store.start({
       description: "worker",
@@ -37,8 +34,7 @@ describe("retained session lifecycle", () => {
       closed = true;
     });
     store.complete(s.id, "done");
-    const cancelled = await store.cancelAll("parent stop");
-    console.log("cancelAll returned:", cancelled, "| close invoked:", closed);
+    await store.cancelAll("parent stop");
     expect(closed).toBe(true);
   });
 
@@ -63,7 +59,6 @@ describe("retained session lifecycle", () => {
       store.registerClose(s.id, async () => {});
       store.complete(s.id, "done");
     }
-    console.log("sessions retained despite maxRetained=3:", store.list().length);
     expect(store.list().length).toBeLessThanOrEqual(3);
   });
 

tests/unit/exec/runner.test.ts

@@ -298,6 +298,12 @@ describe("runExec", () => {
     const sessionId = "exec-dispose-fail";
     let disposeCalls = 0;
     const dummySource = { id: "test", provider: "test", model: "test" } as InferenceSource;
+    const stderrChunks: string[] = [];
+    const origWrite = process.stderr.write.bind(process.stderr);
+    process.stderr.write = ((chunk: string | Uint8Array, ...rest: unknown[]) => {
+      stderrChunks.push(typeof chunk === "string" ? chunk : Buffer.from(chunk).toString("utf8"));
+      return origWrite(chunk as never, ...(rest as never[]));
+    }) as typeof process.stderr.write;
     try {
       await withMockedModuleDuring(
         import.meta.resolve("node:os"),
@@ -347,6 +353,9 @@ describe("runExec", () => {
                     providers: [],
                   });
                   expect(result.exitCode).toBe(1);
+                  expect(result.status).toBe("failed");
+                  expect(result.error).toMatch(/plugin dispose failed|runtime dispose failed/i);
+                  expect(stderrChunks.join("")).toMatch(/runtime dispose failed/i);
                   expect(disposeCalls).toBe(1);
                   expect(getActiveDisposeHost()).toBeNull();
                 },
@@ -356,6 +365,7 @@ describe("runExec", () => {
         },
       );
     } finally {
+      process.stderr.write = origWrite;
       if (previous !== null) setActiveRun(previous);
       else clearActiveRun();
       rmSync(cwd, { recursive: true, force: true });
@@ -415,6 +425,20 @@ describe("disposeExecRuntime", () => {
     expect(calls).toEqual(["agent", "toolset"]);
   });
 
+  test("rejects leftover-child dispose from the toolset", async () => {
+    await expect(
+      disposeExecRuntime({
+        agent: { close: async () => undefined },
+        toolset: {
+          dispose: async () => {
+            throw new Error("1 shell child process still live after 2000ms reap");
+          },
+        },
+        subAgentSessions: null,
+      }),
+    ).rejects.toThrow(/still live after 2000ms reap/);
+  });
+
   test("rejects when toolset dispose fails", async () => {
     await expect(
       disposeExecRuntime({