Surface leftover dispose when agent close hangs

Author: TheGreatAxios

src/exec/runner.ts

@@ -22,6 +22,7 @@ import {
   type SubAgentSessionStore,
 } from "../subagent/index.js";
 import { getProcessAdmissionQueue } from "../subagent/admission.js";
+import { awaitCloseWithoutHidingLeftover } from "../subagent/dispose.js";
 import type { ContextStore, InferenceSource, InboundMessage } from "@intx/types/runtime";
 import { OPERATOR_ORIGINATED_FLAG } from "../agent/message-provenance.js";
 import { loadAgentProfiles } from "../agent/profiles.js";
@@ -181,7 +182,7 @@ async function runExecDispose(args: {
   }
   if (args.agent !== null) {
     try {
-      await args.agent.close();
+      await awaitCloseWithoutHidingLeftover(args.agent.close(), failures[0]);
     } catch (err: unknown) {
       logger.debug("agent.close during exec finally failed: {error}", {
         error: formatCaughtError(err),

src/subagent/dispose.ts

@@ -78,6 +78,24 @@ export async function awaitBoundedTeardown(
   if (timedOut) throw new Error(`session close exceeded ${deadlineMs}ms`);
 }
 
+/**
+ * Always start `close`. Await it only when posix/toolset dispose already
+ * succeeded; a leftover throw must not wait unbounded on a hung close.
+ */
+export async function awaitCloseWithoutHidingLeftover(
+  close: Promise<unknown>,
+  leftover: unknown,
+): Promise<void> {
+  if (leftover === undefined) {
+    await close;
+    return;
+  }
+  void close.then(
+    () => undefined,
+    () => undefined,
+  );
+}
+
 export interface SubAgentSpawnSnapshot {
   inFlightToolCalls: number;
   inFlightByTool: Readonly<Record<string, number>>;
@@ -147,12 +165,12 @@ export async function disposeSubAgentSession(input: SubAgentSessionDisposeInput)
     posixError = err;
   }
   try {
-    await input.agent?.close();
+    await awaitCloseWithoutHidingLeftover(input.agent?.close() ?? Promise.resolve(), posixError);
   } catch {
     // ignore
   }
   try {
-    await input.streamPromise;
+    await awaitCloseWithoutHidingLeftover(input.streamPromise ?? Promise.resolve(), posixError);
   } catch {
     // ignore
   }

src/subagent/index.test.ts

@@ -114,6 +114,38 @@ describe("sub-agent teardown", () => {
     ).rejects.toThrow(/still live after 2000ms reap/);
   });
 
+  test("disposeSubAgentSession surfaces leftover posix dispose when agent.close hangs", async () => {
+    const posixTools = {
+      dispose: async () => {
+        throw new Error("1 shell child process still live after 2000ms reap");
+      },
+    };
+    let closeStarted = false;
+    const pending = disposeSubAgentSession({
+      agent: {
+        close: () => {
+          closeStarted = true;
+          return new Promise<void>(() => {});
+        },
+      },
+      posixTools,
+    });
+    const result = await Promise.race([
+      pending.then(
+        () => ({ kind: "resolved" as const }),
+        (err: unknown) => ({ kind: "rejected" as const, err }),
+      ),
+      new Promise<{ kind: "timeout" }>((resolve) => {
+        setTimeout(() => resolve({ kind: "timeout" }), 200);
+      }),
+    ]);
+    expect(closeStarted).toBe(true);
+    expect(result.kind).toBe("rejected");
+    if (result.kind !== "rejected") throw new Error("expected leftover reject");
+    expect(result.err).toBeInstanceOf(Error);
+    expect((result.err as Error).message).toMatch(/still live after 2000ms reap/);
+  });
+
   test("spawn registry tracks in-flight plugin tool calls", async () => {
     const { plugin, snapshot } = createSubAgentSpawnRegistryPlugin();
     expect(plugin.middleware).toBeDefined();

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

@@ -149,4 +149,62 @@ describe("persist close_agent leftover dispose", () => {
         ),
     );
   });
+
+  test("onAgentReady close surfaces leftover posix dispose when agent.close hangs", async () => {
+    const cwd = await mkdtemp(join(tmpdir(), "corbits-persist-close-leftover-hang-"));
+    let closeStarted = false;
+
+    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(),
+                close: () => {
+                  closeStarted = true;
+                  return new Promise<void>(() => {});
+                },
+              }) 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 hung close 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(200)).rejects.toThrow(/still live after 2000ms reap/);
+            expect(closeStarted).toBe(true);
+          },
+        ),
+    );
+  });
 });

src/tui/runner/shutdown.ts

@@ -1,3 +1,5 @@
+import { awaitCloseWithoutHidingLeftover } from "../../subagent/dispose.js";
+
 export interface RuntimeShutdownDeps {
   disposeHost: () => void;
   cancelWorkers: () => void | Promise<void>;
@@ -37,7 +39,7 @@ export function createRuntimeShutdown(deps: RuntimeShutdownDeps): () => Promise<
         failures.push(err);
       }
       try {
-        await deps.closeAgent();
+        await awaitCloseWithoutHidingLeftover(deps.closeAgent(), failures[0]);
       } catch (err) {
         failures.push(err);
       }

src/tui/runtime-shutdown.test.ts

@@ -160,4 +160,33 @@ describe("runtime shutdown", () => {
     await pending;
     expect(calls).toEqual(["host", "toolset", "workers", "agent"]);
   });
+
+  test("surfaces leftover toolset dispose when agent.close hangs", async () => {
+    let closeStarted = false;
+    const shutdown = createRuntimeShutdown({
+      disposeHost: () => undefined,
+      cancelWorkers: () => undefined,
+      closeAgent: () => {
+        closeStarted = true;
+        return new Promise<void>(() => {});
+      },
+      disposeToolset: async () => {
+        throw new Error("1 shell child process still live after 2000ms reap");
+      },
+    });
+    const result = await Promise.race([
+      shutdown().then(
+        () => ({ kind: "resolved" as const }),
+        (err: unknown) => ({ kind: "rejected" as const, err }),
+      ),
+      new Promise<{ kind: "timeout" }>((resolve) => {
+        setTimeout(() => resolve({ kind: "timeout" }), 200);
+      }),
+    ]);
+    expect(closeStarted).toBe(true);
+    expect(result.kind).toBe("rejected");
+    if (result.kind !== "rejected") throw new Error("expected leftover reject");
+    expect(result.err).toBeInstanceOf(Error);
+    expect((result.err as Error).message).toMatch(/still live after 2000ms reap/);
+  });
 });

tests/unit/exec/runner.test.ts

@@ -466,6 +466,38 @@ describe("disposeExecRuntime", () => {
     ).rejects.toThrow(/still live after 2000ms reap/);
   });
 
+  test("surfaces leftover toolset dispose when agent.close hangs", async () => {
+    let closeStarted = false;
+    const pending = disposeExecRuntime({
+      agent: {
+        close: () => {
+          closeStarted = true;
+          return new Promise<void>(() => {});
+        },
+      },
+      toolset: {
+        dispose: async () => {
+          throw new Error("1 shell child process still live after 2000ms reap");
+        },
+      },
+      subAgentSessions: null,
+    });
+    const result = await Promise.race([
+      pending.then(
+        () => ({ kind: "resolved" as const }),
+        (err: unknown) => ({ kind: "rejected" as const, err }),
+      ),
+      new Promise<{ kind: "timeout" }>((resolve) => {
+        setTimeout(() => resolve({ kind: "timeout" }), 200);
+      }),
+    ]);
+    expect(closeStarted).toBe(true);
+    expect(result.kind).toBe("rejected");
+    if (result.kind !== "rejected") throw new Error("expected leftover reject");
+    expect(result.err).toBeInstanceOf(Error);
+    expect((result.err as Error).message).toMatch(/still live after 2000ms reap/);
+  });
+
   test("rejects when toolset dispose fails", async () => {
     await expect(
       disposeExecRuntime({