@nathapp/nax 0.42.5 → 0.42.6

package/dist/nax.js

@@ -18963,6 +18963,8 @@ class SpawnAcpSession {
   timeoutSeconds;
   permissionMode;
   env;
+  pidRegistry;
+  activeProc = null;
   constructor(opts) {
     this.agentName = opts.agentName;
     this.sessionName = opts.sessionName;
@@ -18971,6 +18973,7 @@ class SpawnAcpSession {
     this.timeoutSeconds = opts.timeoutSeconds;
     this.permissionMode = opts.permissionMode;
     this.env = opts.env;
+    this.pidRegistry = opts.pidRegistry;
   }
   async prompt(text) {
     const cmd = [
@@ -18997,35 +19000,50 @@ class SpawnAcpSession {
       stderr: "pipe",
       env: this.env
     });
-    proc.stdin.write(text);
-    proc.stdin.end();
-    const exitCode = await proc.exited;
-    const stdout = await new Response(proc.stdout).text();
-    const stderr = await new Response(proc.stderr).text();
-    if (exitCode !== 0) {
-      getSafeLogger()?.warn("acp-adapter", `Session prompt exited with code ${exitCode}`, {
-        stderr: stderr.slice(0, 200)
-      });
-      return {
-        messages: [{ role: "assistant", content: stderr || `Exit code ${exitCode}` }],
-        stopReason: "error"
-      };
-    }
+    this.activeProc = proc;
+    const processPid = proc.pid;
+    await this.pidRegistry?.register(processPid);
     try {
-      const parsed = parseAcpxJsonOutput(stdout);
-      return {
-        messages: [{ role: "assistant", content: parsed.text || "" }],
-        stopReason: "end_turn",
-        cumulative_token_usage: parsed.tokenUsage
-      };
-    } catch (err) {
-      getSafeLogger()?.warn("acp-adapter", "Failed to parse session prompt response", {
-        stderr: stderr.slice(0, 200)
-      });
-      throw err;
+      proc.stdin.write(text);
+      proc.stdin.end();
+      const exitCode = await proc.exited;
+      const stdout = await new Response(proc.stdout).text();
+      const stderr = await new Response(proc.stderr).text();
+      if (exitCode !== 0) {
+        getSafeLogger()?.warn("acp-adapter", `Session prompt exited with code ${exitCode}`, {
+          stderr: stderr.slice(0, 200)
+        });
+        return {
+          messages: [{ role: "assistant", content: stderr || `Exit code ${exitCode}` }],
+          stopReason: "error"
+        };
+      }
+      try {
+        const parsed = parseAcpxJsonOutput(stdout);
+        return {
+          messages: [{ role: "assistant", content: parsed.text || "" }],
+          stopReason: "end_turn",
+          cumulative_token_usage: parsed.tokenUsage
+        };
+      } catch (err) {
+        getSafeLogger()?.warn("acp-adapter", "Failed to parse session prompt response", {
+          stderr: stderr.slice(0, 200)
+        });
+        throw err;
+      }
+    } finally {
+      this.activeProc = null;
+      await this.pidRegistry?.unregister(processPid);
     }
   }
   async close() {
+    if (this.activeProc) {
+      try {
+        this.activeProc.kill(15);
+        getSafeLogger()?.debug("acp-adapter", `Killed active prompt process PID ${this.activeProc.pid}`);
+      } catch {}
+      this.activeProc = null;
+    }
     const cmd = ["acpx", this.agentName, "sessions", "close", this.sessionName];
     getSafeLogger()?.debug("acp-adapter", `Closing session: ${this.sessionName}`);
     const proc = _spawnClientDeps.spawn(cmd, { stdout: "pipe", stderr: "pipe" });
@@ -19039,6 +19057,12 @@ class SpawnAcpSession {
     }
   }
   async cancelActivePrompt() {
+    if (this.activeProc) {
+      try {
+        this.activeProc.kill(15);
+        getSafeLogger()?.debug("acp-adapter", `Killed active prompt process PID ${this.activeProc.pid}`);
+      } catch {}
+    }
     const cmd = ["acpx", this.agentName, "cancel"];
     getSafeLogger()?.debug("acp-adapter", `Cancelling active prompt: ${this.sessionName}`);
     const proc = _spawnClientDeps.spawn(cmd, { stdout: "pipe", stderr: "pipe" });
@@ -19052,7 +19076,8 @@ class SpawnAcpClient {
   cwd;
   timeoutSeconds;
   env;
-  constructor(cmdStr, cwd, timeoutSeconds) {
+  pidRegistry;
+  constructor(cmdStr, cwd, timeoutSeconds, pidRegistry) {
     const parts = cmdStr.split(/\s+/);
     const modelIdx = parts.indexOf("--model");
     this.model = modelIdx >= 0 && parts[modelIdx + 1] ? parts[modelIdx + 1] : "default";
@@ -19064,6 +19089,7 @@ class SpawnAcpClient {
     this.cwd = cwd || process.cwd();
     this.timeoutSeconds = timeoutSeconds || 1800;
     this.env = buildAllowedEnv2();
+    this.pidRegistry = pidRegistry;
   }
   async start() {}
   async createSession(opts) {
@@ -19083,7 +19109,8 @@ class SpawnAcpClient {
       model: this.model,
       timeoutSeconds: this.timeoutSeconds,
       permissionMode: opts.permissionMode,
-      env: this.env
+      env: this.env,
+      pidRegistry: this.pidRegistry
     });
   }
   async loadSession(sessionName, agentName) {
@@ -19100,13 +19127,14 @@ class SpawnAcpClient {
       model: this.model,
       timeoutSeconds: this.timeoutSeconds,
       permissionMode: "approve-all",
-      env: this.env
+      env: this.env,
+      pidRegistry: this.pidRegistry
     });
   }
   async close() {}
 }
-function createSpawnAcpClient(cmdStr, cwd, timeoutSeconds) {
-  return new SpawnAcpClient(cmdStr, cwd, timeoutSeconds);
+function createSpawnAcpClient(cmdStr, cwd, timeoutSeconds, pidRegistry) {
+  return new SpawnAcpClient(cmdStr, cwd, timeoutSeconds, pidRegistry);
 }
 var _spawnClientDeps;
 var init_spawn_client = __esm(() => {
@@ -19367,7 +19395,7 @@ class AcpAgentAdapter {
   }
   async _runWithClient(options, startTime) {
     const cmdStr = `acpx --model ${options.modelDef.model} ${this.name}`;
-    const client = _acpAdapterDeps.createClient(cmdStr, options.workdir, options.timeoutSeconds);
+    const client = _acpAdapterDeps.createClient(cmdStr, options.workdir, options.timeoutSeconds, options.pidRegistry);
     await client.start();
     let sessionName = options.acpSessionName;
     if (!sessionName && options.featureName && options.storyId) {
@@ -19539,7 +19567,8 @@ class AcpAgentAdapter {
       maxInteractionTurns: options.maxInteractionTurns,
       featureName: options.featureName,
       storyId: options.storyId,
-      sessionRole: options.sessionRole
+      sessionRole: options.sessionRole,
+      pidRegistry: options.pidRegistry
     });
     if (!result.success) {
       throw new Error(`[acp-adapter] plan() failed: ${result.output}`);
@@ -19609,8 +19638,8 @@ var init_adapter = __esm(() => {
     async sleep(ms) {
       await Bun.sleep(ms);
     },
-    createClient(cmdStr, cwd, timeoutSeconds) {
-      return createSpawnAcpClient(cmdStr, cwd, timeoutSeconds);
+    createClient(cmdStr, cwd, timeoutSeconds, pidRegistry) {
+      return createSpawnAcpClient(cmdStr, cwd, timeoutSeconds, pidRegistry);
     }
   };
 });
@@ -21870,7 +21899,7 @@ var package_default;
 var init_package = __esm(() => {
   package_default = {
     name: "@nathapp/nax",
-    version: "0.42.5",
+    version: "0.42.6",
     description: "AI Coding Agent Orchestrator \u2014 loops until done",
     type: "module",
     bin: {
@@ -21943,8 +21972,8 @@ var init_version = __esm(() => {
   NAX_VERSION = package_default.version;
   NAX_COMMIT = (() => {
     try {
-      if (/^[0-9a-f]{6,10}$/.test("7b603fa"))
-        return "7b603fa";
+      if (/^[0-9a-f]{6,10}$/.test("deb8333"))
+        return "deb8333";
     } catch {}
     try {
       const result = Bun.spawnSync(["git", "rev-parse", "--short", "HEAD"], {
@@ -65602,6 +65631,7 @@ init_registry();
 import { existsSync as existsSync9 } from "fs";
 import { join as join10 } from "path";
 import { createInterface } from "readline";
+init_pid_registry();
 init_logger2();
 
 // src/prd/schema.ts
@@ -65805,6 +65835,7 @@ async function planCommand(workdir, config2, options) {
     if (!adapter)
       throw new Error(`[plan] No agent adapter found for '${agentName}'`);
     const interactionBridge = createCliInteractionBridge();
+    const pidRegistry = new PidRegistry(workdir);
     logger?.info("plan", "Starting interactive planning session...", { agent: agentName });
     try {
       await adapter.plan({
@@ -65817,9 +65848,11 @@ async function planCommand(workdir, config2, options) {
         modelTier: config2?.plan?.model ?? "balanced",
         dangerouslySkipPermissions: config2?.execution?.dangerouslySkipPermissions ?? false,
         maxInteractionTurns: config2?.agent?.maxInteractionTurns,
-        featureName: options.feature
+        featureName: options.feature,
+        pidRegistry
       });
     } finally {
+      await pidRegistry.killAll().catch(() => {});
       logger?.info("plan", "Interactive session ended");
     }
     if (!_deps2.existsSync(outputPath)) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@nathapp/nax",
-  "version": "0.42.5",
+  "version": "0.42.6",
   "description": "AI Coding Agent Orchestrator — loops until done",
   "type": "module",
   "bin": {

package/src/agents/acp/adapter.ts

@@ -114,8 +114,13 @@ export const _acpAdapterDeps = {
    * Default: spawn-based client (shells out to acpx CLI).
    * Override in tests via: _acpAdapterDeps.createClient = mock(...)
    */
-  createClient(cmdStr: string, cwd?: string, timeoutSeconds?: number): AcpClient {
-    return createSpawnAcpClient(cmdStr, cwd, timeoutSeconds);
+  createClient(
+    cmdStr: string,
+    cwd?: string,
+    timeoutSeconds?: number,
+    pidRegistry?: import("../../execution/pid-registry").PidRegistry,
+  ): AcpClient {
+    return createSpawnAcpClient(cmdStr, cwd, timeoutSeconds, pidRegistry);
   },
 };
 
@@ -436,7 +441,7 @@ export class AcpAgentAdapter implements AgentAdapter {
 
   private async _runWithClient(options: AgentRunOptions, startTime: number): Promise<AgentResult> {
     const cmdStr = `acpx --model ${options.modelDef.model} ${this.name}`;
-    const client = _acpAdapterDeps.createClient(cmdStr, options.workdir, options.timeoutSeconds);
+    const client = _acpAdapterDeps.createClient(cmdStr, options.workdir, options.timeoutSeconds, options.pidRegistry);
     await client.start();
 
     // 1. Resolve session name: explicit > sidecar > derived
@@ -673,6 +678,7 @@ export class AcpAgentAdapter implements AgentAdapter {
       featureName: options.featureName,
       storyId: options.storyId,
       sessionRole: options.sessionRole,
+      pidRegistry: options.pidRegistry,
     });
 
     if (!result.success) {

package/src/agents/acp/spawn-client.ts

@@ -12,6 +12,7 @@
  *   acpx <agent> cancel                             → session.cancelActivePrompt()
  */
 
+import type { PidRegistry } from "../../execution/pid-registry";
 import { getSafeLogger } from "../../logger";
 import type { AcpClient, AcpSession, AcpSessionResponse } from "./adapter";
 import { parseAcpxJsonOutput } from "./parser";
@@ -96,6 +97,8 @@ class SpawnAcpSession implements AcpSession {
   private readonly timeoutSeconds: number;
   private readonly permissionMode: string;
   private readonly env: Record<string, string | undefined>;
+  private readonly pidRegistry?: PidRegistry;
+  private activeProc: { pid: number; kill(signal?: number): void } | null = null;
 
   constructor(opts: {
     agentName: string;
@@ -105,6 +108,7 @@ class SpawnAcpSession implements AcpSession {
     timeoutSeconds: number;
     permissionMode: string;
     env: Record<string, string | undefined>;
+    pidRegistry?: PidRegistry;
   }) {
     this.agentName = opts.agentName;
     this.sessionName = opts.sessionName;
@@ -113,6 +117,7 @@ class SpawnAcpSession implements AcpSession {
     this.timeoutSeconds = opts.timeoutSeconds;
     this.permissionMode = opts.permissionMode;
     this.env = opts.env;
+    this.pidRegistry = opts.pidRegistry;
   }
 
   async prompt(text: string): Promise<AcpSessionResponse> {
@@ -143,40 +148,60 @@ class SpawnAcpSession implements AcpSession {
       env: this.env,
     });
 
-    proc.stdin.write(text);
-    proc.stdin.end();
+    this.activeProc = proc;
+    const processPid = proc.pid;
+    await this.pidRegistry?.register(processPid);
 
-    const exitCode = await proc.exited;
-    const stdout = await new Response(proc.stdout).text();
-    const stderr = await new Response(proc.stderr).text();
+    try {
+      proc.stdin.write(text);
+      proc.stdin.end();
 
-    if (exitCode !== 0) {
-      getSafeLogger()?.warn("acp-adapter", `Session prompt exited with code ${exitCode}`, {
-        stderr: stderr.slice(0, 200),
-      });
-      // Return error response so the adapter can handle it
-      return {
-        messages: [{ role: "assistant", content: stderr || `Exit code ${exitCode}` }],
-        stopReason: "error",
-      };
-    }
+      const exitCode = await proc.exited;
+      const stdout = await new Response(proc.stdout).text();
+      const stderr = await new Response(proc.stderr).text();
 
-    try {
-      const parsed = parseAcpxJsonOutput(stdout);
-      return {
-        messages: [{ role: "assistant", content: parsed.text || "" }],
-        stopReason: "end_turn",
-        cumulative_token_usage: parsed.tokenUsage,
-      };
-    } catch (err) {
-      getSafeLogger()?.warn("acp-adapter", "Failed to parse session prompt response", {
-        stderr: stderr.slice(0, 200),
-      });
-      throw err;
+      if (exitCode !== 0) {
+        getSafeLogger()?.warn("acp-adapter", `Session prompt exited with code ${exitCode}`, {
+          stderr: stderr.slice(0, 200),
+        });
+        // Return error response so the adapter can handle it
+        return {
+          messages: [{ role: "assistant", content: stderr || `Exit code ${exitCode}` }],
+          stopReason: "error",
+        };
+      }
+
+      try {
+        const parsed = parseAcpxJsonOutput(stdout);
+        return {
+          messages: [{ role: "assistant", content: parsed.text || "" }],
+          stopReason: "end_turn",
+          cumulative_token_usage: parsed.tokenUsage,
+        };
+      } catch (err) {
+        getSafeLogger()?.warn("acp-adapter", "Failed to parse session prompt response", {
+          stderr: stderr.slice(0, 200),
+        });
+        throw err;
+      }
+    } finally {
+      this.activeProc = null;
+      await this.pidRegistry?.unregister(processPid);
     }
   }
 
   async close(): Promise<void> {
+    // Kill in-flight prompt process first (if any)
+    if (this.activeProc) {
+      try {
+        this.activeProc.kill(15); // SIGTERM
+        getSafeLogger()?.debug("acp-adapter", `Killed active prompt process PID ${this.activeProc.pid}`);
+      } catch {
+        // Process may have already exited
+      }
+      this.activeProc = null;
+    }
+
     const cmd = ["acpx", this.agentName, "sessions", "close", this.sessionName];
     getSafeLogger()?.debug("acp-adapter", `Closing session: ${this.sessionName}`);
 
@@ -193,6 +218,16 @@ class SpawnAcpSession implements AcpSession {
   }
 
   async cancelActivePrompt(): Promise<void> {
+    // Kill in-flight prompt process directly (faster than acpx cancel)
+    if (this.activeProc) {
+      try {
+        this.activeProc.kill(15); // SIGTERM
+        getSafeLogger()?.debug("acp-adapter", `Killed active prompt process PID ${this.activeProc.pid}`);
+      } catch {
+        // Process may have already exited
+      }
+    }
+
     const cmd = ["acpx", this.agentName, "cancel"];
     getSafeLogger()?.debug("acp-adapter", `Cancelling active prompt: ${this.sessionName}`);
 
@@ -220,8 +255,9 @@ export class SpawnAcpClient implements AcpClient {
   private readonly cwd: string;
   private readonly timeoutSeconds: number;
   private readonly env: Record<string, string | undefined>;
+  private readonly pidRegistry?: PidRegistry;
 
-  constructor(cmdStr: string, cwd?: string, timeoutSeconds?: number) {
+  constructor(cmdStr: string, cwd?: string, timeoutSeconds?: number, pidRegistry?: PidRegistry) {
     // Parse: "acpx --model <model> <agentName>"
     const parts = cmdStr.split(/\s+/);
     const modelIdx = parts.indexOf("--model");
@@ -235,6 +271,7 @@ export class SpawnAcpClient implements AcpClient {
     this.cwd = cwd || process.cwd();
     this.timeoutSeconds = timeoutSeconds || 1800;
     this.env = buildAllowedEnv();
+    this.pidRegistry = pidRegistry;
   }
 
   async start(): Promise<void> {
@@ -268,6 +305,7 @@ export class SpawnAcpClient implements AcpClient {
       timeoutSeconds: this.timeoutSeconds,
       permissionMode: opts.permissionMode,
       env: this.env,
+      pidRegistry: this.pidRegistry,
     });
   }
 
@@ -290,6 +328,7 @@ export class SpawnAcpClient implements AcpClient {
       timeoutSeconds: this.timeoutSeconds,
       permissionMode: "approve-all", // Default for resumed sessions
       env: this.env,
+      pidRegistry: this.pidRegistry,
     });
   }
 
@@ -306,6 +345,11 @@ export class SpawnAcpClient implements AcpClient {
  * Create a spawn-based ACP client. This is the default production factory.
  * The cmdStr format is: "acpx --model <model> <agentName>"
  */
-export function createSpawnAcpClient(cmdStr: string, cwd?: string, timeoutSeconds?: number): AcpClient {
-  return new SpawnAcpClient(cmdStr, cwd, timeoutSeconds);
+export function createSpawnAcpClient(
+  cmdStr: string,
+  cwd?: string,
+  timeoutSeconds?: number,
+  pidRegistry?: PidRegistry,
+): AcpClient {
+  return new SpawnAcpClient(cmdStr, cwd, timeoutSeconds, pidRegistry);
 }

package/src/agents/types-extended.ts

@@ -55,6 +55,8 @@ export interface PlanOptions {
    * Used to persist the name to status.json for plan→run session continuity.
    */
   onAcpSessionCreated?: (sessionName: string) => Promise<void> | void;
+  /** PID registry for tracking spawned agent processes — cleanup on crash/SIGTERM */
+  pidRegistry?: import("../execution/pid-registry").PidRegistry;
 }
 
 /**

package/src/cli/plan.ts

@@ -15,6 +15,7 @@ import type { AgentAdapter } from "../agents/types";
 import { scanCodebase } from "../analyze/scanner";
 import type { CodebaseScan } from "../analyze/types";
 import type { NaxConfig } from "../config";
+import { PidRegistry } from "../execution/pid-registry";
 import { getLogger } from "../logger";
 import { validatePlanOutput } from "../prd/schema";
 
@@ -123,6 +124,7 @@ export async function planCommand(workdir: string, config: NaxConfig, options: P
     const adapter = _deps.getAgent(agentName, config);
     if (!adapter) throw new Error(`[plan] No agent adapter found for '${agentName}'`);
     const interactionBridge = createCliInteractionBridge();
+    const pidRegistry = new PidRegistry(workdir);
     logger?.info("plan", "Starting interactive planning session...", { agent: agentName });
     try {
       await adapter.plan({
@@ -136,8 +138,10 @@ export async function planCommand(workdir: string, config: NaxConfig, options: P
         dangerouslySkipPermissions: config?.execution?.dangerouslySkipPermissions ?? false,
         maxInteractionTurns: config?.agent?.maxInteractionTurns,
         featureName: options.feature,
+        pidRegistry,
       });
     } finally {
+      await pidRegistry.killAll().catch(() => {});
       logger?.info("plan", "Interactive session ended");
     }
     // Read back from file written by agent