@nathapp/nax 0.48.3 → 0.49.0

package/src/pipeline/stages/verify.ts

@@ -5,12 +5,11 @@
  * This is a lightweight verification before the full review stage.
  *
  * @returns
- * - `continue`: Tests passed
- * - `escalate`: Tests failed (retry with escalation)
+ * - `continue`: Tests passed, OR TEST_FAILURE (ctx.verifyResult.success===false → rectifyStage handles it)
+ * - `escalate`: TIMEOUT or RUNTIME_CRASH (structural — rectify can't fix these)
  */
 
-import { join } from "node:path";
-import { loadConfigForWorkdir } from "../../config/loader";
+import { basename, join } from "node:path";
 import type { SmartTestRunnerConfig } from "../../config/types";
 import { getLogger } from "../../logger";
 import { logTestOutput } from "../../utils/log-test-output";
@@ -18,6 +17,7 @@ import { detectRuntimeCrash } from "../../verification/crash-detector";
 import type { VerifyStatus } from "../../verification/orchestrator-types";
 import { regression } from "../../verification/runners";
 import { _smartRunnerDeps } from "../../verification/smart-runner";
+import { isMonorepoOrchestratorCommand } from "../../verification/strategies/scoped";
 import type { PipelineContext, PipelineStage, StageResult } from "../types";
 
 const DEFAULT_SMART_RUNNER_CONFIG: SmartTestRunnerConfig = {
@@ -47,6 +47,41 @@ function buildScopedCommand(testFiles: string[], baseCommand: string, testScoped
   return _smartRunnerDeps.buildSmartTestCommand(testFiles, baseCommand);
 }
 
+/**
+ * Read the npm package name from <dir>/package.json.
+ * Returns null if not found or file has no name field.
+ */
+async function readPackageName(dir: string): Promise<string | null> {
+  try {
+    const content = await Bun.file(join(dir, "package.json")).json();
+    return typeof content.name === "string" ? content.name : null;
+  } catch {
+    return null;
+  }
+}
+
+/**
+ * Substitute {{package}} placeholder in a testScoped template.
+ *
+ * Reads the npm package name from <packageDir>/package.json.
+ * Returns null when package.json is absent or has no name field — callers
+ * should skip the template entirely in that case (non-JS/non-Node projects
+ * have no package identity to inject, so don't fall back to a dir name guess).
+ *
+ * @param template   - Template string (e.g. "bunx turbo test --filter={{package}}")
+ * @param packageDir - Absolute path to the package directory
+ * @returns Resolved template, or null if {{package}} cannot be resolved
+ */
+async function resolvePackageTemplate(template: string, packageDir: string): Promise<string | null> {
+  if (!template.includes("{{package}}")) return template;
+  const name = await _verifyDeps.readPackageName(packageDir);
+  if (name === null) {
+    // No package.json or no name field — skip template, can't resolve {{package}}
+    return null;
+  }
+  return template.replaceAll("{{package}}", name);
+}
+
 export const verifyStage: PipelineStage = {
   name: "verify",
   enabled: (ctx: PipelineContext) => !ctx.fullSuiteGatePassed,
@@ -55,10 +90,9 @@ export const verifyStage: PipelineStage = {
   async execute(ctx: PipelineContext): Promise<StageResult> {
     const logger = getLogger();
 
-    // MW-009: resolve effective config for per-package test commands
-    const effectiveConfig = ctx.story.workdir
-      ? await _verifyDeps.loadConfigForWorkdir(join(ctx.workdir, "nax", "config.json"), ctx.story.workdir)
-      : ctx.config;
+    // PKG-003: use centrally resolved effective config (set once per story in iteration-runner)
+    // Falls back to ctx.config for contexts that predate PKG-003 (e.g., acceptance-loop)
+    const effectiveConfig = ctx.effectiveConfig ?? ctx.config;
 
     // Skip verification if tests are not required
     if (!effectiveConfig.quality.requireTests) {
@@ -82,10 +116,38 @@ export const verifyStage: PipelineStage = {
     // Determine effective test command (smart runner or full suite)
     let effectiveCommand = testCommand;
     let isFullSuite = true;
-    const smartRunnerConfig = coerceSmartTestRunner(ctx.config.execution.smartTestRunner);
-    const regressionMode = ctx.config.execution.regressionGate?.mode ?? "deferred";
+    const smartRunnerConfig = coerceSmartTestRunner(effectiveConfig.execution.smartTestRunner);
+    const regressionMode = effectiveConfig.execution.regressionGate?.mode ?? "deferred";
 
-    if (smartRunnerConfig.enabled) {
+    // Resolve {{package}} in testScoped template for monorepo stories.
+    // Returns null if package.json is absent (non-JS project) — falls through to smart-runner.
+    let resolvedTestScopedTemplate: string | undefined = testScopedTemplate;
+    if (testScopedTemplate && ctx.story.workdir) {
+      const resolved = await resolvePackageTemplate(testScopedTemplate, effectiveWorkdir);
+      resolvedTestScopedTemplate = resolved ?? undefined; // null → skip template
+    }
+
+    // Monorepo orchestrators (turbo, nx) handle change-aware scoping natively via their own
+    // filter syntax. Skip nax's smart runner — appending file paths would produce invalid syntax.
+    // Instead, use the testScoped template (with {{package}} resolved) to scope per-story.
+    const isMonorepoOrchestrator = isMonorepoOrchestratorCommand(testCommand);
+
+    if (isMonorepoOrchestrator) {
+      if (resolvedTestScopedTemplate && ctx.story.workdir) {
+        // Use the resolved scoped template (e.g. "bunx turbo test --filter=@koda/cli")
+        effectiveCommand = resolvedTestScopedTemplate;
+        isFullSuite = false;
+        logger.info("verify", "Monorepo orchestrator — using testScoped template", {
+          storyId: ctx.story.id,
+          command: effectiveCommand,
+        });
+      } else {
+        logger.info("verify", "Monorepo orchestrator — running full suite (no package context)", {
+          storyId: ctx.story.id,
+          command: effectiveCommand,
+        });
+      }
+    } else if (smartRunnerConfig.enabled) {
       // MW-006: pass packagePrefix so git diff is scoped to the package in monorepos
       const sourceFiles = await _smartRunnerDeps.getChangedSourceFiles(
         effectiveWorkdir,
@@ -99,7 +161,7 @@ export const verifyStage: PipelineStage = {
         logger.info("verify", `[smart-runner] Pass 1: path convention matched ${pass1Files.length} test files`, {
           storyId: ctx.story.id,
         });
-        effectiveCommand = buildScopedCommand(pass1Files, testCommand, testScopedTemplate);
+        effectiveCommand = buildScopedCommand(pass1Files, testCommand, resolvedTestScopedTemplate);
         isFullSuite = false;
       } else if (smartRunnerConfig.fallback === "import-grep") {
         // Pass 2: import-grep fallback
@@ -112,7 +174,7 @@ export const verifyStage: PipelineStage = {
           logger.info("verify", `[smart-runner] Pass 2: import-grep matched ${pass2Files.length} test files`, {
             storyId: ctx.story.id,
           });
-          effectiveCommand = buildScopedCommand(pass2Files, testCommand, testScopedTemplate);
+          effectiveCommand = buildScopedCommand(pass2Files, testCommand, resolvedTestScopedTemplate);
           isFullSuite = false;
         }
       }
@@ -143,8 +205,8 @@ export const verifyStage: PipelineStage = {
     const result = await _verifyDeps.regression({
       workdir: effectiveWorkdir,
       command: effectiveCommand,
-      timeoutSeconds: ctx.config.execution.verificationTimeoutSeconds,
-      acceptOnTimeout: ctx.config.execution.regressionGate?.acceptOnTimeout ?? true,
+      timeoutSeconds: effectiveConfig.execution.verificationTimeoutSeconds,
+      acceptOnTimeout: effectiveConfig.execution.regressionGate?.acceptOnTimeout ?? true,
     });
 
     // Store result on context for rectify stage
@@ -172,7 +234,7 @@ export const verifyStage: PipelineStage = {
     if (!result.success) {
       // BUG-019: Distinguish timeout from actual test failures
       if (result.status === "TIMEOUT") {
-        const timeout = ctx.config.execution.verificationTimeoutSeconds;
+        const timeout = effectiveConfig.execution.verificationTimeoutSeconds;
         logger.error(
           "verify",
           `Test suite exceeded timeout (${timeout}s). This is NOT a test failure — consider increasing execution.verificationTimeoutSeconds or scoping tests.`,
@@ -195,13 +257,19 @@ export const verifyStage: PipelineStage = {
         logTestOutput(logger, "verify", result.output, { storyId: ctx.story.id });
       }
 
-      return {
-        action: "escalate",
-        reason:
-          result.status === "TIMEOUT"
-            ? `Test suite TIMEOUT after ${ctx.config.execution.verificationTimeoutSeconds}s (not a code failure)`
-            : `Tests failed (exit code ${result.status ?? "non-zero"})`,
-      };
+      // RUNTIME_CRASH and TIMEOUT are structural — escalate immediately (rectify can't fix them)
+      if (result.status === "TIMEOUT" || detectRuntimeCrash(result.output)) {
+        return {
+          action: "escalate",
+          reason:
+            result.status === "TIMEOUT"
+              ? `Test suite TIMEOUT after ${effectiveConfig.execution.verificationTimeoutSeconds}s (not a code failure)`
+              : `Tests failed with runtime crash (exit code ${result.status ?? "non-zero"})`,
+        };
+      }
+
+      // TEST_FAILURE: ctx.verifyResult is set with success:false — rectifyStage handles it next
+      return { action: "continue" };
     }
 
     logger.info("verify", "Tests passed", { storyId: ctx.story.id });
@@ -214,5 +282,5 @@ export const verifyStage: PipelineStage = {
  */
 export const _verifyDeps = {
   regression,
-  loadConfigForWorkdir,
+  readPackageName,
 };

package/src/pipeline/types.ts

@@ -58,6 +58,13 @@ export type AgentGetFn = (name: string) => import("../agents/types").AgentAdapte
 export interface PipelineContext {
   /** Ngent configuration */
   config: NaxConfig;
+  /**
+   * Resolved config for this story's package.
+   * When story.workdir is set, this is root config merged with package config.
+   * When no workdir, this equals ctx.config (root).
+   * Set once per story in the iteration runner before pipeline execution.
+   */
+  effectiveConfig: NaxConfig;
   /** Full PRD document */
   prd: PRD;
   /** Current story (or batch leader) */

package/src/review/runner.ts

@@ -221,11 +221,26 @@ export async function runReview(
 
   // RQ-001: Check for uncommitted tracked files before running checks
   const allUncommittedFiles = await _deps.getUncommittedFiles(workdir);
-  // Exclude nax runtime files — written by nax itself during the run, not by the agent
-  const NAX_RUNTIME_FILES = new Set(["nax/status.json", ".nax-verifier-verdict.json"]);
-  const uncommittedFiles = allUncommittedFiles.filter(
-    (f) => !NAX_RUNTIME_FILES.has(f) && !f.match(/^nax\/features\/.+\/prd\.json$/),
-  );
+  // Exclude nax runtime files — written by nax itself during the run, not by the agent.
+  // Patterns use a suffix match (no leading ^) so they work in both single-package repos
+  // (nax/features/…) and monorepos where paths are prefixed (apps/cli/nax/features/…).
+  const NAX_RUNTIME_PATTERNS = [
+    /nax\.lock$/,
+    /nax\/metrics\.json$/,
+    /nax\/status\.json$/,
+    /nax\/features\/[^/]+\/status\.json$/,
+    /nax\/features\/[^/]+\/prd\.json$/,
+    /nax\/features\/[^/]+\/runs\//,
+    /nax\/features\/[^/]+\/plan\//,
+    /nax\/features\/[^/]+\/acp-sessions\.json$/,
+    /nax\/features\/[^/]+\/interactions\//,
+    /nax\/features\/[^/]+\/progress\.txt$/,
+    /nax\/features\/[^/]+\/acceptance-refined\.json$/,
+    /\.nax-verifier-verdict\.json$/,
+    /\.nax-pids$/,
+    /\.nax-wt\//,
+  ];
+  const uncommittedFiles = allUncommittedFiles.filter((f) => !NAX_RUNTIME_PATTERNS.some((pattern) => pattern.test(f)));
   if (uncommittedFiles.length > 0) {
     const fileList = uncommittedFiles.join(", ");
     logger?.warn("review", `Uncommitted changes detected before review: ${fileList}`);