From 2471e2b2bb45d1f8f350571451feda04a4a8786d Mon Sep 17 00:00:00 2001
From: pku-xht <xht@deepseek.com>
Date: Thu, 9 Jul 2026 10:42:34 +0800
Subject: [PATCH] fix review finding: exitsWithin cleans up its listener and
 timer on both arms

Each timed-out wait used to leave the once('exit') listener from its inner
waitForExit attached to the child; the dispose ladder accumulates at most a
couple, but in a shared library a caller polling exitsWithin in a loop would
pile listeners onto one child (MaxListenersExceededWarning at 11) and retain
their closures. The race now owns its wiring: the timeout arm removes the
exit listener, the exit arm clears the (still unref'ed) grace timer, and an
already-exited child short-circuits true without attaching anything. Tests
pin listenerCount('exit') === 0 after every outcome.
---
 packages/subagent/subagent-process/README.md  |  2 +-
 .../subagent/subagent-process/src/index.ts    | 24 ++++++++++++++-----
 .../tests/subagent-process.spec.ts            | 12 ++++++++++
 3 files changed, 31 insertions(+), 7 deletions(-)

diff --git a/packages/subagent/subagent-process/README.md b/packages/subagent/subagent-process/README.md
index e42bb4b611..e6c8e10a96 100644
--- a/packages/subagent/subagent-process/README.md
+++ b/packages/subagent/subagent-process/README.md
@@ -16,7 +16,7 @@ Spawn-failure capture: a promise that resolves (never rejects) with the child's
 
 ### `waitForExit(child)` / `exitsWithin(child, ms)`
 
-Exit waits over a `ChildProcess`: resolve once the child exits by any code or signal (immediately if it is already gone), or race that against a timer (`true` = exited in time; the pending timer is `unref()`ed so a grace window never keeps the parent's event loop alive).
+Exit waits over a `ChildProcess`: resolve once the child exits by any code or signal (immediately if it is already gone), or race that against a timer (`true` = exited in time). The race cleans up after itself on both outcomes — the pending timer is `unref()`ed and cleared on exit, the exit listener removed on timeout — so repeated calls (the dispose ladder's tiers, a poll loop) never accumulate listeners on the child.
 
 ### `disposeChildProcess(child, graces)`
 
diff --git a/packages/subagent/subagent-process/src/index.ts b/packages/subagent/subagent-process/src/index.ts
index b54681d3c7..219ed6b083 100644
--- a/packages/subagent/subagent-process/src/index.ts
+++ b/packages/subagent/subagent-process/src/index.ts
@@ -78,17 +78,29 @@ export function waitForExit(child: ChildProcess): Promise<void> {
 }
 
 /**
- * Race the child's exit against a timer.
+ * Race the child's exit against a timer. Neither outcome leaves anything
+ * behind on the child: the exit listener is removed on timeout and the timer
+ * is cleared on exit, so repeated calls (the dispose ladder's tiers, a poll
+ * loop) never accumulate listeners.
  * @param child - the child process to watch.
  * @param ms - the wait window in milliseconds.
- * @returns `true` if the child exits within `ms`, `false` on timeout.
+ * @returns `true` if the child exits within `ms` (immediately if it is
+ * already gone), `false` on timeout.
  */
 export function exitsWithin(child: ChildProcess, ms: number): Promise<boolean> {
-  return Promise.race([
-    waitForExit(child).then(() => true),
+  if (child.exitCode !== null || child.signalCode !== null) return Promise.resolve(true)
+  return new Promise<boolean>((resolve) => {
+    const onExit = (): void => {
+      clearTimeout(timer)
+      resolve(true)
+    }
     // `.unref()` so a pending grace timer never keeps the parent's loop alive.
-    new Promise<boolean>(resolve => setTimeout(() => { resolve(false) }, ms).unref()),
-  ])
+    const timer = setTimeout(() => {
+      child.removeListener('exit', onExit)
+      resolve(false)
+    }, ms).unref()
+    child.once('exit', onExit)
+  })
 }
 
 /**
diff --git a/packages/subagent/subagent-process/tests/subagent-process.spec.ts b/packages/subagent/subagent-process/tests/subagent-process.spec.ts
index 24f2a3a97d..d23f075284 100644
--- a/packages/subagent/subagent-process/tests/subagent-process.spec.ts
+++ b/packages/subagent/subagent-process/tests/subagent-process.spec.ts
@@ -181,15 +181,27 @@ describe('waitForExit / exitsWithin', () => {
     expect(fake.signalCode).toBe('SIGTERM')
   })
 
+  it('exitsWithin resolves true immediately for an already-exited child (no listener attached)', async () => {
+    const fake = new FakeChild()
+    fake.exitCode = 0
+    await expect(exitsWithin(asChild(fake), 1000)).resolves.toBe(true)
+    expect(fake.listenerCount('exit')).toBe(0)
+  })
+
   it('exitsWithin resolves true when the child exits inside the window', async () => {
     const fake = new FakeChild({ diesOn: 'SIGTERM', delayMs: 5 })
     fake.kill('SIGTERM')
     await expect(exitsWithin(asChild(fake), 1000)).resolves.toBe(true)
+    // The once-listener fired and the grace timer was cleared — nothing lingers.
+    expect(fake.listenerCount('exit')).toBe(0)
   })
 
   it('exitsWithin resolves false on timeout for a child that never exits', async () => {
     const fake = new FakeChild() // nothing short of SIGKILL fells it; no signal sent
     await expect(exitsWithin(asChild(fake), 20)).resolves.toBe(false)
+    // The timeout arm removed its exit listener: repeated waits (a poll loop,
+    // the ladder's tiers) never accumulate listeners on the same child.
+    expect(fake.listenerCount('exit')).toBe(0)
   })
 })