fix: kill entire process group on agent close to prevent orphan child processes

kiro-cli is a wrapper that forks kiro-cli-chat as the actual ACP server.
Sending SIGTERM to the wrapper (kiro-cli) does not kill the child process
(kiro-cli-chat), which becomes an orphan and accumulates over time.

Fix: spawn the agent with detached:true so it becomes a process group
leader, then use process.kill(-pgid, SIGTERM) to kill the entire process
group including all child processes.

Also adds onAgentPid callback to runQueuedTask/runSessionPrompt to allow
callers to track the agent pid for cleanup purposes.

Fixes: kiro-cli-chat acp process leak on /new

Author: pahud

src/client.ts

@@ -372,6 +372,7 @@ export class AcpClient {
       cwd: this.options.cwd,
       env: buildAgentEnvironment(this.options.authCredentials),
       stdio: ["pipe", "pipe", "pipe"],
+      detached: true,
     });
 
     try {
@@ -718,10 +719,14 @@ export class AcpClient {
 
     const agent = this.agent;
     if (agent) {
-      // Some adapters keep stdio handles alive after SIGTERM; explicitly
-      // destroy/unref so CLI calls can exit deterministically.
+      // Kill the entire process group to ensure child processes (e.g. kiro-cli-chat)
+      // are also terminated when the parent wrapper exits.
       if (!agent.killed) {
-        agent.kill();
+        try {
+          process.kill(-agent.pid!, "SIGTERM");
+        } catch {
+          agent.kill();
+        }
       }
       this.detachAgentHandles(agent);
     }

src/session-runtime.ts

@@ -201,6 +201,7 @@ type RunSessionPromptOptions = {
   onClientAvailable?: (controller: ActiveSessionController) => void;
   onClientClosed?: () => void;
   onPromptActive?: () => Promise<void> | void;
+  onAgentPid?: (pid: number) => void;
 };
 
 type ActiveSessionController = QueueOwnerActiveSessionController;
@@ -291,6 +292,7 @@ async function runQueuedTask(
     onClientAvailable?: (controller: ActiveSessionController) => void;
     onClientClosed?: () => void;
     onPromptActive?: () => Promise<void> | void;
+    onAgentPid?: (pid: number) => void;
   },
 ): Promise<void> {
   const outputFormatter = task.waitForCompletion
@@ -314,6 +316,7 @@ async function runQueuedTask(
       onClientAvailable: options.onClientAvailable,
       onClientClosed: options.onClientClosed,
       onPromptActive: options.onPromptActive,
+      onAgentPid: options.onAgentPid,
     });
 
     if (task.waitForCompletion) {
@@ -448,6 +451,9 @@ async function runSessionPrompt(
           },
           onConnectedRecord: (connectedRecord) => {
             connectedRecord.lastPromptAt = isoNow();
+            if (connectedRecord.pid != null) {
+              options.onAgentPid?.(connectedRecord.pid);
+            }
           },
           onSessionIdResolved: (sessionId) => {
             activeSessionIdForControl = sessionId;
@@ -745,6 +751,7 @@ export async function runSessionQueueOwner(
   }
 
   let owner: SessionQueueOwner | undefined;
+  let lastAgentPid: number | undefined;
   const ttlMs = normalizeQueueOwnerTtlMs(options.ttlMs);
   const taskPollTimeoutMs = ttlMs === 0 ? undefined : ttlMs;
   const initialTaskPollTimeoutMs =
@@ -857,13 +864,23 @@ export async function runSessionQueueOwner(
           authCredentials: options.authCredentials,
           authPolicy: options.authPolicy,
           suppressSdkConsoleErrors: options.suppressSdkConsoleErrors,
-          onClientAvailable: setActiveController,
+          onClientAvailable: (controller) => {
+            setActiveController(controller);
+          },
           onClientClosed: clearActiveController,
           onPromptActive: async () => {
             turnController.markPromptActive();
             await applyPendingCancel();
           },
+          onAgentPid: (pid) => {
+            lastAgentPid = pid;
+          },
         });
+        // Track the agent pid after each task so we can kill it when the queue owner exits
+        const record = await resolveSessionRecord(options.sessionId).catch(() => null);
+        if (record?.pid != null) {
+          lastAgentPid = record.pid;
+        }
       });
     }
   } finally {
@@ -872,6 +889,15 @@ export async function runSessionQueueOwner(
       await owner.close();
     }
     await releaseQueueOwnerLease(lease);
+    // Kill the agent process if it is still alive (e.g. kiro-cli which does not self-exit)
+    if (lastAgentPid != null && isProcessAlive(lastAgentPid)) {
+      await terminateProcess(lastAgentPid).catch(() => {});
+      if (options.verbose) {
+        process.stderr.write(
+          `[acpx] killed agent pid ${lastAgentPid} on queue owner exit for session ${options.sessionId}\n`,
+        );
+      }
+    }
     if (options.verbose) {
       process.stderr.write(
         `[acpx] queue owner stopped for session ${options.sessionId}\n`,