@nathapp/nax 0.54.0 → 0.54.2

package/README.md

@@ -12,7 +12,9 @@ nax is an **orchestrator, not an agent** — it doesn't write code itself. It dr
 - **TDD-enforced** — acceptance tests must fail before implementation starts
 - **Loop until done** — verify, retry, escalate, and regression-check automatically
 - **Monorepo-ready** — per-package config and per-story working directories
-- **Extensible** — plugin system for routing, review, and reporting
+- **Extensible** — plugin system for routing, review, reporting, and post-run actions
+- **Language-aware** — auto-detects Go, Rust, Python, TypeScript from manifest files; adapts commands, test structure, and mocking patterns per language
+- **Semantic review** — LLM-based behavioral review against story acceptance criteria; catches stubs, placeholders, and out-of-scope changes
 
 ## Install
 
@@ -160,7 +162,7 @@ See [Hooks Guide](docs/guides/hooks.md).
 
 ### Plugins
 
-Extensible plugin architecture for prompt optimization, custom routing, code review, and reporting. Plugins live in `.nax/plugins/` (project) or `~/.nax/plugins/` (global).
+Extensible plugin architecture for prompt optimization, custom routing, code review, and reporting. Plugins live in `.nax/plugins/` (project) or `~/.nax/plugins/` (global). Post-run action plugins (e.g. auto-PR creation) can implement `IPostRunAction` for results-aware post-completion workflows.
 
 See [Plugins Guide](docs/guides/agents.md#plugins).
 

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: {
@@ -18839,6 +18844,7 @@ __export(exports_generator, {
   generateAcceptanceTests: () => generateAcceptanceTests,
   extractTestCode: () => extractTestCode,
   buildAcceptanceTestPrompt: () => buildAcceptanceTestPrompt,
+  buildAcceptanceRunCommand: () => buildAcceptanceRunCommand,
   acceptanceTestFilename: () => acceptanceTestFilename,
   _generatorPRDDeps: () => _generatorPRDDeps
 });
@@ -18858,13 +18864,33 @@ 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) {
+  if (commandOverride) {
+    const resolved = commandOverride.replace(/\{\{files\}\}/g, testPath).replace(/\{\{file\}\}/g, testPath).replace(/\{\{FILE\}\}/g, testPath);
+    return resolved.trim().split(/\s+/);
+  }
+  switch (testFramework?.toLowerCase()) {
+    case "vitest":
+      return ["npx", "vitest", "run", testPath];
+    case "jest":
+      return ["npx", "jest", testPath];
+    case "pytest":
+      return ["pytest", testPath];
+    case "go-test":
+      return ["go", "test", testPath];
+    case "cargo-test":
+      return ["cargo", "test", "--test", "acceptance"];
+    default:
+      return ["bun", "test", testPath, "--timeout=60000"];
   }
 }
 async function generateFromPRD(_stories, refinedCriteria, options) {
@@ -18915,7 +18941,7 @@ Rules:
 - 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')\`).`;
+- **Path anchor (CRITICAL)**: This test file lives at \`<package-root>/${acceptanceTestFilename(options.language)}\` and runs from the package root. 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, {
@@ -18926,7 +18952,7 @@ Rules:
   });
   let testCode = extractTestCode(rawOutput);
   if (!testCode) {
-    const targetPath = join2(options.featureDir, "acceptance.test.ts");
+    const targetPath = join2(options.featureDir, acceptanceTestFilename(options.language));
     try {
       const existing = await Bun.file(targetPath).text();
       const recovered = extractTestCode(existing);
@@ -19450,37 +19476,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;
@@ -19570,7 +19565,7 @@ class SpawnAcpSession {
       await this.pidRegistry?.unregister(processPid);
     }
   }
-  async close() {
+  async close(options) {
     if (this.activeProc) {
       try {
         this.activeProc.kill(15);
@@ -19589,6 +19584,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) {
@@ -19622,7 +19625,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() {}
@@ -19674,6 +19677,7 @@ var _spawnClientDeps;
 var init_spawn_client = __esm(() => {
   init_logger2();
   init_bun_deps();
+  init_env();
   _spawnClientDeps = {
     spawn: typedSpawn
   };
@@ -20095,6 +20099,7 @@ class AcpAgentAdapter {
       const client = _acpAdapterDeps.createClient(cmdStr, workdir);
       await client.start();
       let session = null;
+      let hadError = false;
       try {
         session = await client.createSession({
           agentName: this.name,
@@ -20136,6 +20141,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;
@@ -20149,7 +20155,7 @@ class AcpAgentAdapter {
         await _acpAdapterDeps.sleep(backoffMs);
       } finally {
         if (session) {
-          await session.close().catch(() => {});
+          await session.close({ forceTerminate: hadError }).catch(() => {});
         }
         await client.close().catch(() => {});
       }
@@ -20957,7 +20963,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)) {
@@ -20989,7 +20995,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}/`;
@@ -21025,10 +21031,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 = () => {};
@@ -22299,7 +22305,7 @@ var package_default;
 var init_package = __esm(() => {
   package_default = {
     name: "@nathapp/nax",
-    version: "0.54.0",
+    version: "0.54.2",
     description: "AI Coding Agent Orchestrator \u2014 loops until done",
     type: "module",
     bin: {
@@ -22376,8 +22382,8 @@ var init_version = __esm(() => {
   NAX_VERSION = package_default.version;
   NAX_COMMIT = (() => {
     try {
-      if (/^[0-9a-f]{6,10}$/.test("f0107a4"))
-        return "f0107a4";
+      if (/^[0-9a-f]{6,10}$/.test("18dd8fc"))
+        return "18dd8fc";
     } catch {}
     try {
       const result = Bun.spawnSync(["git", "rev-parse", "--short", "HEAD"], {
@@ -24041,6 +24047,7 @@ function areAllStoriesComplete(ctx) {
 }
 var acceptanceStage;
 var init_acceptance2 = __esm(() => {
+  init_generator();
   init_logger2();
   init_prd();
   acceptanceStage = {
@@ -24063,59 +24070,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 acceptanceCmd = effectiveConfig.acceptance.command;
-      let testCmdParts;
-      if (acceptanceCmd) {
-        const resolved = acceptanceCmd.includes("{{FILE}}") ? acceptanceCmd.replace("{{FILE}}", testPath) : acceptanceCmd;
-        testCmdParts = resolved.trim().split(/\s+/);
-      } else {
-        testCmdParts = ["bun", "test", testPath, "--timeout=60000"];
-      }
-      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)", {
@@ -24123,19 +24115,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(", ")}`
+      };
     }
   };
 });
@@ -24252,6 +24277,7 @@ var init_acceptance_setup = __esm(() => {
   init_generator();
   init_registry();
   init_config();
+  init_logger2();
   _acceptanceSetupDeps = {
     getAgent,
     fileExists: async (_path) => {
@@ -24282,14 +24308,8 @@ var init_acceptance_setup = __esm(() => {
     writeMeta: async (metaPath, meta3) => {
       await Bun.write(metaPath, JSON.stringify(meta3, null, 2));
     },
-    runTest: async (_testPath, _workdir, _testCmd) => {
-      let cmd;
-      if (_testCmd) {
-        const parts = _testCmd.trim().split(/\s+/);
-        cmd = [...parts, _testPath];
-      } else {
-        cmd = ["bun", "test", _testPath];
-      }
+    runTest: async (_testPath, _workdir, _cmd) => {
+      const cmd = _cmd;
       const proc = Bun.spawn(cmd, {
         cwd: _workdir,
         stdout: "pipe",
@@ -24322,57 +24342,103 @@ ${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 existsResults = await Promise.all(testPaths.map(({ testPath }) => _acceptanceSetupDeps.fileExists(testPath)));
+      const anyFileMissing = existsResults.some((exists) => !exists);
+      let shouldGenerate = anyFileMissing;
+      if (!anyFileMissing) {
         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
+        });
         if (!meta3 || meta3.acFingerprint !== fingerprint) {
-          await _acceptanceSetupDeps.copyFile(testPath, `${testPath}.bak`);
-          await _acceptanceSetupDeps.deleteFile(testPath);
+          getSafeLogger()?.info("acceptance-setup", "ACs changed \u2014 regenerating acceptance tests", {
+            reason: !meta3 ? "no meta file" : "fingerprint mismatch"
+          });
+          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,
+              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 = 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);
         }
-        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);
         await _acceptanceSetupDeps.writeMeta(metaPath, {
           generatedAt: new Date().toISOString(),
@@ -24382,20 +24448,32 @@ ${stderr}` };
           generator: "nax"
         });
       }
+      ctx.acceptanceTestPaths = testPaths;
       if (ctx.config.acceptance.redGate === false) {
         ctx.acceptanceSetup = { totalCriteria, testableCount, redFailCount: 0 };
         return { action: "continue" };
       }
-      const testCmd = ctx.config.quality?.commands?.test;
-      const { exitCode } = await _acceptanceSetupDeps.runTest(testPath, ctx.workdir, testCmd);
-      if (exitCode === 0) {
+      const effectiveConfig = ctx.effectiveConfig ?? ctx.config;
+      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" };
     }
   };
@@ -24723,7 +24801,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;
@@ -24771,6 +24853,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);
@@ -24790,7 +24873,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 {
@@ -24815,6 +24902,11 @@ 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
+    });
     const output = `Semantic review failed:
 
 ${formatFindings(parsed.findings)}`;
@@ -24824,17 +24916,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;
@@ -25017,7 +25113,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) {
@@ -25042,7 +25139,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) {
@@ -31077,7 +31178,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);
@@ -31094,7 +31195,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);
@@ -31722,7 +31823,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[^/]*$/
   ];
 });
 
@@ -31935,7 +32037,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);
@@ -32035,7 +32137,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;
@@ -32067,7 +32170,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",
@@ -32170,6 +32273,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 = {
@@ -32361,7 +32482,8 @@ function getEnvironmentWarnings(config2, workdir) {
     () => checkHomeEnvValid(),
     () => checkPromptOverrideFiles(config2, workdir),
     () => checkLanguageTools(config2.project, workdir),
-    () => checkMultiAgentHealth()
+    () => checkMultiAgentHealth(),
+    () => Promise.resolve(checkBuildCommandInReviewChecks(config2))
   ];
 }
 function getProjectBlockers(prd) {
@@ -34698,12 +34820,12 @@ 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) => {
@@ -34877,12 +34999,12 @@ 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 () => {
@@ -35746,7 +35868,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) {
@@ -67545,7 +67668,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
@@ -71088,10 +71211,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
@@ -79655,7 +79778,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;

package/package.json

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