@nathapp/nax 0.42.4 → 0.42.6

package/dist/nax.js

@@ -3244,7 +3244,10 @@ async function executeComplete(binary, prompt, options) {
   if (options?.jsonMode) {
     cmd.push("--output-format", "json");
   }
-  const proc = _completeDeps.spawn(cmd, { stdout: "pipe", stderr: "pipe" });
+  const spawnOpts = { stdout: "pipe", stderr: "pipe" };
+  if (options?.workdir)
+    spawnOpts.cwd = options.workdir;
+  const proc = _completeDeps.spawn(cmd, spawnOpts);
   const exitCode = await proc.exited;
   const stdout = await new Response(proc.stdout).text();
   const stderr = await new Response(proc.stderr).text();
@@ -18960,6 +18963,8 @@ class SpawnAcpSession {
   timeoutSeconds;
   permissionMode;
   env;
+  pidRegistry;
+  activeProc = null;
   constructor(opts) {
     this.agentName = opts.agentName;
     this.sessionName = opts.sessionName;
@@ -18968,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 = [
@@ -18994,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" });
@@ -19036,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" });
@@ -19049,20 +19076,26 @@ 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";
-    this.agentName = parts[parts.length - 1] || "claude";
+    const lastToken = parts[parts.length - 1];
+    if (!lastToken || lastToken.startsWith("-")) {
+      throw new Error(`[acp-adapter] Could not parse agentName from cmdStr: "${cmdStr}"`);
+    }
+    this.agentName = lastToken;
     this.cwd = cwd || process.cwd();
     this.timeoutSeconds = timeoutSeconds || 1800;
     this.env = buildAllowedEnv2();
+    this.pidRegistry = pidRegistry;
   }
   async start() {}
   async createSession(opts) {
     const sessionName = opts.sessionName || `nax-${Date.now()}`;
-    const cmd = ["acpx", "--cwd", this.cwd, opts.agentName, "sessions", "new", "--name", sessionName];
-    getSafeLogger()?.debug("acp-adapter", `Creating new session: ${sessionName}`);
+    const cmd = ["acpx", "--cwd", this.cwd, opts.agentName, "sessions", "ensure", "--name", sessionName];
+    getSafeLogger()?.debug("acp-adapter", `Ensuring session: ${sessionName}`);
     const proc = _spawnClientDeps.spawn(cmd, { stdout: "pipe", stderr: "pipe" });
     const exitCode = await proc.exited;
     if (exitCode !== 0) {
@@ -19076,30 +19109,32 @@ class SpawnAcpClient {
       model: this.model,
       timeoutSeconds: this.timeoutSeconds,
       permissionMode: opts.permissionMode,
-      env: this.env
+      env: this.env,
+      pidRegistry: this.pidRegistry
     });
   }
-  async loadSession(sessionName) {
-    const cmd = ["acpx", "--cwd", this.cwd, this.agentName, "sessions", "ensure", "--name", sessionName];
+  async loadSession(sessionName, agentName) {
+    const cmd = ["acpx", "--cwd", this.cwd, agentName, "sessions", "ensure", "--name", sessionName];
     const proc = _spawnClientDeps.spawn(cmd, { stdout: "pipe", stderr: "pipe" });
     const exitCode = await proc.exited;
     if (exitCode !== 0) {
       return null;
     }
     return new SpawnAcpSession({
-      agentName: this.agentName,
+      agentName,
       sessionName,
       cwd: this.cwd,
       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(() => {
@@ -19177,9 +19212,12 @@ function buildSessionName(workdir, featureName, storyId, sessionRole) {
   return parts.join("-");
 }
 async function ensureAcpSession(client, sessionName, agentName, permissionMode) {
+  if (!agentName) {
+    throw new Error("[acp-adapter] agentName is required for ensureAcpSession");
+  }
   if (client.loadSession) {
     try {
-      const existing = await client.loadSession(sessionName);
+      const existing = await client.loadSession(sessionName, agentName);
       if (existing) {
         getSafeLogger()?.debug("acp-adapter", `Resumed existing session: ${sessionName}`);
         return existing;
@@ -19357,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) {
@@ -19445,10 +19483,11 @@ class AcpAgentAdapter {
     const model = _options?.model ?? "default";
     const timeoutMs = _options?.timeoutMs ?? 120000;
     const permissionMode = _options?.dangerouslySkipPermissions ? "approve-all" : "default";
+    const workdir = _options?.workdir;
     let lastError;
     for (let attempt = 0;attempt < MAX_RATE_LIMIT_RETRIES; attempt++) {
       const cmdStr = `acpx --model ${model} ${this.name}`;
-      const client = _acpAdapterDeps.createClient(cmdStr);
+      const client = _acpAdapterDeps.createClient(cmdStr, workdir);
       await client.start();
       let session = null;
       try {
@@ -19528,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}`);
@@ -19598,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);
     }
   };
 });
@@ -21859,7 +21899,7 @@ var package_default;
 var init_package = __esm(() => {
   package_default = {
     name: "@nathapp/nax",
-    version: "0.42.4",
+    version: "0.42.6",
     description: "AI Coding Agent Orchestrator \u2014 loops until done",
     type: "module",
     bin: {
@@ -21932,8 +21972,8 @@ var init_version = __esm(() => {
   NAX_VERSION = package_default.version;
   NAX_COMMIT = (() => {
     try {
-      if (/^[0-9a-f]{6,10}$/.test("35ef278"))
-        return "35ef278";
+      if (/^[0-9a-f]{6,10}$/.test("deb8333"))
+        return "deb8333";
     } catch {}
     try {
       const result = Bun.spawnSync(["git", "rev-parse", "--short", "HEAD"], {
@@ -65591,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
@@ -65781,7 +65822,7 @@ async function planCommand(workdir, config2, options) {
     const cliAdapter = _deps2.getAgent(agentName);
     if (!cliAdapter)
       throw new Error(`[plan] No agent adapter found for '${agentName}'`);
-    rawResponse = await cliAdapter.complete(prompt, { jsonMode: true });
+    rawResponse = await cliAdapter.complete(prompt, { jsonMode: true, workdir });
     try {
       const envelope = JSON.parse(rawResponse);
       if (envelope?.type === "result" && typeof envelope?.result === "string") {
@@ -65794,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({
@@ -65805,9 +65847,12 @@ async function planCommand(workdir, config2, options) {
         config: config2,
         modelTier: config2?.plan?.model ?? "balanced",
         dangerouslySkipPermissions: config2?.execution?.dangerouslySkipPermissions ?? false,
-        maxInteractionTurns: config2?.agent?.maxInteractionTurns
+        maxInteractionTurns: config2?.agent?.maxInteractionTurns,
+        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.4",
+  "version": "0.42.6",
   "description": "AI Coding Agent Orchestrator — loops until done",
   "type": "module",
   "bin": {

package/src/agents/acp/adapter.ts

@@ -92,7 +92,7 @@ export interface AcpClient {
   start(): Promise<void>;
   createSession(opts: { agentName: string; permissionMode: string; sessionName?: string }): Promise<AcpSession>;
   /** Resume an existing named session. Returns null if the session is not found. */
-  loadSession?(sessionName: string): Promise<AcpSession | null>;
+  loadSession?(sessionName: string, agentName: string): Promise<AcpSession | null>;
   close(): Promise<void>;
 }
 
@@ -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);
   },
 };
 
@@ -180,10 +185,14 @@ export async function ensureAcpSession(
   agentName: string,
   permissionMode: string,
 ): Promise<AcpSession> {
+  if (!agentName) {
+    throw new Error("[acp-adapter] agentName is required for ensureAcpSession");
+  }
+
   // Try to resume existing session first
   if (client.loadSession) {
     try {
-      const existing = await client.loadSession(sessionName);
+      const existing = await client.loadSession(sessionName, agentName);
       if (existing) {
         getSafeLogger()?.debug("acp-adapter", `Resumed existing session: ${sessionName}`);
         return existing;
@@ -432,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
@@ -554,12 +563,13 @@ export class AcpAgentAdapter implements AgentAdapter {
     const model = _options?.model ?? "default";
     const timeoutMs = _options?.timeoutMs ?? 120_000; // 2-min safety net by default
     const permissionMode = _options?.dangerouslySkipPermissions ? "approve-all" : "default";
+    const workdir = _options?.workdir;
 
     let lastError: Error | undefined;
 
     for (let attempt = 0; attempt < MAX_RATE_LIMIT_RETRIES; attempt++) {
       const cmdStr = `acpx --model ${model} ${this.name}`;
-      const client = _acpAdapterDeps.createClient(cmdStr);
+      const client = _acpAdapterDeps.createClient(cmdStr, workdir);
       await client.start();
 
       let session: AcpSession | null = null;
@@ -668,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}`);
 
@@ -211,7 +246,7 @@ class SpawnAcpSession implements AcpSession {
  * The cmdStr is parsed to extract --model and agent name:
  *   "acpx --model claude-sonnet-4-5 claude" → model=claude-sonnet-4-5, agent=claude
  *
- * createSession() spawns: acpx --cwd <dir> <agent> sessions new --name <name>
+ * createSession() spawns: acpx <agent> sessions ensure --name <name>
  * loadSession() tries to resume an existing named session.
  */
 export class SpawnAcpClient implements AcpClient {
@@ -220,17 +255,23 @@ 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");
     this.model = modelIdx >= 0 && parts[modelIdx + 1] ? parts[modelIdx + 1] : "default";
-    // Agent name is the last non-flag token
-    this.agentName = parts[parts.length - 1] || "claude";
+    // Agent name is the last non-flag token — must be present and not a flag
+    const lastToken = parts[parts.length - 1];
+    if (!lastToken || lastToken.startsWith("-")) {
+      throw new Error(`[acp-adapter] Could not parse agentName from cmdStr: "${cmdStr}"`);
+    }
+    this.agentName = lastToken;
     this.cwd = cwd || process.cwd();
     this.timeoutSeconds = timeoutSeconds || 1800;
     this.env = buildAllowedEnv();
+    this.pidRegistry = pidRegistry;
   }
 
   async start(): Promise<void> {
@@ -244,9 +285,9 @@ export class SpawnAcpClient implements AcpClient {
   }): Promise<AcpSession> {
     const sessionName = opts.sessionName || `nax-${Date.now()}`;
 
-    // Create new session via CLI (sessions new = always creates; sessions ensure = lookup only)
-    const cmd = ["acpx", "--cwd", this.cwd, opts.agentName, "sessions", "new", "--name", sessionName];
-    getSafeLogger()?.debug("acp-adapter", `Creating new session: ${sessionName}`);
+    // Ensure session exists via CLI
+    const cmd = ["acpx", "--cwd", this.cwd, opts.agentName, "sessions", "ensure", "--name", sessionName];
+    getSafeLogger()?.debug("acp-adapter", `Ensuring session: ${sessionName}`);
 
     const proc = _spawnClientDeps.spawn(cmd, { stdout: "pipe", stderr: "pipe" });
     const exitCode = await proc.exited;
@@ -264,12 +305,13 @@ export class SpawnAcpClient implements AcpClient {
       timeoutSeconds: this.timeoutSeconds,
       permissionMode: opts.permissionMode,
       env: this.env,
+      pidRegistry: this.pidRegistry,
     });
   }
 
-  async loadSession(sessionName: string): Promise<AcpSession | null> {
+  async loadSession(sessionName: string, agentName: string): Promise<AcpSession | null> {
     // Try to ensure session exists — if it does, acpx returns success
-    const cmd = ["acpx", "--cwd", this.cwd, this.agentName, "sessions", "ensure", "--name", sessionName];
+    const cmd = ["acpx", "--cwd", this.cwd, agentName, "sessions", "ensure", "--name", sessionName];
 
     const proc = _spawnClientDeps.spawn(cmd, { stdout: "pipe", stderr: "pipe" });
     const exitCode = await proc.exited;
@@ -279,13 +321,14 @@ export class SpawnAcpClient implements AcpClient {
     }
 
     return new SpawnAcpSession({
-      agentName: this.agentName,
+      agentName,
       sessionName,
       cwd: this.cwd,
       model: this.model,
       timeoutSeconds: this.timeoutSeconds,
       permissionMode: "approve-all", // Default for resumed sessions
       env: this.env,
+      pidRegistry: this.pidRegistry,
     });
   }
 
@@ -302,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/claude-complete.ts

@@ -51,7 +51,9 @@ export async function executeComplete(binary: string, prompt: string, options?:
     cmd.push("--output-format", "json");
   }
 
-  const proc = _completeDeps.spawn(cmd, { stdout: "pipe", stderr: "pipe" });
+  const spawnOpts: { stdout: "pipe"; stderr: "pipe"; cwd?: string } = { stdout: "pipe", stderr: "pipe" };
+  if (options?.workdir) spawnOpts.cwd = options.workdir;
+  const proc = _completeDeps.spawn(cmd, spawnOpts);
   const exitCode = await proc.exited;
 
   const stdout = await new Response(proc.stdout).text();

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/agents/types.ts

@@ -102,6 +102,12 @@ export interface CompleteOptions {
   model?: string;
   /** Whether to skip permission prompts (maps to permissionMode in ACP) */
   dangerouslySkipPermissions?: boolean;
+  /**
+   * Working directory for the completion call.
+   * Used by ACP adapter to set --cwd on the spawned acpx session.
+   * CLI adapter uses this as the process cwd when spawning the agent binary.
+   */
+  workdir?: string;
   /**
    * Timeout for the completion call in milliseconds.
    * Adapters that support it (e.g. ACP) will enforce this as a hard deadline.

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";
 
@@ -107,7 +108,7 @@ export async function planCommand(workdir: string, config: NaxConfig, options: P
     const prompt = buildPlanningPrompt(specContent, codebaseContext);
     const cliAdapter = _deps.getAgent(agentName);
     if (!cliAdapter) throw new Error(`[plan] No agent adapter found for '${agentName}'`);
-    rawResponse = await cliAdapter.complete(prompt, { jsonMode: true });
+    rawResponse = await cliAdapter.complete(prompt, { jsonMode: true, workdir });
     // CLI adapter returns {"type":"result","result":"..."} envelope — unwrap it
     try {
       const envelope = JSON.parse(rawResponse) as Record<string, unknown>;
@@ -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({
@@ -135,8 +137,11 @@ export async function planCommand(workdir: string, config: NaxConfig, options: P
         modelTier: config?.plan?.model ?? "balanced",
         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