@nathapp/nax 0.70.6 → 0.70.8

package/dist/nax.js

@@ -24693,7 +24693,7 @@ function parsePytestOutput(output) {
   const failures = [];
   for (const line of output.split(`
 `)) {
-    const m = line.match(/^FAILED\s+(\S+)(?:\s+-\s+(.*))?$/);
+    const m = line.match(/^(?:\S+:\s+)?FAILED\s+(\S+)(?:\s+-\s+(.*))?$/);
     if (m) {
       const [, location, reason] = m;
       const parts = location.split("::");
@@ -24705,6 +24705,28 @@ function parsePytestOutput(output) {
       });
     }
   }
+  const PLACEHOLDER_REASON = "Collection/import error";
+  const errorByFile = new Map;
+  for (const line of output.split(`
+`)) {
+    const collecting = line.match(/^(?:\S+:\s+)?_*\s*ERROR\s+collecting\s+(\S+\.\w+)/);
+    const summary = line.match(/^(?:\S+:\s+)?ERROR\s+(\S+\.\w+(?:::\S+)?)\s+-\s+(.*)/);
+    const location = collecting?.[1] ?? summary?.[1];
+    if (!location)
+      continue;
+    const reason = summary?.[2]?.trim();
+    const file3 = location.split("::")[0] ?? location;
+    const existing = errorByFile.get(file3);
+    if (existing && existing.error !== PLACEHOLDER_REASON)
+      continue;
+    errorByFile.set(file3, {
+      file: file3,
+      testName: `collection error: ${file3}`,
+      error: reason || PLACEHOLDER_REASON,
+      stackTrace: []
+    });
+  }
+  failures.push(...errorByFile.values());
   const verboseStacks = parsePytestVerboseStacks(output);
   for (const failure of failures) {
     const leafName = failure.testName.split(" > ").pop() ?? failure.testName;
@@ -24808,6 +24830,10 @@ function parseCommonOutput(output) {
       failed = Number.parseInt(failMatches[failMatches.length - 1][1], 10);
     }
   }
+  const errorMatches = Array.from(output.matchAll(/(\d+)\s+errors?\b(?=[^\n]*\bin\s+[\d.]+\s*s\b)/gi));
+  if (errorMatches.length > 0) {
+    failed += Number.parseInt(errorMatches[errorMatches.length - 1][1], 10);
+  }
   return { passed, failed, failures: [] };
 }
 function formatFailureSummary(failures, maxChars = 2000) {
@@ -24860,9 +24886,10 @@ var init_parser = __esm(() => {
 
 // src/test-runners/ac-parser.ts
 function parseTestFailures(output) {
-  const framework = detectFramework(output);
+  const clean = output.replace(ANSI_ESCAPE_PATTERN, "");
+  const framework = detectFramework(clean);
   const failedACs = [];
-  const lines = output.split(`
+  const lines = clean.split(`
 `);
   for (const line of lines) {
     if (framework === "bun" || framework === "unknown") {
@@ -24896,7 +24923,7 @@ function parseTestFailures(output) {
       }
     }
     if (framework === "jest" || framework === "vitest" || framework === "unknown") {
-      if (/[\u25CF\u00D7\u2715]/.test(line)) {
+      if (/[\u25CF\u00D7\u2715]/.test(line) || /^\s*FAIL\s/.test(line)) {
         const acMatch = line.match(/AC[-_]?(\d+)/i);
         if (acMatch) {
           const acId = `AC-${acMatch[1]}`;
@@ -24913,8 +24940,10 @@ function parseTestFailures(output) {
   }
   return failedACs;
 }
+var ANSI_ESCAPE_PATTERN;
 var init_ac_parser = __esm(() => {
   init_detector2();
+  ANSI_ESCAPE_PATTERN = new RegExp(`${String.fromCharCode(27)}\\[[0-9;?]*[A-Za-z]`, "g");
 });
 
 // src/utils/git.ts
@@ -30246,11 +30275,7 @@ async function gitLsFiles2(workdir) {
     return null;
   }
 }
-async function hasTestFiles(workdir, patterns) {
-  const files = await gitLsFiles2(workdir);
-  if (files !== null) {
-    return files.some((f) => isTestFileByPatterns(f, patterns));
-  }
+async function hasTestFilesOnDisk(workdir, patterns) {
   for (const pattern of patterns) {
     const g = new Bun.Glob(pattern);
     for await (const path3 of g.scan({ cwd: workdir, onlyFiles: true })) {
@@ -30261,6 +30286,13 @@ async function hasTestFiles(workdir, patterns) {
   }
   return false;
 }
+async function hasTestFiles(workdir, patterns) {
+  const files = await gitLsFiles2(workdir);
+  if (files !== null) {
+    return files.some((f) => isTestFileByPatterns(f, patterns));
+  }
+  return hasTestFilesOnDisk(workdir, patterns);
+}
 async function isGreenfieldStory(_story, workdir, patterns) {
   try {
     return !await hasTestFiles(workdir, patterns ?? DEFAULT_TEST_FILE_PATTERNS);
@@ -30291,6 +30323,7 @@ var init_greenfield = __esm(() => {
     "out",
     "tmp",
     "temp",
+    ".nax",
     ".git"
   ]);
 });
@@ -32865,13 +32898,13 @@ var init_semantic_helpers = __esm(() => {
 
 // src/review/semantic-evidence.ts
 import { isAbsolute as isAbsolute8 } from "path";
-async function substantiateSemanticEvidence(findings, diffMode, workdir, storyId, blockingThreshold = "error") {
+async function substantiateSemanticEvidence(findings, diffMode, workdir, storyId, blockingThreshold = "error", repoRoot) {
   if (diffMode !== "ref")
     return findings;
   return Promise.all(findings.map(async (finding) => {
     if (!isBlockingSeverity(finding.severity, blockingThreshold))
       return finding;
-    const evidence = await checkFindingEvidence({ finding, workdir });
+    const evidence = await checkFindingEvidence({ finding, workdir, repoRoot });
     if (evidence.status !== "unmatched")
       return finding;
     return downgradeUnsubstantiatedFinding({ finding, storyId, ...evidence });
@@ -32883,7 +32916,8 @@ async function checkFindingEvidence(opts) {
   const line = opts.finding.verifiedBy?.line ?? opts.finding.line;
   if (!observed)
     return { status: "missing-observed", file: file3, line };
-  const contents = await readSafeFile(opts.workdir, file3);
+  const roots = opts.repoRoot && opts.repoRoot !== opts.workdir ? [opts.repoRoot, opts.workdir] : [opts.workdir];
+  const contents = await readSafeFile(roots, file3);
   if (contents === null)
     return { status: "unreadable", file: file3, line, observed };
   return matchesEvidence(contents, observed, line) ? { status: "matched", file: file3, line, observed } : { status: "unmatched", file: file3, line, observed };
@@ -32912,13 +32946,13 @@ function downgradeUnsubstantiatedFinding(opts) {
   });
   return { ...opts.finding, severity: "unverifiable" };
 }
-async function readSafeFile(workdir, file3) {
-  const validated = validateModulePath(file3, [workdir]);
-  if (validated.valid && validated.absolutePath) {
-    try {
-      return await Bun.file(validated.absolutePath).text();
-    } catch {
-      return null;
+async function readSafeFile(roots, file3) {
+  for (const root of roots) {
+    const validated = validateModulePath(file3, [root]);
+    if (validated.valid && validated.absolutePath) {
+      try {
+        return await Bun.file(validated.absolutePath).text();
+      } catch {}
     }
   }
   if (isAbsolute8(file3)) {
@@ -32963,11 +32997,11 @@ function hasInspectionTrail(raw) {
   return Array.isArray(files) && files.some((f) => typeof f === "string" && f.trim().length > 0);
 }
 async function substantiateAdversarialFindings(opts) {
-  const { findings, workdir, storyId, blockingThreshold } = opts;
+  const { findings, workdir, storyId, blockingThreshold, repoRoot } = opts;
   return Promise.all(findings.map(async (finding) => {
     if (!isBlockingSeverity(finding.severity, blockingThreshold))
       return finding;
-    const evidence = await checkFindingEvidence({ finding, workdir });
+    const evidence = await checkFindingEvidence({ finding, workdir, repoRoot });
     if (evidence.status !== "unmatched" && evidence.status !== "missing-observed")
       return finding;
     return downgradeUnsubstantiatedFinding({
@@ -33072,7 +33106,11 @@ async function requoteBlockingAdversarialFindings(findings, ctx) {
   for (const [index, finding] of next.entries()) {
     if (!isBlockingSeverity(finding.severity, threshold))
       continue;
-    const initialEvidence = await checkFindingEvidence({ finding, workdir: ctx.input.workdir });
+    const initialEvidence = await checkFindingEvidence({
+      finding,
+      workdir: ctx.input.workdir,
+      repoRoot: ctx.input.repoRoot
+    });
     if (initialEvidence.status !== "unmatched")
       continue;
     if (used >= maxRequotes)
@@ -33101,7 +33139,8 @@ async function requoteBlockingAdversarialFindings(findings, ctx) {
     };
     const requotedEvidence = await checkFindingEvidence({
       finding: updatedFinding,
-      workdir: ctx.input.workdir
+      workdir: ctx.input.workdir,
+      repoRoot: ctx.input.repoRoot
     });
     if (requotedEvidence.status === "matched") {
       getSafeLogger()?.info("review", "Recovered adversarial finding via same-session requote", {
@@ -33329,6 +33368,7 @@ var init_adversarial_review = __esm(() => {
       const substantiated = await substantiateAdversarialFindings({
         findings,
         workdir: input.workdir,
+        repoRoot: input.repoRoot,
         storyId: input.story.id,
         blockingThreshold: threshold
       });
@@ -34026,6 +34066,7 @@ async function runAdversarialReview(opts) {
   try {
     opResult = await _adversarialDeps.callOp(callCtx, adversarialReviewOp, {
       workdir,
+      repoRoot: projectDir ?? workdir,
       story,
       adversarialConfig,
       mode: diffMode,
@@ -35548,6 +35589,10 @@ var init_decompose2 = __esm(() => {
 });
 
 // src/routing/classify.ts
+function isSecurityCriticalStory(title, tags = []) {
+  const text = [title, ...tags ?? []].join(" ").toLowerCase();
+  return SECURITY_KEYWORDS.some((kw) => text.includes(kw)) || PUBLIC_API_KEYWORDS.some((kw) => text.includes(kw));
+}
 function classifyComplexity(title, _description, acceptanceCriteria, tags = []) {
   const text = [title, ...acceptanceCriteria ?? [], ...tags ?? []].join(" ").toLowerCase();
   if (EXPERT_KEYWORDS.some((kw) => text.includes(kw)))
@@ -35565,10 +35610,7 @@ function determineTestStrategy(complexity, title, _description, tags = [], tddSt
     return "tdd-simple";
   if (tddStrategy === "off")
     return "test-after";
-  const text = [title, ...tags ?? []].join(" ").toLowerCase();
-  const isSecurityCritical = SECURITY_KEYWORDS.some((kw) => text.includes(kw));
-  const isPublicApi = PUBLIC_API_KEYWORDS.some((kw) => text.includes(kw));
-  if (isSecurityCritical || isPublicApi)
+  if (isSecurityCriticalStory(title, tags))
     return "three-session-tdd";
   if (complexity === "expert")
     return "three-session-tdd";
@@ -35956,6 +35998,7 @@ __export(exports_routing, {
   routeTask: () => routeTask,
   routeStory: () => routeStory,
   resolveRouting: () => resolveRouting,
+  isSecurityCriticalStory: () => isSecurityCriticalStory,
   determineTestStrategy: () => determineTestStrategy,
   complexityToModelTier: () => complexityToModelTier,
   clearCache: () => clearCache,
@@ -36801,7 +36844,11 @@ async function requoteBlockingFindings(findings, ctx) {
   for (const [index, finding] of next.entries()) {
     if (!isBlockingSeverity(finding.severity, threshold))
       continue;
-    const initialEvidence = await checkFindingEvidence({ finding, workdir: ctx.input.workdir });
+    const initialEvidence = await checkFindingEvidence({
+      finding,
+      workdir: ctx.input.workdir,
+      repoRoot: ctx.input.repoRoot
+    });
     if (initialEvidence.status !== "unmatched")
       continue;
     if (used >= maxRequotes)
@@ -36831,7 +36878,8 @@ async function requoteBlockingFindings(findings, ctx) {
     };
     const requotedEvidence = await checkFindingEvidence({
       finding: updatedFinding,
-      workdir: ctx.input.workdir
+      workdir: ctx.input.workdir,
+      repoRoot: ctx.input.repoRoot
     });
     if (requotedEvidence.status === "matched") {
       getSafeLogger()?.info("review", "Recovered semantic finding via same-session requote", {
@@ -36967,7 +37015,7 @@ var init_semantic_review = __esm(() => {
       const threshold = input.blockingThreshold ?? "error";
       const findings = parsed.findings;
       const sanitized = sanitizeRefModeFindings(findings, input.mode, threshold);
-      const substantiated = await substantiateSemanticEvidence(sanitized, input.mode, input.workdir, input.story.id, threshold);
+      const substantiated = await substantiateSemanticEvidence(sanitized, input.mode, input.workdir, input.story.id, threshold, input.repoRoot);
       const { accepted, dropped } = filterByAcGroundingMinimal(substantiated, input.story.acceptanceCriteria);
       const blocking = accepted.filter((f) => isBlockingSeverity(f.severity, threshold));
       const passed = parsed.passed && blocking.length === 0;
@@ -38975,8 +39023,13 @@ var init_greenfield_gate = __esm(() => {
     config: greenfieldGateConfigSelector,
     async execute(input, _ctx) {
       const globs = input.resolvedTestPatterns.globs;
-      const isGreenfield = await isGreenfieldStory(input.story, input.workdir, globs);
-      if (isGreenfield) {
+      let hasTests;
+      try {
+        hasTests = await hasTestFilesOnDisk(input.workdir, globs);
+      } catch {
+        return { success: true, hasPreExistingTests: true };
+      }
+      if (!hasTests) {
         return { success: false, hasPreExistingTests: false, pauseReason: "greenfield-no-tests" };
       }
       return { success: true, hasPreExistingTests: true };
@@ -38984,6 +39037,33 @@ var init_greenfield_gate = __esm(() => {
   };
 });
 
+// src/operations/test-presence-gate.ts
+var testPresenceGateConfigSelector, testPresenceGateOp;
+var init_test_presence_gate = __esm(() => {
+  init_config();
+  init_greenfield();
+  testPresenceGateConfigSelector = pickSelector("test-presence-gate", "execution");
+  testPresenceGateOp = {
+    kind: "deterministic",
+    name: "test-presence-gate",
+    stage: "verify",
+    config: testPresenceGateConfigSelector,
+    async execute(input, _ctx) {
+      const globs = input.resolvedTestPatterns.globs;
+      let hasTests;
+      try {
+        hasTests = await hasTestFilesOnDisk(input.workdir, globs);
+      } catch {
+        return { success: true, hasTests: true };
+      }
+      if (!hasTests) {
+        return { success: false, hasTests: false, pauseReason: "no-tests-authored" };
+      }
+      return { success: true, hasTests: true };
+    }
+  };
+});
+
 // src/utils/command-argv.ts
 function parseCommandToArgv(command) {
   const safeEnv = buildAllowedEnv();
@@ -40667,6 +40747,7 @@ var init_operations = __esm(() => {
   init_plan_critic_llm();
   init_execution_gates();
   init_greenfield_gate();
+  init_test_presence_gate();
   init_full_suite_gate();
   init_full_suite_rectify();
   init_full_suite_rectify_op();
@@ -42048,6 +42129,7 @@ async function runSemanticReview(opts) {
   try {
     opResult = await _semanticDeps.callOp(callCtx, semanticReviewOp, {
       workdir,
+      repoRoot: projectDir ?? workdir,
       story,
       semanticConfig,
       mode: diffMode,
@@ -42602,6 +42684,7 @@ var init_runner2 = __esm(() => {
 var init_review = __esm(() => {
   init_semantic_helpers();
   init_category_fix_target();
+  init_finding_filters();
   init_ac_quote_validator();
   init_ac_structural_counterfactual();
   init_adversarial();
@@ -42629,6 +42712,13 @@ UNRESOLVED: <brief explanation of which findings conflicted and why they cannot
 
 Before emitting UNRESOLVED, confirm none of Exceptions 1\u2013${count} apply.
 
+**A missing-test or \`test-gap\` finding is never a false positive because a \`.nax/\` file exists.**
+\`.nax/\` is nax's own artifact directory; \`.nax-acceptance.test.ts\` is generated scaffolding for the
+acceptance gate \u2014 it is NOT source-tree test coverage. You may NOT cite any \`.nax/\`-resident file as
+evidence that an acceptance criterion is already tested, and you may NOT emit UNRESOLVED on that basis.
+The only valid response to a missing-test finding is to
+author a real test under the package's resolved test path.
+
 ## Test-file edit exceptions
 
 The "do not modify test files" rule has ${countWord} narrow escape valves. Each requires a
@@ -53992,7 +54082,7 @@ ${stderr}`;
           errorExitCode = exitCode;
           allFailedACs.push("AC-ERROR");
           allFindings.push(acSentinelToFinding("AC-ERROR", output));
-          failedPackages.push({ testPath, packageDir, testFramework, commandOverride });
+          failedPackages.push({ testPath, packageDir, testFramework, commandOverride, output, failedACs: ["AC-ERROR"] });
           continue;
         }
         for (const acId of actualFailures) {
@@ -54002,7 +54092,14 @@ ${stderr}`;
           }
         }
         if (actualFailures.length > 0) {
-          failedPackages.push({ testPath, packageDir, testFramework, commandOverride });
+          failedPackages.push({
+            testPath,
+            packageDir,
+            testFramework,
+            commandOverride,
+            output,
+            failedACs: actualFailures
+          });
           logger.error("acceptance", "Acceptance tests failed", {
             storyId: ctx.story.id,
             failedACs: actualFailures,
@@ -55441,6 +55538,7 @@ var init_types9 = __esm(() => {
     "test-writer",
     "greenfield-gate",
     "implementer",
+    "test-presence-gate",
     "full-suite-gate",
     "verifier",
     "verify-scoped",
@@ -55453,6 +55551,7 @@ var init_types9 = __esm(() => {
     "test-writer": "testWriter",
     "greenfield-gate": "greenfieldGate",
     implementer: "implementer",
+    "test-presence-gate": "testPresenceGate",
     "full-suite-gate": "fullSuiteGate",
     verifier: "verifier",
     "verify-scoped": "verifyScoped",
@@ -55595,6 +55694,8 @@ function collectOrderedPhases(state) {
       return [state.greenfieldGate];
     if (kind === "implementer" && state.implementer)
       return [state.implementer];
+    if (kind === "test-presence-gate" && state.testPresenceGate)
+      return [state.testPresenceGate];
     if (kind === "full-suite-gate" && state.fullSuiteGate)
       return [state.fullSuiteGate];
     if (kind === "verifier" && state.verifier)
@@ -56219,10 +56320,11 @@ class ExecutionPlan {
         }
       }
     }
+    const storyCurrentlyGreen = !rectResult.rectificationExhausted && Object.entries(phaseOutputs).every(([name, output]) => phasePassed(name, output, this.ctx.storyId));
     const advCfg = this.state.adversarialReview ? this.state.nonBlockingFix : undefined;
     const advisoryOut = phaseOutputs["adversarial-review"];
     const advisoryFindings = advisoryOut?.advisoryFindings ?? [];
-    if (advCfg && this.state.rectification && this.ctx.storyId && shouldRunNonBlockingFix(advCfg, advisoryFindings.length)) {
+    if (advCfg && storyCurrentlyGreen && this.state.rectification && this.ctx.storyId && shouldRunNonBlockingFix(advCfg, advisoryFindings.length)) {
       await _storyOrchestratorDeps.runNonBlockingFix({
         workdir: this.ctx.packageDir,
         storyId: this.ctx.storyId,
@@ -56333,6 +56435,10 @@ class StoryOrchestratorBuilder {
     setPhase(this.state, "greenfield-gate", isSlot(value) ? value : { op: greenfieldGateOp, input: value });
     return this;
   }
+  addTestPresenceGate(value) {
+    setPhase(this.state, "test-presence-gate", isSlot(value) ? value : { op: testPresenceGateOp, input: value });
+    return this;
+  }
   addVerifier(value) {
     setPhase(this.state, "verifier", isSlot(value) ? value : { op: verifierOp, input: value });
     return this;
@@ -56418,6 +56524,9 @@ async function buildPlanForStrategy(ctx, story, config2, testStrategy, inputs) {
   if (inputs.implementer) {
     builder.addImplementer(inputs.implementer);
   }
+  if (!isThreeSession && inputs.testPresenceGate) {
+    builder.addTestPresenceGate(inputs.testPresenceGate);
+  }
   const regressionMode = config2.execution?.regressionGate?.mode ?? "deferred";
   if (inputs.fullSuiteGate && (isThreeSession || regressionMode === "per-story")) {
     builder.addFullSuiteGate(inputs.fullSuiteGate);
@@ -56491,7 +56600,12 @@ async function buildPlanForStrategy(ctx, story, config2, testStrategy, inputs) {
   const nbStrategies = [];
   if (nbf?.enabled && inputs.adversarialReview) {
     const nbSink = makeDeclarationSink();
-    if (nbf.scope === "source") {
+    if (!isThreeSession) {
+      nbStrategies.push(makeAutofixImplementerStrategy(story, config2, nbSink, {
+        includeAdversarialReview: true,
+        promptSeverityFloor: "info"
+      }));
+    } else if (nbf.scope === "source") {
       nbStrategies.push(makeAutofixImplementerStrategy(story, config2, nbSink, {
         includeAdversarialReview: true,
         promptSeverityFloor: "info"
@@ -56637,6 +56751,7 @@ async function assemblePlanInputsFromCtx(ctx) {
     featureContextMarkdown: ctx.featureContextMarkdown,
     constitution: ctx.constitution?.content
   };
+  const testPresenceGateInput = isSingleSessionTestOwningStrategy(ctx.routing.testStrategy) && resolvedTestPatterns ? { story, workdir: ctx.workdir, resolvedTestPatterns } : undefined;
   const _regressionMode = ctx.config.execution?.regressionGate?.mode;
   const fullSuiteGateInput = _isTdd || _regressionMode === "per-story" ? {
     story,
@@ -56741,6 +56856,7 @@ async function assemblePlanInputsFromCtx(ctx) {
     testWriter: testWriterInput,
     greenfieldGate: greenfieldGateInput,
     implementer: implementerInput,
+    testPresenceGate: testPresenceGateInput,
     fullSuiteGate: fullSuiteGateInput,
     verifier: verifierInput,
     verifyScoped: verifyScopedInput,
@@ -56798,6 +56914,11 @@ function routeTddFailure(failureCategory, isLiteMode, ctx, reviewReason, failure
     case "review-incomplete":
     case "greenfield-no-tests":
       return { action: "escalate", reason: buildReason(failureCategory) };
+    case "no-tests-authored":
+      return {
+        action: "escalate",
+        reason: "No test files were authored for this story. You MUST write tests covering every acceptance criterion under the package's resolved test path before implementation is considered complete."
+      };
     case "dependency-prep":
       return pauseFallback;
     default:
@@ -56902,6 +57023,10 @@ function deriveTddFailureCategory(phaseOutputs, unfixedFindings, gateRegressedDu
   if (greenfieldOutput?.success === false && greenfieldOutput?.pauseReason === "greenfield-no-tests") {
     return "greenfield-no-tests";
   }
+  const testPresenceOutput = phaseOutputs[testPresenceGateOp.name];
+  if (testPresenceOutput?.success === false && testPresenceOutput?.pauseReason === "no-tests-authored") {
+    return "no-tests-authored";
+  }
   const verifierOutput = phaseOutputs[verifierOp.name];
   if (verifierOutput?.success === false) {
     if (verifierOutput.failureCategory) {
@@ -57941,13 +58066,21 @@ var init_routing2 = __esm(() => {
         });
         const isGreenfield = await _routingDeps.isGreenfieldStory(ctx.story, greenfieldScanDir, resolved?.globs);
         if (isGreenfield) {
-          logger.info("routing", "Greenfield detected \u2014 forcing test-after strategy", {
-            storyId: ctx.story.id,
-            originalStrategy: routing.testStrategy,
-            scanDir: greenfieldScanDir
-          });
-          routing.testStrategy = "test-after";
-          routing.reasoning = `${routing.reasoning} [GREENFIELD OVERRIDE: No test files exist, using test-after instead of TDD]`;
+          if (isSecurityCriticalStory(ctx.story.title, ctx.story.tags)) {
+            logger.info("routing", "Greenfield + security-critical \u2014 keeping three-session strategy", {
+              storyId: ctx.story.id,
+              strategy: routing.testStrategy,
+              scanDir: greenfieldScanDir
+            });
+          } else {
+            logger.info("routing", "Greenfield detected \u2014 forcing tdd-simple strategy", {
+              storyId: ctx.story.id,
+              originalStrategy: routing.testStrategy,
+              scanDir: greenfieldScanDir
+            });
+            routing.testStrategy = "tdd-simple";
+            routing.reasoning = `${routing.reasoning} [GREENFIELD OVERRIDE: No test files exist, using tdd-simple (test-first, single-session) instead of three-session TDD]`;
+          }
         }
       }
       ctx.routing = routing;
@@ -61057,7 +61190,7 @@ var package_default;
 var init_package = __esm(() => {
   package_default = {
     name: "@nathapp/nax",
-    version: "0.70.6",
+    version: "0.70.8",
     description: "AI Coding Agent Orchestrator \u2014 loops until done",
     type: "module",
     bin: {
@@ -61157,8 +61290,8 @@ var init_version = __esm(() => {
   NAX_VERSION = package_default.version;
   NAX_COMMIT = (() => {
     try {
-      if (/^[0-9a-f]{6,10}$/.test("eb4e2b89"))
-        return "eb4e2b89";
+      if (/^[0-9a-f]{6,10}$/.test("54e59fa6"))
+        return "54e59fa6";
     } catch {}
     try {
       const result = Bun.spawnSync(["git", "rev-parse", "--short", "HEAD"], {
@@ -61756,12 +61889,12 @@ __export(exports_acceptance_loop, {
   isTestLevelFailure: () => isTestLevelFailure,
   isStubTestFile: () => isStubTestFile,
   buildResult: () => buildResult,
+  _runAcceptanceTestsOnceDeps: () => _runAcceptanceTestsOnceDeps,
   _regenerateDeps: () => _regenerateDeps,
   _acceptanceLoopDeps: () => _acceptanceLoopDeps,
   _acceptanceFixCycleDeps: () => _acceptanceFixCycleDeps
 });
-function resolveAcceptanceFixTarget(acceptanceTestPaths, failedPackages, config2) {
-  const failedPackage = failedPackages?.[0];
+function resolveAcceptanceFixTarget(acceptanceTestPaths, failedPackage, config2) {
   const matchedEntry = failedPackage ? acceptanceTestPaths?.find((entry) => entry.testPath === failedPackage.testPath || entry.packageDir === failedPackage.packageDir) : undefined;
   const selectedPathEntry = matchedEntry ?? acceptanceTestPaths?.[0];
   return {
@@ -61792,11 +61925,11 @@ function findingsForDiagnosis(failedACs, testOutput, diagnosis) {
     { ...f, fixTarget: "test" }
   ]);
 }
-function buildFixCycleCtx(ctx, runtime, storyId) {
+function buildFixCycleCtx(ctx, runtime, storyId, packageDir) {
   return {
     runtime,
-    packageView: runtime.packages.resolve(ctx.workdir),
-    packageDir: ctx.workdir,
+    packageView: runtime.packages.resolve(packageDir),
+    packageDir,
     storyId,
     featureName: ctx.feature,
     agentName: ctx.agentManager?.getDefault() ?? "claude"
@@ -61830,9 +61963,10 @@ function buildAcceptanceContext(ctx, prd) {
     abortSignal: ctx.abortSignal
   };
 }
-async function runAcceptanceTestsOnce(ctx, prd) {
-  const acceptanceContext = buildAcceptanceContext(ctx, prd);
-  const { acceptanceStage: acceptanceStage2 } = await Promise.resolve().then(() => (init_acceptance3(), exports_acceptance2));
+async function runAcceptanceTestsOnce(ctx, prd, packageFilter) {
+  const baseCtx = packageFilter ? { ...ctx, acceptanceTestPaths: packageFilter } : ctx;
+  const acceptanceContext = buildAcceptanceContext(baseCtx, prd);
+  const { acceptanceStage: acceptanceStage2 } = await _runAcceptanceTestsOnceDeps.importAcceptanceStage();
   const result = await acceptanceStage2.execute(acceptanceContext);
   if (result.action !== "fail")
     return { passed: true, failedACs: [], testOutput: "" };
@@ -61846,7 +61980,7 @@ async function runAcceptanceTestsOnce(ctx, prd) {
     failedPackages: failures.failedPackages
   };
 }
-async function runAcceptanceFixCycle(ctx, prd, initialFailures, diagnosis, acceptanceTestPath, testCommand) {
+async function runAcceptanceFixCycle(ctx, prd, initialFailures, diagnosis, acceptanceTestPath, testCommand, fixTarget) {
   const runtime = ctx.runtime;
   if (!runtime) {
     return { iterations: [], finalFindings: [], exitReason: "no-strategy" };
@@ -61854,7 +61988,7 @@ async function runAcceptanceFixCycle(ctx, prd, initialFailures, diagnosis, accep
   let currentTestOutput = initialFailures.testOutput;
   let currentFailedACs = initialFailures.failedACs;
   const storyId = prd.userStories[0]?.id ?? "unknown";
-  const cycleCtx = buildFixCycleCtx(ctx, runtime, storyId);
+  const cycleCtx = buildFixCycleCtx(ctx, runtime, storyId, fixTarget?.packageDir ?? ctx.workdir);
   const cycle = {
     findings: findingsForDiagnosis(initialFailures.failedACs, initialFailures.testOutput, diagnosis),
     iterations: [],
@@ -61892,7 +62026,8 @@ async function runAcceptanceFixCycle(ctx, prd, initialFailures, diagnosis, accep
       }
     ],
     validate: async (_ctx, _opts) => {
-      const result = await runAcceptanceTestsOnce(ctx, prd);
+      const packageFilter = fixTarget ? ctx.acceptanceTestPaths?.filter((entry) => entry.packageDir === fixTarget.packageDir) : undefined;
+      const result = await runAcceptanceTestsOnce(ctx, prd, packageFilter);
       if (result.passed)
         return [];
       currentTestOutput = result.testOutput;
@@ -61918,7 +62053,7 @@ async function runAcceptanceLoop(ctx) {
   const storiesCompleted = ctx.storiesCompleted;
   const prdDirty = false;
   logger?.info("acceptance", "All stories complete, running acceptance validation");
-  const { acceptanceStage: acceptanceStage2 } = await Promise.resolve().then(() => (init_acceptance3(), exports_acceptance2));
+  const { acceptanceStage: acceptanceStage2 } = await _runAcceptanceTestsOnceDeps.importAcceptanceStage();
   while (acceptanceRetries < maxRetries) {
     const firstStory = prd.userStories[0];
     const acceptanceContext = buildAcceptanceContext(ctx, prd);
@@ -61981,40 +62116,55 @@ async function runAcceptanceLoop(ctx) {
       logger?.error("acceptance", "Runtime not found for diagnosis", { storyId: firstStory?.id });
       return buildResult(false, prd, totalCost, iterations, storiesCompleted, prdDirty, failures.failedACs, acceptanceRetries);
     }
-    const { acceptanceTestPath, testCommand } = resolveAcceptanceFixTarget(ctx.acceptanceTestPaths, failures.failedPackages, ctx.config);
-    const testEntries = ctx.acceptanceTestPaths ? await loadAcceptanceTestContent(ctx.acceptanceTestPaths.map((p) => p.testPath)) : [];
-    const effectiveAcceptanceTestPath = acceptanceTestPath || testEntries[0]?.testPath || "";
-    const selectedTestEntry = testEntries.find((entry) => entry.testPath === effectiveAcceptanceTestPath);
-    const testFileContent = selectedTestEntry?.content ?? testEntries[0]?.content ?? "";
+    const failedPkgs = failures.failedPackages && failures.failedPackages.length > 0 ? failures.failedPackages : [{ testPath: "", packageDir: ctx.workdir, output: failures.testOutput, failedACs: failures.failedACs }];
     const strategy = ctx.config.acceptance.fix?.strategy ?? "diagnose-first";
-    const diagnosis = await resolveAcceptanceDiagnosis({
-      ctx,
-      failures,
-      totalACs,
-      strategy,
-      semanticVerdicts,
-      diagnosisOpts: {
-        testOutput: failures.testOutput,
-        testFileContent,
-        acceptanceTestPath: effectiveAcceptanceTestPath,
-        workdir: ctx.workdir,
-        storyId: firstStory?.id
-      }
-    });
-    logger?.info("acceptance.diagnosis", "Diagnosis resolved", {
-      storyId: firstStory?.id,
-      verdict: diagnosis.verdict,
-      confidence: diagnosis.confidence,
-      attempt: acceptanceRetries
-    });
-    const cycleResult = await runAcceptanceFixCycle(ctx, prd, failures, diagnosis, effectiveAcceptanceTestPath, testCommand);
-    totalCost += cycleResult.costUsd ?? 0;
-    const success2 = cycleResult.exitReason === "resolved" || cycleResult.finalFindings.length === 0;
-    return buildResult(success2, prd, totalCost, iterations, storiesCompleted, prdDirty, success2 ? undefined : cycleResult.finalFindings.map((f) => f.message), acceptanceRetries + cycleResult.iterations.length);
+    const testEntries = ctx.acceptanceTestPaths ? await _acceptanceLoopDeps.loadAcceptanceTestContent(ctx.acceptanceTestPaths.map((p) => p.testPath)) : [];
+    const remainingFindings = [];
+    let totalInternalIterations = 0;
+    for (const pkg of failedPkgs) {
+      const { acceptanceTestPath, testCommand } = resolveAcceptanceFixTarget(ctx.acceptanceTestPaths, pkg, ctx.config);
+      const effectivePath = acceptanceTestPath || pkg.testPath || testEntries[0]?.testPath || "";
+      const testFileContent = testEntries.find((entry) => entry.testPath === effectivePath)?.content ?? "";
+      const pkgFailures = { failedACs: pkg.failedACs, testOutput: pkg.output };
+      const diagnosis = await resolveAcceptanceDiagnosis({
+        ctx,
+        failures: pkgFailures,
+        totalACs,
+        strategy,
+        semanticVerdicts,
+        diagnosisOpts: {
+          testOutput: pkg.output,
+          testFileContent,
+          acceptanceTestPath: effectivePath,
+          workdir: pkg.packageDir,
+          storyId: firstStory?.id
+        }
+      });
+      logger?.info("acceptance.diagnosis", "Diagnosis resolved", {
+        storyId: firstStory?.id,
+        packageDir: pkg.packageDir,
+        verdict: diagnosis.verdict,
+        confidence: diagnosis.confidence,
+        attempt: acceptanceRetries
+      });
+      const cycleResult = await runAcceptanceFixCycle(ctx, prd, pkgFailures, diagnosis, effectivePath, testCommand, {
+        packageDir: pkg.packageDir,
+        testPath: effectivePath
+      });
+      totalCost += cycleResult.costUsd ?? 0;
+      totalInternalIterations += cycleResult.iterations.length;
+      const pkgResolved = cycleResult.exitReason === "resolved" || cycleResult.finalFindings.length === 0;
+      if (!pkgResolved)
+        remainingFindings.push(...cycleResult.finalFindings);
+    }
+    const finalCheck = await runAcceptanceTestsOnce(ctx, prd);
+    const success2 = finalCheck.passed && remainingFindings.length === 0;
+    const failureMessages = !success2 ? finalCheck.failedACs.length > 0 ? finalCheck.failedACs : remainingFindings.length > 0 ? remainingFindings.map((f) => f.message) : ["acceptance validation failed (unknown cause)"] : undefined;
+    return buildResult(success2, prd, totalCost, iterations, storiesCompleted, prdDirty, failureMessages, acceptanceRetries + totalInternalIterations);
   }
   return buildResult(false, prd, totalCost, iterations, storiesCompleted, prdDirty);
 }
-var _acceptanceLoopDeps, _acceptanceFixCycleDeps, MAX_STUB_REGENS = 2;
+var _acceptanceLoopDeps, _acceptanceFixCycleDeps, _runAcceptanceTestsOnceDeps, MAX_STUB_REGENS = 2;
 var init_acceptance_loop = __esm(() => {
   init_acceptance2();
   init_findings();
@@ -62027,11 +62177,15 @@ var init_acceptance_loop = __esm(() => {
   init_acceptance_helpers();
   init_acceptance_helpers();
   _acceptanceLoopDeps = {
-    loadSemanticVerdicts
+    loadSemanticVerdicts,
+    loadAcceptanceTestContent
   };
   _acceptanceFixCycleDeps = {
     runFixCycle
   };
+  _runAcceptanceTestsOnceDeps = {
+    importAcceptanceStage: () => Promise.resolve().then(() => (init_acceptance3(), exports_acceptance2))
+  };
 });
 
 // src/session/scratch-purge.ts
@@ -62100,6 +62254,23 @@ var init_verification = __esm(() => {
 });
 
 // src/execution/lifecycle/run-regression.ts
+function buildRegressionFindings(summary, rawOutput) {
+  const structured = testSummaryToFindings(summary);
+  if (structured.length > 0)
+    return structured;
+  return [
+    {
+      source: "test-runner",
+      severity: "error",
+      category: "failed-test",
+      rule: "regression-suite",
+      message: `Full test suite is failing but no individual test failures could be parsed from the output. Diagnose and fix the underlying failure. Raw test output:
+
+${rawOutput.slice(0, SYNTHETIC_FINDING_OUTPUT_LIMIT)}`,
+      fixTarget: "source"
+    }
+  ];
+}
 async function findResponsibleStory(testFile, workdir, passedStories) {
   const logger = getSafeLogger();
   for (let i = passedStories.length - 1;i >= 0; i--) {
@@ -62311,7 +62482,7 @@ async function runDeferredRegression(options) {
       maxRectificationAttempts
     });
     const storyStartMs = Date.now();
-    const initialFindings = testSummaryToFindings(_regressionDeps.parseTestOutput(currentTestOutput));
+    const initialFindings = buildRegressionFindings(_regressionDeps.parseTestOutput(currentTestOutput), currentTestOutput);
     const packageView = runtime.packages.repo();
     const cycleCtx = {
       runtime,
@@ -62332,7 +62503,7 @@ async function runDeferredRegression(options) {
         if (verification.success)
           return [];
         if (verification.output)
-          return testSummaryToFindings(_regressionDeps.parseTestOutput(verification.output));
+          return buildRegressionFindings(_regressionDeps.parseTestOutput(verification.output), verification.output);
         return initialFindings;
       }
     };
@@ -62406,7 +62577,7 @@ async function runDeferredRegression(options) {
     storyOutcomes: storyOutcomeAccum
   };
 }
-var _regressionDeps;
+var SYNTHETIC_FINDING_OUTPUT_LIMIT = 2000, _regressionDeps;
 var init_run_regression = __esm(() => {
   init_findings();
   init_logger2();
@@ -64063,6 +64234,7 @@ function resolveMaxAttemptsOutcome(failureCategory) {
     case "isolation-violation":
     case "verifier-rejected":
     case "greenfield-no-tests":
+    case "no-tests-authored":
       return "pause";
     case "runtime-crash":
       return "pause";
@@ -64098,7 +64270,7 @@ async function handleTierEscalation(ctx) {
   const escalateRetryAsLite = ctx.pipelineResult.context.retryAsLite === true;
   const escalateFailureCategory = ctx.pipelineResult.context.tddFailureCategory;
   const escalateReviewFindings = ctx.pipelineResult.context.reviewFindings;
-  const escalateRetryAsTestAfter = escalateFailureCategory === "greenfield-no-tests";
+  const escalateRetryAsTddSimple = escalateFailureCategory === "greenfield-no-tests";
   const routingMode = ctx.config.routing.llm?.mode ?? "hybrid";
   if (!escalationResult || !ctx.config.autoMode.escalation.enabled) {
     return await handleNoTierAvailable(ctx, escalateFailureCategory);
@@ -64111,12 +64283,12 @@ async function handleTierEscalation(ctx) {
   const escalatedTier = escalationResult.tier;
   for (const s of storiesToEscalate) {
     const currentTestStrategy = s.routing?.testStrategy ?? ctx.routing.testStrategy;
-    const shouldSwitchToTestAfter = escalateRetryAsTestAfter && currentTestStrategy !== "test-after" && currentTestStrategy !== "no-test";
-    if (shouldSwitchToTestAfter) {
-      logger?.warn("escalation", "Switching strategy to test-after (greenfield-no-tests fallback)", {
+    const shouldSwitchToTddSimple = escalateRetryAsTddSimple && isThreeSessionStrategy(currentTestStrategy);
+    if (shouldSwitchToTddSimple) {
+      logger?.warn("escalation", "Switching strategy to tdd-simple (greenfield-no-tests fallback)", {
         storyId: s.id,
         fromStrategy: currentTestStrategy,
-        toStrategy: "test-after"
+        toStrategy: "tdd-simple"
       });
     } else {
       logger?.warn("escalation", "Escalating story to next tier", {
@@ -64137,19 +64309,19 @@ async function handleTierEscalation(ctx) {
       if (!shouldEscalate)
         return s;
       const currentTestStrategy = s.routing?.testStrategy ?? ctx.routing.testStrategy;
-      const shouldSwitchToTestAfter = escalateRetryAsTestAfter && currentTestStrategy !== "test-after" && currentTestStrategy !== "no-test";
+      const shouldSwitchToTddSimple = escalateRetryAsTddSimple && isThreeSessionStrategy(currentTestStrategy);
       const baseRouting = s.routing ?? { ...ctx.routing };
       const updatedRouting = {
         ...baseRouting,
-        modelTier: shouldSwitchToTestAfter ? baseRouting.modelTier : escalatedTier,
+        modelTier: shouldSwitchToTddSimple ? baseRouting.modelTier : escalatedTier,
         ...nextAgent !== undefined ? { agent: nextAgent } : {},
         ...escalateRetryAsLite ? { testStrategy: "three-session-tdd-lite" } : {},
-        ...shouldSwitchToTestAfter ? { testStrategy: "test-after" } : {}
+        ...shouldSwitchToTddSimple ? { testStrategy: "tdd-simple" } : {}
       };
       const currentStoryTier = s.routing?.modelTier ?? ctx.routing.modelTier;
       const isChangingTier = currentStoryTier !== escalatedTier;
-      const shouldResetAttempts = isChangingTier || shouldSwitchToTestAfter;
-      const escalationRecord = isChangingTier || shouldSwitchToTestAfter ? buildEscalationRecord(currentStoryTier, shouldSwitchToTestAfter ? currentStoryTier : escalatedTier, ctx.pipelineResult.reason ?? "Escalated to next retry path", { fromAgent: s.routing?.agent, toAgent: nextAgent }) : undefined;
+      const shouldResetAttempts = isChangingTier || shouldSwitchToTddSimple;
+      const escalationRecord = isChangingTier || shouldSwitchToTddSimple ? buildEscalationRecord(currentStoryTier, shouldSwitchToTddSimple ? currentStoryTier : escalatedTier, ctx.pipelineResult.reason ?? "Escalated to next retry path", { fromAgent: s.routing?.agent, toAgent: nextAgent }) : undefined;
       const escalationFailure = buildEscalationFailure(s, currentStoryTier, escalateReviewFindings, ctx.attemptCost, verifiedPipelineReason, escalateFailureCategory);
       return {
         ...s,
@@ -64188,6 +64360,7 @@ async function handleTierEscalation(ctx) {
 var _tierEscalationDeps;
 var init_tier_escalation = __esm(() => {
   init_pipeline();
+  init_config();
   init_hooks();
   init_logger2();
   init_prd();
@@ -97923,7 +98096,7 @@ var FIELD_DESCRIPTIONS = {
   "tdd.sessionTiers.verifier": "Model tier for verifier session",
   "tdd.testWriterAllowedPaths": "Glob patterns for files test-writer can modify",
   "tdd.rollbackOnFailure": "Rollback git changes when TDD fails",
-  "tdd.greenfieldDetection": "Force test-after on projects with no test files",
+  "tdd.greenfieldDetection": "Force tdd-simple on projects with no test files",
   constitution: "Constitution settings (core rules and constraints)",
   "constitution.enabled": "Enable constitution loading and injection",
   "constitution.path": "Path to constitution file (relative to nax/ directory)",

package/package.json

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