Fail persist close_agent when child dispose throws

A leftover child after posix reap must fail persist close and parent toolset dispose instead of looking like a successful shutdown. A wedged close still times out as shutdown.

Author: TheGreatAxios

CHANGELOG.md

@@ -18,6 +18,8 @@ parallel copies under `docs/` or `scripts/notes/`. At cut time: rename
 - TUI quit, crash, and process signals await once-only runtime shutdown so live
   shell-guard children are reaped. Teardown failure after a completed session
   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.
 
 ## [0.3.18] - 2026-09-08
 

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

@@ -53,6 +53,38 @@ describe("primary fleet verb mount", () => {
     await toolset.dispose();
   });
 
+  test("createAgentToolset dispose rejects when a fleet closeOne throws leftover children", 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 worker = sessions.start({ description: "d", agentId: "a", brief: "b" });
+    sessions.markRunning(worker.id);
+    sessions.registerClose(worker.id, async () => {
+      throw new Error("1 shell child process still live after 2000ms reap");
+    });
+
+    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/);
+  });
+
   test("createAgentToolset omits fleet verbs when subAgent is not set", async () => {
     const cwd = mkdtempSync(join(tmpdir(), "corbits-fleet-mount-"));
     const { createAgentToolset } = await import("./tools.js");

src/subagent/run-persist-close.test.ts

@@ -0,0 +1,97 @@
+/**
+ * Persist close_agent must surface a leftover-child posix dispose, not treat
+ * it as a successful bounded close.
+ */
+import { describe, expect, test } from "bun:test";
+import { mkdtemp } from "node:fs/promises";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+
+import type { ReactorEmittedEvent } from "@intx/inference";
+
+import { withMockedModuleDuring } from "../../tests/helpers/mock-module.js";
+import { createPermissionGate } from "../permission/gate.js";
+import type { RunSubAgentParams } from "./types.js";
+
+const permissionGate = createPermissionGate({
+  approvals: [],
+  interactive: false,
+  skipPermissions: true,
+  reactorGated: false,
+});
+
+function stubAgent() {
+  return {
+    send: async () => {
+      await new Promise((resolve) => setTimeout(resolve, 20));
+      return {
+        type: "reply" as const,
+        reply: "done",
+        turn: { role: "assistant", content: [] },
+      };
+    },
+    stream: () => (async function* (): AsyncGenerator<ReactorEmittedEvent> {})(),
+    deliver: () => {},
+    close: async () => {},
+    setSource: () => {},
+    setSources: () => {},
+    history: async () => [],
+    checkpoints: async () => [],
+    readAt: async () => [],
+    blobReader: {},
+  };
+}
+
+describe("persist close_agent leftover dispose", () => {
+  test("onAgentReady close rejects when posix dispose reports leftover children", async () => {
+    const cwd = await mkdtemp(join(tmpdir(), "corbits-persist-close-"));
+
+    await withMockedModuleDuring(
+      import.meta.resolve("@intx/tools-posix"),
+      (real: typeof import("@intx/tools-posix")) => ({
+        ...real,
+        createPosixTools: (opts: Parameters<typeof real.createPosixTools>[0]) =>
+          Object.assign(real.createPosixTools(opts), {
+            dispose: async () => {
+              throw new Error("1 shell child process still live after 2000ms reap");
+            },
+          }),
+      }),
+      async () =>
+        withMockedModuleDuring(
+          import.meta.resolve("../agent/live-tool-dispatch.js"),
+          (real: typeof import("../agent/live-tool-dispatch.js")) => ({
+            ...real,
+            createAgentWithLiveToolDispatch: async () =>
+              stubAgent() as unknown as Awaited<
+                ReturnType<typeof real.createAgentWithLiveToolDispatch>
+              >,
+          }),
+          async () => {
+            const { runSubAgent } = await import("./run.js");
+            let handles:
+              | {
+                  close: (deadlineMs?: number) => Promise<void>;
+                }
+              | undefined;
+            const params: RunSubAgentParams = {
+              cwd,
+              workdirBase: join(cwd, ".ctx"),
+              permissionGate,
+              provider: { providerName: "test", baseURL: "http://localhost", model: "test-model" },
+              description: "persist close leftover probe",
+              prompt: "finish the first turn",
+              persist: true,
+              onAgentReady: (h) => {
+                handles = h;
+              },
+            };
+            const result = await runSubAgent(params);
+            expect(result.agentRetained).toBe(true);
+            if (handles === undefined) throw new Error("onAgentReady never fired");
+            await expect(handles.close(1000)).rejects.toThrow(/still live after 2000ms reap/);
+          },
+        ),
+    );
+  });
+});

src/subagent/run.ts

@@ -1095,15 +1095,19 @@ async function runSubAgentInner(
     if (params.onAgentReady !== undefined) {
       const boundedClose = async (deadlineMs = DEFAULT_CLOSE_DEADLINE_MS): Promise<void> => {
         if (!runController.signal.aborted) runController.abort(new Error("closed by close_agent"));
+        let disposeError: unknown;
         const teardown = disposeSubAgentSession({
           signal: runController.signal,
           ...(closeOnAbort !== undefined ? { closeOnAbort } : {}),
           agent,
           ...(streamPromise !== undefined ? { streamPromise } : {}),
           posixTools,
-        }).catch(() => {
-          // Best-effort: a wedged descendant must not reject the caller.
-        });
+        }).then(
+          () => undefined,
+          (err: unknown) => {
+            disposeError = err;
+          },
+        );
         await Promise.race([
           teardown,
           new Promise<void>((resolve) => setTimeout(resolve, deadlineMs)),
@@ -1112,6 +1116,7 @@ async function runSubAgentInner(
         // for a persisted session (see runController.dispose's doc); now that
         // this session is actually closing, tear it down for real.
         runController.dispose();
+        if (disposeError !== undefined) throw disposeError;
       };
       // Interrupt only fires interruptController — never runController/
       // close, so it cannot hit the close()-ordering wedge documented in

src/subagent/session-store.test.ts

@@ -547,6 +547,19 @@ describe("CL-6943 reusable worker sessions", () => {
     expect(store.get(session.id)?.retained).toBe(false);
   });
 
+  test("closeOne rejects when the registered close throws a leftover child after reap", async () => {
+    const store = createSubAgentSessionStore();
+    const session = store.start({ description: "d", agentId: "a", brief: "b", retained: true });
+    store.registerClose(session.id, async () => {
+      throw new Error("1 shell child process still live after 2000ms reap");
+    });
+
+    await expect(store.closeOne(session.id, 1000)).rejects.toThrow(/still live after 2000ms reap/);
+    expect(store.get(session.id)?.lifecycleStatus).toBe("shutdown");
+    expect(store.get(session.id)?.retained).toBe(false);
+    expect(await store.closeOne(session.id, 1000)).toBe("shutdown");
+  });
+
   test("closeOne is idempotent and returns not_found for an unknown id", async () => {
     const store = createSubAgentSessionStore();
     const session = store.start({ description: "d", agentId: "a", brief: "b", retained: true });

src/subagent/session-store.ts

@@ -1218,12 +1218,17 @@ export function createSubAgentSessionStore(
       // Bounded here too, defense-in-depth against a caller-registered
       // close that does not honor its own deadline argument — a wedged
       // descendant must not hang the whole close_agent call.
+      let closeError: unknown;
       await Promise.race([
-        close(deadlineMs).catch((err: unknown) => {
-          log.warn("session close raced deadline: {error}", {
-            error: err instanceof Error ? err.message : String(err),
-          });
-        }),
+        close(deadlineMs).then(
+          () => undefined,
+          (err: unknown) => {
+            closeError = err;
+            log.warn("session close raced deadline: {error}", {
+              error: err instanceof Error ? err.message : String(err),
+            });
+          },
+        ),
         new Promise<void>((resolve) => setTimeout(resolve, deadlineMs)),
       ]);
       if (keepFailed) {
@@ -1235,6 +1240,7 @@ export function createSubAgentSessionStore(
         deliverHandles.delete(id);
         runInFlight.delete(id);
         pruneCompleted();
+        if (closeError !== undefined) throw closeError;
         const after = sessions.get(id);
         return after === undefined ? "not_found" : projectLifecycleStatus(after.lifecycle);
       }
@@ -1258,6 +1264,7 @@ export function createSubAgentSessionStore(
       deliverHandles.delete(id);
       runInFlight.delete(id);
       pruneCompleted();
+      if (closeError !== undefined) throw closeError;
       return "shutdown";
     },