@nathapp/nax 0.54.1 → 0.54.3

package/dist/nax.js

@@ -3580,6 +3580,44 @@ var init_complete = __esm(() => {
   };
 });
 
+// src/agents/shared/env.ts
+import { homedir } from "os";
+import { isAbsolute } from "path";
+function buildAllowedEnv(options) {
+  const allowed = {};
+  for (const varName of ESSENTIAL_VARS) {
+    if (process.env[varName])
+      allowed[varName] = process.env[varName];
+  }
+  const rawHome = process.env.HOME ?? "";
+  const safeHome = rawHome && isAbsolute(rawHome) ? rawHome : homedir();
+  if (rawHome !== safeHome) {
+    getSafeLogger()?.warn("env", `HOME env is not absolute ("${rawHome}"), falling back to os.homedir(): ${safeHome}`);
+  }
+  allowed.HOME = safeHome;
+  for (const varName of API_KEY_VARS) {
+    if (process.env[varName])
+      allowed[varName] = process.env[varName];
+  }
+  for (const [key, value] of Object.entries(process.env)) {
+    if (ALLOWED_PREFIXES.some((prefix) => key.startsWith(prefix))) {
+      allowed[key] = value;
+    }
+  }
+  if (options?.modelEnv)
+    Object.assign(allowed, options.modelEnv);
+  if (options?.env)
+    Object.assign(allowed, options.env);
+  return allowed;
+}
+var ESSENTIAL_VARS, API_KEY_VARS, ALLOWED_PREFIXES;
+var init_env = __esm(() => {
+  init_logger2();
+  ESSENTIAL_VARS = ["PATH", "TMPDIR", "NODE_ENV", "USER", "LOGNAME"];
+  API_KEY_VARS = ["ANTHROPIC_API_KEY", "OPENAI_API_KEY", "GEMINI_API_KEY", "GOOGLE_API_KEY", "CLAUDE_API_KEY"];
+  ALLOWED_PREFIXES = ["CLAUDE_", "NAX_", "CLAW_", "TURBO_", "ACPX_", "CODEX_", "GEMINI_", "ANTHROPIC_"];
+});
+
 // src/agents/cost/pricing.ts
 var COST_RATES, MODEL_PRICING;
 var init_pricing = __esm(() => {
@@ -3743,49 +3781,12 @@ var init_cost2 = __esm(() => {
 });
 
 // src/agents/claude/execution.ts
-import { homedir } from "os";
-import { isAbsolute } from "path";
 function buildCommand(binary, options) {
   const model = options.modelDef.model;
   const { skipPermissions } = resolvePermissions(options.config, options.pipelineStage ?? "run");
   const permArgs = skipPermissions ? ["--dangerously-skip-permissions"] : [];
   return [binary, "--model", model, ...permArgs, "-p", options.prompt];
 }
-function buildAllowedEnv(options) {
-  const allowed = {};
-  const essentialVars = ["PATH", "TMPDIR", "NODE_ENV", "USER", "LOGNAME"];
-  for (const varName of essentialVars) {
-    if (process.env[varName]) {
-      allowed[varName] = process.env[varName];
-    }
-  }
-  const rawHome = process.env.HOME ?? "";
-  const safeHome = rawHome && isAbsolute(rawHome) ? rawHome : homedir();
-  if (rawHome !== safeHome) {
-    const logger = getLogger();
-    logger.warn("env", `HOME env is not absolute ("${rawHome}"), falling back to os.homedir(): ${safeHome}`);
-  }
-  allowed.HOME = safeHome;
-  const apiKeyVars = ["ANTHROPIC_API_KEY", "OPENAI_API_KEY"];
-  for (const varName of apiKeyVars) {
-    if (process.env[varName]) {
-      allowed[varName] = process.env[varName];
-    }
-  }
-  const allowedPrefixes = ["CLAUDE_", "NAX_", "CLAW_", "TURBO_"];
-  for (const [key, value] of Object.entries(process.env)) {
-    if (allowedPrefixes.some((prefix) => key.startsWith(prefix))) {
-      allowed[key] = value;
-    }
-  }
-  if (options.modelDef.env) {
-    Object.assign(allowed, options.modelDef.env);
-  }
-  if (options.env) {
-    Object.assign(allowed, options.env);
-  }
-  return allowed;
-}
 async function executeOnce(binary, options, pidRegistry) {
   const cmd = _runOnceDeps.buildCmd(binary, options);
   const startTime = Date.now();
@@ -3803,7 +3804,7 @@ async function executeOnce(binary, options, pidRegistry) {
     cwd: options.workdir,
     stdout: "pipe",
     stderr: "inherit",
-    env: buildAllowedEnv(options)
+    env: buildAllowedEnv({ env: options.env, modelEnv: options.modelDef.env })
   });
   const processPid = proc.pid;
   await pidRegistry.register(processPid);
@@ -3866,7 +3867,9 @@ var MAX_AGENT_OUTPUT_CHARS = 5000, MAX_AGENT_STDERR_CHARS = 1000, SIGKILL_GRACE_
 var init_execution = __esm(() => {
   init_logger2();
   init_bun_deps();
+  init_env();
   init_cost2();
+  init_env();
   _runOnceDeps = {
     killProc(proc, signal) {
       proc.kill(signal);
@@ -17978,7 +17981,8 @@ var init_schemas3 = __esm(() => {
   });
   SemanticReviewConfigSchema = exports_external.object({
     modelTier: ModelTierSchema.default("balanced"),
-    rules: exports_external.array(exports_external.string()).default([])
+    rules: exports_external.array(exports_external.string()).default([]),
+    timeoutMs: exports_external.number().int().positive().default(600000)
   });
   ReviewConfigSchema = exports_external.object({
     enabled: exports_external.boolean(),
@@ -18273,7 +18277,8 @@ var init_defaults = __esm(() => {
       pluginMode: "per-story",
       semantic: {
         modelTier: "balanced",
-        rules: []
+        rules: [],
+        timeoutMs: 600000
       }
     },
     plan: {
@@ -18781,7 +18786,7 @@ async function refineAcceptanceCriteria(criteria, context) {
   if (criteria.length === 0) {
     return [];
   }
-  const { storyId, codebaseContext, config: config2, testStrategy, testFramework } = context;
+  const { storyId, featureName, workdir, codebaseContext, config: config2, testStrategy, testFramework } = context;
   const logger = getLogger();
   const modelTier = config2.acceptance?.model ?? "fast";
   const modelEntry = config2.models[modelTier] ?? config2.models.fast;
@@ -18796,7 +18801,11 @@ async function refineAcceptanceCriteria(criteria, context) {
       jsonMode: true,
       maxTokens: 4096,
       model: modelDef.model,
-      config: config2
+      config: config2,
+      featureName,
+      storyId,
+      workdir,
+      sessionRole: "refine"
     });
   } catch (error48) {
     const reason = errorMessage(error48);
@@ -18859,13 +18868,13 @@ function skeletonImportLine(testFramework) {
 function acceptanceTestFilename(language) {
   switch (language?.toLowerCase()) {
     case "go":
-      return "acceptance_test.go";
+      return ".nax-acceptance_test.go";
     case "python":
-      return "test_acceptance.py";
+      return ".nax-acceptance.test.py";
     case "rust":
-      return "tests/acceptance.rs";
+      return ".nax-acceptance.rs";
     default:
-      return "acceptance.test.ts";
+      return ".nax-acceptance.test.ts";
   }
 }
 function buildAcceptanceRunCommand(testPath, testFramework, commandOverride) {
@@ -18935,27 +18944,58 @@ Rules:
 - **NEVER use placeholder assertions** \u2014 no always-passing or always-failing stubs, no TODO comments as the only content, no empty test bodies
 - Every test MUST have real assertions that PASS when the feature is correctly implemented and FAIL when it is broken
 - **Prefer behavioral tests** \u2014 import functions and call them rather than reading source files. For example, to verify "getPostRunActions() returns empty array", import PluginRegistry and call getPostRunActions(), don't grep the source file for the method name.
-- Output raw code only \u2014 no markdown fences, start directly with the language's import or package declaration
-- **Path anchor (CRITICAL)**: This test file will be saved at \`<repo-root>/.nax/features/${options.featureName}/${acceptanceTestFilename(options.language)}\` and will ALWAYS run from the repo root. The repo root is exactly 4 \`../\` levels above \`__dirname\`: \`join(__dirname, '..', '..', '..', '..')\`. For monorepo projects, navigate into packages from root (e.g. \`join(root, 'apps/api/src')\`).`;
+- **File output (REQUIRED)**: Write the acceptance test file DIRECTLY to the path shown below. Do NOT output the test code in your response. After writing the file, reply with a brief confirmation.
+- **Path anchor (CRITICAL)**: Write the test file to this exact path: \`${options.featureDir}/${acceptanceTestFilename(options.language)}\`. Import from package sources using relative paths like \`./src/...\`. No deep \`../../../../\` traversal needed.`;
   const prompt = basePrompt;
   logger.info("acceptance", "Generating tests from PRD refined criteria", { count: refinedCriteria.length });
   const rawOutput = await (options.adapter ?? _generatorPRDDeps.adapter).complete(prompt, {
     model: options.modelDef.model,
     config: options.config,
     timeoutMs: options.config?.acceptance?.timeoutMs ?? 1800000,
-    workdir: options.workdir
+    workdir: options.workdir,
+    featureName: options.featureName,
+    sessionRole: "acceptance-gen"
   });
   let testCode = extractTestCode(rawOutput);
+  logger.debug("acceptance", "Received raw output from LLM", {
+    hasCode: testCode !== null,
+    outputLength: rawOutput.length,
+    outputPreview: rawOutput.slice(0, 300)
+  });
   if (!testCode) {
-    const targetPath = join2(options.featureDir, "acceptance.test.ts");
+    const targetPath = join2(options.featureDir, acceptanceTestFilename(options.language));
+    let recoveryFailed = false;
+    logger.debug("acceptance", "BUG-076 recovery: checking for agent-written file", { targetPath });
     try {
       const existing = await Bun.file(targetPath).text();
       const recovered = extractTestCode(existing);
+      logger.debug("acceptance", "BUG-076 recovery: file check result", {
+        fileSize: existing.length,
+        extractedCode: recovered !== null,
+        filePreview: existing.slice(0, 300)
+      });
       if (recovered) {
         logger.info("acceptance", "Acceptance test written directly by agent \u2014 using existing file", { targetPath });
         testCode = recovered;
+      } else {
+        recoveryFailed = true;
+        logger.error("acceptance", "BUG-076: ACP adapter wrote file but no code extractable \u2014 falling back to skeleton", {
+          targetPath,
+          filePreview: existing.slice(0, 300)
+        });
       }
-    } catch {}
+    } catch {
+      recoveryFailed = true;
+      logger.debug("acceptance", "BUG-076 recovery: no file written by agent, falling back to skeleton", {
+        targetPath,
+        rawOutputPreview: rawOutput.slice(0, 500)
+      });
+    }
+    if (recoveryFailed) {
+      logger.error("acceptance", "BUG-076: LLM returned non-code output and no file was written by agent \u2014 falling back to skeleton", {
+        rawOutputPreview: rawOutput.slice(0, 500)
+      });
+    }
   }
   if (!testCode) {
     logger.warn("acceptance", "LLM returned non-code output for acceptance tests \u2014 falling back to skeleton", {
@@ -19056,7 +19096,9 @@ async function generateAcceptanceTests(adapter, options) {
       model: options.modelDef.model,
       config: options.config,
       timeoutMs: options.config?.acceptance?.timeoutMs ?? 1800000,
-      workdir: options.workdir
+      workdir: options.workdir,
+      featureName: options.featureName,
+      sessionRole: "acceptance-gen"
     });
     const testCode = extractTestCode(output);
     if (!testCode) {
@@ -19307,7 +19349,10 @@ async function generateFixStories(adapter, options) {
     try {
       const fixDescription = await adapter.complete(prompt, {
         model: modelDef.model,
-        config: options.config
+        config: options.config,
+        featureName: options.prd.feature,
+        workdir: options.workdir,
+        sessionRole: "fix-gen"
       });
       fixStories.push({
         id: `US-FIX-${String(i + 1).padStart(3, "0")}`,
@@ -19471,37 +19516,6 @@ function parseAcpxJsonOutput(rawOutput) {
 }
 
 // src/agents/acp/spawn-client.ts
-import { homedir as homedir2 } from "os";
-import { isAbsolute as isAbsolute2 } from "path";
-function buildAllowedEnv2(extraEnv) {
-  const allowed = {};
-  const essentialVars = ["PATH", "TMPDIR", "NODE_ENV", "USER", "LOGNAME"];
-  for (const varName of essentialVars) {
-    if (process.env[varName])
-      allowed[varName] = process.env[varName];
-  }
-  const rawHome = process.env.HOME ?? "";
-  const safeHome = rawHome && isAbsolute2(rawHome) ? rawHome : homedir2();
-  if (rawHome !== safeHome) {
-    getSafeLogger()?.warn("env", `HOME env is not absolute ("${rawHome}"), falling back to os.homedir(): ${safeHome}`);
-  }
-  allowed.HOME = safeHome;
-  const apiKeyVars = ["ANTHROPIC_API_KEY", "OPENAI_API_KEY", "GEMINI_API_KEY", "GOOGLE_API_KEY", "CLAUDE_API_KEY"];
-  for (const varName of apiKeyVars) {
-    if (process.env[varName])
-      allowed[varName] = process.env[varName];
-  }
-  const allowedPrefixes = ["CLAUDE_", "NAX_", "CLAW_", "TURBO_", "ACPX_", "CODEX_", "GEMINI_"];
-  for (const [key, value] of Object.entries(process.env)) {
-    if (allowedPrefixes.some((prefix) => key.startsWith(prefix))) {
-      allowed[key] = value;
-    }
-  }
-  if (extraEnv)
-    Object.assign(allowed, extraEnv);
-  return allowed;
-}
-
 class SpawnAcpSession {
   agentName;
   sessionName;
@@ -19591,7 +19605,7 @@ class SpawnAcpSession {
       await this.pidRegistry?.unregister(processPid);
     }
   }
-  async close() {
+  async close(options) {
     if (this.activeProc) {
       try {
         this.activeProc.kill(15);
@@ -19610,6 +19624,14 @@ class SpawnAcpSession {
         stderr: stderr.slice(0, 200)
       });
     }
+    if (options?.forceTerminate) {
+      try {
+        const stopProc = _spawnClientDeps.spawn(["acpx", this.agentName, "stop"], { stdout: "pipe", stderr: "pipe" });
+        await stopProc.exited;
+      } catch (err) {
+        getSafeLogger()?.debug("acp-adapter", "acpx stop failed (swallowed)", { cause: String(err) });
+      }
+    }
   }
   async cancelActivePrompt() {
     if (this.activeProc) {
@@ -19643,7 +19665,7 @@ class SpawnAcpClient {
     this.agentName = lastToken;
     this.cwd = cwd || process.cwd();
     this.timeoutSeconds = timeoutSeconds || 1800;
-    this.env = buildAllowedEnv2();
+    this.env = buildAllowedEnv();
     this.pidRegistry = pidRegistry;
   }
   async start() {}
@@ -19695,6 +19717,7 @@ var _spawnClientDeps;
 var init_spawn_client = __esm(() => {
   init_logger2();
   init_bun_deps();
+  init_env();
   _spawnClientDeps = {
     spawn: typedSpawn
   };
@@ -20116,11 +20139,13 @@ class AcpAgentAdapter {
       const client = _acpAdapterDeps.createClient(cmdStr, workdir);
       await client.start();
       let session = null;
+      let hadError = false;
       try {
+        const completeSessionName = _options?.sessionName ?? buildSessionName(workdir ?? process.cwd(), _options?.featureName, _options?.storyId, _options?.sessionRole);
         session = await client.createSession({
           agentName: this.name,
           permissionMode,
-          sessionName: _options?.sessionName
+          sessionName: completeSessionName
         });
         let timeoutId;
         const timeoutPromise = new Promise((_, reject) => {
@@ -20157,6 +20182,7 @@ class AcpAgentAdapter {
         }
         return unwrapped;
       } catch (err) {
+        hadError = true;
         const error48 = err instanceof Error ? err : new Error(String(err));
         lastError = error48;
         const shouldRetry = isRateLimitError(error48) && attempt < MAX_RATE_LIMIT_RETRIES - 1;
@@ -20170,7 +20196,7 @@ class AcpAgentAdapter {
         await _acpAdapterDeps.sleep(backoffMs);
       } finally {
         if (session) {
-          await session.close().catch(() => {});
+          await session.close({ forceTerminate: hadError }).catch(() => {});
         }
         await client.close().catch(() => {});
       }
@@ -20225,7 +20251,9 @@ class AcpAgentAdapter {
       output = await this.complete(prompt, {
         model,
         jsonMode: true,
-        config: options.config
+        config: options.config,
+        workdir: options.workdir,
+        sessionRole: "decompose"
       });
     } catch (err) {
       const msg = err instanceof Error ? err.message : String(err);
@@ -20978,7 +21006,7 @@ function isPlainObject2(value) {
 
 // src/config/path-security.ts
 import { existsSync as existsSync4, lstatSync, realpathSync } from "fs";
-import { isAbsolute as isAbsolute3, normalize, resolve } from "path";
+import { isAbsolute as isAbsolute2, normalize, resolve } from "path";
 function validateDirectory(dirPath, baseDir) {
   const resolved = resolve(dirPath);
   if (!existsSync4(resolved)) {
@@ -21010,7 +21038,7 @@ function validateDirectory(dirPath, baseDir) {
 function isWithinDirectory(targetPath, basePath) {
   const normalizedTarget = normalize(targetPath);
   const normalizedBase = normalize(basePath);
-  if (!isAbsolute3(normalizedTarget) || !isAbsolute3(normalizedBase)) {
+  if (!isAbsolute2(normalizedTarget) || !isAbsolute2(normalizedBase)) {
     return false;
   }
   const baseWithSlash = normalizedBase.endsWith("/") ? normalizedBase : `${normalizedBase}/`;
@@ -21046,10 +21074,10 @@ var MAX_DIRECTORY_DEPTH = 10;
 var init_path_security = () => {};
 
 // src/config/paths.ts
-import { homedir as homedir3 } from "os";
+import { homedir as homedir2 } from "os";
 import { join as join5, resolve as resolve2 } from "path";
 function globalConfigDir() {
-  return join5(homedir3(), ".nax");
+  return join5(homedir2(), ".nax");
 }
 var PROJECT_NAX_DIR = ".nax";
 var init_paths = () => {};
@@ -22320,7 +22348,7 @@ var package_default;
 var init_package = __esm(() => {
   package_default = {
     name: "@nathapp/nax",
-    version: "0.54.1",
+    version: "0.54.3",
     description: "AI Coding Agent Orchestrator \u2014 loops until done",
     type: "module",
     bin: {
@@ -22397,8 +22425,8 @@ var init_version = __esm(() => {
   NAX_VERSION = package_default.version;
   NAX_COMMIT = (() => {
     try {
-      if (/^[0-9a-f]{6,10}$/.test("5282117"))
-        return "5282117";
+      if (/^[0-9a-f]{6,10}$/.test("5acee1f"))
+        return "5acee1f";
     } catch {}
     try {
       const result = Bun.spawnSync(["git", "rev-parse", "--short", "HEAD"], {
@@ -23642,7 +23670,10 @@ class AutoInteractionPlugin {
     const output = await adapter.complete(prompt, {
       ...modelArg && { model: modelArg },
       jsonMode: true,
-      ...this.config.naxConfig && { config: this.config.naxConfig }
+      ...this.config.naxConfig && { config: this.config.naxConfig },
+      featureName: request.featureName,
+      storyId: request.storyId,
+      sessionRole: "auto"
     });
     return this.parseResponse(output);
   }
@@ -24085,53 +24116,44 @@ var init_acceptance2 = __esm(() => {
         logger.warn("acceptance", "No feature directory \u2014 skipping acceptance tests");
         return { action: "continue" };
       }
-      const testPath = path4.join(ctx.featureDir, effectiveConfig.acceptance.testPath);
-      const testFile = Bun.file(testPath);
-      const exists = await testFile.exists();
-      if (!exists) {
-        logger.warn("acceptance", "Acceptance test file not found \u2014 skipping", {
-          testPath
+      const testGroups = ctx.acceptanceTestPaths ?? [
+        {
+          testPath: path4.join(ctx.featureDir, effectiveConfig.acceptance.testPath),
+          packageDir: ctx.workdir
+        }
+      ];
+      const allFailedACs = [];
+      const allOutputParts = [];
+      let anyError = false;
+      let errorExitCode = 0;
+      for (const { testPath, packageDir } of testGroups) {
+        const testFile = Bun.file(testPath);
+        const exists = await testFile.exists();
+        if (!exists) {
+          logger.warn("acceptance", "Acceptance test file not found \u2014 skipping", { testPath });
+          continue;
+        }
+        const testCmdParts = buildAcceptanceRunCommand(testPath, effectiveConfig.project?.testFramework, effectiveConfig.acceptance.command);
+        logger.info("acceptance", "Running acceptance command", {
+          cmd: testCmdParts.join(" "),
+          packageDir
         });
-        return { action: "continue" };
-      }
-      const testCmdParts = buildAcceptanceRunCommand(testPath, effectiveConfig.project?.testFramework, effectiveConfig.acceptance.command);
-      logger.info("acceptance", "Running acceptance command", { cmd: testCmdParts.join(" ") });
-      const proc = Bun.spawn(testCmdParts, {
-        cwd: ctx.workdir,
-        stdout: "pipe",
-        stderr: "pipe"
-      });
-      const [exitCode, stdout, stderr] = await Promise.all([
-        proc.exited,
-        new Response(proc.stdout).text(),
-        new Response(proc.stderr).text()
-      ]);
-      const output = `${stdout}
+        const proc = Bun.spawn(testCmdParts, {
+          cwd: packageDir,
+          stdout: "pipe",
+          stderr: "pipe"
+        });
+        const [exitCode, stdout, stderr] = await Promise.all([
+          proc.exited,
+          new Response(proc.stdout).text(),
+          new Response(proc.stderr).text()
+        ]);
+        const output = `${stdout}
 ${stderr}`;
-      const failedACs = parseTestFailures(output);
-      const overrides = ctx.prd.acceptanceOverrides || {};
-      const actualFailures = failedACs.filter((acId) => !overrides[acId]);
-      if (actualFailures.length === 0 && exitCode === 0) {
-        logger.info("acceptance", "All acceptance tests passed");
-        return { action: "continue" };
-      }
-      if (failedACs.length > 0 && actualFailures.length === 0) {
-        logger.info("acceptance", "All failed ACs are overridden \u2014 treating as pass");
-        return { action: "continue" };
-      }
-      if (failedACs.length === 0 && exitCode !== 0) {
-        logger.error("acceptance", "Tests errored with no AC failures parsed", { exitCode });
-        logTestOutput(logger, "acceptance", output);
-        ctx.acceptanceFailures = {
-          failedACs: ["AC-ERROR"],
-          testOutput: output
-        };
-        return {
-          action: "fail",
-          reason: `Acceptance tests errored (exit code ${exitCode}): syntax error, import failure, or unhandled exception`
-        };
-      }
-      if (actualFailures.length > 0) {
+        allOutputParts.push(output);
+        const failedACs = parseTestFailures(output);
+        const overrides = ctx.prd.acceptanceOverrides ?? {};
+        const actualFailures = failedACs.filter((acId) => !overrides[acId]);
         const overriddenFailures = failedACs.filter((acId) => overrides[acId]);
         if (overriddenFailures.length > 0) {
           logger.warn("acceptance", "Skipped failures (overridden)", {
@@ -24139,19 +24161,52 @@ ${stderr}`;
             overrides: overriddenFailures.map((acId) => ({ acId, reason: overrides[acId] }))
           });
         }
-        logger.error("acceptance", "Acceptance tests failed", { failedACs: actualFailures });
-        logTestOutput(logger, "acceptance", output);
-        ctx.acceptanceFailures = {
-          failedACs: actualFailures,
-          testOutput: output
-        };
+        if (failedACs.length === 0 && exitCode !== 0) {
+          logger.error("acceptance", "Tests errored with no AC failures parsed", {
+            exitCode,
+            packageDir
+          });
+          logTestOutput(logger, "acceptance", output);
+          anyError = true;
+          errorExitCode = exitCode;
+          allFailedACs.push("AC-ERROR");
+          continue;
+        }
+        for (const acId of actualFailures) {
+          if (!allFailedACs.includes(acId)) {
+            allFailedACs.push(acId);
+          }
+        }
+        if (actualFailures.length > 0) {
+          logger.error("acceptance", "Acceptance tests failed", {
+            failedACs: actualFailures,
+            packageDir
+          });
+          logTestOutput(logger, "acceptance", output);
+        } else if (exitCode === 0) {
+          logger.info("acceptance", "Package acceptance tests passed", { packageDir });
+        }
+      }
+      const combinedOutput = allOutputParts.join(`
+`);
+      if (allFailedACs.length === 0) {
+        logger.info("acceptance", "All acceptance tests passed");
+        return { action: "continue" };
+      }
+      ctx.acceptanceFailures = {
+        failedACs: allFailedACs,
+        testOutput: combinedOutput
+      };
+      if (anyError) {
         return {
           action: "fail",
-          reason: `Acceptance tests failed: ${actualFailures.join(", ")}`
+          reason: `Acceptance tests errored (exit code ${errorExitCode}): syntax error, import failure, or unhandled exception`
         };
       }
-      logger.info("acceptance", "All acceptance tests passed");
-      return { action: "continue" };
+      return {
+        action: "fail",
+        reason: `Acceptance tests failed: ${allFailedACs.join(", ")}`
+      };
     }
   };
 });
@@ -24333,82 +24388,142 @@ ${stderr}` };
         return { action: "fail", reason: "[acceptance-setup] featureDir is not set" };
       }
       const language = (ctx.effectiveConfig ?? ctx.config).project?.language;
-      const testPath = path5.join(ctx.featureDir, acceptanceTestFilename(language));
       const metaPath = path5.join(ctx.featureDir, "acceptance-meta.json");
       const allCriteria = ctx.prd.userStories.filter((s) => !s.id.startsWith("US-FIX-")).flatMap((s) => s.acceptanceCriteria);
+      const nonFixStories = ctx.prd.userStories.filter((s) => !s.id.startsWith("US-FIX-"));
+      const workdirGroups = new Map;
+      for (const story of nonFixStories) {
+        const wd = story.workdir ?? "";
+        if (!workdirGroups.has(wd)) {
+          workdirGroups.set(wd, { stories: [], criteria: [] });
+        }
+        const group = workdirGroups.get(wd);
+        if (group) {
+          group.stories.push(story);
+          group.criteria.push(...story.acceptanceCriteria);
+        }
+      }
+      if (workdirGroups.size === 0) {
+        workdirGroups.set("", { stories: [], criteria: [] });
+      }
+      const testPaths = [];
+      for (const [workdir] of workdirGroups) {
+        const packageDir = workdir ? path5.join(ctx.workdir, workdir) : ctx.workdir;
+        const testPath = path5.join(packageDir, acceptanceTestFilename(language));
+        testPaths.push({ testPath, packageDir });
+      }
       let totalCriteria = 0;
       let testableCount = 0;
-      const fileExists = await _acceptanceSetupDeps.fileExists(testPath);
-      let shouldGenerate = !fileExists;
-      if (fileExists) {
-        const fingerprint = computeACFingerprint(allCriteria);
-        const meta3 = await _acceptanceSetupDeps.readMeta(metaPath);
-        if (!meta3 || meta3.acFingerprint !== fingerprint) {
-          await _acceptanceSetupDeps.copyFile(testPath, `${testPath}.bak`);
-          await _acceptanceSetupDeps.deleteFile(testPath);
-          shouldGenerate = true;
+      const fingerprint = computeACFingerprint(allCriteria);
+      const meta3 = await _acceptanceSetupDeps.readMeta(metaPath);
+      getSafeLogger()?.debug("acceptance-setup", "Fingerprint check", {
+        currentFingerprint: fingerprint,
+        storedFingerprint: meta3?.acFingerprint ?? "none",
+        match: meta3?.acFingerprint === fingerprint
+      });
+      let shouldGenerate = false;
+      if (!meta3 || meta3.acFingerprint !== fingerprint) {
+        if (!meta3) {
+          getSafeLogger()?.info("acceptance-setup", "No acceptance meta \u2014 generating acceptance tests");
+        } else {
+          getSafeLogger()?.info("acceptance-setup", "ACs changed \u2014 regenerating acceptance tests", {
+            reason: "fingerprint mismatch",
+            currentFingerprint: fingerprint,
+            storedFingerprint: meta3.acFingerprint
+          });
+        }
+        for (const { testPath } of testPaths) {
+          if (await _acceptanceSetupDeps.fileExists(testPath)) {
+            await _acceptanceSetupDeps.copyFile(testPath, `${testPath}.bak`);
+            await _acceptanceSetupDeps.deleteFile(testPath);
+          }
         }
+        shouldGenerate = true;
+      } else {
+        getSafeLogger()?.info("acceptance-setup", "Reusing existing acceptance tests (fingerprint match)");
       }
       if (shouldGenerate) {
         totalCriteria = allCriteria.length;
         const { getAgent: getAgent2 } = await Promise.resolve().then(() => (init_agents(), exports_agents));
         const agent = (ctx.agentGetFn ?? _acceptanceSetupDeps.getAgent)(ctx.config.autoMode.defaultAgent);
-        let refinedCriteria;
+        let allRefinedCriteria;
         if (ctx.config.acceptance.refinement) {
-          refinedCriteria = await _acceptanceSetupDeps.refine(allCriteria, {
-            storyId: ctx.prd.userStories[0]?.id ?? "US-001",
-            codebaseContext: "",
-            config: ctx.config,
-            testStrategy: ctx.config.acceptance.testStrategy,
-            testFramework: ctx.config.acceptance.testFramework
-          });
+          allRefinedCriteria = [];
+          for (const story of nonFixStories) {
+            const storyRefined = await _acceptanceSetupDeps.refine(story.acceptanceCriteria, {
+              storyId: story.id,
+              featureName: ctx.prd.feature,
+              workdir: ctx.workdir,
+              codebaseContext: "",
+              config: ctx.config,
+              testStrategy: ctx.config.acceptance.testStrategy,
+              testFramework: ctx.config.acceptance.testFramework
+            });
+            allRefinedCriteria = allRefinedCriteria.concat(storyRefined);
+          }
         } else {
-          refinedCriteria = allCriteria.map((c) => ({
+          allRefinedCriteria = nonFixStories.flatMap((story) => story.acceptanceCriteria.map((c) => ({
             original: c,
             refined: c,
             testable: true,
-            storyId: ctx.prd.userStories[0]?.id ?? "US-001"
-          }));
+            storyId: story.id
+          })));
         }
-        testableCount = refinedCriteria.filter((r) => r.testable).length;
-        const result = await _acceptanceSetupDeps.generate(ctx.prd.userStories, refinedCriteria, {
-          featureName: ctx.prd.feature,
-          workdir: ctx.workdir,
-          featureDir: ctx.featureDir,
-          codebaseContext: "",
-          modelTier: ctx.config.acceptance.model ?? "fast",
-          modelDef: resolveModel(ctx.config.models[ctx.config.acceptance.model ?? "fast"]),
-          config: ctx.config,
-          testStrategy: ctx.config.acceptance.testStrategy,
-          testFramework: ctx.config.acceptance.testFramework,
-          adapter: agent ?? undefined
-        });
-        await _acceptanceSetupDeps.writeFile(testPath, result.testCode);
-        const fingerprint = computeACFingerprint(allCriteria);
+        testableCount = allRefinedCriteria.filter((r) => r.testable).length;
+        for (const [workdir, group] of workdirGroups) {
+          const packageDir = workdir ? path5.join(ctx.workdir, workdir) : ctx.workdir;
+          const testPath = path5.join(packageDir, acceptanceTestFilename(language));
+          const groupStoryIds = new Set(group.stories.map((s) => s.id));
+          const groupRefined = allRefinedCriteria.filter((r) => groupStoryIds.has(r.storyId));
+          const result = await _acceptanceSetupDeps.generate(group.stories, groupRefined, {
+            featureName: ctx.prd.feature,
+            workdir: packageDir,
+            featureDir: ctx.featureDir,
+            codebaseContext: "",
+            modelTier: ctx.config.acceptance.model ?? "fast",
+            modelDef: resolveModel(ctx.config.models[ctx.config.acceptance.model ?? "fast"]),
+            config: ctx.config,
+            testStrategy: ctx.config.acceptance.testStrategy,
+            testFramework: ctx.config.acceptance.testFramework,
+            adapter: agent ?? undefined
+          });
+          await _acceptanceSetupDeps.writeFile(testPath, result.testCode);
+        }
+        const fingerprint2 = computeACFingerprint(allCriteria);
         await _acceptanceSetupDeps.writeMeta(metaPath, {
           generatedAt: new Date().toISOString(),
-          acFingerprint: fingerprint,
+          acFingerprint: fingerprint2,
           storyCount: ctx.prd.userStories.length,
           acCount: totalCriteria,
           generator: "nax"
         });
       }
+      ctx.acceptanceTestPaths = testPaths;
       if (ctx.config.acceptance.redGate === false) {
         ctx.acceptanceSetup = { totalCriteria, testableCount, redFailCount: 0 };
         return { action: "continue" };
       }
       const effectiveConfig = ctx.effectiveConfig ?? ctx.config;
-      const runCmd = buildAcceptanceRunCommand(testPath, effectiveConfig.project?.testFramework, effectiveConfig.acceptance.command);
-      getSafeLogger()?.info("acceptance-setup", "Running acceptance RED gate command", { cmd: runCmd.join(" ") });
-      const { exitCode } = await _acceptanceSetupDeps.runTest(testPath, ctx.workdir, runCmd);
-      if (exitCode === 0) {
+      let redFailCount = 0;
+      for (const { testPath, packageDir } of testPaths) {
+        const runCmd = buildAcceptanceRunCommand(testPath, effectiveConfig.project?.testFramework, effectiveConfig.acceptance.command);
+        getSafeLogger()?.info("acceptance-setup", "Running acceptance RED gate command", {
+          cmd: runCmd.join(" "),
+          packageDir
+        });
+        const { exitCode } = await _acceptanceSetupDeps.runTest(testPath, packageDir, runCmd);
+        if (exitCode !== 0) {
+          redFailCount++;
+        }
+      }
+      if (redFailCount === 0) {
         ctx.acceptanceSetup = { totalCriteria, testableCount, redFailCount: 0 };
         return {
           action: "skip",
           reason: "[acceptance-setup] Acceptance tests already pass \u2014 they are not testing new behavior. Skipping acceptance gate."
         };
       }
-      ctx.acceptanceSetup = { totalCriteria, testableCount, redFailCount: 1 };
+      ctx.acceptanceSetup = { totalCriteria, testableCount, redFailCount };
       return { action: "continue" };
     }
   };
@@ -24736,7 +24851,11 @@ If the implementation looks correct, respond with { "passed": true, "findings":
 }
 function parseLLMResponse(raw) {
   try {
-    const parsed = JSON.parse(raw);
+    let cleaned = raw.trim();
+    const fenceMatch = cleaned.match(/^```(?:json)?\s*\n?([\s\S]*?)\n?\s*```$/);
+    if (fenceMatch)
+      cleaned = fenceMatch[1].trim();
+    const parsed = JSON.parse(cleaned);
     if (typeof parsed !== "object" || parsed === null)
       return null;
     const obj = parsed;
@@ -24784,6 +24903,7 @@ async function runSemanticReview(workdir, storyGitRef, story, semanticConfig, mo
       durationMs: Date.now() - startTime
     };
   }
+  logger?.info("review", "Running semantic check", { storyId: story.id, modelTier: semanticConfig.modelTier });
   const rawDiff = await collectDiff(workdir, storyGitRef);
   const diff = truncateDiff(rawDiff);
   const agent = modelResolver(semanticConfig.modelTier);
@@ -24803,7 +24923,11 @@ async function runSemanticReview(workdir, storyGitRef, story, semanticConfig, mo
   const prompt = buildPrompt(story, semanticConfig, diff);
   let rawResponse;
   try {
-    rawResponse = await agent.complete(prompt);
+    rawResponse = await agent.complete(prompt, {
+      sessionName: `nax-semantic-${story.id}`,
+      workdir,
+      timeoutMs: semanticConfig.timeoutMs
+    });
   } catch (err) {
     logger?.warn("semantic", "LLM call failed \u2014 fail-open", { cause: String(err) });
     return {
@@ -24828,6 +24952,21 @@ async function runSemanticReview(workdir, storyGitRef, story, semanticConfig, mo
     };
   }
   if (!parsed.passed && parsed.findings.length > 0) {
+    const durationMs2 = Date.now() - startTime;
+    logger?.warn("review", `Semantic review failed: ${parsed.findings.length} findings`, {
+      storyId: story.id,
+      durationMs: durationMs2
+    });
+    logger?.debug("review", "Semantic review findings", {
+      storyId: story.id,
+      findings: parsed.findings.map((f) => ({
+        severity: f.severity,
+        file: f.file,
+        line: f.line,
+        issue: f.issue,
+        suggestion: f.suggestion
+      }))
+    });
     const output = `Semantic review failed:
 
 ${formatFindings(parsed.findings)}`;
@@ -24837,17 +24976,21 @@ ${formatFindings(parsed.findings)}`;
       command: "",
       exitCode: 1,
       output,
-      durationMs: Date.now() - startTime,
+      durationMs: durationMs2,
       findings: toReviewFindings(parsed.findings)
     };
   }
+  const durationMs = Date.now() - startTime;
+  if (parsed.passed) {
+    logger?.info("review", "Semantic review passed", { storyId: story.id, durationMs });
+  }
   return {
     check: "semantic",
     success: parsed.passed,
     command: "",
     exitCode: parsed.passed ? 0 : 1,
     output: parsed.passed ? "Semantic review passed" : "Semantic review failed (no findings)",
-    durationMs: Date.now() - startTime
+    durationMs
   };
 }
 var _semanticDeps, DIFF_CAP_BYTES = 12288, DEFAULT_RULES;
@@ -25030,7 +25173,8 @@ async function runReview(config2, workdir, executionConfig, qualityCommands, sto
     /nax\/features\/[^/]+\/acceptance-refined\.json$/,
     /\.nax-verifier-verdict\.json$/,
     /\.nax-pids$/,
-    /\.nax-wt\//
+    /\.nax-wt\//,
+    /\.nax-acceptance[^/]*$/
   ];
   const uncommittedFiles = allUncommittedFiles.filter((f) => !NAX_RUNTIME_PATTERNS.some((pattern) => pattern.test(f)));
   if (uncommittedFiles.length > 0) {
@@ -25055,7 +25199,11 @@ Stage and commit these files before running review.`
         description: story?.description ?? "",
         acceptanceCriteria: story?.acceptanceCriteria ?? []
       };
-      const semanticCfg = config2.semantic ?? { modelTier: "balanced", rules: [] };
+      const semanticCfg = config2.semantic ?? {
+        modelTier: "balanced",
+        rules: [],
+        timeoutMs: 600000
+      };
       const result2 = await _reviewSemanticDeps.runSemanticReview(workdir, storyGitRef, semanticStory, semanticCfg, modelResolver ?? (() => null));
       checks3.push(result2);
       if (!result2.success && !firstFailure) {
@@ -31090,7 +31238,7 @@ var init_init_context = __esm(() => {
 
 // src/utils/path-security.ts
 import { realpathSync as realpathSync3 } from "fs";
-import { dirname as dirname4, isAbsolute as isAbsolute4, join as join31, normalize as normalize2, resolve as resolve5 } from "path";
+import { dirname as dirname4, isAbsolute as isAbsolute3, join as join31, normalize as normalize2, resolve as resolve5 } from "path";
 function safeRealpathForComparison(p) {
   try {
     return realpathSync3(p);
@@ -31107,7 +31255,7 @@ function validateModulePath(modulePath, allowedRoots) {
     return { valid: false, error: "Module path is empty" };
   }
   const resolvedRoots = allowedRoots.map((r) => safeRealpathForComparison(resolve5(r)));
-  if (isAbsolute4(modulePath)) {
+  if (isAbsolute3(modulePath)) {
     const normalized = normalize2(modulePath);
     const resolved = safeRealpathForComparison(normalized);
     const isWithin = resolvedRoots.some((root) => resolved.startsWith(`${root}/`) || resolved === root);
@@ -31735,7 +31883,8 @@ var init_checks_git = __esm(() => {
     /^.{2} \.nax\/features\/[^/]+\/acceptance-refined\.json$/,
     /^.{2} \.nax-verifier-verdict\.json$/,
     /^.{2} \.nax-pids$/,
-    /^.{2} \.nax-wt\//
+    /^.{2} \.nax-wt\//,
+    /^.{2} .*\.nax-acceptance[^/]*$/
   ];
 });
 
@@ -31948,7 +32097,7 @@ var init_checks_blockers = __esm(() => {
 
 // src/precheck/checks-warnings.ts
 import { existsSync as existsSync30 } from "fs";
-import { isAbsolute as isAbsolute6 } from "path";
+import { isAbsolute as isAbsolute5 } from "path";
 async function checkClaudeMdExists(workdir) {
   const claudeMdPath = `${workdir}/CLAUDE.md`;
   const passed = existsSync30(claudeMdPath);
@@ -32048,7 +32197,8 @@ async function checkGitignoreCoversNax(workdir) {
     ".nax/metrics.json",
     ".nax/features/*/status.json",
     ".nax-pids",
-    ".nax-wt/"
+    ".nax-wt/",
+    "**/.nax-acceptance*"
   ];
   const missing = patterns.filter((pattern) => !content.includes(pattern));
   const passed = missing.length === 0;
@@ -32080,7 +32230,7 @@ async function checkPromptOverrideFiles(config2, workdir) {
 }
 async function checkHomeEnvValid() {
   const home = process.env.HOME ?? "";
-  const passed = home !== "" && isAbsolute6(home);
+  const passed = home !== "" && isAbsolute5(home);
   return {
     name: "home-env-valid",
     tier: "warning",
@@ -32183,6 +32333,24 @@ async function checkLanguageTools(profile, workdir) {
     message: `Missing ${language} tools: ${missing.join(", ")}. ${toolConfig.installHint}`
   };
 }
+function checkBuildCommandInReviewChecks(config2) {
+  const hasBuildCmd = !!(config2.review?.commands?.build || config2.quality?.commands?.build);
+  const buildInChecks = config2.review?.checks?.includes("build") ?? false;
+  if (hasBuildCmd && !buildInChecks) {
+    return {
+      name: "build-command-in-review-checks",
+      tier: "warning",
+      passed: false,
+      message: 'A build command is configured but "build" is not in review.checks \u2014 the build step will never run. Add "build" to review.checks to enable it.'
+    };
+  }
+  return {
+    name: "build-command-in-review-checks",
+    tier: "warning",
+    passed: true,
+    message: "build command check OK"
+  };
+}
 var _languageToolsDeps;
 var init_checks_warnings = __esm(() => {
   _languageToolsDeps = {
@@ -32374,7 +32542,8 @@ function getEnvironmentWarnings(config2, workdir) {
     () => checkHomeEnvValid(),
     () => checkPromptOverrideFiles(config2, workdir),
     () => checkLanguageTools(config2.project, workdir),
-    () => checkMultiAgentHealth()
+    () => checkMultiAgentHealth(),
+    () => Promise.resolve(checkBuildCommandInReviewChecks(config2))
   ];
 }
 function getProjectBlockers(prd) {
@@ -32719,36 +32888,32 @@ import { appendFileSync as appendFileSync2 } from "fs";
 function startHeartbeat(statusWriter, getTotalCost, getIterations, jsonlFilePath) {
   const logger = getSafeLogger();
   stopHeartbeat();
-  heartbeatTimer = setInterval(async () => {
-    logger?.debug("crash-recovery", "Heartbeat");
-    if (jsonlFilePath) {
+  heartbeatTimer = setInterval(() => {
+    (async () => {
       try {
-        const heartbeatEntry = {
-          timestamp: new Date().toISOString(),
-          level: "debug",
-          stage: "heartbeat",
-          message: "Process alive",
-          data: {
-            pid: process.pid,
-            memoryUsageMB: Math.round(process.memoryUsage().heapUsed / 1024 / 1024)
-          }
-        };
-        const line = `${JSON.stringify(heartbeatEntry)}
+        logger?.debug("crash-recovery", "Heartbeat");
+        if (jsonlFilePath) {
+          const heartbeatEntry = {
+            timestamp: new Date().toISOString(),
+            level: "debug",
+            stage: "heartbeat",
+            message: "Process alive",
+            data: {
+              pid: process.pid,
+              memoryUsageMB: Math.round(process.memoryUsage().heapUsed / 1024 / 1024)
+            }
+          };
+          const line = `${JSON.stringify(heartbeatEntry)}
 `;
-        appendFileSync2(jsonlFilePath, line);
+          appendFileSync2(jsonlFilePath, line);
+        }
+        await statusWriter.update(getTotalCost(), getIterations(), {
+          lastHeartbeat: new Date().toISOString()
+        });
       } catch (err) {
-        logger?.warn("crash-recovery", "Failed to write heartbeat", { error: err.message });
+        logger?.warn("crash-recovery", "Failed during heartbeat", { error: err.message });
       }
-    }
-    try {
-      await statusWriter.update(getTotalCost(), getIterations(), {
-        lastHeartbeat: new Date().toISOString()
-      });
-    } catch (err) {
-      logger?.warn("crash-recovery", "Failed to update status during heartbeat", {
-        error: err.message
-      });
-    }
+    })().catch(() => {});
   }, 60000);
   logger?.debug("crash-recovery", "Heartbeat started (60s interval)");
 }
@@ -32907,6 +33072,10 @@ function createSignalHandler(ctx) {
 }
 function createUncaughtExceptionHandler(ctx) {
   return async (error48) => {
+    process.stderr.write(`
+[nax crash] Uncaught exception: ${error48.message}
+${error48.stack ?? ""}
+`);
     const logger = getSafeLogger();
     logger?.error("crash-recovery", "Uncaught exception", {
       error: error48.message,
@@ -32927,6 +33096,10 @@ function createUncaughtExceptionHandler(ctx) {
 function createUnhandledRejectionHandler(ctx) {
   return async (reason) => {
     const error48 = reason instanceof Error ? reason : new Error(String(reason));
+    process.stderr.write(`
+[nax crash] Unhandled rejection: ${error48.message}
+${error48.stack ?? ""}
+`);
     const logger = getSafeLogger();
     logger?.error("crash-recovery", "Unhandled promise rejection", {
       error: error48.message,
@@ -34711,16 +34884,16 @@ var init_parallel_executor = __esm(() => {
 
 // src/pipeline/subscribers/events-writer.ts
 import { appendFile as appendFile2, mkdir as mkdir2 } from "fs/promises";
-import { homedir as homedir6 } from "os";
+import { homedir as homedir5 } from "os";
 import { basename as basename5, join as join49 } from "path";
 function wireEventsWriter(bus, feature, runId, workdir) {
   const logger = getSafeLogger();
   const project = basename5(workdir);
-  const eventsDir = join49(homedir6(), ".nax", "events", project);
+  const eventsDir = join49(homedir5(), ".nax", "events", project);
   const eventsFile = join49(eventsDir, "events.jsonl");
   let dirReady = false;
   const write = (line) => {
-    (async () => {
+    return (async () => {
       try {
         if (!dirReady) {
           await mkdir2(eventsDir, { recursive: true });
@@ -34738,16 +34911,30 @@ function wireEventsWriter(bus, feature, runId, workdir) {
   };
   const unsubs = [];
   unsubs.push(bus.on("run:started", (_ev) => {
-    write({ ts: new Date().toISOString(), event: "run:started", runId, feature, project });
+    return write({ ts: new Date().toISOString(), event: "run:started", runId, feature, project });
   }));
   unsubs.push(bus.on("story:started", (ev) => {
-    write({ ts: new Date().toISOString(), event: "story:started", runId, feature, project, storyId: ev.storyId });
+    return write({
+      ts: new Date().toISOString(),
+      event: "story:started",
+      runId,
+      feature,
+      project,
+      storyId: ev.storyId
+    });
   }));
   unsubs.push(bus.on("story:completed", (ev) => {
-    write({ ts: new Date().toISOString(), event: "story:completed", runId, feature, project, storyId: ev.storyId });
+    return write({
+      ts: new Date().toISOString(),
+      event: "story:completed",
+      runId,
+      feature,
+      project,
+      storyId: ev.storyId
+    });
   }));
   unsubs.push(bus.on("story:decomposed", (ev) => {
-    write({
+    return write({
       ts: new Date().toISOString(),
       event: "story:decomposed",
       runId,
@@ -34758,13 +34945,20 @@ function wireEventsWriter(bus, feature, runId, workdir) {
     });
   }));
   unsubs.push(bus.on("story:failed", (ev) => {
-    write({ ts: new Date().toISOString(), event: "story:failed", runId, feature, project, storyId: ev.storyId });
+    return write({
+      ts: new Date().toISOString(),
+      event: "story:failed",
+      runId,
+      feature,
+      project,
+      storyId: ev.storyId
+    });
   }));
   unsubs.push(bus.on("run:completed", (_ev) => {
-    write({ ts: new Date().toISOString(), event: "on-complete", runId, feature, project });
+    return write({ ts: new Date().toISOString(), event: "on-complete", runId, feature, project });
   }));
   unsubs.push(bus.on("run:paused", (ev) => {
-    write({
+    return write({
       ts: new Date().toISOString(),
       event: "run:paused",
       runId,
@@ -34786,44 +34980,44 @@ var init_events_writer = __esm(() => {
 function wireHooks(bus, hooks, workdir, feature) {
   const logger = getSafeLogger();
   const safe = (name, fn) => {
-    fn().catch((err) => logger?.warn("hooks-subscriber", `Hook "${name}" failed`, { error: String(err) }));
+    return fn().catch((err) => logger?.warn("hooks-subscriber", `Hook "${name}" failed`, { error: String(err) })).catch(() => {});
   };
   const unsubs = [];
   unsubs.push(bus.on("run:started", (ev) => {
-    safe("on-start", () => fireHook(hooks, "on-start", hookCtx(feature, { status: "running" }), workdir));
+    return safe("on-start", () => fireHook(hooks, "on-start", hookCtx(feature, { status: "running" }), workdir));
   }));
   unsubs.push(bus.on("story:started", (ev) => {
-    safe("on-story-start", () => fireHook(hooks, "on-story-start", hookCtx(feature, { storyId: ev.storyId, model: ev.modelTier, agent: ev.agent }), workdir));
+    return safe("on-story-start", () => fireHook(hooks, "on-story-start", hookCtx(feature, { storyId: ev.storyId, model: ev.modelTier, agent: ev.agent }), workdir));
   }));
   unsubs.push(bus.on("story:completed", (ev) => {
-    safe("on-story-complete", () => fireHook(hooks, "on-story-complete", hookCtx(feature, { storyId: ev.storyId, status: "passed", cost: ev.cost }), workdir));
+    return safe("on-story-complete", () => fireHook(hooks, "on-story-complete", hookCtx(feature, { storyId: ev.storyId, status: "passed", cost: ev.cost }), workdir));
   }));
   unsubs.push(bus.on("story:decomposed", (ev) => {
-    safe("on-story-complete (decomposed)", () => fireHook(hooks, "on-story-complete", hookCtx(feature, { storyId: ev.storyId, status: "decomposed", subStoryCount: ev.subStoryCount }), workdir));
+    return safe("on-story-complete (decomposed)", () => fireHook(hooks, "on-story-complete", hookCtx(feature, { storyId: ev.storyId, status: "decomposed", subStoryCount: ev.subStoryCount }), workdir));
   }));
   unsubs.push(bus.on("story:failed", (ev) => {
-    safe("on-story-fail", () => fireHook(hooks, "on-story-fail", hookCtx(feature, { storyId: ev.storyId, status: "failed", reason: ev.reason }), workdir));
+    return safe("on-story-fail", () => fireHook(hooks, "on-story-fail", hookCtx(feature, { storyId: ev.storyId, status: "failed", reason: ev.reason }), workdir));
   }));
   unsubs.push(bus.on("story:paused", (ev) => {
-    safe("on-pause (story)", () => fireHook(hooks, "on-pause", hookCtx(feature, { storyId: ev.storyId, reason: ev.reason, cost: ev.cost }), workdir));
+    return safe("on-pause (story)", () => fireHook(hooks, "on-pause", hookCtx(feature, { storyId: ev.storyId, reason: ev.reason, cost: ev.cost }), workdir));
   }));
   unsubs.push(bus.on("run:paused", (ev) => {
-    safe("on-pause (run)", () => fireHook(hooks, "on-pause", hookCtx(feature, { storyId: ev.storyId, reason: ev.reason, cost: ev.cost }), workdir));
+    return safe("on-pause (run)", () => fireHook(hooks, "on-pause", hookCtx(feature, { storyId: ev.storyId, reason: ev.reason, cost: ev.cost }), workdir));
   }));
   unsubs.push(bus.on("run:completed", (ev) => {
-    safe("on-complete", () => fireHook(hooks, "on-complete", hookCtx(feature, { status: "complete", cost: ev.totalCost ?? 0 }), workdir));
+    return safe("on-complete", () => fireHook(hooks, "on-complete", hookCtx(feature, { status: "complete", cost: ev.totalCost ?? 0 }), workdir));
   }));
   unsubs.push(bus.on("run:resumed", (ev) => {
-    safe("on-resume", () => fireHook(hooks, "on-resume", hookCtx(feature, { status: "running" }), workdir));
+    return safe("on-resume", () => fireHook(hooks, "on-resume", hookCtx(feature, { status: "running" }), workdir));
   }));
   unsubs.push(bus.on("story:completed", (ev) => {
-    safe("on-session-end (completed)", () => fireHook(hooks, "on-session-end", hookCtx(feature, { storyId: ev.storyId, status: "passed" }), workdir));
+    return safe("on-session-end (completed)", () => fireHook(hooks, "on-session-end", hookCtx(feature, { storyId: ev.storyId, status: "passed" }), workdir));
   }));
   unsubs.push(bus.on("story:failed", (ev) => {
-    safe("on-session-end (failed)", () => fireHook(hooks, "on-session-end", hookCtx(feature, { storyId: ev.storyId, status: "failed" }), workdir));
+    return safe("on-session-end (failed)", () => fireHook(hooks, "on-session-end", hookCtx(feature, { storyId: ev.storyId, status: "failed" }), workdir));
   }));
   unsubs.push(bus.on("run:errored", (ev) => {
-    safe("on-error", () => fireHook(hooks, "on-error", hookCtx(feature, { reason: ev.reason }), workdir));
+    return safe("on-error", () => fireHook(hooks, "on-error", hookCtx(feature, { reason: ev.reason }), workdir));
   }));
   return () => {
     for (const u of unsubs)
@@ -34890,15 +35084,15 @@ var init_interaction2 = __esm(() => {
 
 // src/pipeline/subscribers/registry.ts
 import { mkdir as mkdir3, writeFile } from "fs/promises";
-import { homedir as homedir7 } from "os";
+import { homedir as homedir6 } from "os";
 import { basename as basename6, join as join50 } from "path";
 function wireRegistry(bus, feature, runId, workdir) {
   const logger = getSafeLogger();
   const project = basename6(workdir);
-  const runDir = join50(homedir7(), ".nax", "runs", `${project}-${feature}-${runId}`);
+  const runDir = join50(homedir6(), ".nax", "runs", `${project}-${feature}-${runId}`);
   const metaFile = join50(runDir, "meta.json");
   const unsub = bus.on("run:started", (_ev) => {
-    (async () => {
+    return (async () => {
       try {
         await mkdir3(runDir, { recursive: true });
         const meta3 = {
@@ -34929,11 +35123,11 @@ var init_registry3 = __esm(() => {
 function wireReporters(bus, pluginRegistry, runId, startTime) {
   const logger = getSafeLogger();
   const safe = (name, fn) => {
-    fn().catch((err) => logger?.warn("reporters-subscriber", `Reporter "${name}" error`, { error: String(err) }));
+    return fn().catch((err) => logger?.warn("reporters-subscriber", `Reporter "${name}" error`, { error: String(err) })).catch(() => {});
   };
   const unsubs = [];
   unsubs.push(bus.on("run:started", (ev) => {
-    safe("onRunStart", async () => {
+    return safe("onRunStart", async () => {
       const reporters = pluginRegistry.getReporters();
       for (const r of reporters) {
         if (r.onRunStart) {
@@ -34952,7 +35146,7 @@ function wireReporters(bus, pluginRegistry, runId, startTime) {
     });
   }));
   unsubs.push(bus.on("story:completed", (ev) => {
-    safe("onStoryComplete(completed)", async () => {
+    return safe("onStoryComplete(completed)", async () => {
       const reporters = pluginRegistry.getReporters();
       for (const r of reporters) {
         if (r.onStoryComplete) {
@@ -34974,7 +35168,7 @@ function wireReporters(bus, pluginRegistry, runId, startTime) {
     });
   }));
   unsubs.push(bus.on("story:failed", (ev) => {
-    safe("onStoryComplete(failed)", async () => {
+    return safe("onStoryComplete(failed)", async () => {
       const reporters = pluginRegistry.getReporters();
       for (const r of reporters) {
         if (r.onStoryComplete) {
@@ -34996,7 +35190,7 @@ function wireReporters(bus, pluginRegistry, runId, startTime) {
     });
   }));
   unsubs.push(bus.on("story:paused", (ev) => {
-    safe("onStoryComplete(paused)", async () => {
+    return safe("onStoryComplete(paused)", async () => {
       const reporters = pluginRegistry.getReporters();
       for (const r of reporters) {
         if (r.onStoryComplete) {
@@ -35018,7 +35212,7 @@ function wireReporters(bus, pluginRegistry, runId, startTime) {
     });
   }));
   unsubs.push(bus.on("run:completed", (ev) => {
-    safe("onRunEnd", async () => {
+    return safe("onRunEnd", async () => {
       const reporters = pluginRegistry.getReporters();
       for (const r of reporters) {
         if (r.onRunEnd) {
@@ -35759,7 +35953,8 @@ async function executeSequential(ctx, initialPrd) {
       story: prd.userStories[0],
       stories: prd.userStories,
       routing: { complexity: "simple", modelTier: "fast", testStrategy: "test-after", reasoning: "" },
-      hooks: ctx.hooks
+      hooks: ctx.hooks,
+      agentGetFn: ctx.agentGetFn
     };
     await runPipeline(preRunPipeline, preRunCtx, ctx.eventEmitter);
     while (iterations < ctx.config.execution.maxIterations) {
@@ -67558,7 +67753,7 @@ var require_jsx_dev_runtime = __commonJS((exports, module) => {
 // bin/nax.ts
 init_source();
 import { existsSync as existsSync34, mkdirSync as mkdirSync6 } from "fs";
-import { homedir as homedir9 } from "os";
+import { homedir as homedir8 } from "os";
 import { join as join56 } from "path";
 
 // node_modules/commander/esm.mjs
@@ -68814,7 +69009,14 @@ async function planCommand(workdir, config2, options) {
       if (entry)
         autoModel = resolveModel2(entry).model;
     } catch {}
-    rawResponse = await cliAdapter.complete(prompt, { model: autoModel, jsonMode: true, workdir, config: config2 });
+    rawResponse = await cliAdapter.complete(prompt, {
+      model: autoModel,
+      jsonMode: true,
+      workdir,
+      config: config2,
+      featureName: options.feature,
+      sessionRole: "plan"
+    });
     try {
       const envelope = JSON.parse(rawResponse);
       if (envelope?.type === "result" && typeof envelope?.result === "string") {
@@ -71101,10 +71303,10 @@ import { readdir as readdir3 } from "fs/promises";
 import { join as join39 } from "path";
 
 // src/utils/paths.ts
-import { homedir as homedir5 } from "os";
+import { homedir as homedir4 } from "os";
 import { join as join38 } from "path";
 function getRunsDir() {
-  return process.env.NAX_RUNS_DIR ?? join38(homedir5(), ".nax", "runs");
+  return process.env.NAX_RUNS_DIR ?? join38(homedir4(), ".nax", "runs");
 }
 
 // src/commands/logs-reader.ts
@@ -71239,7 +71441,7 @@ Runs:
     const summary = await extractRunSummary(filePath);
     const timestamp = file2.replace(".jsonl", "");
     const stories = summary ? `${summary.passed}/${summary.total}` : "?/?";
-    const duration3 = summary ? formatDuration2(summary.durationMs) : "?";
+    const duration3 = summary ? formatDuration(summary.durationMs) : "?";
     const cost = summary ? `$${summary.totalCost.toFixed(4)}` : "$?.????";
     const status = summary ? summary.failed === 0 ? source_default.green("\u2713") : source_default.red("\u2717") : "?";
     console.log(`  ${timestamp}  ${stories.padEnd(7)}  ${duration3.padEnd(8)}  ${cost.padEnd(8)}  ${status}`);
@@ -71333,17 +71535,6 @@ function shouldDisplayEntry(entry, options) {
   }
   return true;
 }
-function formatDuration2(ms) {
-  if (ms < 1000) {
-    return `${ms}ms`;
-  }
-  if (ms < 60000) {
-    return `${(ms / 1000).toFixed(1)}s`;
-  }
-  const minutes = Math.floor(ms / 60000);
-  const seconds = Math.floor(ms % 60000 / 1000);
-  return `${minutes}m${seconds}s`;
-}
 
 // src/commands/logs.ts
 async function logsCommand(options) {
@@ -71445,7 +71636,7 @@ var DEFAULT_LIMIT = 20;
 var _runsCmdDeps = {
   getRunsDir
 };
-function formatDuration3(ms) {
+function formatDuration2(ms) {
   if (ms <= 0)
     return "-";
   const minutes = Math.floor(ms / 60000);
@@ -71558,7 +71749,7 @@ async function runsCommand(options = {}) {
       pad3(row.feature, COL.feature),
       pad3(colored, COL.status + (colored.length - visibleLength(colored))),
       pad3(`${row.passed}/${row.total}`, COL.stories),
-      pad3(formatDuration3(row.durationMs), COL.duration),
+      pad3(formatDuration2(row.durationMs), COL.duration),
       formatDate(row.registeredAt)
     ].join("  ");
     console.log(line);
@@ -71881,7 +72072,8 @@ async function runExecutionPhase(options, prd, pluginRegistry) {
     startTime: options.startTime,
     batchPlan,
     agentGetFn: options.agentGetFn,
-    pidRegistry: options.pidRegistry
+    pidRegistry: options.pidRegistry,
+    interactionChain: options.interactionChain
   }, prd);
   prd = sequentialResult.prd;
   iterations = sequentialResult.iterations;
@@ -72007,7 +72199,8 @@ async function run(options) {
       parallel,
       runParallelExecution: _runnerDeps.runParallelExecution ?? undefined,
       agentGetFn,
-      pidRegistry
+      pidRegistry,
+      interactionChain
     }, prd, pluginRegistry);
     prd = executionResult.prd;
     iterations = executionResult.iterations;
@@ -79668,7 +79861,7 @@ program2.command("run").description("Run the orchestration loop for a feature").
     config2.autoMode.defaultAgent = options.agent;
   }
   config2.execution.maxIterations = Number.parseInt(options.maxIterations, 10);
-  const globalNaxDir = join56(homedir9(), ".nax");
+  const globalNaxDir = join56(homedir8(), ".nax");
   const hooks = await loadHooksConfig(naxDir, globalNaxDir);
   const eventEmitter = new PipelineEventEmitter;
   let tuiInstance;