@nathapp/nax 0.64.1 → 0.64.2-canary.1

package/dist/nax.js

@@ -21027,7 +21027,7 @@ function reshapeSelector(name, fn) {
 }
 
 // src/config/selectors.ts
-var reviewConfigSelector, planConfigSelector, decomposeConfigSelector, rectifyConfigSelector, acceptanceConfigSelector, acceptanceFixConfigSelector, acceptanceGenConfigSelector, tddConfigSelector, debateConfigSelector, routingConfigSelector, verifyConfigSelector, rectificationGateConfigSelector, agentConfigSelector, agentManagerConfigSelector, interactionConfigSelector, precheckConfigSelector, qualityConfigSelector, testPatternConfigSelector, contextConfigSelector, contextToolRuntimeConfigSelector, promptLoaderConfigSelector, llmRoutingConfigSelector;
+var reviewConfigSelector, planConfigSelector, decomposeConfigSelector, rectifyConfigSelector, acceptanceConfigSelector, acceptanceFixConfigSelector, acceptanceGenConfigSelector, tddConfigSelector, debateConfigSelector, routingConfigSelector, verifyConfigSelector, rectificationGateConfigSelector, agentConfigSelector, agentManagerConfigSelector, interactionConfigSelector, precheckConfigSelector, qualityConfigSelector, autofixConfigSelector, testPatternConfigSelector, contextConfigSelector, contextToolRuntimeConfigSelector, promptLoaderConfigSelector, llmRoutingConfigSelector;
 var init_selectors = __esm(() => {
   reviewConfigSelector = pickSelector("review", "review", "debate", "models", "execution", "project", "quality", "agent");
   planConfigSelector = pickSelector("plan", "plan", "debate");
@@ -21049,6 +21049,7 @@ var init_selectors = __esm(() => {
   interactionConfigSelector = pickSelector("interaction", "interaction");
   precheckConfigSelector = pickSelector("precheck", "precheck", "quality", "execution", "prompts", "review", "project");
   qualityConfigSelector = pickSelector("quality", "quality", "execution");
+  autofixConfigSelector = pickSelector("autofix", "quality", "execution");
   testPatternConfigSelector = pickSelector("test-pattern", "execution", "project", "quality");
   contextConfigSelector = pickSelector("context", "context");
   contextToolRuntimeConfigSelector = pickSelector("context-tool-runtime", "context", "execution", "project", "quality");
@@ -21664,6 +21665,13 @@ var init_path_security2 = () => {};
 // src/context/engine/providers/code-neighbor.ts
 import { createHash as createHash3 } from "crypto";
 import { join as join6, relative, resolve as resolve5 } from "path";
+function isExcludedPath(file3, ignoreMatchers) {
+  for (const prefix of EXCLUDED_DIR_PREFIXES) {
+    if (file3.startsWith(prefix) || file3.includes(`/${prefix}`))
+      return true;
+  }
+  return ignoreMatchers.some((m) => m.test(file3));
+}
 function contentHash8(content) {
   return createHash3("sha256").update(content).digest("hex").slice(0, 8);
 }
@@ -21768,7 +21776,7 @@ function stripExt(s) {
 function isTestFile(filePath, regex) {
   return regex.some((re) => re.test(filePath));
 }
-async function collectNeighbors(filePath, workdir, extraGlobWorkdirs, siblingTestContext) {
+async function collectNeighbors(filePath, workdir, extraGlobWorkdirs, siblingTestContext, ignoreMatchers) {
   const neighbors = new Set;
   if (await _codeNeighborDeps.fileExists(join6(workdir, filePath))) {
     const content = await _codeNeighborDeps.readFile(join6(workdir, filePath));
@@ -21781,7 +21789,7 @@ async function collectNeighbors(filePath, workdir, extraGlobWorkdirs, siblingTes
   const fileBaseName = (filePath.split("/").pop() ?? filePath).replace(/\.[^.]+$/, "");
   const fileNoExt = filePath.replace(/\.[^.]+$/, "");
   const scanForReverseDeps = async (scanWorkdir) => {
-    const srcFiles = _codeNeighborDeps.glob(SOURCE_GLOB, scanWorkdir);
+    const srcFiles = _codeNeighborDeps.glob(SOURCE_GLOB, scanWorkdir, ignoreMatchers);
     for (const srcFile of srcFiles) {
       if (neighbors.size >= MAX_NEIGHBORS_PER_FILE)
         break;
@@ -21864,9 +21872,10 @@ class CodeNeighborProvider {
       globs: request.resolvedTestPatterns.globs,
       regex: request.resolvedTestPatterns.regex
     } : undefined;
+    const ignoreMatchers = request.naxIgnoreIndex?.getMatchers(workdir);
     const sections = [];
     for (const file3 of filesToProcess) {
-      const neighbors = await collectNeighbors(file3, workdir, extraGlobWorkdirs, siblingTestContext);
+      const neighbors = await collectNeighbors(file3, workdir, extraGlobWorkdirs, siblingTestContext, ignoreMatchers);
       if (neighbors.length > 0) {
         sections.push(`### ${file3}
 ${neighbors.map((n) => `- ${n}`).join(`
@@ -21899,22 +21908,34 @@ ${sections.join(`
     return { chunks: [chunk], pullTools: [] };
   }
 }
-var MAX_FILES = 10, MAX_NEIGHBORS_PER_FILE = 8, MAX_GLOB_FILES = 200, MAX_CHUNK_TOKENS = 500, SOURCE_GLOB = "src/**/*.{ts,tsx,js,jsx,py,go,rs,java,rb,php,cs,cpp,c,h}", _codeNeighborDeps, FROM_PATTERN, REQUIRE_PATTERN, IMPORT_SIDE_EFFECT_PATTERN;
+var MAX_FILES = 10, MAX_NEIGHBORS_PER_FILE = 8, MAX_GLOB_FILES = 200, MAX_CHUNK_TOKENS = 500, SOURCE_GLOB = "**/*.{ts,tsx,js,jsx,py,go,rs,java,rb,php,cs,cpp,c,h}", EXCLUDED_DIR_PREFIXES, _codeNeighborDeps, FROM_PATTERN, REQUIRE_PATTERN, IMPORT_SIDE_EFFECT_PATTERN;
 var init_code_neighbor = __esm(() => {
   init_logger2();
   init_workspace();
   init_path_security2();
+  EXCLUDED_DIR_PREFIXES = [
+    "node_modules/",
+    ".git/",
+    ".nax/",
+    "vendor/",
+    "dist/",
+    "build/",
+    "out/",
+    ".cache/"
+  ];
   _codeNeighborDeps = {
     fileExists: (path) => Bun.file(path).exists(),
     readFile: (path) => Bun.file(path).text(),
     discoverWorkspacePackages: (repoRoot) => discoverWorkspacePackages(repoRoot),
     getLogger,
-    glob: (pattern, cwd) => {
+    glob: (pattern, cwd, ignoreMatchers = []) => {
       const g = new Bun.Glob(pattern);
       const results = [];
       let count = 0;
       let truncated = false;
       for (const file3 of g.scanSync({ cwd, absolute: false })) {
+        if (isExcludedPath(file3, ignoreMatchers))
+          continue;
         if (count >= MAX_GLOB_FILES) {
           truncated = true;
           break;
@@ -24663,7 +24684,7 @@ async function gitLsFiles(workdir) {
   }
 }
 function isExcluded(path) {
-  return EXCLUDED_DIR_PREFIXES.some((prefix) => path.startsWith(prefix) || path.includes(`/${prefix}`));
+  return EXCLUDED_DIR_PREFIXES2.some((prefix) => path.startsWith(prefix) || path.includes(`/${prefix}`));
 }
 async function detectFromFileScan(workdir) {
   const files = await gitLsFiles(workdir);
@@ -24701,9 +24722,9 @@ async function detectFromFileScan(workdir) {
     patterns
   };
 }
-var EXCLUDED_DIR_PREFIXES, MIN_COUNT_THRESHOLD = 5, MIN_FRACTION_THRESHOLD = 0.1, CANDIDATE_SUFFIXES, SUFFIX_TO_GLOB, _fileScanDeps;
+var EXCLUDED_DIR_PREFIXES2, MIN_COUNT_THRESHOLD = 5, MIN_FRACTION_THRESHOLD = 0.1, CANDIDATE_SUFFIXES, SUFFIX_TO_GLOB, _fileScanDeps;
 var init_file_scan = __esm(() => {
-  EXCLUDED_DIR_PREFIXES = ["node_modules/", "dist/", "build/", ".nax/", "coverage/", ".git/"];
+  EXCLUDED_DIR_PREFIXES2 = ["node_modules/", "dist/", "build/", ".nax/", "coverage/", ".git/"];
   CANDIDATE_SUFFIXES = [
     ".test.ts",
     ".test.tsx",
@@ -27118,12 +27139,13 @@ function formatPriorFailures(failures) {
 **Review Findings (fix these issues):**`);
       for (const finding of failure.reviewFindings) {
         const source = finding.source ? ` (${finding.source})` : "";
+        const loc = finding.file ? `${finding.file}:${finding.line ?? 0}` : "global";
         parts.push(`
-- **[${finding.severity}]** \`${finding.file}:${finding.line}\`${source}`);
-        parts.push(`  **Rule:** ${finding.ruleId}`);
+- **[${finding.severity}]** \`${loc}\`${source}`);
+        parts.push(`  **Rule:** ${finding.rule ?? finding.category}`);
         parts.push(`  **Issue:** ${finding.message}`);
-        if (finding.url) {
-          parts.push(`  **Docs:** ${finding.url}`);
+        if (typeof finding.meta?.url === "string") {
+          parts.push(`  **Docs:** ${finding.meta.url}`);
         }
       }
     }
@@ -27685,7 +27707,7 @@ isolation scope: Implement source code in src/ to make tests pass. Do not modify
   if (role === "verifier") {
     return `${header}
 
-isolation scope: Read-only inspection. Review all test results, implementation code, and acceptance criteria compliance. You MAY write a verdict file (.nax-verifier-verdict.json) and apply legitimate fixes if needed.${footer}`;
+isolation scope: Read-only TDD integrity inspection. Review story-scoped test results and test-file modifications. Do NOT apply source or test fixes. You MAY write only the verdict file (.nax-verifier-verdict.json).${footer}`;
   }
   if (role === "single-session") {
     return `${header}
@@ -27783,17 +27805,18 @@ Instructions:
   if (role === "verifier") {
     return `# Role: Verifier
 
-Your task: Review and verify the implementation against acceptance criteria.
+Your task: verify the TDD handoff integrity for this story.
 
-Context: You are the final session in a multi-session workflow. A test-writer created tests, and an implementer wrote the code. The orchestrator has already run the full test suite and confirmed it passes before handing off to you.
+Context: You are the final session in a multi-session workflow. A test-writer created tests, and an implementer wrote the code. The orchestrator has already attempted the full-suite gate before handing off to you; it may have passed, failed, or exhausted rectification.
 
 Instructions:
 - Run ONLY the story's scoped test files \u2014 do NOT run the full test suite (the orchestrator already handled that)
-- Check that implementation meets all acceptance criteria from the story
-- Inspect code quality, error handling, and edge cases
+- Confirm the story-scoped tests pass
+- Check whether the implementer modified test files after the test-writer phase
 - Verify any test modifications (if any) are legitimate fixes, not shortcuts
+- Do NOT perform semantic acceptance review; semantic/adversarial review stages own acceptance criteria and broad code-quality findings
 - Write a detailed verdict with reasoning
-- Goal: verify story-scoped tests pass, provide comprehensive code review and quality assurance`;
+- Goal: verify story-scoped tests pass and test integrity was preserved`;
   }
   if (role === "single-session") {
     return `# Role: Single-Session
@@ -27911,16 +27934,13 @@ After completing your verification, you **MUST** write a verdict file at the **p
 **File:** \`.nax-verifier-verdict.json\`
 
 Set \`approved: true\` when ALL of these conditions are met:
-- All story-scoped tests pass (the orchestrator already confirmed the full suite passes \u2014 you only need to verify the story's own tests)
-- Implementation is clean and follows conventions
-- All acceptance criteria met
+- All story-scoped tests pass (the orchestrator already attempted the full-suite gate \u2014 you only need to verify the story's own tests)
 - Any test modifications by implementer are legitimate fixes
 
 Set \`approved: false\` when ANY of these conditions are true:
 - Tests are failing and you cannot fix them
 - The implementer loosened test assertions to mask bugs
-- Critical acceptance criteria are not met
-- Code quality is poor (security issues, severe bugs, etc.)
+- The implementer made illegitimate test changes
 
 **JSON schema** (fill in all fields with real values):
 
@@ -27931,10 +27951,11 @@ Set \`approved: false\` when ANY of these conditions are true:
 **Field notes:**
 - \`quality.rating\` must be one of: \`"good"\`, \`"acceptable"\`, \`"poor"\`
 - \`testModifications.files\` \u2014 list any test files the implementer changed
-- \`fixes\` \u2014 list any fixes you applied yourself during this verification session
+- \`acceptanceCriteria\` and \`quality\` are advisory in this TDD verifier verdict; do not use them to reject semantic correctness
+- \`fixes\` \u2014 keep this empty; the verifier must not apply code or test fixes
 - \`reasoning\` \u2014 brief summary of your overall assessment
 
-When done, commit any fixes with message: "fix: verify and adjust ${story.title}"`;
+When done, do not commit code changes. Only write the verdict file.`;
 }
 
 // src/prompts/sections/conventions.ts
@@ -28397,7 +28418,7 @@ ${c.output}`).join(`
 `);
   }
   buildReReviewPrompt(updatedDiff, previousFindings) {
-    const findingsList = previousFindings.length > 0 ? previousFindings.map((f) => `- ${f.ruleId}: ${f.message}`).join(`
+    const findingsList = previousFindings.length > 0 ? previousFindings.map((f) => `- ${f.rule ?? "semantic"}: ${f.message}`).join(`
 `) : "(none)";
     return [
       "This is a follow-up re-review. Please review the updated diff below.",
@@ -28442,7 +28463,7 @@ ${c.output}`).join(`
   }
   buildReResolverPrompt(proposals, critiques, diffContext, previousFindings, resolverContext) {
     const framing = this.buildResolverFraming(resolverContext);
-    const findingsList = previousFindings.length > 0 ? previousFindings.map((f) => `- ${f.ruleId}: ${f.message}`).join(`
+    const findingsList = previousFindings.length > 0 ? previousFindings.map((f) => `- ${f.rule ?? "semantic"}: ${f.message}`).join(`
 `) : "(none)";
     const proposalsSection = this.buildLabeledProposalsSection(proposals);
     const critiquesSection = this.buildLabeledCritiquesSection(critiques);
@@ -28655,6 +28676,58 @@ function tryParseLLMJson(text) {
   }
 }
 
+// src/prompts/builders/prior-iterations-builder.ts
+function buildPriorIterationsBlock(iterations) {
+  if (iterations.length === 0)
+    return "";
+  const rows = iterations.map((iter) => {
+    const strategies = iter.fixesApplied.map((fa) => fa.strategyName).join(", ") || "-";
+    const files = iter.fixesApplied.flatMap((fa) => fa.targetFiles).join(", ") || "-";
+    const outcome = iter.outcome;
+    const findingSummary = formatFindingSummary(iter.findingsBefore, iter.findingsAfter);
+    return `| ${iter.iterationNum} | ${strategies} | ${files} | ${outcome} | ${findingSummary} |`;
+  });
+  const header = "| # | Strategies run | Files touched | Outcome | Findings before \u2192 after |";
+  const separator = "|---|----------------|---------------|---------|--------------------------|";
+  const table = [header, separator, ...rows].join(`
+`);
+  const hasUnchanged = iterations.some((i) => i.outcome === "unchanged");
+  const unchangedNote = hasUnchanged ? `
+When outcome is "unchanged", the prior hypothesis is FALSIFIED \u2014 the change did not affect what was tested. Choose a different category before producing a new verdict. Do NOT repeat fixes listed above.` : "";
+  return `## Prior Iterations \u2014 verdict required before new analysis
+
+${table}${unchangedNote}
+
+`;
+}
+function formatFindingSummary(before, after) {
+  const beforeStr = before.length === 0 ? "0" : formatFindingCount(before);
+  const afterStr = after.length === 0 ? "0" : formatFindingCount(after);
+  return `${beforeStr} \u2192 ${afterStr}`;
+}
+function formatFindingCount(findings) {
+  const count = findings.length;
+  const topCategory = mostFrequentCategory(findings);
+  return topCategory !== null ? `${count} [${topCategory}]` : `${count}`;
+}
+function mostFrequentCategory(findings) {
+  if (findings.length === 0)
+    return null;
+  const freq = new Map;
+  for (const f of findings) {
+    freq.set(f.category, (freq.get(f.category) ?? 0) + 1);
+  }
+  let top = null;
+  let topCount = 0;
+  for (const [cat, cnt] of freq) {
+    if (cnt > topCount) {
+      topCount = cnt;
+      top = cat;
+    }
+  }
+  return top;
+}
+
 // src/prompts/builders/review-builder.ts
 class ReviewPromptBuilder {
   buildSemanticReviewPrompt(story, semanticConfig, options) {
@@ -28665,7 +28738,7 @@ class ReviewPromptBuilder {
 ${semanticConfig.rules.map((r, i) => `${i + 1}. ${r}`).join(`
 `)}
 ` : "";
-    const attemptContextBlock = buildAttemptContextBlock(options.priorFailures);
+    const priorIterationsBlock = buildPriorIterationsBlock(options.priorSemanticIterations ?? []);
     let diffSection;
     if (options.mode === "ref") {
       diffSection = buildRefDiffSection(options.storyGitRef ?? "", options.stat ?? "", options.excludePatterns ?? []);
@@ -28681,7 +28754,7 @@ ${story.description}
 
 ### Acceptance Criteria
 ${acList}
-${customRulesBlock}${attemptContextBlock}${diffSection}
+${customRulesBlock}${priorIterationsBlock}${diffSection}
 ${SEMANTIC_INSTRUCTIONS}
 ${SEMANTIC_OUTPUT_SCHEMA}`;
     return wrapJsonPrompt(core2);
@@ -28705,17 +28778,6 @@ Output ONLY a complete, valid JSON object. It must start with { and end with }.
 Schema: {"passed": boolean, "findings": [{"severity": string, "category": string, "file": string, "line": number, "issue": string, "suggestion": string}]}`;
   }
 }
-function buildAttemptContextBlock(priorFailures) {
-  if (!priorFailures || priorFailures.length === 0)
-    return "";
-  const attemptNumber = priorFailures.length + 1;
-  const stages = priorFailures.map((f) => f.stage).join(", ");
-  return `## Attempt Context
-This is escalation attempt ${attemptNumber}. Prior attempts failed at stages: ${stages}.
-The diff shows the NET result of all changes since story start \u2014 verify against the current codebase state.
-
-`;
-}
 function buildEmbeddedDiffSection(diff) {
   return `## Git Diff (production code only \u2014 test files excluded)
 
@@ -28769,7 +28831,7 @@ Do NOT flag: style issues, naming conventions, import ordering, file length, or
   "passed": boolean,
   "findings": [
     {
-      "severity": "error" | "warn" | "info" | "unverifiable",
+      "severity": "error" | "warning" | "info" | "unverifiable",
       "file": "path/to/file",
       "line": 42,
       "issue": "description of the issue",
@@ -28853,25 +28915,6 @@ ${testInventory.addedTestFiles.map((f) => `  - ${f}`).join(`
 \`\`\`diff
 ${diff}\`\`\`
 
-`;
-}
-function buildPriorFindingsBlock(round, findings) {
-  const rows = findings.map((f) => {
-    const location = f.line !== undefined ? `${f.file}:${f.line}` : f.file;
-    const category = f.category ?? "\u2014";
-    return `| ${f.severity} | ${category} | ${location} | ${f.issue} |`;
-  }).join(`
-`);
-  return `## Prior Adversarial Findings \u2014 Round ${round}
-
-The following issues were flagged in the previous adversarial review round.
-**Verdict on each of these first \u2014 determine whether each has been fixed, partially addressed, or is still present.**
-Then continue scanning for new issues.
-
-| Severity | Category | Location | Issue |
-|:---------|:---------|:---------|:------|
-${rows}
-
 `;
 }
 
@@ -28882,14 +28925,13 @@ class AdversarialReviewPromptBuilder {
       diff,
       storyGitRef,
       stat,
-      priorFailures,
       testInventory,
       excludePatterns,
       testGlobs,
       refExcludePatterns,
-      priorAdversarialFindings
+      priorAdversarialIterations
     } = options;
-    const priorFindingsBlock = priorAdversarialFindings && priorAdversarialFindings.findings.length > 0 ? buildPriorFindingsBlock(priorAdversarialFindings.round, priorAdversarialFindings.findings) : "";
+    const priorFindingsBlock = buildPriorIterationsBlock(priorAdversarialIterations ?? []);
     const storyBlock = `## Story Under Review
 
 **ID:** ${story.id}
@@ -28907,7 +28949,6 @@ ${config2.rules.map((r) => `- ${r}`).join(`
 `)}
 
 ` : "";
-    const attemptBlock = buildAttemptContextBlock(priorFailures);
     let diffBlock;
     if (mode === "ref" && storyGitRef) {
       diffBlock = buildAdversarialRefDiffSection(storyGitRef, stat, excludePatterns ?? [], testGlobs ?? [], refExcludePatterns ?? []);
@@ -28936,7 +28977,6 @@ ${config2.rules.map((r) => `- ${r}`).join(`
       `
 
 `,
-      attemptBlock,
       diffBlock
     ].join("");
   }
@@ -28998,7 +29038,7 @@ Respond with ONLY a JSON object \u2014 no preamble, no explanation outside the J
   "passed": true | false,
   "findings": [
     {
-      "severity": "error" | "warn" | "info" | "unverifiable",
+      "severity": "error" | "warning" | "info" | "unverifiable",
       "category": "input" | "error-path" | "abandonment" | "test-gap" | "convention" | "assumption",
       "file": "relative/path/to/file.ts",
       "line": 42,
@@ -29011,15 +29051,13 @@ Respond with ONLY a JSON object \u2014 no preamble, no explanation outside the J
 
 Severity guide:
 - \`"error"\`: confident this will cause real failure or regression
-- \`"warn"\`: fragile or incomplete but may ship without immediate breakage
+- \`"warning"\`: fragile or incomplete but may ship without immediate breakage
 - \`"info"\`: noteworthy but not actionable as a blocker
 - \`"unverifiable"\`: suspect problem but couldn't confirm from available artifacts
 
-\`passed\` must be \`false\` if any finding has severity \`"error"\` or \`"warn"\`.
+\`passed\` must be \`false\` if any finding has severity \`"error"\` or \`"warning"\`.
 \`passed\` may be \`true\` with findings if all findings are \`"info"\` or \`"unverifiable"\`.`;
-var init_adversarial_review_builder = __esm(() => {
-  init_review_builder();
-});
+var init_adversarial_review_builder = () => {};
 
 // src/prompts/builders/acceptance-builder.ts
 class AcceptancePromptBuilder {
@@ -29036,9 +29074,6 @@ ${f.content}
 \`\`\``).join(`
 
 `)}` : "";
-    const prevFailureSection = p.previousFailure && p.previousFailure.length > 0 ? `
-
-Previous test failed because: ${p.previousFailure}` : "";
     return `You are a senior test engineer. Your task is to generate a complete acceptance test file for the "${p.featureName}" feature.
 
 ${STEP1}
@@ -29052,7 +29087,7 @@ ${STEP3_HEADER}
 ${STEP3_SHARED_RULES}
 - **File output (REQUIRED)**: Write the acceptance test file DIRECTLY to the path shown below. Do NOT output the test code in your response. After writing the file, reply with a brief confirmation.
 - **Path anchor (CRITICAL)**: Write the test file to this exact path: \`${p.targetTestFilePath}\`. Import from package sources using relative paths like \`../../../src/...\` (3 levels up from \`.nax/features/<name>/\` to the package root).
-- **Process cwd**: When spawning child processes to invoke a CLI or binary, set the working directory to the **package root** (\`join(import.meta.dir, "../../..")\`) as your default \u2014 unless your Step 2 exploration reveals the CLI uses a different working directory convention (e.g. reads config from \`~/.config/\`, or resolves paths relative to a flag value). Always check how the CLI resolves file paths before assuming.${implSection}${prevFailureSection}`;
+- **Process cwd**: When spawning child processes to invoke a CLI or binary, set the working directory to the **package root** (\`join(import.meta.dir, "../../..")\`) as your default \u2014 unless your Step 2 exploration reveals the CLI uses a different working directory convention (e.g. reads config from \`~/.config/\`, or resolves paths relative to a flag value). Always check how the CLI resolves file paths before assuming.${implSection}`;
   }
   buildGeneratorFromSpecPrompt(p) {
     return `You are a senior test engineer. Your task is to generate a complete acceptance test file for the "${p.featureName}" feature.
@@ -29070,6 +29105,21 @@ ${STEP3_SHARED_RULES}
 - **Path anchor (CRITICAL)**: This test file will be saved at \`<repo-root>/.nax/features/${p.featureName}/${p.resolvedTestPath}\` and will ALWAYS run from the repo root. The repo root is exactly 3 \`../\` levels above \`__dirname\`: \`join(__dirname, '..', '..', '..')\`. For monorepo projects, navigate into packages from root (e.g. \`join(root, 'apps/api/src')\`).`;
   }
   buildDiagnosisPromptTemplate(p) {
+    const responseSchema = `{
+  "verdict": "source_bug" | "test_bug" | "both",
+  "reasoning": "Your analysis explaining why this is a source_bug, test_bug, or both",
+  "confidence": 0.0-1.0,
+  "findings": [
+    {
+      "fixTarget": "source" | "test",
+      "category": "stdout-capture" | "ac-mismatch" | "framework-misuse" | "missing-impl" | "import-path" | "hook-failure" | "test-runner-error" | "stub-test" | "other",
+      "file": "optional/path/relative/to/workdir.ts",
+      "line": 0,
+      "message": "Concrete description of the issue",
+      "suggestion": "Optional concrete fix suggestion"
+    }
+  ]
+}`;
     return `You are a debugging expert. An acceptance test has failed.
 
 TASK: Diagnose whether the failure is due to a bug in the SOURCE CODE or a bug in the TEST CODE.
@@ -29084,15 +29134,9 @@ ${p.testFileContent}
 
 SOURCE FILES (auto-detected from imports, up to ${p.maxFileLines} lines each):
 ${p.sourceFilesSection}
-${p.verdictSection}${p.previousFailureSection}
+${p.verdictSection}
 Respond with ONLY a JSON object in this exact format (no markdown, no extra text):
-{
-  "verdict": "source_bug" | "test_bug" | "both",
-  "reasoning": "Your analysis explaining why this is a source_bug, test_bug, or both",
-  "confidence": 0.0-1.0,
-  "testIssues": ["Issue in test code if any"],
-  "sourceIssues": ["Issue in source code if any"]
-}`;
+${responseSchema}`;
   }
   buildSourceFixPrompt(p) {
     let prompt = `ACCEPTANCE TEST FAILURE:
@@ -29104,6 +29148,8 @@ ${p.testOutput}
 ${p.diagnosisReasoning}
 
 `;
+    if (p.priorIterationsBlock)
+      prompt += p.priorIterationsBlock;
     prompt += `ACCEPTANCE TEST FILE: ${p.acceptanceTestPath}
 
 `;
@@ -29167,17 +29213,12 @@ ${f.content}
 SEMANTIC VERDICTS:
 ${p.semanticVerdicts.map((v) => `- ${v.storyId}: ${v.passed ? "likely test bug (semantic review confirmed AC implementation)" : "unconfirmed"}`).join(`
 `)}
-` : "";
-    const previousFailureSection = p.previousFailure && p.previousFailure.length > 0 ? `
-PREVIOUS FIX ATTEMPTS:
-${p.previousFailure}
 ` : "";
     return this.buildDiagnosisPromptTemplate({
       truncatedOutput,
       testFileContent: p.testFileContent,
       sourceFilesSection,
       verdictSection,
-      previousFailureSection,
       maxFileLines: MAX_FILE_LINES
     });
   }
@@ -29277,12 +29318,8 @@ ${p.testOutput}
 ${p.diagnosisReasoning}
 
 `;
-    if (p.previousFailure && p.previousFailure.length > 0) {
-      prompt += `PREVIOUS FAILED ATTEMPTS:
-${p.previousFailure}
-
-`;
-    }
+    if (p.priorIterationsBlock)
+      prompt += p.priorIterationsBlock;
     prompt += `ACCEPTANCE TEST FILE: ${p.acceptanceTestPath}
 
 `;
@@ -31876,8 +31913,7 @@ var init_acceptance_generate = __esm(() => {
         criteriaList: input.criteriaList,
         frameworkOverrideLine: input.frameworkOverrideLine,
         targetTestFilePath: input.targetTestFilePath,
-        implementationContext: input.implementationContext,
-        previousFailure: input.previousFailure
+        implementationContext: input.implementationContext
       });
       return {
         role: { id: "role", content: "", overridable: false },
@@ -31990,8 +32026,7 @@ var init_acceptance_diagnose = __esm(() => {
         testOutput: input.testOutput,
         testFileContent: input.testFileContent,
         sourceFiles: input.sourceFiles,
-        semanticVerdicts: input.semanticVerdicts,
-        previousFailure: input.previousFailure
+        semanticVerdicts: input.semanticVerdicts
       });
       return {
         role: { id: "role", content: "", overridable: false },
@@ -32001,13 +32036,26 @@ var init_acceptance_diagnose = __esm(() => {
     parse(output, _input, _ctx) {
       const raw = tryParseLLMJson(output);
       if (raw && typeof raw.verdict === "string" && typeof raw.reasoning === "string" && typeof raw.confidence === "number") {
-        return {
+        const base = {
           verdict: raw.verdict,
           reasoning: raw.reasoning,
-          confidence: raw.confidence,
-          testIssues: Array.isArray(raw.testIssues) ? raw.testIssues : undefined,
-          sourceIssues: Array.isArray(raw.sourceIssues) ? raw.sourceIssues : undefined
+          confidence: raw.confidence
         };
+        if (Array.isArray(raw.findings) && raw.findings.length > 0) {
+          const findings = raw.findings.filter((f) => typeof f.message === "string" && typeof f.category === "string").map((f) => ({
+            source: "acceptance-diagnose",
+            severity: typeof f.severity === "string" ? f.severity : "error",
+            category: String(f.category),
+            message: String(f.message),
+            fixTarget: f.fixTarget ?? undefined,
+            file: typeof f.file === "string" ? f.file : undefined,
+            line: typeof f.line === "number" ? f.line : undefined,
+            suggestion: typeof f.suggestion === "string" ? f.suggestion : undefined
+          }));
+          if (findings.length > 0)
+            return { ...base, findings };
+        }
+        return base;
       }
       return FALLBACK;
     }
@@ -32030,6 +32078,7 @@ var init_acceptance_fix = __esm(() => {
       const prompt = new AcceptancePromptBuilder().buildSourceFixPrompt({
         testOutput: input.testOutput,
         diagnosisReasoning: input.diagnosisReasoning,
+        priorIterationsBlock: input.priorIterationsBlock,
         acceptanceTestPath: input.acceptanceTestPath,
         testFileContent: input.testFileContent
       });
@@ -32053,10 +32102,10 @@ var init_acceptance_fix = __esm(() => {
       const prompt = new AcceptancePromptBuilder().buildTestFixPrompt({
         testOutput: input.testOutput,
         diagnosisReasoning: input.diagnosisReasoning,
+        priorIterationsBlock: input.priorIterationsBlock,
         failedACs: input.failedACs,
         acceptanceTestPath: input.acceptanceTestPath,
-        testFileContent: input.testFileContent ?? "",
-        previousFailure: input.previousFailure
+        testFileContent: input.testFileContent ?? ""
       });
       return {
         role: { id: "role", content: "", overridable: false },
@@ -32069,32 +32118,120 @@ var init_acceptance_fix = __esm(() => {
   };
 });
 
-// src/review/truncation.ts
-function looksLikeTruncatedJson(raw) {
-  return raw.trimEnd().length >= MAX_AGENT_OUTPUT_CHARS - 100;
-}
-var init_truncation = __esm(() => {
-  init_adapter();
+// src/review/severity.ts
+var SEVERITY_RANK;
+var init_severity = __esm(() => {
+  SEVERITY_RANK = {
+    info: 0,
+    unverifiable: 0,
+    low: 1,
+    warning: 1,
+    error: 2,
+    critical: 3
+  };
 });
 
-// src/operations/types.ts
-function parseLlmReviewShape(raw) {
-  if (typeof raw !== "object" || raw === null)
+// src/review/semantic-helpers.ts
+function validateLLMShape(parsed) {
+  if (typeof parsed !== "object" || parsed === null)
     return null;
-  const obj = raw;
+  const obj = parsed;
   if (typeof obj.passed !== "boolean")
     return null;
   if (!Array.isArray(obj.findings))
     return null;
   return { passed: obj.passed, findings: obj.findings };
 }
+function parseLLMResponse(raw) {
+  try {
+    return validateLLMShape(tryParseLLMJson(raw));
+  } catch {
+    return null;
+  }
+}
+function formatFindings(findings) {
+  return findings.map((f) => `[${f.severity}] ${f.file}:${f.line} \u2014 ${f.issue}
+  Suggestion: ${f.suggestion}`).join(`
+`);
+}
+function normalizeSeverity(sev) {
+  if (sev === "warn")
+    return "warning";
+  if (sev === "critical" || sev === "error" || sev === "warning" || sev === "info" || sev === "low" || sev === "unverifiable")
+    return sev;
+  return "info";
+}
+function isBlockingSeverity(sev, threshold = "error") {
+  return (SEVERITY_RANK[sev] ?? 0) >= (SEVERITY_RANK[threshold] ?? 2);
+}
+function sanitizeRefModeFindings(findings, diffMode) {
+  if (diffMode !== "ref")
+    return findings;
+  return findings.map((finding) => needsDowngradeForMissingEvidence(finding) ? downgradeToUnverifiable(finding) : finding);
+}
+function needsDowngradeForMissingEvidence(finding) {
+  if ((SEVERITY_RANK[finding.severity] ?? 0) < SEVERITY_RANK.error)
+    return false;
+  return mentionsUnverifiedSource(finding) || !hasVerifiedEvidence(finding);
+}
+function mentionsUnverifiedSource(finding) {
+  const text = `${finding.issue} ${finding.suggestion}`.toLowerCase();
+  return UNVERIFIED_FINDING_PATTERNS.some((pattern) => text.includes(pattern));
+}
+function hasVerifiedEvidence(finding) {
+  const evidence = finding.verifiedBy;
+  return !!evidence?.file?.trim() && !!evidence.observed?.trim();
+}
+function downgradeToUnverifiable(finding) {
+  return {
+    ...finding,
+    severity: "unverifiable"
+  };
+}
+function llmFindingToFinding(f) {
+  return {
+    source: "semantic-review",
+    severity: normalizeSeverity(f.severity),
+    category: "",
+    file: f.file,
+    line: f.line,
+    message: f.issue,
+    suggestion: f.suggestion ?? undefined,
+    fixTarget: "source",
+    meta: f.verifiedBy ? { verifiedBy: f.verifiedBy } : undefined
+  };
+}
+function toReviewFindings(findings) {
+  return findings.map(llmFindingToFinding);
+}
+var UNVERIFIED_FINDING_PATTERNS;
+var init_semantic_helpers = __esm(() => {
+  init_severity();
+  UNVERIFIED_FINDING_PATTERNS = [
+    "cannot verify",
+    "can't verify",
+    "from diff alone",
+    "missing from diff",
+    "not found in diff",
+    "not present in diff",
+    "does not appear in diff"
+  ];
+});
+
+// src/review/truncation.ts
+function looksLikeTruncatedJson(raw) {
+  return raw.trimEnd().length >= MAX_AGENT_OUTPUT_CHARS - 100;
+}
+var init_truncation = __esm(() => {
+  init_adapter();
+});
 
 // src/operations/semantic-review.ts
 var FAIL_OPEN, semanticReviewHopBody = async (initialPrompt, ctx) => {
   const first = await ctx.send(initialPrompt);
   const isTruncated = looksLikeTruncatedJson(first.output);
   const parsed = tryParseLLMJson(first.output);
-  if (!isTruncated && parsed && parseLlmReviewShape(parsed))
+  if (!isTruncated && parsed && validateLLMShape(parsed))
     return first;
   const retryPrompt = isTruncated ? ReviewPromptBuilder.jsonRetryCondensed({ blockingThreshold: ctx.input.blockingThreshold }) : ReviewPromptBuilder.jsonRetry();
   if (isTruncated) {
@@ -32114,6 +32251,7 @@ var init_semantic_review = __esm(() => {
   init_config();
   init_logger2();
   init_prompts();
+  init_semantic_helpers();
   init_truncation();
   FAIL_OPEN = { passed: true, findings: [], failOpen: true };
   semanticReviewOp = {
@@ -32131,7 +32269,7 @@ var init_semantic_review = __esm(() => {
         diff: input.diff,
         storyGitRef: input.storyGitRef,
         stat: input.stat,
-        priorFailures: input.priorFailures,
+        priorSemanticIterations: input.priorSemanticIterations,
         excludePatterns: input.excludePatterns
       });
       const content = input.featureCtxBlock ? `${input.featureCtxBlock}${base}` : base;
@@ -32142,9 +32280,9 @@ var init_semantic_review = __esm(() => {
     },
     parse(output, _input, _ctx) {
       const raw = tryParseLLMJson(output);
-      const parsed = parseLlmReviewShape(raw);
+      const parsed = validateLLMShape(raw);
       if (parsed)
-        return parsed;
+        return { passed: parsed.passed, findings: parsed.findings };
       if (/"passed"\s*:\s*false/.test(output))
         return { passed: false, findings: [], looksLikeFail: true };
       return FAIL_OPEN;
@@ -32152,12 +32290,54 @@ var init_semantic_review = __esm(() => {
   };
 });
 
+// src/review/adversarial-helpers.ts
+function validateAdversarialShape(parsed) {
+  if (typeof parsed !== "object" || parsed === null)
+    return null;
+  const obj = parsed;
+  if (typeof obj.passed !== "boolean")
+    return null;
+  if (!Array.isArray(obj.findings))
+    return null;
+  return { passed: obj.passed, findings: obj.findings };
+}
+function formatFindings2(findings) {
+  return findings.map((f) => `[${f.severity}][${f.category}] ${f.file}:${f.line} \u2014 ${f.issue}
+  Suggestion: ${f.suggestion}`).join(`
+`);
+}
+function normalizeSeverity2(sev) {
+  if (sev === "warn")
+    return "warning";
+  if (sev === "critical" || sev === "error" || sev === "warning" || sev === "info" || sev === "low" || sev === "unverifiable")
+    return sev;
+  return "info";
+}
+function isBlockingSeverity2(sev, threshold = "error") {
+  return (SEVERITY_RANK[sev] ?? 0) >= (SEVERITY_RANK[threshold] ?? 2);
+}
+function toAdversarialReviewFindings(findings) {
+  return findings.map((f) => ({
+    source: "adversarial-review",
+    severity: normalizeSeverity2(f.severity),
+    category: f.category,
+    file: f.file,
+    line: f.line,
+    message: f.issue,
+    suggestion: f.suggestion,
+    fixTarget: f.category === "test-gap" ? "test" : undefined
+  }));
+}
+var init_adversarial_helpers = __esm(() => {
+  init_severity();
+});
+
 // src/operations/adversarial-review.ts
 var FAIL_OPEN2, adversarialReviewHopBody = async (initialPrompt, ctx) => {
   const first = await ctx.send(initialPrompt);
   const isTruncated = looksLikeTruncatedJson(first.output);
   const parsed = tryParseLLMJson(first.output);
-  if (!isTruncated && parsed && parseLlmReviewShape(parsed))
+  if (!isTruncated && parsed && validateAdversarialShape(parsed))
     return first;
   const retryPrompt = isTruncated ? ReviewPromptBuilder.jsonRetryCondensed({ blockingThreshold: ctx.input.blockingThreshold }) : ReviewPromptBuilder.jsonRetry();
   if (isTruncated) {
@@ -32177,6 +32357,7 @@ var init_adversarial_review = __esm(() => {
   init_config();
   init_logger2();
   init_prompts();
+  init_adversarial_helpers();
   init_truncation();
   FAIL_OPEN2 = { passed: true, findings: [], failOpen: true };
   adversarialReviewOp = {
@@ -32194,12 +32375,11 @@ var init_adversarial_review = __esm(() => {
         diff: input.diff,
         storyGitRef: input.storyGitRef,
         stat: input.stat,
-        priorFailures: input.priorFailures,
         testInventory: input.testInventory,
         excludePatterns: input.excludePatterns,
         testGlobs: input.testGlobs,
         refExcludePatterns: input.refExcludePatterns,
-        priorAdversarialFindings: input.priorAdversarialFindings
+        priorAdversarialIterations: input.priorAdversarialIterations
       });
       const content = input.featureCtxBlock ? `${input.featureCtxBlock}${base}` : base;
       return {
@@ -32209,9 +32389,9 @@ var init_adversarial_review = __esm(() => {
     },
     parse(output, _input, _ctx) {
       const raw = tryParseLLMJson(output);
-      const parsed = parseLlmReviewShape(raw);
+      const parsed = validateAdversarialShape(raw);
       if (parsed)
-        return parsed;
+        return { passed: parsed.passed, findings: parsed.findings };
       if (/"passed"\s*:\s*false/.test(output))
         return { passed: false, findings: [], looksLikeFail: true };
       return FAIL_OPEN2;
@@ -32225,6 +32405,55 @@ var init_rectify = __esm(() => {
   init_prompts();
 });
 
+// src/operations/autofix-implementer.ts
+var implementerRectifyOp;
+var init_autofix_implementer = __esm(() => {
+  init_config();
+  init_prompts();
+  implementerRectifyOp = {
+    kind: "run",
+    name: "autofix-implementer",
+    stage: "rectification",
+    session: { role: "implementer", lifetime: "fresh" },
+    config: autofixConfigSelector,
+    build(input, _ctx) {
+      const prompt = RectifierPromptBuilder.reviewRectification(input.failedChecks, input.story);
+      return {
+        role: { id: "role", content: "", overridable: false },
+        task: { id: "task", content: prompt, overridable: false }
+      };
+    },
+    parse(output, _input, _ctx) {
+      const match = output.match(/^UNRESOLVED:\s*(.+)$/ms);
+      return { applied: true, ...match ? { unresolvedReason: match[1]?.trim() } : {} };
+    }
+  };
+});
+
+// src/operations/autofix-test-writer.ts
+var testWriterRectifyOp;
+var init_autofix_test_writer = __esm(() => {
+  init_config();
+  init_prompts();
+  testWriterRectifyOp = {
+    kind: "run",
+    name: "autofix-test-writer",
+    stage: "rectification",
+    session: { role: "test-writer", lifetime: "fresh" },
+    config: autofixConfigSelector,
+    build(input, _ctx) {
+      const prompt = RectifierPromptBuilder.testWriterRectification(input.failedChecks, input.story);
+      return {
+        role: { id: "role", content: "", overridable: false },
+        task: { id: "task", content: prompt, overridable: false }
+      };
+    },
+    parse(_output, _input, _ctx) {
+      return { applied: true };
+    }
+  };
+});
+
 // src/operations/debate-propose.ts
 var debateProposeOp;
 var init_debate_propose = __esm(() => {
@@ -32645,7 +32874,8 @@ async function runTddSessionOp(op, options, beforeRef, contextBundle, sessionBin
       break;
   }
   const interactionBridge = includeContext ? buildInteractionBridge(interactionChain, { featureName, storyId: story.id, stage: "execution" }) : undefined;
-  return runTddSession(role, agent, agentManager, story, config2, workdir, tier, beforeRef, includeContext ? contextMarkdown : undefined, lite, skipIsolation, constitution, featureName, interactionBridge, projectDir, includeContext ? featureContextMarkdown : undefined, contextBundle, sessionBinding, abortSignal);
+  const verifierLimitedContext = role === "verifier";
+  return runTddSession(role, agent, agentManager, story, config2, workdir, tier, beforeRef, includeContext ? contextMarkdown : undefined, lite, skipIsolation, verifierLimitedContext ? undefined : constitution, featureName, interactionBridge, projectDir, includeContext ? featureContextMarkdown : undefined, verifierLimitedContext ? undefined : contextBundle, sessionBinding, abortSignal);
 }
 var writeTddTestOp, implementTddOp, verifyTddOp;
 var init_session_op = __esm(() => {
@@ -32764,6 +32994,8 @@ var init_operations = __esm(() => {
   init_semantic_review();
   init_adversarial_review();
   init_rectify();
+  init_autofix_implementer();
+  init_autofix_test_writer();
   init_debate_propose();
   init_debate_rebut();
   init_write_test();
@@ -39538,6 +39770,393 @@ var init_runner2 = __esm(() => {
   init_logger2();
 });
 
+// src/findings/types.ts
+function findingKey(f) {
+  return JSON.stringify([f.source, f.file ?? null, f.line ?? null, f.rule ?? null, f.message]);
+}
+var SEVERITY_ORDER;
+var init_types7 = __esm(() => {
+  SEVERITY_ORDER = Object.freeze({
+    critical: 5,
+    error: 4,
+    warning: 3,
+    info: 2,
+    low: 1,
+    unverifiable: 0
+  });
+});
+
+// src/findings/path-utils.ts
+import { relative as relative9, resolve as resolve14 } from "path";
+function rebaseToWorkdir(rawPath, cwd, workdir) {
+  if (rawPath.startsWith("/")) {
+    return relative9(workdir, rawPath);
+  }
+  return relative9(workdir, resolve14(cwd, rawPath));
+}
+var init_path_utils = () => {};
+
+// src/findings/adapters/lint.ts
+function lintDiagnosticToFinding(d, workdir, tool) {
+  return {
+    source: "lint",
+    tool,
+    severity: d.severity ?? "warning",
+    category: "lint",
+    rule: d.ruleId,
+    file: rebaseToWorkdir(d.file, workdir, workdir),
+    line: d.line,
+    column: d.column,
+    message: d.message
+  };
+}
+var init_lint = __esm(() => {
+  init_path_utils();
+});
+
+// src/findings/adapters/plugin.ts
+function pluginToFinding(rf, _workdir) {
+  return {
+    source: "plugin",
+    tool: rf.source ?? "plugin",
+    severity: rf.severity,
+    category: rf.category ?? "general",
+    rule: rf.ruleId,
+    file: rf.file,
+    line: rf.line,
+    column: rf.column,
+    endLine: rf.endLine,
+    endColumn: rf.endColumn,
+    message: rf.message,
+    meta: rf.url ? { url: rf.url } : undefined
+  };
+}
+
+// src/findings/adapters/semantic-review.ts
+function reviewFindingToFinding(f) {
+  return {
+    source: "semantic-review",
+    severity: f.severity,
+    category: f.category ?? "",
+    rule: f.ruleId,
+    file: f.file,
+    line: f.line,
+    column: f.column,
+    endLine: f.endLine,
+    endColumn: f.endColumn,
+    message: f.message,
+    fixTarget: "source"
+  };
+}
+
+// src/findings/adapters/test-runner.ts
+function extractExcerpt(output, acId) {
+  const lines = output.split(`
+`);
+  const idx = lines.findIndex((l) => l.toLowerCase().includes(acId.toLowerCase()));
+  if (idx === -1)
+    return `${acId} failed`;
+  const end = Math.min(lines.length, idx + 5);
+  return lines.slice(idx, end).join(`
+`).trim() || `${acId} failed`;
+}
+function acFailureToFinding(acId, output) {
+  return {
+    source: "test-runner",
+    severity: "error",
+    category: "assertion-failure",
+    rule: acId,
+    message: extractExcerpt(output, acId),
+    fixTarget: "source"
+  };
+}
+function acSentinelToFinding(sentinel, _output) {
+  if (sentinel === "AC-HOOK") {
+    return {
+      source: "test-runner",
+      severity: "error",
+      category: "hook-failure",
+      message: "beforeAll/afterAll hook timed out",
+      fixTarget: "test"
+    };
+  }
+  return {
+    source: "test-runner",
+    severity: "critical",
+    category: "test-runner-error",
+    message: "Test runner crashed before test bodies ran",
+    fixTarget: "test"
+  };
+}
+
+// src/findings/adapters/typecheck.ts
+function tscDiagnosticToFinding(d, workdir) {
+  return {
+    source: "typecheck",
+    tool: "tsc",
+    severity: "error",
+    category: "type-error",
+    rule: d.code ? `TS${d.code}` : undefined,
+    file: rebaseToWorkdir(d.file, workdir, workdir),
+    line: d.line,
+    column: d.column,
+    message: d.message
+  };
+}
+var init_typecheck = __esm(() => {
+  init_path_utils();
+});
+
+// src/findings/adapters/index.ts
+var init_adapters = __esm(() => {
+  init_lint();
+  init_typecheck();
+});
+
+// src/findings/cycle.ts
+function classifySingleSource(before, after) {
+  const beforeKeys = new Set(before.map(findingKey));
+  const afterKeys = new Set(after.map(findingKey));
+  if (afterKeys.size === 0 && beforeKeys.size === 0)
+    return "resolved";
+  if (afterKeys.size === 0)
+    return "resolved";
+  const hasNew = [...afterKeys].some((k) => !beforeKeys.has(k));
+  const hasResolved = [...beforeKeys].some((k) => !afterKeys.has(k));
+  if (hasNew && !hasResolved)
+    return "regressed";
+  if (!hasNew && !hasResolved)
+    return "unchanged";
+  if (hasNew && hasResolved)
+    return "regressed";
+  return "partial";
+}
+function classifyOutcome(before, after) {
+  if (before.length === 0 && after.length === 0)
+    return "resolved";
+  if (before.length === 0)
+    return "regressed";
+  const beforeSources = new Set(before.map((f) => f.source));
+  const afterSources = new Set(after.map((f) => f.source));
+  const newSources = [...afterSources].filter((s) => !beforeSources.has(s));
+  if (newSources.length > 0)
+    return "regressed-different-source";
+  const sources = [...beforeSources];
+  const perSource = sources.map((source) => classifySingleSource(before.filter((f) => f.source === source), after.filter((f) => f.source === source)));
+  if (perSource.every((o) => o === "resolved"))
+    return "resolved";
+  if (perSource.some((o) => o === "regressed"))
+    return "regressed";
+  if (perSource.every((o) => o === "unchanged"))
+    return "unchanged";
+  return "partial";
+}
+function selectActiveStrategies(strategies, findings, verdict) {
+  if (findings.length > 0) {
+    return strategies.filter((s) => findings.some((f) => s.appliesTo(f)));
+  }
+  if (verdict !== undefined) {
+    return strategies.filter((s) => s.appliesToVerdict?.(verdict) ?? false);
+  }
+  return [];
+}
+function selectExecutionGroup(active) {
+  const exclusive = active.find((s) => !s.coRun || s.coRun === "exclusive");
+  if (exclusive)
+    return [exclusive];
+  return active.filter((s) => s.coRun === "co-run-sequential");
+}
+function countStrategyAttempts(iterations, strategyName) {
+  return iterations.reduce((sum, iter) => sum + iter.fixesApplied.filter((fa) => fa.strategyName === strategyName).length, 0);
+}
+function countTotalAttempts(iterations) {
+  return iterations.reduce((sum, iter) => sum + iter.fixesApplied.length, 0);
+}
+async function runFixCycle(cycle, ctx, cycleName, _deps = {}) {
+  const logger = getSafeLogger();
+  const doCallOp = _deps.callOp ?? _cycleDeps.callOp;
+  const now = _deps.now ?? _cycleDeps.now;
+  const storyId = ctx.storyId;
+  const packageDir = ctx.packageDir;
+  let totalCostUsd = 0;
+  for (;; ) {
+    if (cycle.findings.length === 0 && cycle.verdict === undefined) {
+      return { iterations: cycle.iterations, finalFindings: [], exitReason: "resolved", costUsd: totalCostUsd };
+    }
+    const active = selectActiveStrategies(cycle.strategies, cycle.findings, cycle.verdict);
+    if (active.length === 0) {
+      logger?.info("findings.cycle", "cycle exited \u2014 no matching strategy", {
+        storyId,
+        packageDir,
+        cycleName,
+        reason: "no-strategy",
+        findingsCount: cycle.findings.length
+      });
+      return {
+        iterations: cycle.iterations,
+        finalFindings: cycle.findings,
+        exitReason: "no-strategy",
+        costUsd: totalCostUsd
+      };
+    }
+    for (const strategy of active) {
+      const attempts = countStrategyAttempts(cycle.iterations, strategy.name);
+      if (attempts >= strategy.maxAttempts) {
+        logger?.info("findings.cycle", "cycle exited \u2014 strategy attempt cap reached", {
+          storyId,
+          packageDir,
+          cycleName,
+          reason: "max-attempts-per-strategy",
+          exhaustedStrategy: strategy.name,
+          attempts,
+          maxAttempts: strategy.maxAttempts
+        });
+        return {
+          iterations: cycle.iterations,
+          finalFindings: cycle.findings,
+          exitReason: "max-attempts-per-strategy",
+          exhaustedStrategy: strategy.name,
+          costUsd: totalCostUsd
+        };
+      }
+    }
+    const totalAttempts = countTotalAttempts(cycle.iterations);
+    if (totalAttempts >= cycle.config.maxAttemptsTotal) {
+      logger?.info("findings.cycle", "cycle exited \u2014 total attempt cap reached", {
+        storyId,
+        packageDir,
+        cycleName,
+        reason: "max-attempts-total",
+        totalAttempts,
+        maxAttemptsTotal: cycle.config.maxAttemptsTotal
+      });
+      return {
+        iterations: cycle.iterations,
+        finalFindings: cycle.findings,
+        exitReason: "max-attempts-total",
+        costUsd: totalCostUsd
+      };
+    }
+    for (const strategy of active) {
+      const bailReason = strategy.bailWhen?.(cycle.iterations) ?? null;
+      if (bailReason !== null) {
+        logger?.info("findings.cycle", "cycle exited \u2014 bail predicate fired", {
+          storyId,
+          packageDir,
+          cycleName,
+          reason: "bail-when",
+          strategyName: strategy.name,
+          bailDetail: bailReason
+        });
+        return {
+          iterations: cycle.iterations,
+          finalFindings: cycle.findings,
+          exitReason: "bail-when",
+          bailDetail: bailReason,
+          costUsd: totalCostUsd
+        };
+      }
+    }
+    const group = selectExecutionGroup(active);
+    const startedAt = now();
+    const findingsBefore = [...cycle.findings];
+    const fixesApplied = [];
+    for (const strategy of group) {
+      const relevantFindings = findingsBefore.filter((f) => strategy.appliesTo(f));
+      const input = strategy.buildInput(relevantFindings, cycle.iterations, ctx);
+      const output = await doCallOp(ctx, strategy.fixOp, input);
+      const extracted = strategy.extractApplied?.(output, input) ?? {};
+      fixesApplied.push({
+        strategyName: strategy.name,
+        op: strategy.fixOp.name,
+        targetFiles: extracted.targetFiles ?? [],
+        summary: extracted.summary ?? "",
+        costUsd: extracted.costUsd
+      });
+    }
+    let findingsAfter;
+    let validatorAttempt = 0;
+    for (;; ) {
+      try {
+        findingsAfter = await cycle.validate(ctx);
+        break;
+      } catch (err) {
+        if (validatorAttempt >= cycle.config.validatorRetries) {
+          logger?.error("findings.cycle", "cycle exited \u2014 validator error", {
+            storyId,
+            packageDir,
+            cycleName,
+            reason: "validator-error",
+            error: errorMessage(err)
+          });
+          return {
+            iterations: cycle.iterations,
+            finalFindings: cycle.findings,
+            exitReason: "validator-error",
+            costUsd: totalCostUsd
+          };
+        }
+        logger?.warn("findings.cycle", "validator retry", {
+          storyId,
+          packageDir,
+          cycleName,
+          attempt: validatorAttempt + 1,
+          error: errorMessage(err)
+        });
+        validatorAttempt++;
+      }
+    }
+    const outcome = classifyOutcome(findingsBefore, findingsAfter);
+    const finishedAt = now();
+    const iterationNum = cycle.iterations.length + 1;
+    const iteration = {
+      iterationNum,
+      findingsBefore,
+      fixesApplied,
+      findingsAfter,
+      outcome,
+      startedAt,
+      finishedAt
+    };
+    cycle.iterations.push(iteration);
+    cycle.findings = findingsAfter;
+    const iterationCostUsd = fixesApplied.reduce((sum, fa) => sum + (fa.costUsd ?? 0), 0);
+    totalCostUsd += iterationCostUsd;
+    logger?.info("findings.cycle", "iteration completed", {
+      storyId,
+      packageDir,
+      cycleName,
+      iterationNum,
+      strategiesRan: fixesApplied.map((fa) => fa.strategyName),
+      outcome,
+      findingsBefore: findingsBefore.length,
+      findingsAfter: findingsAfter.length,
+      ...iterationCostUsd > 0 ? { costUsd: iterationCostUsd } : {}
+    });
+    if (outcome === "resolved") {
+      return { iterations: cycle.iterations, finalFindings: [], exitReason: "resolved", costUsd: totalCostUsd };
+    }
+  }
+}
+var _cycleDeps;
+var init_cycle = __esm(() => {
+  init_logger2();
+  init_call();
+  init_types7();
+  _cycleDeps = {
+    callOp,
+    now: () => new Date().toISOString()
+  };
+});
+
+// src/findings/index.ts
+var init_findings = __esm(() => {
+  init_types7();
+  init_adapters();
+  init_path_utils();
+  init_cycle();
+});
+
 // src/utils/log-test-output.ts
 function logTestOutput(logger, stage, output, opts = {}) {
   if (!logger || !output)
@@ -39719,6 +40338,7 @@ var _acceptanceStageDeps, parseTestFailures2, acceptanceStage;
 var init_acceptance2 = __esm(() => {
   init_generator();
   init_test_path();
+  init_findings();
   init_logger2();
   init_prd();
   init_ac_parser();
@@ -39754,6 +40374,7 @@ var init_acceptance2 = __esm(() => {
         }
       ];
       const allFailedACs = [];
+      const allFindings = [];
       const allOutputParts = [];
       let anyError = false;
       let errorExitCode = 0;
@@ -39806,11 +40427,13 @@ ${stderr}`;
           anyError = true;
           errorExitCode = exitCode;
           allFailedACs.push("AC-ERROR");
+          allFindings.push(acSentinelToFinding("AC-ERROR", output));
           continue;
         }
         for (const acId of actualFailures) {
           if (!allFailedACs.includes(acId)) {
             allFailedACs.push(acId);
+            allFindings.push(acId === "AC-HOOK" ? acSentinelToFinding("AC-HOOK", output) : acFailureToFinding(acId, output));
           }
         }
         if (actualFailures.length > 0) {
@@ -39861,6 +40484,7 @@ ${stderr}`;
       }
       ctx.acceptanceFailures = {
         failedACs: allFailedACs,
+        findings: allFindings,
         testOutput: combinedOutput
       };
       if (anyError) {
@@ -40092,8 +40716,7 @@ ${stderr}` };
             criteriaList,
             frameworkOverrideLine,
             targetTestFilePath: testPath,
-            ..."implementationContext" in ctx && ctx.implementationContext ? { implementationContext: ctx.implementationContext } : {},
-            ..."previousFailure" in ctx && ctx.previousFailure ? { previousFailure: ctx.previousFailure } : {}
+            ..."implementationContext" in ctx && ctx.implementationContext ? { implementationContext: ctx.implementationContext } : {}
           }, groupStoryId);
           const testCode = genResult.testCode;
           if (testCode) {
@@ -40361,10 +40984,10 @@ async function executeWithTimeout(command, timeoutSeconds, env2, options) {
   const timeoutMs = timeoutSeconds * 1000;
   let timedOut = false;
   const timer = { id: undefined };
-  const timeoutPromise = new Promise((resolve14) => {
+  const timeoutPromise = new Promise((resolve15) => {
     timer.id = setTimeout(() => {
       timedOut = true;
-      resolve14();
+      resolve15();
     }, timeoutMs);
   });
   const processPromise = proc.exited;
@@ -40378,8 +41001,8 @@ async function executeWithTimeout(command, timeoutSeconds, env2, options) {
       proc.exited.then(() => {
         exitedDuringGrace = true;
       }),
-      new Promise((resolve14) => {
-        setTimeout(resolve14, gracePeriodMs);
+      new Promise((resolve15) => {
+        setTimeout(resolve15, gracePeriodMs);
       })
     ]);
     if (!exitedDuringGrace) {
@@ -40557,7 +41180,7 @@ var init_runners = __esm(() => {
 });
 
 // src/verification/smart-runner.ts
-import { join as join33, relative as relative9 } from "path";
+import { join as join33, relative as relative10 } from "path";
 function extractPatternSuffix(pattern) {
   const lastStar = pattern.lastIndexOf("*");
   if (lastStar === -1)
@@ -40665,7 +41288,7 @@ async function getChangedNonTestFiles(workdir, baseRef, packagePrefix, testFileR
     let effectivePrefix = packagePrefix;
     if (packagePrefix && repoRoot) {
       const gitRoot = await _gitUtilDeps.getGitRoot(workdir);
-      const extraPrefix2 = gitRoot && gitRoot !== repoRoot ? relative9(gitRoot, repoRoot) : "";
+      const extraPrefix2 = gitRoot && gitRoot !== repoRoot ? relative10(gitRoot, repoRoot) : "";
       effectivePrefix = extraPrefix2 ? `${extraPrefix2}/${packagePrefix}` : packagePrefix;
     }
     const scopedRaw = effectivePrefix ? lines.filter((f) => f.startsWith(`${effectivePrefix}/`)) : lines;
@@ -40692,7 +41315,7 @@ async function getChangedTestFiles(workdir, repoRoot, baseRef, packagePrefix, te
     const packageDir = packagePrefix ? join33(repoRoot, packagePrefix) : undefined;
     const ignoreMatchers = naxIgnoreIndex?.getMatchers(packageDir) ?? await resolveNaxIgnorePatterns(repoRoot, packageDir);
     const gitRoot = await _gitUtilDeps.getGitRoot(workdir);
-    const extraPrefix = gitRoot && gitRoot !== repoRoot ? relative9(gitRoot, repoRoot) : "";
+    const extraPrefix = gitRoot && gitRoot !== repoRoot ? relative10(gitRoot, repoRoot) : "";
     const effectivePrefix = packagePrefix ? extraPrefix ? `${extraPrefix}/${packagePrefix}` : packagePrefix : undefined;
     const scopedRaw = effectivePrefix ? lines.filter((f) => f.startsWith(`${effectivePrefix}/`)) : lines;
     const scoped = filterNaxInternalPaths(scopedRaw, ignoreMatchers);
@@ -40977,6 +41600,158 @@ var init_event_bus = __esm(() => {
   pipelineEventBus = new PipelineEventBus;
 });
 
+// src/pipeline/stages/autofix-cycle.ts
+import { join as join35 } from "path";
+function fixCallCtx(ctx) {
+  const packageView = ctx.packageView ?? ctx.runtime.packages.repo();
+  return {
+    runtime: ctx.runtime,
+    packageView,
+    packageDir: ctx.workdir,
+    storyId: ctx.story.id,
+    featureName: ctx.prd.feature,
+    agentName: ctx.agentManager.getDefault(),
+    story: ctx.story
+  };
+}
+function collectFailedChecks(ctx) {
+  return (ctx.reviewResult?.checks ?? []).filter((c) => !c.success);
+}
+function collectCurrentFindings(ctx) {
+  const checks3 = collectFailedChecks(ctx);
+  if (checks3.length === 0)
+    return [];
+  return checks3.flatMap((c) => {
+    if (c.findings?.length)
+      return c.findings;
+    return [
+      {
+        source: c.check === "adversarial" ? "adversarial-review" : c.check === "semantic" ? "semantic-review" : "lint",
+        severity: "error",
+        category: c.check,
+        message: (c.output ?? c.check).slice(0, 200),
+        fixTarget: "source"
+      }
+    ];
+  });
+}
+function collectTestTargetedChecks(ctx) {
+  return collectFailedChecks(ctx).filter((c) => c.findings?.some((f) => f.fixTarget === "test"));
+}
+function buildAutofixStrategies(ctx, maxAttempts) {
+  const implementer = {
+    name: "autofix-implementer",
+    appliesTo: (f) => (f.fixTarget ?? "source") === "source",
+    fixOp: implementerRectifyOp,
+    maxAttempts,
+    coRun: "co-run-sequential",
+    buildInput: (_findings, _prior, _cycleCtx) => ({
+      failedChecks: collectFailedChecks(ctx),
+      story: ctx.story
+    }),
+    extractApplied: (output) => ({
+      summary: output.unresolvedReason ?? ""
+    })
+  };
+  const testWriter = {
+    name: "autofix-test-writer",
+    appliesTo: (f) => f.fixTarget === "test",
+    fixOp: testWriterRectifyOp,
+    maxAttempts: 1,
+    coRun: "co-run-sequential",
+    buildInput: (_findings, _prior, _cycleCtx) => ({
+      failedChecks: collectTestTargetedChecks(ctx),
+      story: ctx.story
+    })
+  };
+  return [implementer, testWriter];
+}
+function findUnresolvedReason(result) {
+  for (const iter of result.iterations) {
+    for (const fa of iter.fixesApplied) {
+      if (fa.strategyName === "autofix-implementer" && fa.summary) {
+        return fa.summary;
+      }
+    }
+  }
+  return;
+}
+async function writeShadowReport(ctx, result, initialFindingsCount) {
+  const logger = getLogger();
+  const shadowDir = join35(ctx.workdir, ".nax", "cycle-shadow", ctx.story.id);
+  const timestamp = new Date().toISOString().replace(/[:.]/g, "-");
+  const report = {
+    storyId: ctx.story.id,
+    timestamp,
+    initialFindingsCount,
+    exitReason: result.exitReason,
+    iterations: result.iterations.length,
+    finalFindingsCount: result.finalFindings.length,
+    ...result.exhaustedStrategy ? { exhaustedStrategy: result.exhaustedStrategy } : {}
+  };
+  try {
+    const file3 = join35(shadowDir, `${timestamp}.json`);
+    await Bun.write(file3, JSON.stringify(report, null, 2));
+  } catch (err) {
+    logger.debug("autofix-cycle", "Shadow report write failed (non-fatal)", {
+      storyId: ctx.story.id,
+      error: String(err)
+    });
+  }
+}
+async function runAgentRectificationV2(ctx, _lintFixCmd, _formatFixCmd, _effectiveWorkdir) {
+  const logger = getLogger();
+  const storyId = ctx.story.id;
+  const cycleCtx = fixCallCtx(ctx);
+  const initialFindings = collectCurrentFindings(ctx);
+  const maxAttempts = ctx.config.quality.autofix?.maxAttempts ?? 3;
+  const maxTotalAttempts = ctx.config.quality.autofix?.maxTotalAttempts ?? 12;
+  logger.info("autofix-cycle", "Starting V2 fix cycle", {
+    storyId,
+    initialFindingsCount: initialFindings.length,
+    maxAttempts,
+    maxTotalAttempts
+  });
+  const cycle = {
+    findings: initialFindings,
+    iterations: [...ctx.autofixPriorIterations ?? []],
+    strategies: buildAutofixStrategies(ctx, maxAttempts),
+    config: {
+      maxAttemptsTotal: maxTotalAttempts,
+      validatorRetries: 1
+    },
+    async validate(_cycleCtx) {
+      await _autofixDeps.recheckReview(ctx);
+      return collectCurrentFindings(ctx);
+    }
+  };
+  const result = await runFixCycle(cycle, cycleCtx, "autofix-v2");
+  ctx.autofixPriorIterations = result.iterations;
+  await writeShadowReport(ctx, result, initialFindings.length);
+  const unresolvedReason = findUnresolvedReason(result);
+  const succeeded = result.exitReason === "resolved" || result.finalFindings.length === 0;
+  logger.info("autofix-cycle", "V2 fix cycle complete", {
+    storyId,
+    exitReason: result.exitReason,
+    iterations: result.iterations.length,
+    finalFindingsCount: result.finalFindings.length,
+    succeeded,
+    ...unresolvedReason ? { unresolvedReason } : {}
+  });
+  return { succeeded, cost: 0, ...unresolvedReason ? { unresolvedReason } : {} };
+}
+var init_autofix_cycle = __esm(() => {
+  init_findings();
+  init_logger2();
+  init_operations();
+  init_autofix();
+});
+
+// src/pipeline/stages/autofix-agent.ts
+var init_autofix_agent = __esm(() => {
+  init_autofix_cycle();
+});
+
 // src/review/lint-parsing/strategies/biome-json.ts
 function asRecord(value) {
   return typeof value === "object" && value !== null ? value : null;
@@ -41223,12 +41998,24 @@ function strategiesFor(format) {
     return [];
   return [eslintJsonStrategy, biomeJsonStrategy, textBlockStrategy];
 }
-function parseLintOutput(output, format = "auto") {
+function toolForFormat(format) {
+  if (format === "biome-json")
+    return "biome";
+  if (format === "eslint-json")
+    return "eslint";
+  return "text";
+}
+function parseLintOutput(output, format = "auto", opts) {
   if (!output.trim())
     return null;
   for (const strategy of strategiesFor(format)) {
     const parsed = strategy.parse(output);
     if (parsed && parsed.diagnostics.length > 0) {
+      if (opts) {
+        const tool = toolForFormat(parsed.format);
+        const findings = parsed.diagnostics.map((d) => lintDiagnosticToFinding(d, opts.workdir, tool));
+        return { ...parsed, findings };
+      }
       return parsed;
     }
   }
@@ -41242,6 +42029,7 @@ function formatDiagnosticsOutput(diagnostics) {
 `).trim() || null;
 }
 var init_parse3 = __esm(() => {
+  init_findings();
   init_biome_json();
   init_eslint_json();
   init_text_block();
@@ -41438,12 +42226,16 @@ function strategiesFor2(format) {
     return [];
   return [tscStrategy, typecheckTextBlockStrategy];
 }
-function parseTypecheckOutput(output, format = "auto") {
+function parseTypecheckOutput(output, format = "auto", opts) {
   if (!output.trim())
     return null;
   for (const strategy of strategiesFor2(format)) {
     const parsed = strategy.parse(output);
     if (parsed && parsed.diagnostics.length > 0) {
+      if (opts) {
+        const findings = parsed.diagnostics.map((d) => tscDiagnosticToFinding(d, opts.workdir));
+        return { ...parsed, findings };
+      }
       return parsed;
     }
   }
@@ -41457,6 +42249,7 @@ function formatTypecheckDiagnosticsOutput(diagnostics) {
 `).trim() || null;
 }
 var init_parse4 = __esm(() => {
+  init_findings();
   init_text_block2();
   init_tsc();
 });
@@ -41493,49 +42286,84 @@ function splitByStructuredFindings(check2, testFilePatterns) {
   };
   return { testFindings: toCheck(testFs), sourceFindings: toCheck(sourceFs) };
 }
-function splitByOutputParsing(check2, testFilePatterns, format = "auto") {
-  const parsed = parseLintOutput(check2.output, format);
+function deriveFixTarget(file3, testFilePatterns) {
+  return file3 && isTestFile2(file3, testFilePatterns) ? "test" : "source";
+}
+function splitFindingsByFixTarget(findings, diagnostics, testFilePatterns) {
+  const testDiagnostics = [];
+  const sourceDiagnostics = [];
+  for (let i = 0;i < findings.length; i++) {
+    const diagnostic = diagnostics[i];
+    if (!diagnostic) {
+      throw new NaxError(`findings and diagnostics arrays are not co-produced: length mismatch at index ${i}`, "INVARIANT_VIOLATION", {
+        stage: "autofix-scope-split",
+        index: i,
+        findingsCount: findings.length,
+        diagnosticsCount: diagnostics.length
+      });
+    }
+    const f = findings[i];
+    const target = f.fixTarget ?? deriveFixTarget(f.file, testFilePatterns);
+    (target === "test" ? testDiagnostics : sourceDiagnostics).push(diagnostic);
+  }
+  return { testDiagnostics, sourceDiagnostics };
+}
+function splitByOutputParsing(check2, testFilePatterns, format = "auto", opts) {
+  const parsed = parseLintOutput(check2.output, format, opts);
   if (!parsed) {
     if (check2.output.trim()) {
       return { testFindings: null, sourceFindings: check2 };
     }
     return { testFindings: null, sourceFindings: null };
   }
-  const testDiagnostics = parsed.diagnostics.filter((d) => isTestFile2(d.file, testFilePatterns));
-  const sourceDiagnostics = parsed.diagnostics.filter((d) => !isTestFile2(d.file, testFilePatterns));
+  let testDiagnostics;
+  let sourceDiagnostics;
+  if (parsed.findings) {
+    ({ testDiagnostics, sourceDiagnostics } = splitFindingsByFixTarget(parsed.findings, parsed.diagnostics, testFilePatterns));
+  } else {
+    testDiagnostics = parsed.diagnostics.filter((d) => isTestFile2(d.file, testFilePatterns));
+    sourceDiagnostics = parsed.diagnostics.filter((d) => !isTestFile2(d.file, testFilePatterns));
+  }
   return {
     testFindings: buildScopedLintCheck(check2, testDiagnostics),
     sourceFindings: buildScopedLintCheck(check2, sourceDiagnostics)
   };
 }
-function splitByTypecheckOutputParsing(check2, testFilePatterns, format = "auto") {
-  const parsed = parseTypecheckOutput(check2.output, format);
+function splitByTypecheckOutputParsing(check2, testFilePatterns, format = "auto", opts) {
+  const parsed = parseTypecheckOutput(check2.output, format, opts);
   if (!parsed) {
     if (check2.output.trim()) {
       return { testFindings: null, sourceFindings: check2 };
     }
     return { testFindings: null, sourceFindings: null };
   }
-  const testDiagnostics = parsed.diagnostics.filter((d) => isTestFile2(d.file, testFilePatterns));
-  const sourceDiagnostics = parsed.diagnostics.filter((d) => !isTestFile2(d.file, testFilePatterns));
+  let testDiagnostics;
+  let sourceDiagnostics;
+  if (parsed.findings) {
+    ({ testDiagnostics, sourceDiagnostics } = splitFindingsByFixTarget(parsed.findings, parsed.diagnostics, testFilePatterns));
+  } else {
+    testDiagnostics = parsed.diagnostics.filter((d) => isTestFile2(d.file, testFilePatterns));
+    sourceDiagnostics = parsed.diagnostics.filter((d) => !isTestFile2(d.file, testFilePatterns));
+  }
   return {
     testFindings: buildScopedTypecheckCheck(check2, testDiagnostics),
     sourceFindings: buildScopedTypecheckCheck(check2, sourceDiagnostics)
   };
 }
-function splitFindingsByScope(check2, testFilePatterns, lintOutputFormat = "auto", typecheckOutputFormat = "auto") {
+function splitFindingsByScope(check2, testFilePatterns, lintOutputFormat = "auto", typecheckOutputFormat = "auto", opts) {
   if (check2.check === "adversarial") {
     return splitByStructuredFindings(check2, testFilePatterns);
   }
   if (check2.check === "lint") {
-    return splitByOutputParsing(check2, testFilePatterns, lintOutputFormat);
+    return splitByOutputParsing(check2, testFilePatterns, lintOutputFormat, opts);
   }
   if (check2.check === "typecheck") {
-    return splitByTypecheckOutputParsing(check2, testFilePatterns, typecheckOutputFormat);
+    return splitByTypecheckOutputParsing(check2, testFilePatterns, typecheckOutputFormat, opts);
   }
   return { testFindings: null, sourceFindings: null };
 }
 var init_autofix_scope_split = __esm(() => {
+  init_errors();
   init_lint_parsing();
   init_typecheck_parsing();
   init_test_runners();
@@ -41591,7 +42419,7 @@ async function runTestWriterRectification(ctx, testWriterChecks, story, agentMan
     return 0;
   }
 }
-var init_autofix_test_writer = __esm(() => {
+var init_autofix_test_writer2 = __esm(() => {
   init_config();
   init_errors();
   init_logger2();
@@ -41600,25 +42428,28 @@ var init_autofix_test_writer = __esm(() => {
 });
 
 // src/review/dialogue.ts
+function findingId(f) {
+  return f.rule ?? `${f.file ?? ""}:${f.line ?? 0}:${f.message.slice(0, 40)}`;
+}
 function extractDeltaSummary(rawOutput, previousFindings, newFindings) {
   const parsed = tryParseLLMJson(rawOutput);
   if (parsed && typeof parsed.deltaSummary === "string" && parsed.deltaSummary.length > 0) {
     return parsed.deltaSummary;
   }
-  const newIds = new Set(newFindings.map((f) => f.ruleId));
-  const prevIds = new Set(previousFindings.map((f) => f.ruleId));
-  const resolved = previousFindings.filter((f) => !newIds.has(f.ruleId));
-  const stillPresent = newFindings.filter((f) => prevIds.has(f.ruleId));
-  const added = newFindings.filter((f) => !prevIds.has(f.ruleId));
+  const newIds = new Set(newFindings.map(findingId));
+  const prevIds = new Set(previousFindings.map(findingId));
+  const resolved = previousFindings.filter((f) => !newIds.has(findingId(f)));
+  const stillPresent = newFindings.filter((f) => prevIds.has(findingId(f)));
+  const added = newFindings.filter((f) => !prevIds.has(findingId(f)));
   const parts = [];
   if (resolved.length > 0) {
-    parts.push(`Resolved: ${resolved.map((f) => f.ruleId).join(", ")}.`);
+    parts.push(`Resolved: ${resolved.map(findingId).join(", ")}.`);
   }
   if (stillPresent.length > 0) {
-    parts.push(`Still present: ${stillPresent.map((f) => f.ruleId).join(", ")}.`);
+    parts.push(`Still present: ${stillPresent.map(findingId).join(", ")}.`);
   }
   if (added.length > 0) {
-    parts.push(`New findings: ${added.map((f) => f.ruleId).join(", ")}.`);
+    parts.push(`New findings: ${added.map(findingId).join(", ")}.`);
   }
   if (parts.length === 0) {
     return previousFindings.length > 0 ? "All previous findings resolved." : "No changes from previous review.";
@@ -41641,24 +42472,21 @@ function compactHistory(history) {
   history.push(lastReviewer);
   return summary;
 }
-function mapLLMFindingToReviewFinding(f) {
+function mapLLMFindingToFinding(f) {
   const rawSeverity = typeof f.severity === "string" ? f.severity : "info";
   let severity = "info";
   if (rawSeverity === "warn" || rawSeverity === "warning")
     severity = "warning";
-  else if (rawSeverity === "critical" || rawSeverity === "error" || rawSeverity === "low")
+  else if (rawSeverity === "critical" || rawSeverity === "error" || rawSeverity === "low" || rawSeverity === "unverifiable")
     severity = rawSeverity;
-  else if (rawSeverity === "unverifiable")
-    severity = "info";
-  else if (rawSeverity === "info")
-    severity = "info";
   return {
-    ruleId: typeof f.ruleId === "string" && f.ruleId ? f.ruleId : "semantic",
+    source: "semantic-review",
     severity,
+    category: "",
+    rule: typeof f.ruleId === "string" && f.ruleId ? f.ruleId : undefined,
     file: typeof f.file === "string" ? f.file : "",
     line: typeof f.line === "number" ? f.line : 0,
-    message: typeof f.message === "string" && f.message ? f.message : typeof f.issue === "string" ? f.issue : "",
-    source: typeof f.source === "string" ? f.source : "semantic-review"
+    message: typeof f.message === "string" && f.message ? f.message : typeof f.issue === "string" ? f.issue : ""
   };
 }
 function parseReviewResponse(output) {
@@ -41679,7 +42507,7 @@ function parseReviewResponse(output) {
   }
   const success2 = Boolean(parsed.passed);
   const rawFindings = Array.isArray(parsed.findings) ? parsed.findings : [];
-  const findings = rawFindings.map((f) => mapLLMFindingToReviewFinding(f));
+  const findings = rawFindings.map((f) => mapLLMFindingToFinding(f));
   const reasoningObj = parsed.findingReasoning && typeof parsed.findingReasoning === "object" ? parsed.findingReasoning : {};
   const findingReasoning = new Map(Object.entries(reasoningObj));
   return { checkResult: { success: success2, findings }, findingReasoning };
@@ -41898,52 +42726,6 @@ var init_dialogue = __esm(() => {
   init_prompts();
 });
 
-// src/review/severity.ts
-var SEVERITY_RANK;
-var init_severity = __esm(() => {
-  SEVERITY_RANK = {
-    info: 0,
-    unverifiable: 0,
-    low: 1,
-    warning: 1,
-    error: 2,
-    critical: 3
-  };
-});
-
-// src/review/adversarial-helpers.ts
-function formatFindings(findings) {
-  return findings.map((f) => `[${f.severity}][${f.category}] ${f.file}:${f.line} \u2014 ${f.issue}
-  Suggestion: ${f.suggestion}`).join(`
-`);
-}
-function normalizeSeverity(sev) {
-  if (sev === "warn")
-    return "warning";
-  if (sev === "unverifiable")
-    return "info";
-  if (sev === "critical" || sev === "error" || sev === "warning" || sev === "info" || sev === "low")
-    return sev;
-  return "info";
-}
-function isBlockingSeverity(sev, threshold = "error") {
-  return (SEVERITY_RANK[sev] ?? 0) >= (SEVERITY_RANK[threshold] ?? 2);
-}
-function toAdversarialReviewFindings(findings) {
-  return findings.map((f) => ({
-    ruleId: "adversarial",
-    severity: normalizeSeverity(f.severity),
-    file: f.file,
-    line: f.line,
-    message: f.issue,
-    source: "adversarial-review",
-    category: f.category
-  }));
-}
-var init_adversarial_helpers = __esm(() => {
-  init_severity();
-});
-
 // src/review/diff-utils.ts
 var {spawn: spawn3 } = globalThis.Bun;
 async function resolveNaxIgnorePathspecExcludes(workdir, options) {
@@ -42090,7 +42872,7 @@ var init_diff_utils = __esm(() => {
 });
 
 // src/review/adversarial.ts
-import { relative as relative10, sep as sep3 } from "path";
+import { relative as relative11, sep as sep3 } from "path";
 function recordAdversarialAudit(opts) {
   opts.runtime?.reviewAuditor.recordDecision({
     reviewer: "adversarial",
@@ -42123,7 +42905,7 @@ async function runAdversarialReview(opts) {
     projectDir,
     naxIgnoreIndex,
     runtime,
-    priorAdversarialFindings
+    priorAdversarialIterations
   } = opts;
   const startTime = Date.now();
   const logger = getSafeLogger();
@@ -42161,7 +42943,7 @@ async function runAdversarialReview(opts) {
   let testInventory;
   const effectiveConfig = naxConfig ?? reviewConfigSelector.select(DEFAULT_CONFIG);
   const packageDirRelative = projectDir && workdir !== projectDir ? (() => {
-    const rel = relative10(projectDir, workdir);
+    const rel = relative11(projectDir, workdir);
     if (rel === ".." || rel.startsWith(`..${sep3}`))
       return;
     return rel && rel !== "." ? rel : undefined;
@@ -42248,7 +43030,7 @@ async function runAdversarialReview(opts) {
       excludePatterns: adversarialConfig.excludePatterns,
       testGlobs: resolvedTestPatterns.globs,
       featureCtxBlock,
-      priorAdversarialFindings,
+      priorAdversarialIterations,
       blockingThreshold,
       refExcludePatterns: effectiveRefExcludePatterns
     });
@@ -42333,8 +43115,8 @@ async function runAdversarialReview(opts) {
     findings: opResult.findings
   };
   const threshold = blockingThreshold ?? "error";
-  const blockingFindings = parsed.findings.filter((f) => isBlockingSeverity(f.severity, threshold));
-  const advisoryFindings = parsed.findings.filter((f) => !isBlockingSeverity(f.severity, threshold));
+  const blockingFindings = parsed.findings.filter((f) => isBlockingSeverity2(f.severity, threshold));
+  const advisoryFindings = parsed.findings.filter((f) => !isBlockingSeverity2(f.severity, threshold));
   if (advisoryFindings.length > 0) {
     logger?.debug("review", `Adversarial review: ${advisoryFindings.length} advisory findings (below threshold '${threshold}')`, {
       storyId: story.id,
@@ -42382,7 +43164,7 @@ async function runAdversarialReview(opts) {
       exitCode: 1,
       output: `Adversarial review failed:
 
-${formatFindings(blockingFindings)}`,
+${formatFindings2(blockingFindings)}`,
       durationMs: durationMs2,
       findings: toAdversarialReviewFindings(blockingFindings),
       advisoryFindings: advisoryFindings.length > 0 ? toAdversarialReviewFindings(advisoryFindings) : undefined,
@@ -42507,89 +43289,6 @@ var init_language_commands = __esm(() => {
   };
 });
 
-// src/review/semantic-helpers.ts
-function validateLLMShape(parsed) {
-  if (typeof parsed !== "object" || parsed === null)
-    return null;
-  const obj = parsed;
-  if (typeof obj.passed !== "boolean")
-    return null;
-  if (!Array.isArray(obj.findings))
-    return null;
-  return { passed: obj.passed, findings: obj.findings };
-}
-function parseLLMResponse(raw) {
-  try {
-    return validateLLMShape(tryParseLLMJson(raw));
-  } catch {
-    return null;
-  }
-}
-function formatFindings2(findings) {
-  return findings.map((f) => `[${f.severity}] ${f.file}:${f.line} \u2014 ${f.issue}
-  Suggestion: ${f.suggestion}`).join(`
-`);
-}
-function normalizeSeverity2(sev) {
-  if (sev === "warn")
-    return "warning";
-  if (sev === "unverifiable")
-    return "info";
-  if (sev === "critical" || sev === "error" || sev === "warning" || sev === "info" || sev === "low")
-    return sev;
-  return "info";
-}
-function isBlockingSeverity2(sev, threshold = "error") {
-  return (SEVERITY_RANK[sev] ?? 0) >= (SEVERITY_RANK[threshold] ?? 2);
-}
-function sanitizeRefModeFindings(findings, diffMode) {
-  if (diffMode !== "ref")
-    return findings;
-  return findings.map((finding) => needsDowngradeForMissingEvidence(finding) ? downgradeToUnverifiable(finding) : finding);
-}
-function needsDowngradeForMissingEvidence(finding) {
-  if ((SEVERITY_RANK[finding.severity] ?? 0) < SEVERITY_RANK.error)
-    return false;
-  return mentionsUnverifiedSource(finding) || !hasVerifiedEvidence(finding);
-}
-function mentionsUnverifiedSource(finding) {
-  const text = `${finding.issue} ${finding.suggestion}`.toLowerCase();
-  return UNVERIFIED_FINDING_PATTERNS.some((pattern) => text.includes(pattern));
-}
-function hasVerifiedEvidence(finding) {
-  const evidence = finding.verifiedBy;
-  return !!evidence?.file?.trim() && !!evidence.observed?.trim();
-}
-function downgradeToUnverifiable(finding) {
-  return {
-    ...finding,
-    severity: "unverifiable"
-  };
-}
-function toReviewFindings(findings) {
-  return findings.map((f) => ({
-    ruleId: "semantic",
-    severity: normalizeSeverity2(f.severity),
-    file: f.file,
-    line: f.line,
-    message: f.issue,
-    source: "semantic-review"
-  }));
-}
-var UNVERIFIED_FINDING_PATTERNS;
-var init_semantic_helpers = __esm(() => {
-  init_severity();
-  UNVERIFIED_FINDING_PATTERNS = [
-    "cannot verify",
-    "can't verify",
-    "from diff alone",
-    "missing from diff",
-    "not found in diff",
-    "not present in diff",
-    "does not appear in diff"
-  ];
-});
-
 // src/review/semantic-debate.ts
 function recordSemanticDebateAudit(opts) {
   opts.runtime.reviewAuditor.recordDecision({
@@ -42698,7 +43397,7 @@ async function runSemanticDebate(opts) {
           exitCode: 1,
           output: `Semantic review failed:
 
-${findings.map((f) => `${f.ruleId}: ${f.message}`).join(`
+${findings.map((f) => `${f.rule ?? "semantic"}: ${f.message}`).join(`
 `)}`,
           durationMs: durationMs2,
           findings,
@@ -42751,8 +43450,8 @@ ${findings.map((f) => `${f.ruleId}: ${f.message}`).join(`
   }
   const debateFindings = sanitizeRefModeFindings(deduped, diffMode);
   const debateThreshold = blockingThreshold ?? "error";
-  const debateBlocking = debateFindings.filter((f) => isBlockingSeverity2(f.severity, debateThreshold));
-  const debateAdvisory = debateFindings.filter((f) => !isBlockingSeverity2(f.severity, debateThreshold));
+  const debateBlocking = debateFindings.filter((f) => isBlockingSeverity(f.severity, debateThreshold));
+  const debateAdvisory = debateFindings.filter((f) => !isBlockingSeverity(f.severity, debateThreshold));
   const durationMs = Date.now() - startTime;
   if (!resolverPassed) {
     if (debateBlocking.length > 0) {
@@ -42778,7 +43477,7 @@ ${findings.map((f) => `${f.ruleId}: ${f.message}`).join(`
         exitCode: 1,
         output: `Semantic review failed:
 
-${formatFindings2(debateBlocking)}`,
+${formatFindings(debateBlocking)}`,
         durationMs,
         findings: toReviewFindings(debateBlocking),
         advisoryFindings: debateAdvisory.length > 0 ? toReviewFindings(debateAdvisory) : undefined,
@@ -42840,6 +43539,7 @@ var init_semantic_debate = __esm(() => {
 });
 
 // src/review/semantic-evidence.ts
+import { isAbsolute as isAbsolute10 } from "path";
 async function substantiateSemanticEvidence(findings, diffMode, workdir, storyId) {
   if (diffMode !== "ref")
     return findings;
@@ -42853,7 +43553,9 @@ async function substantiateFinding(finding, workdir, storyId) {
     return finding;
   const file3 = finding.verifiedBy?.file?.trim() || finding.file;
   const contents = await readSafeFile(workdir, file3);
-  if (contents !== null && normalizedIncludes(contents, observed))
+  if (contents === null)
+    return finding;
+  if (normalizedIncludes(contents, observed))
     return finding;
   _evidenceDeps.getLogger()?.warn("review", "Downgraded unsubstantiated semantic error finding", {
     storyId,
@@ -42867,13 +43569,21 @@ async function substantiateFinding(finding, workdir, storyId) {
 }
 async function readSafeFile(workdir, file3) {
   const validated = validateModulePath(file3, [workdir]);
-  if (!validated.valid || !validated.absolutePath)
-    return null;
-  try {
-    return await Bun.file(validated.absolutePath).text();
-  } catch {
-    return null;
+  if (validated.valid && validated.absolutePath) {
+    try {
+      return await Bun.file(validated.absolutePath).text();
+    } catch {
+      return null;
+    }
+  }
+  if (isAbsolute10(file3)) {
+    try {
+      return await Bun.file(file3).text();
+    } catch {
+      return null;
+    }
   }
+  return null;
 }
 function normalizedIncludes(contents, observed) {
   const normalizedObserved = normalizeEvidenceText(observed);
@@ -42902,7 +43612,7 @@ var init_semantic_evidence = __esm(() => {
 });
 
 // src/review/semantic.ts
-import { relative as relative11, sep as sep4 } from "path";
+import { relative as relative12, sep as sep4 } from "path";
 function recordSemanticAudit(opts) {
   opts.runtime?.reviewAuditor.recordDecision({
     reviewer: "semantic",
@@ -42929,7 +43639,7 @@ async function runSemanticReview(opts) {
     naxConfig,
     featureName,
     resolverSession,
-    priorFailures,
+    priorSemanticIterations,
     blockingThreshold,
     featureContextMarkdown,
     contextBundle,
@@ -42966,7 +43676,7 @@ async function runSemanticReview(opts) {
   const packageDir = workdir !== repoRoot ? workdir : undefined;
   const stat = await collectDiffStat(workdir, effectiveRef, { naxIgnoreIndex, packageDir });
   const packageDirRelative = projectDir && workdir !== projectDir ? (() => {
-    const rel = relative11(projectDir, workdir);
+    const rel = relative12(projectDir, workdir);
     if (rel === ".." || rel.startsWith(`..${sep4}`))
       return;
     return rel && rel !== "." ? rel : undefined;
@@ -43037,7 +43747,7 @@ async function runSemanticReview(opts) {
     diff,
     storyGitRef: effectiveRef,
     stat,
-    priorFailures,
+    priorSemanticIterations,
     excludePatterns: semanticConfig.excludePatterns
   });
   const prompt = featureCtxBlock ? `${featureCtxBlock}${basePrompt}` : basePrompt;
@@ -43094,7 +43804,7 @@ async function runSemanticReview(opts) {
       diff,
       storyGitRef: effectiveRef,
       stat,
-      priorFailures,
+      priorSemanticIterations,
       excludePatterns,
       featureCtxBlock,
       blockingThreshold
@@ -43179,8 +43889,8 @@ async function runSemanticReview(opts) {
   const sanitizedFindings = await substantiateSemanticEvidence(sanitizeRefModeFindings(parsed.findings, diffMode), diffMode, workdir, story.id);
   const sanitizedParsed = { ...parsed, findings: sanitizedFindings };
   const threshold = blockingThreshold ?? "error";
-  const blockingFindings = sanitizedParsed.findings.filter((f) => isBlockingSeverity2(f.severity, threshold));
-  const advisoryFindings = sanitizedParsed.findings.filter((f) => !isBlockingSeverity2(f.severity, threshold));
+  const blockingFindings = sanitizedParsed.findings.filter((f) => isBlockingSeverity(f.severity, threshold));
+  const advisoryFindings = sanitizedParsed.findings.filter((f) => !isBlockingSeverity(f.severity, threshold));
   if (advisoryFindings.length > 0) {
     logger?.debug("review", `Semantic review: ${advisoryFindings.length} advisory findings (below threshold '${threshold}')`, {
       storyId: story.id,
@@ -43205,7 +43915,7 @@ async function runSemanticReview(opts) {
     });
     const output = `Semantic review failed:
 
-${formatFindings2(blockingFindings)}`;
+${formatFindings(blockingFindings)}`;
     recordSemanticAudit({
       runtime,
       workdir,
@@ -43409,13 +44119,14 @@ async function runReview(opts) {
     featureName,
     resolverSession,
     priorFailures,
+    priorSemanticIterations,
     featureContextMarkdown,
     contextBundles,
     projectDir,
     env: env2,
     naxIgnoreIndex,
     runtime,
-    priorAdversarialFindings
+    priorAdversarialIterations
   } = opts;
   const startTime = Date.now();
   const logger = getSafeLogger();
@@ -43489,7 +44200,7 @@ Stage and commit these files before running review.`
         naxConfig,
         featureName,
         resolverSession,
-        priorFailures,
+        priorSemanticIterations,
         blockingThreshold: config2.blockingThreshold,
         featureContextMarkdown,
         contextBundle: contextBundles?.semantic,
@@ -43537,7 +44248,7 @@ Stage and commit these files before running review.`
         projectDir,
         naxIgnoreIndex,
         runtime,
-        priorAdversarialFindings
+        priorAdversarialIterations
       });
       checks3.push(result2);
       if (!result2.success && !firstFailure) {
@@ -43595,16 +44306,16 @@ var init_runner4 = __esm(() => {
 
 // src/review/verdict-writer.ts
 import { mkdir as mkdir6 } from "fs/promises";
-import { join as join35 } from "path";
+import { join as join36 } from "path";
 async function writeReviewVerdict(entry) {
   const logger = getSafeLogger();
   try {
-    const projectDir = await _verdictWriterDeps.findNaxProjectRoot(entry.featureName ? join35(entry.featureName) : ".");
+    const projectDir = await _verdictWriterDeps.findNaxProjectRoot(entry.featureName ? join36(entry.featureName) : ".");
     const baseDir = projectDir ?? ".";
-    const verdictDir = entry.featureName ? join35(baseDir, ".nax", "review-verdicts", entry.featureName) : join35(baseDir, ".nax", "review-verdicts", "_unknown");
+    const verdictDir = entry.featureName ? join36(baseDir, ".nax", "review-verdicts", entry.featureName) : join36(baseDir, ".nax", "review-verdicts", "_unknown");
     await _verdictWriterDeps.mkdir(verdictDir, { recursive: true });
     const fileName = `${entry.storyId}.json`;
-    const filePath = join35(verdictDir, fileName);
+    const filePath = join36(verdictDir, fileName);
     await _verdictWriterDeps.writeFile(filePath, JSON.stringify(entry, null, 2));
     logger?.debug("review", "Review verdict written", {
       storyId: entry.storyId,
@@ -43629,7 +44340,7 @@ var init_verdict_writer = __esm(() => {
 });
 
 // src/review/orchestrator.ts
-import { join as join36 } from "path";
+import { join as join37 } from "path";
 var {spawn: spawn4 } = globalThis.Bun;
 async function getChangedFiles2(workdir, baseRef) {
   try {
@@ -43704,13 +44415,14 @@ class ReviewOrchestrator {
       featureName,
       resolverSession,
       priorFailures,
+      priorSemanticIterations,
       featureContextMarkdown,
       contextBundles,
       projectDir,
       env: env2,
       naxIgnoreIndex,
       runtime,
-      priorAdversarialFindings
+      priorAdversarialIterations
     } = opts;
     const logger = getSafeLogger();
     const hasSemantic = reviewConfig.checks.includes("semantic");
@@ -43755,12 +44467,14 @@ class ReviewOrchestrator {
         featureName,
         resolverSession,
         priorFailures,
+        priorSemanticIterations,
         featureContextMarkdown,
         contextBundles,
         projectDir,
         env: env2,
         naxIgnoreIndex,
-        runtime
+        runtime,
+        priorAdversarialIterations
       });
     } else {
       const mechanicalCheckNames = ORDERED_MECHANICAL_REVIEW_CHECKS.filter((check2) => reviewConfig.checks.includes(check2));
@@ -43834,7 +44548,7 @@ class ReviewOrchestrator {
             naxConfig,
             featureName,
             resolverSession,
-            priorFailures,
+            priorSemanticIterations,
             blockingThreshold: reviewConfig.blockingThreshold,
             featureContextMarkdown,
             contextBundle: contextBundles?.semantic,
@@ -43857,7 +44571,7 @@ class ReviewOrchestrator {
             projectDir,
             naxIgnoreIndex,
             runtime,
-            priorAdversarialFindings
+            priorAdversarialIterations
           })
         ]);
         llmCheckResults = [semResult, advResult];
@@ -43877,13 +44591,14 @@ class ReviewOrchestrator {
           featureName,
           resolverSession,
           priorFailures,
+          priorSemanticIterations,
           featureContextMarkdown,
           contextBundles,
           projectDir,
           env: env2,
           naxIgnoreIndex,
           runtime,
-          priorAdversarialFindings
+          priorAdversarialIterations
         });
         llmCheckResults = llmResult.checks;
       }
@@ -43948,7 +44663,7 @@ class ReviewOrchestrator {
         const baseRef = storyGitRef ?? executionConfig?.storyGitRef;
         const changedFiles = await getChangedFiles2(workdir, baseRef);
         const repoRoot = projectDir ?? workdir;
-        const packageDir = scopePrefix ? join36(repoRoot, scopePrefix) : undefined;
+        const packageDir = scopePrefix ? join37(repoRoot, scopePrefix) : undefined;
         const ignoreMatchers = naxIgnoreIndex?.getMatchers(packageDir) ?? await resolveNaxIgnorePatterns(repoRoot, packageDir);
         const visibleChangedFiles = filterNaxInternalPaths(changedFiles, ignoreMatchers);
         const scopedFiles = scopePrefix ? visibleChangedFiles.filter((f) => f === scopePrefix || f.startsWith(`${scopePrefix}/`)) : visibleChangedFiles;
@@ -43970,7 +44685,7 @@ class ReviewOrchestrator {
               passed: result.passed,
               output: result.output,
               exitCode: result.exitCode,
-              findings: result.findings
+              findings: result.findings?.map((rf) => pluginToFinding(rf, workdir))
             });
             if (!result.passed) {
               builtIn.pluginReviewers = pluginResults;
@@ -44031,32 +44746,60 @@ class ReviewOrchestrator {
       featureName: ctx.prd.feature,
       resolverSession,
       priorFailures: ctx.story.priorFailures,
+      priorSemanticIterations: ctx.priorSemanticIterations,
       featureContextMarkdown: ctx.featureContextMarkdown,
       contextBundles,
       projectDir: ctx.projectDir,
       env: ctx.worktreeDependencyContext?.env,
       naxIgnoreIndex: ctx.naxIgnoreIndex,
       runtime: ctx.runtime,
-      priorAdversarialFindings: ctx.priorAdversarialFindings
+      priorAdversarialIterations: ctx.priorAdversarialIterations
     });
     const advCheck = result.builtIn.checks?.find((c) => c.check === "adversarial");
     if (advCheck) {
-      if (!advCheck.success && (advCheck.findings?.length ?? 0) > 0) {
-        ctx.priorAdversarialFindings = {
-          round: (ctx.priorAdversarialFindings?.round ?? 0) + 1,
-          findings: (advCheck.findings ?? []).map((f) => ({
-            severity: f.severity,
-            category: f.category,
-            file: f.file,
-            line: f.line,
-            issue: f.message
-          }))
+      if (!advCheck.success && !advCheck.skipped) {
+        const prior = ctx.priorAdversarialIterations ?? [];
+        const findingsBefore = prior.length > 0 ? prior[prior.length - 1].findingsAfter ?? [] : [];
+        const findingsAfter = advCheck.findings ?? [];
+        const now = new Date().toISOString();
+        const newIteration = {
+          iterationNum: prior.length + 1,
+          findingsBefore,
+          fixesApplied: [],
+          findingsAfter,
+          outcome: classifyOutcome(findingsBefore, findingsAfter),
+          startedAt: now,
+          finishedAt: now
         };
+        ctx.priorAdversarialIterations = [...prior, newIteration];
       } else if (advCheck.success && !advCheck.skipped) {
-        ctx.priorAdversarialFindings = undefined;
+        ctx.priorAdversarialIterations = undefined;
       }
     } else if (retrySkipChecks?.has("adversarial")) {
-      ctx.priorAdversarialFindings = undefined;
+      ctx.priorAdversarialIterations = undefined;
+    }
+    const semCheck = result.builtIn.checks?.find((c) => c.check === "semantic");
+    if (semCheck) {
+      if (!semCheck.success && !semCheck.skipped) {
+        const prior = ctx.priorSemanticIterations ?? [];
+        const findingsBefore = prior.length > 0 ? prior[prior.length - 1].findingsAfter ?? [] : [];
+        const findingsAfter = semCheck.findings ?? [];
+        const now = new Date().toISOString();
+        const newIteration = {
+          iterationNum: prior.length + 1,
+          findingsBefore,
+          fixesApplied: [],
+          findingsAfter,
+          outcome: classifyOutcome(findingsBefore, findingsAfter),
+          startedAt: now,
+          finishedAt: now
+        };
+        ctx.priorSemanticIterations = [...prior, newIteration];
+      } else if (semCheck.success && !semCheck.skipped) {
+        ctx.priorSemanticIterations = undefined;
+      }
+    } else if (retrySkipChecks?.has("semantic")) {
+      ctx.priorSemanticIterations = undefined;
     }
     return result;
   }
@@ -44064,6 +44807,7 @@ class ReviewOrchestrator {
 var _orchestratorDeps2, reviewOrchestrator;
 var init_orchestrator2 = __esm(() => {
   init_engine();
+  init_findings();
   init_logger2();
   init_path_filters();
   init_adversarial();
@@ -44201,11 +44945,9 @@ var init_review = __esm(() => {
         return { action: "continue", cost: reviewCost };
       }
       if (!result.success) {
-        const pluginFindings = result.builtIn.pluginReviewers?.flatMap((pr) => pr.findings ?? []) ?? [];
         const semanticFindings = (result.builtIn.checks ?? []).filter((c) => c.check === "semantic" && !c.success && c.findings?.length).flatMap((c) => c.findings ?? []);
-        const allFindings = [...pluginFindings, ...semanticFindings];
-        if (allFindings.length > 0) {
-          ctx.reviewFindings = allFindings;
+        if (semanticFindings.length > 0) {
+          ctx.reviewFindings = semanticFindings;
         }
         if (result.pluginFailed) {
           if (ctx.interaction && isTriggerEnabled("security-review", ctx.config)) {
@@ -44238,481 +44980,6 @@ var init_review = __esm(() => {
     createReviewerSession
   };
 });
-// src/review/index.ts
-var init_review2 = __esm(() => {
-  init_adversarial();
-  init_categorization();
-  init_diff_utils();
-  init_runner4();
-});
-
-// src/verification/shared-rectification-loop.ts
-function buildProgressivePromptPreamble(opts) {
-  const rethinkAt = Math.min(opts.rethinkAtAttempt ?? 2, opts.maxAttempts);
-  const urgencyAt = Math.min(opts.urgencyAtAttempt ?? 3, opts.maxAttempts);
-  const shouldRethink = opts.attempt >= rethinkAt;
-  const shouldUrgency = opts.attempt >= urgencyAt;
-  if (!shouldRethink && !shouldUrgency) {
-    return "";
-  }
-  if (shouldUrgency) {
-    opts.logger?.info(opts.stage, "Progressive prompt escalation: urgency + rethink injected", {
-      attempt: opts.attempt,
-      rethinkAtAttempt: rethinkAt,
-      urgencyAtAttempt: urgencyAt,
-      maxAttempts: opts.maxAttempts
-    });
-  } else {
-    opts.logger?.info(opts.stage, "Progressive prompt escalation: rethink injected", {
-      attempt: opts.attempt,
-      rethinkAtAttempt: rethinkAt,
-      maxAttempts: opts.maxAttempts
-    });
-  }
-  const urgencySection = shouldUrgency ? opts.urgencySection : "";
-  const rethinkSection = shouldRethink ? opts.rethinkSection : "";
-  return `${urgencySection}${rethinkSection}`;
-}
-async function runRetryLoop(input) {
-  let currentFailure = input.failure;
-  const previous = [...input.previousAttempts];
-  for (let attempt = 1;attempt <= input.maxAttempts; attempt++) {
-    const prompt = await Promise.resolve(input.buildPrompt(currentFailure, previous));
-    const result = await input.execute(prompt);
-    const outcome = await input.verify(result);
-    previous.push({ attempt, result });
-    if (outcome.passed) {
-      return { outcome: "fixed", result, attempts: attempt };
-    }
-    currentFailure = outcome.newFailure;
-    if (input.shouldAbort?.(currentFailure, attempt)) {
-      return { outcome: "aborted", attempts: attempt };
-    }
-  }
-  return { outcome: "exhausted", attempts: input.maxAttempts, finalFailure: currentFailure };
-}
-
-// src/pipeline/stages/autofix-agent.ts
-var exports_autofix_agent = {};
-__export(exports_autofix_agent, {
-  runAgentRectification: () => runAgentRectification
-});
-function collectFailedChecks(ctx) {
-  return (ctx.reviewResult?.checks ?? []).filter((c) => !c.success);
-}
-function getCheckSignature(checks3) {
-  return [...new Set(checks3.map((check2) => check2.check))].sort().join("|");
-}
-function buildAutofixEscalationPreamble(attempt, maxAttempts, rethinkAtAttempt, urgencyAtAttempt) {
-  return buildProgressivePromptPreamble({
-    attempt,
-    maxAttempts,
-    rethinkAtAttempt,
-    urgencyAtAttempt,
-    stage: "autofix",
-    logger: getLogger(),
-    urgencySection: `## Final Autofix Attempt Before Escalation
-
-This is attempt ${attempt}. If the review still fails after this, autofix will escalate instead of retrying.
-A different approach is required. Do not repeat the same fix.
-
-`,
-    rethinkSection: `## Previous Attempt Did Not Fix the Failures
-
-Your previous fix attempt (attempt ${attempt}) did not resolve the quality errors. Rethink your approach.
-
-- Do not repeat the same edit pattern.
-- Re-read the failing diagnostics carefully.
-- Try a fundamentally different fix strategy if the earlier one did not work.
-
-`
-  });
-}
-async function runAgentRectification(ctx, lintFixCmd, formatFixCmd, effectiveWorkdir) {
-  const logger = getLogger();
-  const maxPerCycle = ctx.config.quality.autofix?.maxAttempts ?? 2;
-  const maxTotal = ctx.config.quality.autofix?.maxTotalAttempts ?? 10;
-  const rethinkAtAttempt = ctx.config.quality.autofix?.rethinkAtAttempt ?? 2;
-  const urgencyAtAttempt = ctx.config.quality.autofix?.urgencyAtAttempt ?? 3;
-  const consumed = ctx.autofixAttempt ?? 0;
-  const failedChecks = collectFailedChecks(ctx);
-  if (failedChecks.length === 0) {
-    logger.debug("autofix", "No failed checks found \u2014 skipping agent rectification", { storyId: ctx.story.id });
-    return { succeeded: false, cost: 0 };
-  }
-  if (consumed >= maxTotal) {
-    logger.warn("autofix", "Global autofix budget exhausted \u2014 escalating", {
-      storyId: ctx.story.id,
-      totalAttempts: consumed,
-      maxTotalAttempts: maxTotal
-    });
-    return { succeeded: false, cost: 0 };
-  }
-  const remainingBudget = maxTotal - consumed;
-  const maxAttempts = Math.min(maxPerCycle, remainingBudget);
-  if (!ctx.agentManager) {
-    logger.error("autofix", "Agent manager unavailable \u2014 cannot run agent rectification", { storyId: ctx.story.id });
-    return { succeeded: false, cost: 0 };
-  }
-  if (!ctx.runtime) {
-    throw new NaxError("runtime required \u2014 legacy agentManager.run path removed (ADR-019 Wave 3, issue #762)", "DISPATCH_NO_RUNTIME", { stage: "rectification", storyId: ctx.story.id });
-  }
-  const { agentManager } = ctx;
-  const { runtime } = ctx;
-  let implementerChecks = failedChecks;
-  let testWriterChecks = [];
-  const stageTestFilePatterns = typeof ctx.rootConfig.execution?.smartTestRunner === "object" ? ctx.rootConfig.execution.smartTestRunner?.testFilePatterns : undefined;
-  const lintOutputFormat = ctx.config.quality.lintOutput?.format ?? "auto";
-  const typecheckOutputFormat = ctx.config.quality.typecheckOutput?.format ?? "auto";
-  for (const check2 of failedChecks) {
-    if (check2.check === "adversarial" || check2.check === "lint" || check2.check === "typecheck") {
-      const { testFindings, sourceFindings } = splitFindingsByScope(check2, stageTestFilePatterns, lintOutputFormat, typecheckOutputFormat);
-      if (testFindings || sourceFindings) {
-        if (testFindings)
-          testWriterChecks = [...testWriterChecks, testFindings];
-        if (sourceFindings) {
-          implementerChecks = implementerChecks.map((c) => c === check2 ? sourceFindings : c);
-        } else {
-          implementerChecks = implementerChecks.filter((c) => c !== check2);
-        }
-      }
-    }
-  }
-  let autofixCostAccum = 0;
-  if (testWriterChecks.length > 0) {
-    if (ctx.routing.testStrategy === "no-test") {
-      logger.warn("autofix", "Skipping test-writer rectification (no-test strategy)", {
-        storyId: ctx.story.id,
-        checks: testWriterChecks.map((c) => c.check)
-      });
-    } else {
-      logger.info("autofix", "Routing test-file findings to test-writer session", {
-        storyId: ctx.story.id,
-        checks: testWriterChecks.map((c) => c.check)
-      });
-      autofixCostAccum += await _autofixDeps.runTestWriterRectification(ctx, testWriterChecks, ctx.story, agentManager);
-    }
-  }
-  if (implementerChecks.length === 0) {
-    logger.info("autofix", "All findings routed to test-writer \u2014 skipping implementer loop", {
-      storyId: ctx.story.id
-    });
-    return { succeeded: false, cost: autofixCostAccum };
-  }
-  let unresolvedReason;
-  let autofixBeforeRef;
-  const implementerSession = formatSessionName({
-    workdir: ctx.workdir,
-    featureName: ctx.prd.feature,
-    storyId: ctx.story.id,
-    role: "implementer"
-  });
-  let sessionConfirmedOpen = consumed === 0;
-  logger.info("autofix", "Starting agent rectification for review failures", {
-    storyId: ctx.story.id,
-    failedChecks: implementerChecks.map((check2) => check2.check),
-    maxAttempts,
-    totalUsed: consumed,
-    maxTotalAttempts: maxTotal
-  });
-  const initialFailure = {
-    checks: implementerChecks,
-    checkSignature: getCheckSignature(implementerChecks)
-  };
-  let currentAttempt = 0;
-  let currentConsecutiveNoOps = 0;
-  let currentCheckSignatureChanged = false;
-  let failOpenAborted = false;
-  let heldHandle;
-  const outcome = await runRetryLoop({
-    stage: "rectification",
-    storyId: ctx.story.id,
-    packageDir: ctx.workdir,
-    maxAttempts,
-    failure: initialFailure,
-    previousAttempts: [],
-    shouldAbort: (_failure, _attempt) => failOpenAborted,
-    buildPrompt: (failure, previous) => {
-      currentAttempt = previous.length + 1;
-      const lastResult = previous[previous.length - 1]?.result;
-      const lastWasNoOp = lastResult?.noOp ?? false;
-      currentConsecutiveNoOps = lastResult?.consecutiveNoOps ?? 0;
-      currentCheckSignatureChanged = failure.checkSignature !== initialFailure.checkSignature;
-      logger.debug("autofix", `Building prompt for attempt ${consumed + currentAttempt}/${maxTotal}`, {
-        storyId: ctx.story.id,
-        lastWasNoOp,
-        consecutiveNoOps: currentConsecutiveNoOps
-      });
-      if (lastWasNoOp) {
-        return RectifierPromptBuilder.noOpReprompt(failure.checks, currentConsecutiveNoOps, MAX_CONSECUTIVE_NOOP_REPROMPTS);
-      }
-      if (currentAttempt === 1 && sessionConfirmedOpen) {
-        return RectifierPromptBuilder.firstAttemptDelta(failure.checks, maxAttempts);
-      }
-      const isSessionContinuation = currentAttempt > 1 && sessionConfirmedOpen;
-      if (isSessionContinuation) {
-        if (currentCheckSignatureChanged) {
-          const attemptsRemaining = Math.max(1, maxAttempts - currentAttempt + 1);
-          return RectifierPromptBuilder.firstAttemptDelta(failure.checks, attemptsRemaining);
-        }
-        return RectifierPromptBuilder.continuation(failure.checks, currentAttempt, Math.min(rethinkAtAttempt, maxAttempts), Math.min(urgencyAtAttempt, maxAttempts));
-      }
-      let prompt = RectifierPromptBuilder.reviewRectification(failure.checks, ctx.story);
-      const escalationPreamble = buildAutofixEscalationPreamble(currentAttempt, maxAttempts, rethinkAtAttempt, urgencyAtAttempt);
-      if (escalationPreamble) {
-        prompt = `${escalationPreamble}${prompt}`;
-      }
-      return prompt;
-    },
-    execute: async (prompt) => {
-      logger.info("autofix", `Agent rectification attempt ${consumed + currentAttempt}/${maxTotal}`, {
-        storyId: ctx.story.id
-      });
-      autofixBeforeRef = await _autofixDeps.captureGitRef(ctx.workdir);
-      ctx.autofixAttempt = consumed + currentAttempt;
-      const modelTier = ctx.story.routing?.modelTier ?? ctx.rootConfig.autoMode.escalation.tierOrder[0]?.tier ?? "balanced";
-      const defaultAgent = agentManager.getDefault();
-      const modelDef = resolveModelForAgent(ctx.rootConfig.models, ctx.routing.agent ?? defaultAgent, modelTier, defaultAgent);
-      let result;
-      try {
-        if (!heldHandle) {
-          heldHandle = await runtime.sessionManager.openSession(implementerSession, {
-            agentName: defaultAgent,
-            role: "implementer",
-            workdir: ctx.workdir,
-            pipelineStage: "rectification",
-            modelDef,
-            timeoutSeconds: ctx.config.execution.sessionTimeoutSeconds,
-            featureName: ctx.prd.feature,
-            storyId: ctx.story.id,
-            signal: runtime.signal
-          });
-        }
-        const turn = await agentManager.runAsSession(defaultAgent, heldHandle, prompt, {
-          storyId: ctx.story.id,
-          featureName: ctx.prd.feature,
-          workdir: ctx.workdir,
-          projectDir: ctx.projectDir,
-          pipelineStage: "rectification",
-          sessionRole: "implementer",
-          signal: runtime.signal,
-          maxTurns: ctx.config.agent?.maxInteractionTurns
-        });
-        result = {
-          success: true,
-          exitCode: 0,
-          output: turn.output,
-          rateLimited: false,
-          durationMs: 0,
-          estimatedCostUsd: turn.estimatedCostUsd,
-          ...turn.exactCostUsd !== undefined && { exactCostUsd: turn.exactCostUsd },
-          ...turn.tokenUsage && { tokenUsage: turn.tokenUsage },
-          ...heldHandle.protocolIds && { protocolIds: heldHandle.protocolIds }
-        };
-        sessionConfirmedOpen = true;
-      } catch (err) {
-        sessionConfirmedOpen = false;
-        if (heldHandle) {
-          const stale = heldHandle;
-          heldHandle = undefined;
-          await runtime.sessionManager.closeSession(stale).catch(() => {});
-        }
-        throw err;
-      }
-      autofixCostAccum += result.estimatedCostUsd ?? 0;
-      if (ctx.sessionManager && ctx.sessionId && result.protocolIds) {
-        try {
-          const desc = ctx.sessionManager.get(ctx.sessionId);
-          if (desc) {
-            ctx.sessionManager.bindHandle(ctx.sessionId, implementerSession, result.protocolIds);
-          }
-        } catch {}
-      }
-      if (result.output) {
-        const unresolvedMatch = UNRESOLVED_REGEX.exec(result.output);
-        if (unresolvedMatch) {
-          unresolvedReason = (unresolvedMatch[1] ?? "reviewer findings contradicted each other").trim();
-          logger.warn("autofix", "Implementer signalled reviewer contradiction \u2014 escalating", {
-            storyId: ctx.story.id,
-            unresolvedReason
-          });
-          throw new Error("AUTOFIX_UNRESOLVED");
-        }
-      }
-      if (ctx.reviewerSession && result.output) {
-        const maxClarifications = ctx.config.review?.dialogue?.maxClarificationsPerAttempt ?? 3;
-        let clarifyCount = 0;
-        const clarifyRegex = new RegExp(CLARIFY_REGEX.source, `${CLARIFY_REGEX.flags}g`);
-        let match;
-        while ((match = clarifyRegex.exec(result.output)) !== null) {
-          if (clarifyCount >= maxClarifications)
-            break;
-          const question = match[1]?.trim() ?? "";
-          if (!question)
-            continue;
-          try {
-            await ctx.reviewerSession.clarify(question);
-            clarifyCount++;
-          } catch (err) {
-            logger.debug("autofix", "reviewerSession.clarify() failed \u2014 proceeding without clarification", {
-              storyId: ctx.story.id
-            });
-          }
-        }
-      }
-      const refAfterAttempt = await _autofixDeps.captureGitRef(ctx.workdir);
-      const sourceFilesChanged = autofixBeforeRef === undefined || refAfterAttempt === undefined || autofixBeforeRef !== refAfterAttempt;
-      const noOp = !sourceFilesChanged;
-      const checkSignatureChanged = false;
-      const newConsecutiveNoOps = noOp ? currentConsecutiveNoOps + 1 : 0;
-      return {
-        agentSuccess: result.success,
-        cost: result.estimatedCostUsd ?? 0,
-        checkSignatureChanged,
-        noOp,
-        consecutiveNoOps: newConsecutiveNoOps
-      };
-    },
-    verify: async (result) => {
-      const failingChecks = (ctx.reviewResult?.checks ?? []).filter((c) => !c.success);
-      const hasMechanicalFailure = failingChecks.some((c) => !LLM_REVIEW_CHECKS.has(c.check));
-      const recheckWorthwhile = !result.noOp || hasMechanicalFailure;
-      const passed = recheckWorthwhile ? await _autofixDeps.recheckReview(ctx) : false;
-      if (passed) {
-        if (result.noOp) {
-          logger.info("autofix", `[OK] Checks pass without new commit on attempt ${consumed + currentAttempt} (transient or already resolved)`, { storyId: ctx.story.id });
-        } else {
-          logger.info("autofix", `[OK] Agent rectification succeeded on attempt ${consumed + currentAttempt}`, {
-            storyId: ctx.story.id
-          });
-        }
-        return { passed: true };
-      }
-      if (result.consecutiveNoOps > MAX_CONSECUTIVE_NOOP_REPROMPTS) {
-        logger.warn("autofix", "No source changes (no-op limit reached) \u2014 counting as consumed attempt", {
-          storyId: ctx.story.id,
-          attemptsRemaining: maxAttempts - currentAttempt
-        });
-        const passedChecks = (ctx.reviewResult?.checks ?? []).filter((c) => c.success && !c.skipped).map((c) => c.check);
-        if (passedChecks.length > 0) {
-          ctx.retrySkipChecks = new Set(passedChecks);
-          logger.debug("autofix", "No source changes \u2014 skipping already-passed checks on recheck", {
-            storyId: ctx.story.id,
-            skippedChecks: passedChecks
-          });
-        }
-        return {
-          passed: false,
-          newFailure: initialFailure
-        };
-      }
-      if (result.noOp) {
-        logger.info("autofix", "No source changes and checks still failing \u2014 re-prompting with stronger directive (counts as consumed attempt)", {
-          storyId: ctx.story.id,
-          noOpCount: `${result.consecutiveNoOps}/${MAX_CONSECUTIVE_NOOP_REPROMPTS}`,
-          attemptsRemaining: maxAttempts - currentAttempt
-        });
-        return {
-          passed: false,
-          newFailure: initialFailure
-        };
-      }
-      const updatedFailed = collectFailedChecks(ctx);
-      const hasNewLintFailure = updatedFailed.some((c) => c.check === "lint");
-      if (hasNewLintFailure && (lintFixCmd || formatFixCmd)) {
-        if (lintFixCmd) {
-          logger.debug("autofix", "Agent introduced lint errors \u2014 running lintFix before next attempt", {
-            storyId: ctx.story.id
-          });
-          pipelineEventBus.emit({ type: "autofix:started", storyId: ctx.story.id, command: lintFixCmd });
-          await _autofixDeps.runQualityCommand({
-            commandName: "lintFix",
-            command: lintFixCmd,
-            workdir: effectiveWorkdir,
-            storyId: ctx.story.id
-          });
-        }
-        if (formatFixCmd) {
-          pipelineEventBus.emit({ type: "autofix:started", storyId: ctx.story.id, command: formatFixCmd });
-          await _autofixDeps.runQualityCommand({
-            commandName: "formatFix",
-            command: formatFixCmd,
-            workdir: effectiveWorkdir,
-            storyId: ctx.story.id
-          });
-        }
-        const mechPassed = await _autofixDeps.recheckReview(ctx);
-        pipelineEventBus.emit({ type: "autofix:completed", storyId: ctx.story.id, fixed: mechPassed });
-        if (mechPassed) {
-          logger.info("autofix", `[OK] Mechanical fix resolved agent-introduced lint errors on attempt ${consumed + currentAttempt}`, {
-            storyId: ctx.story.id
-          });
-          return { passed: true };
-        }
-      }
-      if (updatedFailed.length > 0) {
-        const updatedCheckSignature = getCheckSignature(updatedFailed);
-        currentCheckSignatureChanged = updatedCheckSignature !== initialFailure.checkSignature;
-        logger.warn("autofix", `Agent rectification still failing after attempt ${consumed + currentAttempt}`, {
-          storyId: ctx.story.id,
-          attemptsRemaining: maxAttempts - currentAttempt,
-          globalBudgetRemaining: maxTotal - (consumed + currentAttempt)
-        });
-        return {
-          passed: false,
-          newFailure: {
-            checks: updatedFailed,
-            checkSignature: updatedCheckSignature
-          }
-        };
-      }
-      const isFailOpenOnly = (ctx.reviewResult?.checks ?? []).some((c) => c.failOpen);
-      if (isFailOpenOnly) {
-        failOpenAborted = true;
-      }
-      logger.warn("autofix", isFailOpenOnly ? "Adversarial timed out during recheck (fail-open) \u2014 aborting retry to avoid stale re-prompt" : "Agent rectification exhausted \u2014 no failed checks detected after recheck", {
-        storyId: ctx.story.id,
-        attemptsUsed: currentAttempt,
-        globalBudgetUsed: consumed + currentAttempt,
-        maxTotalAttempts: maxTotal
-      });
-      return {
-        passed: false,
-        newFailure: initialFailure
-      };
-    }
-  }).catch((error48) => {
-    if (error48 instanceof Error && error48.message === "AUTOFIX_AGENT_NOT_FOUND") {
-      return { outcome: "exhausted", attempts: 0, finalFailure: initialFailure };
-    }
-    if (error48 instanceof Error && error48.message === "AUTOFIX_UNRESOLVED") {
-      return { outcome: "exhausted", attempts: 0, finalFailure: initialFailure };
-    }
-    throw error48;
-  }).finally(async () => {
-    if (heldHandle) {
-      const stale = heldHandle;
-      heldHandle = undefined;
-      await runtime.sessionManager.closeSession(stale).catch(() => {});
-    }
-  });
-  const succeeded = outcome.outcome === "fixed";
-  return { succeeded, cost: autofixCostAccum, unresolvedReason };
-}
-var CLARIFY_REGEX, UNRESOLVED_REGEX, MAX_CONSECUTIVE_NOOP_REPROMPTS = 1;
-var init_autofix_agent = __esm(() => {
-  init_config();
-  init_errors();
-  init_logger2();
-  init_prompts();
-  init_review2();
-  init_naming();
-  init_event_bus();
-  init_autofix();
-  init_autofix_scope_split();
-  CLARIFY_REGEX = /^CLARIFY:\s*(.+)$/ms;
-  UNRESOLVED_REGEX = /^UNRESOLVED:\s*(.+)$/ms;
-});
 
 // src/pipeline/stages/autofix.ts
 async function recheckReview(ctx) {
@@ -44729,10 +44996,10 @@ var autofixStage, _autofixDeps;
 var init_autofix = __esm(() => {
   init_logger2();
   init_quality();
-  init_git();
   init_event_bus();
+  init_autofix_agent();
   init_autofix_scope_split();
-  init_autofix_test_writer();
+  init_autofix_test_writer2();
   autofixStage = {
     name: "autofix",
     enabled(ctx) {
@@ -44823,7 +45090,7 @@ var init_autofix = __esm(() => {
       if (ctx.routing.testStrategy === "no-test") {
         const failedChecks = (reviewResult.checks ?? []).filter((c) => !c.success);
         if (failedChecks.length > 0 && failedChecks.every((c) => {
-          const { testFindings, sourceFindings } = splitFindingsByScope(c, testFilePatterns, lintOutputFormat, typecheckOutputFormat);
+          const { testFindings, sourceFindings } = splitFindingsByScope(c, testFilePatterns, lintOutputFormat, typecheckOutputFormat, { workdir: ctx.workdir });
           return testFindings !== null && sourceFindings === null;
         })) {
           const skippedFindingCount = failedChecks.flatMap((c) => c.findings ?? []).length;
@@ -44896,8 +45163,7 @@ var init_autofix = __esm(() => {
   _autofixDeps = {
     runQualityCommand,
     recheckReview,
-    captureGitRef,
-    runAgentRectification: (ctx, lintFixCmd, formatFixCmd, effectiveWorkdir) => Promise.resolve().then(() => (init_autofix_agent(), exports_autofix_agent)).then(({ runAgentRectification: runAgentRectification2 }) => runAgentRectification2(ctx, lintFixCmd, formatFixCmd, effectiveWorkdir)),
+    runAgentRectification: runAgentRectificationV2,
     runTestWriterRectification: (ctx, testWriterChecks, story, agentManager) => runTestWriterRectification(ctx, testWriterChecks, story, agentManager)
   };
 });
@@ -44910,6 +45176,17 @@ async function persistSemanticVerdict(featureDir, storyId, verdict) {
   const filePath = path8.join(dir, `${storyId}.json`);
   await _semanticVerdictDeps.writeFile(filePath, JSON.stringify(verdict, null, 2));
 }
+function migrateSemanticVerdict(verdict) {
+  if (!verdict.findings?.length)
+    return verdict;
+  const first = verdict.findings[0];
+  if ("source" in first)
+    return verdict;
+  return {
+    ...verdict,
+    findings: verdict.findings.map((f) => reviewFindingToFinding(f))
+  };
+}
 async function loadSemanticVerdicts(featureDir) {
   const dir = path8.join(featureDir, "semantic-verdicts");
   let files;
@@ -44927,7 +45204,8 @@ async function loadSemanticVerdicts(featureDir) {
     const filePath = path8.join(dir, file3);
     const content = await _semanticVerdictDeps.readFile(filePath);
     try {
-      results.push(JSON.parse(content));
+      const parsed = JSON.parse(content);
+      results.push(migrateSemanticVerdict(parsed));
     } catch {
       _semanticVerdictDeps.logDebug(`Skipping invalid JSON in semantic-verdicts/${file3}`);
     }
@@ -44936,6 +45214,7 @@ async function loadSemanticVerdicts(featureDir) {
 }
 var _semanticVerdictDeps;
 var init_semantic_verdict = __esm(() => {
+  init_findings();
   init_logger2();
   _semanticVerdictDeps = {
     mkdirp: async (dir) => {
@@ -45088,10 +45367,10 @@ var init_effectiveness = __esm(() => {
 
 // src/execution/progress.ts
 import { appendFile as appendFile3, mkdir as mkdir7 } from "fs/promises";
-import { join as join37 } from "path";
+import { join as join38 } from "path";
 async function appendProgress(featureDir, storyId, status, message) {
   await mkdir7(featureDir, { recursive: true });
-  const progressPath = join37(featureDir, "progress.txt");
+  const progressPath = join38(featureDir, "progress.txt");
   const timestamp = new Date().toISOString();
   const entry = `[${timestamp}] ${storyId} \u2014 ${status.toUpperCase()} \u2014 ${message}
 `;
@@ -45223,7 +45502,7 @@ var init_completion = __esm(() => {
 
 // src/constitution/loader.ts
 import { existsSync as existsSync19 } from "fs";
-import { join as join38 } from "path";
+import { join as join39 } from "path";
 function truncateToTokens(text, maxTokens) {
   const maxChars = maxTokens * 3;
   if (text.length <= maxChars) {
@@ -45245,7 +45524,7 @@ async function loadConstitution(projectDir, config2) {
   }
   let combinedContent = "";
   if (!config2.skipGlobal) {
-    const globalPath = join38(globalConfigDir(), config2.path);
+    const globalPath = join39(globalConfigDir(), config2.path);
     if (existsSync19(globalPath)) {
       const validatedPath = validateFilePath(globalPath, globalConfigDir());
       const globalFile = Bun.file(validatedPath);
@@ -45255,7 +45534,7 @@ async function loadConstitution(projectDir, config2) {
       }
     }
   }
-  const projectPath = join38(projectDir, config2.path);
+  const projectPath = join39(projectDir, config2.path);
   if (existsSync19(projectPath)) {
     const validatedPath = validateFilePath(projectPath, projectDir);
     const projectFile = Bun.file(validatedPath);
@@ -45813,14 +46092,14 @@ async function closeAllRunSessions(sessionManager, agentGetFn) {
 
 // src/context/greenfield.ts
 import { readdir as readdir2 } from "fs/promises";
-import { join as join39 } from "path";
+import { join as join40 } from "path";
 async function scanForTestFiles(dir, testPatterns, isRootCall = true) {
   const results = [];
   const ignoreDirs = new Set(["node_modules", "dist", "build", ".next", ".git"]);
   try {
     const entries = await readdir2(dir, { withFileTypes: true });
     for (const entry of entries) {
-      const fullPath = join39(dir, entry.name);
+      const fullPath = join40(dir, entry.name);
       if (entry.isDirectory()) {
         if (ignoreDirs.has(entry.name))
           continue;
@@ -45882,6 +46161,26 @@ function shouldRetryRectification(state, config2) {
   return true;
 }
 
+// src/verification/shared-rectification-loop.ts
+async function runRetryLoop(input) {
+  let currentFailure = input.failure;
+  const previous = [...input.previousAttempts];
+  for (let attempt = 1;attempt <= input.maxAttempts; attempt++) {
+    const prompt = await Promise.resolve(input.buildPrompt(currentFailure, previous));
+    const result = await input.execute(prompt);
+    const outcome = await input.verify(result);
+    previous.push({ attempt, result });
+    if (outcome.passed) {
+      return { outcome: "fixed", result, attempts: attempt };
+    }
+    currentFailure = outcome.newFailure;
+    if (input.shouldAbort?.(currentFailure, attempt)) {
+      return { outcome: "aborted", attempts: attempt };
+    }
+  }
+  return { outcome: "exhausted", attempts: input.maxAttempts, finalFailure: currentFailure };
+}
+
 // src/verification/index.ts
 var init_verification = __esm(() => {
   init_executor();
@@ -46441,26 +46740,7 @@ function categorizeVerdict(verdict, testsPass) {
       reviewReason: `Tests failing: ${verdict.tests.failCount} failure(s). ${verdict.reasoning}`
     };
   }
-  if (!verdict.acceptanceCriteria.allMet) {
-    const unmet = verdict.acceptanceCriteria.criteria.filter((c) => !c.met).map((c) => c.criterion);
-    return {
-      success: false,
-      failureCategory: "verifier-rejected",
-      reviewReason: `Acceptance criteria not met: ${unmet.join("; ")}`
-    };
-  }
-  if (verdict.quality.rating === "poor") {
-    return {
-      success: false,
-      failureCategory: "verifier-rejected",
-      reviewReason: `Poor code quality: ${verdict.quality.issues.join("; ")}`
-    };
-  }
-  return {
-    success: false,
-    failureCategory: "verifier-rejected",
-    reviewReason: verdict.reasoning || "Verifier rejected without specific reason"
-  };
+  return { success: true };
 }
 var init_verdict = __esm(() => {
   init_verdict_reader();
@@ -46637,9 +46917,9 @@ async function runThreeSessionTdd(options) {
   let allSuccessful = sessions.every((s) => s.success);
   let finalFailureCategory;
   if (verdict !== null) {
-    const categorization2 = categorizeVerdict(verdict, verdict.tests.allPassing);
-    if (categorization2.success) {
-      logger.info("tdd", "[OK] Verifier verdict: approved", {
+    const categorization = categorizeVerdict(verdict, verdict.tests.allPassing);
+    if (categorization.success) {
+      logger.info("tdd", "[OK] Verifier verdict: accepted", {
         storyId: story.id,
         verdictApproved: verdict.approved,
         testsAllPassing: verdict.tests.allPassing
@@ -46651,13 +46931,13 @@ async function runThreeSessionTdd(options) {
       logger.warn("tdd", "[WARN] Verifier verdict: rejected", {
         storyId: story.id,
         verdictApproved: verdict.approved,
-        failureCategory: categorization2.failureCategory,
-        reviewReason: categorization2.reviewReason
+        failureCategory: categorization.failureCategory,
+        reviewReason: categorization.reviewReason
       });
       allSuccessful = false;
-      finalFailureCategory = categorization2.failureCategory;
+      finalFailureCategory = categorization.failureCategory;
       needsHumanReview = true;
-      reviewReason = categorization2.reviewReason;
+      reviewReason = categorization.reviewReason;
     }
   } else {
     if (!allSuccessful) {
@@ -48222,16 +48502,16 @@ class AcceptanceStrategy {
     }, timeoutMs);
     const exitCode = await Promise.race([
       proc.exited,
-      new Promise((resolve14) => setTimeout(() => resolve14(124), timeoutMs + 6000))
+      new Promise((resolve15) => setTimeout(() => resolve15(124), timeoutMs + 6000))
     ]);
     clearTimeout(timeoutId);
     const stdout = await Promise.race([
       new Response(proc.stdout).text(),
-      new Promise((resolve14) => setTimeout(() => resolve14(""), 3000))
+      new Promise((resolve15) => setTimeout(() => resolve15(""), 3000))
     ]);
     const stderr = await Promise.race([
       new Response(proc.stderr).text(),
-      new Promise((resolve14) => setTimeout(() => resolve14(""), 3000))
+      new Promise((resolve15) => setTimeout(() => resolve15(""), 3000))
     ]);
     const durationMs = Date.now() - start;
     if (timedOut || exitCode === 124) {
@@ -48835,7 +49115,7 @@ __export(exports_init_context, {
 });
 import { existsSync as existsSync22 } from "fs";
 import { mkdir as mkdir8 } from "fs/promises";
-import { basename as basename5, join as join43 } from "path";
+import { basename as basename5, join as join44 } from "path";
 async function findFiles(dir, maxFiles = 200) {
   try {
     const proc = Bun.spawnSync([
@@ -48863,7 +49143,7 @@ async function findFiles(dir, maxFiles = 200) {
   return [];
 }
 async function readPackageManifest(projectRoot) {
-  const packageJsonPath = join43(projectRoot, "package.json");
+  const packageJsonPath = join44(projectRoot, "package.json");
   if (!existsSync22(packageJsonPath)) {
     return null;
   }
@@ -48881,7 +49161,7 @@ async function readPackageManifest(projectRoot) {
   }
 }
 async function readReadmeSnippet(projectRoot) {
-  const readmePath = join43(projectRoot, "README.md");
+  const readmePath = join44(projectRoot, "README.md");
   if (!existsSync22(readmePath)) {
     return null;
   }
@@ -48899,7 +49179,7 @@ async function detectEntryPoints(projectRoot) {
   const candidates = ["src/index.ts", "src/main.ts", "main.go", "src/lib.rs"];
   const found = [];
   for (const candidate of candidates) {
-    const path13 = join43(projectRoot, candidate);
+    const path13 = join44(projectRoot, candidate);
     if (existsSync22(path13)) {
       found.push(candidate);
     }
@@ -48910,7 +49190,7 @@ async function detectConfigFiles(projectRoot) {
   const candidates = ["tsconfig.json", "biome.json", "turbo.json", ".env.example"];
   const found = [];
   for (const candidate of candidates) {
-    const path13 = join43(projectRoot, candidate);
+    const path13 = join44(projectRoot, candidate);
     if (existsSync22(path13)) {
       found.push(candidate);
     }
@@ -49071,8 +49351,8 @@ function generatePackageContextTemplate(packagePath) {
 }
 async function initPackage(repoRoot, packagePath, force = false) {
   const logger = getLogger();
-  const naxDir = join43(repoRoot, ".nax", "mono", packagePath);
-  const contextPath = join43(naxDir, "context.md");
+  const naxDir = join44(repoRoot, ".nax", "mono", packagePath);
+  const contextPath = join44(naxDir, "context.md");
   if (existsSync22(contextPath) && !force) {
     logger.info("init", "Package context.md already exists (use --force to overwrite)", { path: contextPath });
     return;
@@ -49086,8 +49366,8 @@ async function initPackage(repoRoot, packagePath, force = false) {
 }
 async function initContext(projectRoot, options = {}) {
   const logger = getLogger();
-  const naxDir = join43(projectRoot, ".nax");
-  const contextPath = join43(naxDir, "context.md");
+  const naxDir = join44(projectRoot, ".nax");
+  const contextPath = join44(naxDir, "context.md");
   if (existsSync22(contextPath) && !options.force) {
     logger.info("init", "context.md already exists, skipping (use --force to overwrite)", { path: contextPath });
     return;
@@ -49694,19 +49974,19 @@ var init_command_argv = __esm(() => {
 });
 
 // src/hooks/runner.ts
-import { join as join60 } from "path";
+import { join as join61 } from "path";
 async function loadHooksConfig(projectDir, globalDir) {
   let globalHooks = { hooks: {} };
   let projectHooks = { hooks: {} };
   let skipGlobal = false;
-  const projectPath = join60(projectDir, "hooks.json");
+  const projectPath = join61(projectDir, "hooks.json");
   const projectData = await loadJsonFile(projectPath, "hooks");
   if (projectData) {
     projectHooks = projectData;
     skipGlobal = projectData.skipGlobal ?? false;
   }
   if (!skipGlobal && globalDir) {
-    const globalPath = join60(globalDir, "hooks.json");
+    const globalPath = join61(globalDir, "hooks.json");
     const globalData = await loadJsonFile(globalPath, "hooks");
     if (globalData) {
       globalHooks = globalData;
@@ -49861,7 +50141,7 @@ var package_default;
 var init_package = __esm(() => {
   package_default = {
     name: "@nathapp/nax",
-    version: "0.64.1",
+    version: "0.64.2-canary.1",
     description: "AI Coding Agent Orchestrator \u2014 loops until done",
     type: "module",
     bin: {
@@ -49945,8 +50225,8 @@ var init_version = __esm(() => {
   NAX_VERSION = package_default.version;
   NAX_COMMIT = (() => {
     try {
-      if (/^[0-9a-f]{6,10}$/.test("8afbec51"))
-        return "8afbec51";
+      if (/^[0-9a-f]{6,10}$/.test("b8feb3bf"))
+        return "b8feb3bf";
     } catch {}
     try {
       const result = Bun.spawnSync(["git", "rev-parse", "--short", "HEAD"], {
@@ -50392,7 +50672,7 @@ async function loadAcceptanceTestContent2(featureDir, testPaths, configuredTestP
 function buildResult(success2, prd, totalCost, iterations, storiesCompleted, prdDirty, failedACs, retries) {
   return { success: success2, prd, totalCost, iterations, storiesCompleted, prdDirty, failedACs, retries };
 }
-async function regenerateAcceptanceTest(testPath, acceptanceContext, previousFailure) {
+async function regenerateAcceptanceTest(testPath, acceptanceContext) {
   const logger = getSafeLogger();
   const bakPath = `${testPath}.bak`;
   const content = await Bun.file(testPath).text();
@@ -50440,8 +50720,7 @@ async function regenerateAcceptanceTest(testPath, acceptanceContext, previousFai
   }
   const contextForSetup = {
     ...acceptanceContext,
-    ...implementationContext ? { implementationContext } : {},
-    ...previousFailure ? { previousFailure } : {}
+    ...implementationContext ? { implementationContext } : {}
   };
   await _regenerateDeps.acceptanceSetupExecute(contextForSetup);
   if (!await Bun.file(testPath).exists()) {
@@ -50474,7 +50753,7 @@ var init_acceptance_helpers = __esm(() => {
 });
 
 // src/execution/lifecycle/acceptance-fix.ts
-function fixCallCtx(ctx) {
+function fixCallCtx2(ctx) {
   if (!ctx.runtime) {
     throw new NaxError("runtime required for acceptance fix callOp", "CALL_OP_NO_RUNTIME", { stage: "acceptance" });
   }
@@ -50489,7 +50768,7 @@ function fixCallCtx(ctx) {
 }
 async function resolveAcceptanceDiagnosis(opts) {
   const logger = getSafeLogger();
-  const { ctx, failures, totalACs, strategy, semanticVerdicts, diagnosisOpts, previousFailure } = opts;
+  const { ctx, failures, totalACs, strategy, semanticVerdicts, diagnosisOpts } = opts;
   const storyId = diagnosisOpts.storyId;
   if (strategy === "implement-only") {
     logger?.info("acceptance.diagnosis", "Fast path: implement-only strategy \u2192 source_bug", { storyId });
@@ -50525,74 +50804,21 @@ async function resolveAcceptanceDiagnosis(opts) {
     };
   }
   const sourceFiles = await loadSourceFilesForDiagnosis(diagnosisOpts.testFileContent, diagnosisOpts.workdir);
-  return await _applyFixDeps.callOp(fixCallCtx(ctx), acceptanceDiagnoseOp, {
+  return await _diagnosisDeps.callOp(fixCallCtx2(ctx), acceptanceDiagnoseOp, {
     testOutput: diagnosisOpts.testOutput,
     testFileContent: diagnosisOpts.testFileContent,
     sourceFiles,
-    semanticVerdicts,
-    previousFailure
+    semanticVerdicts
   });
 }
-async function applyFix(opts) {
-  const logger = getSafeLogger();
-  const { ctx, failures, diagnosis, previousFailure } = opts;
-  const storyId = ctx.prd.userStories[0]?.id ?? "unknown";
-  if (!ctx.runtime) {
-    logger?.error("acceptance.applyFix", "Runtime not found", { storyId });
-    return { cost: 0 };
-  }
-  const testPaths = ctx.acceptanceTestPaths;
-  let testFileContent = "";
-  let acceptanceTestPath = "";
-  if (testPaths && testPaths.length > 0) {
-    const pathStrings = testPaths.map((p) => typeof p === "string" ? p : p.testPath);
-    const moduleEntries = await loadAcceptanceTestContent(pathStrings);
-    if (moduleEntries.length > 0) {
-      testFileContent = moduleEntries[0].content;
-      acceptanceTestPath = moduleEntries[0].testPath;
-    }
-  } else if (ctx.featureDir) {
-    const fallbackPath = resolveAcceptanceFeatureTestPath(ctx.featureDir, ctx.config.acceptance.testPath, ctx.config.project?.language);
-    const moduleEntries = await loadAcceptanceTestContent(fallbackPath);
-    if (moduleEntries.length > 0) {
-      testFileContent = moduleEntries[0].content;
-      acceptanceTestPath = moduleEntries[0].testPath;
-    }
-  }
-  const callCtx = fixCallCtx(ctx);
-  if (diagnosis.verdict === "source_bug" || diagnosis.verdict === "both") {
-    logger?.info("acceptance.applyFix", "Applying source fix", { storyId, verdict: diagnosis.verdict });
-    await _applyFixDeps.callOp(callCtx, acceptanceFixSourceOp, {
-      testOutput: failures.testOutput,
-      diagnosisReasoning: diagnosis.reasoning,
-      acceptanceTestPath,
-      testFileContent
-    });
-    logger?.info("acceptance.source-fix", "Source fix completed", { storyId });
-  }
-  if (diagnosis.verdict === "test_bug" || diagnosis.verdict === "both") {
-    logger?.info("acceptance.applyFix", "Applying test fix", { storyId, verdict: diagnosis.verdict });
-    await _applyFixDeps.callOp(callCtx, acceptanceFixTestOp, {
-      testOutput: failures.testOutput,
-      diagnosisReasoning: diagnosis.reasoning,
-      failedACs: failures.failedACs,
-      acceptanceTestPath,
-      testFileContent,
-      previousFailure
-    });
-    logger?.info("acceptance.test-fix", "Test fix completed", { storyId });
-  }
-  return { cost: 0 };
-}
-var _applyFixDeps;
+var _diagnosisDeps;
 var init_acceptance_fix2 = __esm(() => {
-  init_test_path();
   init_errors();
   init_logger2();
   init_operations();
   init_call();
   init_acceptance_helpers();
-  _applyFixDeps = {
+  _diagnosisDeps = {
     callOp
   };
 });
@@ -50601,6 +50827,7 @@ var init_acceptance_fix2 = __esm(() => {
 var exports_acceptance_loop = {};
 __export(exports_acceptance_loop, {
   runAcceptanceLoop: () => runAcceptanceLoop,
+  runAcceptanceFixCycle: () => runAcceptanceFixCycle,
   regenerateAcceptanceTest: () => regenerateAcceptanceTest,
   loadSpecContent: () => loadSpecContent,
   loadAcceptanceTestContent: () => loadAcceptanceTestContent2,
@@ -50608,48 +50835,157 @@ __export(exports_acceptance_loop, {
   isStubTestFile: () => isStubTestFile,
   buildResult: () => buildResult,
   _regenerateDeps: () => _regenerateDeps,
-  _acceptanceLoopDeps: () => _acceptanceLoopDeps
-});
+  _acceptanceLoopDeps: () => _acceptanceLoopDeps,
+  _acceptanceFixCycleDeps: () => _acceptanceFixCycleDeps
+});
+function convertFailuresToFindings(failedACs, testOutput) {
+  return failedACs.map((ac) => {
+    if (ac === "AC-HOOK" || ac === "AC-ERROR") {
+      return acSentinelToFinding(ac, testOutput);
+    }
+    return acFailureToFinding(ac, testOutput);
+  });
+}
+function findingsForDiagnosis(failedACs, testOutput, diagnosis) {
+  if (diagnosis.findings && diagnosis.findings.length > 0)
+    return diagnosis.findings;
+  const findings = convertFailuresToFindings(failedACs, testOutput);
+  const isTestRunnerSentinel = (f) => f.category === "hook-failure" || f.category === "test-runner-error";
+  if (diagnosis.verdict === "source_bug") {
+    return findings.map((f) => isTestRunnerSentinel(f) ? f : { ...f, fixTarget: "source" });
+  }
+  if (diagnosis.verdict === "test_bug")
+    return findings.map((f) => ({ ...f, fixTarget: "test" }));
+  return findings.flatMap((f) => isTestRunnerSentinel(f) ? [f] : [
+    { ...f, fixTarget: "source" },
+    { ...f, fixTarget: "test" }
+  ]);
+}
+function buildFixCycleCtx(ctx, runtime, storyId) {
+  return {
+    runtime,
+    packageView: runtime.packages.resolve(ctx.workdir),
+    packageDir: ctx.workdir,
+    storyId,
+    featureName: ctx.feature,
+    agentName: ctx.agentManager?.getDefault() ?? "claude"
+  };
+}
+function buildAcceptanceContext(ctx, prd) {
+  const firstStory = prd.userStories[0];
+  return {
+    config: ctx.config,
+    rootConfig: ctx.config,
+    prd,
+    story: firstStory,
+    stories: [firstStory],
+    routing: {
+      complexity: "simple",
+      modelTier: "balanced",
+      testStrategy: "test-after",
+      reasoning: "Acceptance validation"
+    },
+    projectDir: ctx.workdir,
+    workdir: ctx.workdir,
+    naxIgnoreIndex: ctx.naxIgnoreIndex,
+    featureDir: ctx.featureDir,
+    hooks: ctx.hooks,
+    plugins: ctx.pluginRegistry,
+    agentGetFn: ctx.agentGetFn,
+    agentManager: ctx.agentManager,
+    sessionManager: ctx.sessionManager,
+    acceptanceTestPaths: ctx.acceptanceTestPaths,
+    runtime: ctx.runtime,
+    abortSignal: ctx.abortSignal
+  };
+}
+async function runAcceptanceTestsOnce(ctx, prd) {
+  const acceptanceContext = buildAcceptanceContext(ctx, prd);
+  const { acceptanceStage: acceptanceStage2 } = await Promise.resolve().then(() => (init_acceptance2(), exports_acceptance));
+  const result = await acceptanceStage2.execute(acceptanceContext);
+  if (result.action !== "fail")
+    return { passed: true, failedACs: [], testOutput: "" };
+  const failures = acceptanceContext.acceptanceFailures;
+  if (!failures || failures.failedACs.length === 0)
+    return { passed: true, failedACs: [], testOutput: "" };
+  return { passed: false, failedACs: failures.failedACs, testOutput: failures.testOutput };
+}
+async function runAcceptanceFixCycle(ctx, prd, initialFailures, diagnosis, testFileContent, acceptanceTestPath) {
+  const runtime = ctx.runtime;
+  if (!runtime) {
+    return { iterations: [], finalFindings: [], exitReason: "no-strategy" };
+  }
+  let currentTestOutput = initialFailures.testOutput;
+  let currentFailedACs = initialFailures.failedACs;
+  const storyId = prd.userStories[0]?.id ?? "unknown";
+  const cycleCtx = buildFixCycleCtx(ctx, runtime, storyId);
+  const cycle = {
+    findings: findingsForDiagnosis(initialFailures.failedACs, initialFailures.testOutput, diagnosis),
+    iterations: [],
+    strategies: [
+      {
+        name: "acceptance-source-fix",
+        appliesTo: (f) => f.fixTarget === "source",
+        appliesToVerdict: (v) => v === "source_bug" || v === "both",
+        fixOp: acceptanceFixSourceOp,
+        buildInput: (_findings, priorIterations, _ctx) => ({
+          testOutput: currentTestOutput,
+          diagnosisReasoning: diagnosis.reasoning,
+          priorIterationsBlock: buildPriorIterationsBlock(priorIterations),
+          acceptanceTestPath,
+          testFileContent
+        }),
+        maxAttempts: 3,
+        coRun: "co-run-sequential"
+      },
+      {
+        name: "acceptance-test-fix",
+        appliesTo: (f) => f.fixTarget === "test",
+        appliesToVerdict: (v) => v === "test_bug" || v === "both",
+        fixOp: acceptanceFixTestOp,
+        buildInput: (_findings, priorIterations, _ctx) => ({
+          testOutput: currentTestOutput,
+          diagnosisReasoning: diagnosis.reasoning,
+          priorIterationsBlock: buildPriorIterationsBlock(priorIterations),
+          failedACs: currentFailedACs,
+          acceptanceTestPath,
+          testFileContent
+        }),
+        maxAttempts: 3,
+        coRun: "co-run-sequential"
+      }
+    ],
+    validate: async (_ctx) => {
+      const result = await runAcceptanceTestsOnce(ctx, prd);
+      if (result.passed)
+        return [];
+      currentTestOutput = result.testOutput;
+      currentFailedACs = result.failedACs;
+      return findingsForDiagnosis(result.failedACs, result.testOutput, diagnosis);
+    },
+    config: {
+      maxAttemptsTotal: ctx.config.acceptance.maxRetries,
+      validatorRetries: 1
+    },
+    verdict: diagnosis.verdict
+  };
+  return _acceptanceFixCycleDeps.runFixCycle(cycle, cycleCtx, "acceptance");
+}
 async function runAcceptanceLoop(ctx) {
   const logger = getSafeLogger();
   const maxRetries = ctx.config.acceptance.maxRetries;
   let acceptanceRetries = 0;
   let stubRegenCount = 0;
-  let previousFailure = "";
   const prd = ctx.prd;
   let totalCost = ctx.totalCost;
   const iterations = ctx.iterations;
   const storiesCompleted = ctx.storiesCompleted;
   const prdDirty = false;
   logger?.info("acceptance", "All stories complete, running acceptance validation");
+  const { acceptanceStage: acceptanceStage2 } = await Promise.resolve().then(() => (init_acceptance2(), exports_acceptance));
   while (acceptanceRetries < maxRetries) {
     const firstStory = prd.userStories[0];
-    const acceptanceContext = {
-      config: ctx.config,
-      rootConfig: ctx.config,
-      prd,
-      story: firstStory,
-      stories: [firstStory],
-      routing: {
-        complexity: "simple",
-        modelTier: "balanced",
-        testStrategy: "test-after",
-        reasoning: "Acceptance validation"
-      },
-      projectDir: ctx.workdir,
-      workdir: ctx.workdir,
-      naxIgnoreIndex: ctx.naxIgnoreIndex,
-      featureDir: ctx.featureDir,
-      hooks: ctx.hooks,
-      plugins: ctx.pluginRegistry,
-      agentGetFn: ctx.agentGetFn,
-      agentManager: ctx.agentManager,
-      sessionManager: ctx.sessionManager,
-      acceptanceTestPaths: ctx.acceptanceTestPaths,
-      runtime: ctx.runtime,
-      abortSignal: ctx.abortSignal
-    };
-    const { acceptanceStage: acceptanceStage2 } = await Promise.resolve().then(() => (init_acceptance2(), exports_acceptance));
+    const acceptanceContext = buildAcceptanceContext(ctx, prd);
     const acceptanceResult = await acceptanceStage2.execute(acceptanceContext);
     if (acceptanceResult.action === "continue") {
       logger?.info("acceptance", "Acceptance validation passed!");
@@ -50711,6 +51047,7 @@ async function runAcceptanceLoop(ctx) {
     }
     const testEntries = ctx.acceptanceTestPaths ? await loadAcceptanceTestContent(ctx.acceptanceTestPaths.map((p) => p.testPath)) : [];
     const testFileContent = testEntries[0]?.content ?? "";
+    const acceptanceTestPath = testEntries[0]?.testPath ?? ctx.acceptanceTestPaths?.[0]?.testPath ?? "";
     const strategy = ctx.config.acceptance.fix?.strategy ?? "diagnose-first";
     const diagnosis = await resolveAcceptanceDiagnosis({
       ctx,
@@ -50723,8 +51060,7 @@ async function runAcceptanceLoop(ctx) {
         testFileContent,
         workdir: ctx.workdir,
         storyId: firstStory?.id
-      },
-      previousFailure
+      }
     });
     logger?.info("acceptance.diagnosis", "Diagnosis resolved", {
       storyId: firstStory?.id,
@@ -50732,28 +51068,22 @@ async function runAcceptanceLoop(ctx) {
       confidence: diagnosis.confidence,
       attempt: acceptanceRetries
     });
-    const fixResult = await applyFix({
-      ctx,
-      failures,
-      diagnosis,
-      previousFailure
-    });
-    totalCost += fixResult.cost;
-    previousFailure += `
----
-Attempt ${acceptanceRetries}/${maxRetries}: verdict=${diagnosis.verdict}, confidence=${diagnosis.confidence}
-Reasoning: ${diagnosis.reasoning}
-Failed ACs: ${failures.failedACs.join(", ")}
-`;
+    const cycleResult = await runAcceptanceFixCycle(ctx, prd, failures, diagnosis, testFileContent, acceptanceTestPath);
+    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);
   }
   return buildResult(false, prd, totalCost, iterations, storiesCompleted, prdDirty);
 }
-var _acceptanceLoopDeps, MAX_STUB_REGENS = 2;
+var _acceptanceLoopDeps, _acceptanceFixCycleDeps, MAX_STUB_REGENS = 2;
 var init_acceptance_loop = __esm(() => {
   init_semantic_verdict();
   init_test_path();
+  init_findings();
   init_hooks();
   init_logger2();
+  init_operations();
+  init_prompts();
   init_helpers();
   init_acceptance_fix2();
   init_acceptance_helpers();
@@ -50761,19 +51091,22 @@ var init_acceptance_loop = __esm(() => {
   _acceptanceLoopDeps = {
     loadSemanticVerdicts
   };
+  _acceptanceFixCycleDeps = {
+    runFixCycle
+  };
 });
 
 // src/session/scratch-purge.ts
 import { mkdir as mkdir10, rename, rm } from "fs/promises";
-import { dirname as dirname9, join as join61 } from "path";
+import { dirname as dirname9, join as join62 } from "path";
 async function purgeStaleScratch(projectDir, featureName, retentionDays, archiveInsteadOfDelete = false) {
-  const sessionsDir = join61(projectDir, ".nax", "features", featureName, "sessions");
+  const sessionsDir = join62(projectDir, ".nax", "features", featureName, "sessions");
   const sessionIds = await _scratchPurgeDeps.listSessionDirs(sessionsDir);
   const cutoffMs = _scratchPurgeDeps.now() - retentionDays * 86400000;
   let purged = 0;
   for (const sessionId of sessionIds) {
-    const sessionDir = join61(sessionsDir, sessionId);
-    const descriptorPath = join61(sessionDir, "descriptor.json");
+    const sessionDir = join62(sessionsDir, sessionId);
+    const descriptorPath = join62(sessionDir, "descriptor.json");
     if (!await _scratchPurgeDeps.fileExists(descriptorPath))
       continue;
     let lastActivityAt;
@@ -50789,7 +51122,7 @@ async function purgeStaleScratch(projectDir, featureName, retentionDays, archive
     if (new Date(lastActivityAt).getTime() >= cutoffMs)
       continue;
     if (archiveInsteadOfDelete) {
-      const archiveDest = join61(projectDir, ".nax", "features", featureName, "_archive", "sessions", sessionId);
+      const archiveDest = join62(projectDir, ".nax", "features", featureName, "_archive", "sessions", sessionId);
       await _scratchPurgeDeps.move(sessionDir, archiveDest);
     } else {
       await _scratchPurgeDeps.remove(sessionDir);
@@ -51452,12 +51785,12 @@ var DEFAULT_MAX_BATCH_SIZE = 4;
 // src/pipeline/subscribers/events-writer.ts
 import { appendFile as appendFile4, mkdir as mkdir11 } from "fs/promises";
 import { homedir as homedir5 } from "os";
-import { basename as basename9, join as join62 } from "path";
+import { basename as basename9, join as join63 } from "path";
 function wireEventsWriter(bus, feature, runId, workdir) {
   const logger = getSafeLogger();
   const project = basename9(workdir);
-  const eventsDir = join62(homedir5(), ".nax", "events", project);
-  const eventsFile = join62(eventsDir, "events.jsonl");
+  const eventsDir = join63(homedir5(), ".nax", "events", project);
+  const eventsFile = join63(eventsDir, "events.jsonl");
   let dirReady = false;
   const write = (line) => {
     return (async () => {
@@ -51638,12 +51971,12 @@ var init_interaction2 = __esm(() => {
 // src/pipeline/subscribers/registry.ts
 import { mkdir as mkdir12, writeFile } from "fs/promises";
 import { homedir as homedir6 } from "os";
-import { basename as basename10, join as join63 } from "path";
+import { basename as basename10, join as join64 } from "path";
 function wireRegistry(bus, feature, runId, workdir) {
   const logger = getSafeLogger();
   const project = basename10(workdir);
-  const runDir = join63(homedir6(), ".nax", "runs", `${project}-${feature}-${runId}`);
-  const metaFile = join63(runDir, "meta.json");
+  const runDir = join64(homedir6(), ".nax", "runs", `${project}-${feature}-${runId}`);
+  const metaFile = join64(runDir, "meta.json");
   const unsub = bus.on("run:started", (_ev) => {
     return (async () => {
       try {
@@ -51653,8 +51986,8 @@ function wireRegistry(bus, feature, runId, workdir) {
           project,
           feature,
           workdir,
-          statusPath: join63(workdir, ".nax", "features", feature, "status.json"),
-          eventsDir: join63(workdir, ".nax", "features", feature, "runs"),
+          statusPath: join64(workdir, ".nax", "features", feature, "status.json"),
+          eventsDir: join64(workdir, ".nax", "features", feature, "runs"),
           registeredAt: new Date().toISOString()
         };
         await writeFile(metaFile, JSON.stringify(meta3, null, 2));
@@ -51888,7 +52221,7 @@ function buildPreviewRouting(story, config2) {
 
 // src/worktree/types.ts
 var WorktreeDependencyPreparationError;
-var init_types7 = __esm(() => {
+var init_types8 = __esm(() => {
   WorktreeDependencyPreparationError = class WorktreeDependencyPreparationError extends Error {
     mode;
     failureCategory = "dependency-prep";
@@ -51902,7 +52235,7 @@ var init_types7 = __esm(() => {
 
 // src/worktree/dependencies.ts
 import { existsSync as existsSync30 } from "fs";
-import { join as join64 } from "path";
+import { join as join65 } from "path";
 async function prepareWorktreeDependencies(options) {
   const mode = options.config.execution.worktreeDependencies.mode;
   const resolvedCwd = resolveDependencyCwd(options);
@@ -51916,7 +52249,7 @@ async function prepareWorktreeDependencies(options) {
   }
 }
 function resolveDependencyCwd(options) {
-  return options.storyWorkdir ? join64(options.worktreeRoot, options.storyWorkdir) : options.worktreeRoot;
+  return options.storyWorkdir ? join65(options.worktreeRoot, options.storyWorkdir) : options.worktreeRoot;
 }
 function resolveInheritedDependencies(options, resolvedCwd) {
   if (hasDependencyManifests(options.worktreeRoot, resolvedCwd)) {
@@ -51926,7 +52259,7 @@ function resolveInheritedDependencies(options, resolvedCwd) {
 }
 function hasDependencyManifests(worktreeRoot, resolvedCwd) {
   const directories = resolvedCwd === worktreeRoot ? [worktreeRoot] : [worktreeRoot, resolvedCwd];
-  return directories.some((directory) => PHASE_ONE_INHERIT_UNSUPPORTED_FILES.some((filename) => _worktreeDependencyDeps.existsSync(join64(directory, filename))));
+  return directories.some((directory) => PHASE_ONE_INHERIT_UNSUPPORTED_FILES.some((filename) => _worktreeDependencyDeps.existsSync(join65(directory, filename))));
 }
 async function provisionDependencies(config2, worktreeRoot, resolvedCwd) {
   const setupCommand = config2.execution.worktreeDependencies.setupCommand;
@@ -51958,7 +52291,7 @@ var PHASE_ONE_INHERIT_UNSUPPORTED_FILES, _worktreeDependencyDeps;
 var init_dependencies = __esm(() => {
   init_bun_deps();
   init_command_argv();
-  init_types7();
+  init_types8();
   PHASE_ONE_INHERIT_UNSUPPORTED_FILES = [
     "package.json",
     "bun.lock",
@@ -51990,13 +52323,13 @@ __export(exports_manager, {
 });
 import { existsSync as existsSync31, symlinkSync } from "fs";
 import { mkdir as mkdir13 } from "fs/promises";
-import { join as join65 } from "path";
+import { join as join66 } from "path";
 
 class WorktreeManager {
   async ensureGitExcludes(projectRoot) {
     const logger = getSafeLogger();
-    const infoDir = join65(projectRoot, ".git", "info");
-    const excludePath = join65(infoDir, "exclude");
+    const infoDir = join66(projectRoot, ".git", "info");
+    const excludePath = join66(infoDir, "exclude");
     try {
       await mkdir13(infoDir, { recursive: true });
       let existing = "";
@@ -52023,7 +52356,7 @@ ${missing.join(`
   }
   async create(projectRoot, storyId) {
     validateStoryId(storyId);
-    const worktreePath = join65(projectRoot, ".nax-wt", storyId);
+    const worktreePath = join66(projectRoot, ".nax-wt", storyId);
     const branchName = `nax/${storyId}`;
     try {
       const pruneProc = _managerDeps.spawn(["git", "worktree", "prune"], {
@@ -52064,9 +52397,9 @@ ${missing.join(`
       }
       throw new Error(`Failed to create worktree: ${String(error48)}`);
     }
-    const envSource = join65(projectRoot, ".env");
+    const envSource = join66(projectRoot, ".env");
     if (existsSync31(envSource)) {
-      const envTarget = join65(worktreePath, ".env");
+      const envTarget = join66(worktreePath, ".env");
       try {
         symlinkSync(envSource, envTarget, "file");
       } catch (error48) {
@@ -52077,7 +52410,7 @@ ${missing.join(`
   }
   async remove(projectRoot, storyId) {
     validateStoryId(storyId);
-    const worktreePath = join65(projectRoot, ".nax-wt", storyId);
+    const worktreePath = join66(projectRoot, ".nax-wt", storyId);
     const branchName = `nax/${storyId}`;
     try {
       const proc = _managerDeps.spawn(["git", "worktree", "remove", worktreePath, "--force"], {
@@ -52789,10 +53122,10 @@ var init_merge_conflict_rectify = __esm(() => {
 });
 
 // src/execution/pipeline-result-handler.ts
-import { join as join66 } from "path";
+import { join as join67 } from "path";
 async function removeWorktreeDirectory(projectRoot, storyId) {
   const logger = getSafeLogger();
-  const worktreePath = join66(projectRoot, ".nax-wt", storyId);
+  const worktreePath = join67(projectRoot, ".nax-wt", storyId);
   try {
     const proc = _resultHandlerDeps.spawn(["git", "worktree", "remove", worktreePath, "--force"], {
       cwd: projectRoot,
@@ -53003,7 +53336,7 @@ var init_pipeline_result_handler = __esm(() => {
 
 // src/execution/iteration-runner.ts
 import { existsSync as existsSync32 } from "fs";
-import { join as join67 } from "path";
+import { join as join68 } from "path";
 async function runIteration(ctx, prd, selection, iterations, totalCost, allStoryMetrics) {
   const { story, storiesToExecute, routing, isBatchExecution } = selection;
   if (ctx.dryRun) {
@@ -53028,7 +53361,7 @@ async function runIteration(ctx, prd, selection, iterations, totalCost, allStory
   const storyStartTime = Date.now();
   let effectiveWorkdir = ctx.workdir;
   if (ctx.config.execution.storyIsolation === "worktree") {
-    const worktreePath = join67(ctx.workdir, ".nax-wt", story.id);
+    const worktreePath = join68(ctx.workdir, ".nax-wt", story.id);
     const worktreeExists = _iterationRunnerDeps.existsSync(worktreePath);
     if (!worktreeExists) {
       await _iterationRunnerDeps.worktreeManager.ensureGitExcludes(ctx.workdir);
@@ -53048,7 +53381,7 @@ async function runIteration(ctx, prd, selection, iterations, totalCost, allStory
   }
   const accumulatedAttemptCost = (story.priorFailures || []).reduce((sum, f) => sum + (f.cost || 0), 0);
   const profileOverride = ctx.config.profile && ctx.config.profile !== "default" ? { profile: ctx.config.profile } : undefined;
-  const effectiveConfig = story.workdir ? await _iterationRunnerDeps.loadConfigForWorkdir(join67(ctx.workdir, ".nax", "config.json"), story.workdir, profileOverride) : ctx.config;
+  const effectiveConfig = story.workdir ? await _iterationRunnerDeps.loadConfigForWorkdir(join68(ctx.workdir, ".nax", "config.json"), story.workdir, profileOverride) : ctx.config;
   let dependencyContext;
   if (ctx.config.execution.storyIsolation === "worktree") {
     try {
@@ -53075,7 +53408,7 @@ async function runIteration(ctx, prd, selection, iterations, totalCost, allStory
       };
     }
   }
-  const resolvedWorkdir = dependencyContext?.cwd ? dependencyContext.cwd : ctx.config.execution.storyIsolation === "worktree" ? story.workdir ? join67(effectiveWorkdir, story.workdir) : effectiveWorkdir : story.workdir ? join67(ctx.workdir, story.workdir) : ctx.workdir;
+  const resolvedWorkdir = dependencyContext?.cwd ? dependencyContext.cwd : ctx.config.execution.storyIsolation === "worktree" ? story.workdir ? join68(effectiveWorkdir, story.workdir) : effectiveWorkdir : story.workdir ? join68(ctx.workdir, story.workdir) : ctx.workdir;
   const pipelineContext = {
     config: effectiveConfig,
     rootConfig: ctx.config,
@@ -53272,7 +53605,7 @@ __export(exports_parallel_worker, {
   executeParallelBatch: () => executeParallelBatch,
   _parallelWorkerDeps: () => _parallelWorkerDeps
 });
-import { join as join68 } from "path";
+import { join as join69 } from "path";
 async function executeStoryInWorktree(story, worktreePath, dependencyContext, context, routing, eventEmitter) {
   const logger = getSafeLogger();
   try {
@@ -53292,7 +53625,7 @@ async function executeStoryInWorktree(story, worktreePath, dependencyContext, co
       story,
       stories: [story],
       projectDir: context.projectDir,
-      workdir: dependencyContext.cwd ?? (story.workdir ? join68(worktreePath, story.workdir) : worktreePath),
+      workdir: dependencyContext.cwd ?? (story.workdir ? join69(worktreePath, story.workdir) : worktreePath),
       worktreeDependencyContext: dependencyContext,
       routing,
       storyGitRef: storyGitRef ?? undefined
@@ -54053,16 +54386,16 @@ var init_unified_executor = __esm(() => {
 });
 
 // src/project/detector.ts
-import { join as join69 } from "path";
+import { join as join70 } from "path";
 async function detectLanguage(workdir, pkg) {
   const deps = _detectorDeps;
-  if (await deps.fileExists(join69(workdir, "go.mod")))
+  if (await deps.fileExists(join70(workdir, "go.mod")))
     return "go";
-  if (await deps.fileExists(join69(workdir, "Cargo.toml")))
+  if (await deps.fileExists(join70(workdir, "Cargo.toml")))
     return "rust";
-  if (await deps.fileExists(join69(workdir, "pyproject.toml")))
+  if (await deps.fileExists(join70(workdir, "pyproject.toml")))
     return "python";
-  if (await deps.fileExists(join69(workdir, "requirements.txt")))
+  if (await deps.fileExists(join70(workdir, "requirements.txt")))
     return "python";
   if (pkg != null) {
     const allDeps = {
@@ -54122,18 +54455,18 @@ async function detectLintTool(workdir, language) {
   if (language === "python")
     return "ruff";
   const deps = _detectorDeps;
-  if (await deps.fileExists(join69(workdir, "biome.json")))
+  if (await deps.fileExists(join70(workdir, "biome.json")))
     return "biome";
-  if (await deps.fileExists(join69(workdir, ".eslintrc")))
+  if (await deps.fileExists(join70(workdir, ".eslintrc")))
     return "eslint";
-  if (await deps.fileExists(join69(workdir, ".eslintrc.js")))
+  if (await deps.fileExists(join70(workdir, ".eslintrc.js")))
     return "eslint";
-  if (await deps.fileExists(join69(workdir, ".eslintrc.json")))
+  if (await deps.fileExists(join70(workdir, ".eslintrc.json")))
     return "eslint";
   return;
 }
 async function detectProjectProfile(workdir, existing) {
-  const pkg = await _detectorDeps.readJson(join69(workdir, "package.json"));
+  const pkg = await _detectorDeps.readJson(join70(workdir, "package.json"));
   const language = existing.language !== undefined ? existing.language : await detectLanguage(workdir, pkg);
   const type = existing.type !== undefined ? existing.type : detectType(pkg);
   const testFramework = existing.testFramework !== undefined ? existing.testFramework : await detectTestFramework(workdir, language, pkg);
@@ -54170,7 +54503,7 @@ var init_project = __esm(() => {
 
 // src/execution/status-file.ts
 import { rename as rename2, unlink as unlink3 } from "fs/promises";
-import { resolve as resolve15 } from "path";
+import { resolve as resolve16 } from "path";
 function countProgress(prd) {
   const stories = prd.userStories;
   const passed = stories.filter((s) => s.status === "passed").length;
@@ -54215,7 +54548,7 @@ function buildStatusSnapshot(state) {
   return snapshot;
 }
 async function writeStatusFile(filePath, status) {
-  const resolvedPath = resolve15(filePath);
+  const resolvedPath = resolve16(filePath);
   if (filePath.includes("../") || filePath.includes("..\\")) {
     throw new Error("Invalid status file path: path traversal detected");
   }
@@ -54229,7 +54562,7 @@ async function writeStatusFile(filePath, status) {
 var init_status_file = () => {};
 
 // src/execution/status-writer.ts
-import { join as join70 } from "path";
+import { join as join71 } from "path";
 
 class StatusWriter {
   statusFile;
@@ -54348,7 +54681,7 @@ class StatusWriter {
     if (!this._prd)
       return;
     const safeLogger = getSafeLogger();
-    const featureStatusPath = join70(featureDir, "status.json");
+    const featureStatusPath = join71(featureDir, "status.json");
     const write = async () => {
       try {
         const base = this.getSnapshot(totalCost, iterations);
@@ -54560,7 +54893,7 @@ __export(exports_run_initialization, {
   initializeRun: () => initializeRun,
   _reconcileDeps: () => _reconcileDeps
 });
-import { join as join71 } from "path";
+import { join as join72 } from "path";
 async function reconcileState(prd, prdPath, workdir, config2) {
   const logger = getSafeLogger();
   let reconciledCount = 0;
@@ -54577,7 +54910,7 @@ async function reconcileState(prd, prdPath, workdir, config2) {
       });
       continue;
     }
-    const effectiveWorkdir = story.workdir ? join71(workdir, story.workdir) : workdir;
+    const effectiveWorkdir = story.workdir ? join72(workdir, story.workdir) : workdir;
     try {
       const reviewResult = await _reconcileDeps.runReview(config2.review, effectiveWorkdir, config2.execution);
       if (!reviewResult.success) {
@@ -55451,14 +55784,14 @@ See https://react.dev/link/invalid-hook-call for tips about how to debug and fix
       prevActScopeDepth !== actScopeDepth - 1 && console.error("You seem to have overlapping act() calls, this is not supported. Be sure to await previous act() calls before making a new one. ");
       actScopeDepth = prevActScopeDepth;
     }
-    function recursivelyFlushAsyncActWork(returnValue, resolve16, reject) {
+    function recursivelyFlushAsyncActWork(returnValue, resolve17, reject) {
       var queue = ReactSharedInternals.actQueue;
       if (queue !== null)
         if (queue.length !== 0)
           try {
             flushActQueue(queue);
             enqueueTask(function() {
-              return recursivelyFlushAsyncActWork(returnValue, resolve16, reject);
+              return recursivelyFlushAsyncActWork(returnValue, resolve17, reject);
             });
             return;
           } catch (error48) {
@@ -55466,7 +55799,7 @@ See https://react.dev/link/invalid-hook-call for tips about how to debug and fix
           }
         else
           ReactSharedInternals.actQueue = null;
-      0 < ReactSharedInternals.thrownErrors.length ? (queue = aggregateErrors(ReactSharedInternals.thrownErrors), ReactSharedInternals.thrownErrors.length = 0, reject(queue)) : resolve16(returnValue);
+      0 < ReactSharedInternals.thrownErrors.length ? (queue = aggregateErrors(ReactSharedInternals.thrownErrors), ReactSharedInternals.thrownErrors.length = 0, reject(queue)) : resolve17(returnValue);
     }
     function flushActQueue(queue) {
       if (!isFlushing) {
@@ -55642,14 +55975,14 @@ See https://react.dev/link/invalid-hook-call for tips about how to debug and fix
           didAwaitActCall || didWarnNoAwaitAct || (didWarnNoAwaitAct = true, console.error("You called act(async () => ...) without await. This could lead to unexpected testing behaviour, interleaving multiple act calls and mixing their scopes. You should - await act(async () => ...);"));
         });
         return {
-          then: function(resolve16, reject) {
+          then: function(resolve17, reject) {
             didAwaitActCall = true;
             thenable.then(function(returnValue) {
               popActScope(prevActQueue, prevActScopeDepth);
               if (prevActScopeDepth === 0) {
                 try {
                   flushActQueue(queue), enqueueTask(function() {
-                    return recursivelyFlushAsyncActWork(returnValue, resolve16, reject);
+                    return recursivelyFlushAsyncActWork(returnValue, resolve17, reject);
                   });
                 } catch (error$0) {
                   ReactSharedInternals.thrownErrors.push(error$0);
@@ -55660,7 +55993,7 @@ See https://react.dev/link/invalid-hook-call for tips about how to debug and fix
                   reject(_thrownError);
                 }
               } else
-                resolve16(returnValue);
+                resolve17(returnValue);
             }, function(error48) {
               popActScope(prevActQueue, prevActScopeDepth);
               0 < ReactSharedInternals.thrownErrors.length ? (error48 = aggregateErrors(ReactSharedInternals.thrownErrors), ReactSharedInternals.thrownErrors.length = 0, reject(error48)) : reject(error48);
@@ -55676,11 +56009,11 @@ See https://react.dev/link/invalid-hook-call for tips about how to debug and fix
       if (0 < ReactSharedInternals.thrownErrors.length)
         throw callback = aggregateErrors(ReactSharedInternals.thrownErrors), ReactSharedInternals.thrownErrors.length = 0, callback;
       return {
-        then: function(resolve16, reject) {
+        then: function(resolve17, reject) {
           didAwaitActCall = true;
           prevActScopeDepth === 0 ? (ReactSharedInternals.actQueue = queue, enqueueTask(function() {
-            return recursivelyFlushAsyncActWork(returnValue$jscomp$0, resolve16, reject);
-          })) : resolve16(returnValue$jscomp$0);
+            return recursivelyFlushAsyncActWork(returnValue$jscomp$0, resolve17, reject);
+          })) : resolve17(returnValue$jscomp$0);
         }
       };
     };
@@ -58522,8 +58855,8 @@ It can also happen if the client has a browser extension installed which messes
         currentEntangledActionThenable = {
           status: "pending",
           value: undefined,
-          then: function(resolve16) {
-            entangledListeners.push(resolve16);
+          then: function(resolve17) {
+            entangledListeners.push(resolve17);
           }
         };
       }
@@ -58547,8 +58880,8 @@ It can also happen if the client has a browser extension installed which messes
         status: "pending",
         value: null,
         reason: null,
-        then: function(resolve16) {
-          listeners.push(resolve16);
+        then: function(resolve17) {
+          listeners.push(resolve17);
         }
       };
       thenable.then(function() {
@@ -85940,7 +86273,7 @@ var require_jsx_dev_runtime = __commonJS((exports, module) => {
 init_source();
 import { existsSync as existsSync34, mkdirSync as mkdirSync7 } from "fs";
 import { homedir as homedir8 } from "os";
-import { join as join73 } from "path";
+import { join as join74 } from "path";
 
 // node_modules/commander/esm.mjs
 var import__ = __toESM(require_commander(), 1);
@@ -86836,7 +87169,7 @@ async function runsShowCommand(options) {
 // src/cli/prompts-main.ts
 init_logger2();
 import { existsSync as existsSync20, mkdirSync as mkdirSync3 } from "fs";
-import { join as join41 } from "path";
+import { join as join42 } from "path";
 
 // src/pipeline/index.ts
 init_runner2();
@@ -86912,7 +87245,7 @@ function buildFrontmatter(story, ctx, role) {
 
 // src/cli/prompts-tdd.ts
 init_prompts();
-import { join as join40 } from "path";
+import { join as join41 } from "path";
 async function handleThreeSessionTddPrompts(story, ctx, outputDir, logger) {
   const [testWriterPrompt, implementerPrompt, verifierPrompt] = await Promise.all([
     TddPromptBuilder.for("test-writer", { isolation: "strict" }).withLoader(ctx.workdir, ctx.config).story(story).context(ctx.contextMarkdown).constitution(ctx.constitution?.content).testCommand(ctx.config.quality?.commands?.test).build(),
@@ -86931,7 +87264,7 @@ ${frontmatter}---
 
 ${session.prompt}`;
     if (outputDir) {
-      const promptFile = join40(outputDir, `${story.id}.${session.role}.md`);
+      const promptFile = join41(outputDir, `${story.id}.${session.role}.md`);
       await Bun.write(promptFile, fullOutput);
       logger.info("cli", "Written TDD prompt file", {
         storyId: story.id,
@@ -86947,7 +87280,7 @@ ${"=".repeat(80)}`);
     }
   }
   if (outputDir && ctx.contextMarkdown) {
-    const contextFile = join40(outputDir, `${story.id}.context.md`);
+    const contextFile = join41(outputDir, `${story.id}.context.md`);
     const frontmatter = buildFrontmatter(story, ctx);
     const contextOutput = `---
 ${frontmatter}---
@@ -86961,12 +87294,12 @@ ${ctx.contextMarkdown}`;
 async function promptsCommand(options) {
   const logger = getLogger();
   const { feature, workdir, config: config2, storyId, outputDir } = options;
-  const naxDir = join41(workdir, ".nax");
+  const naxDir = join42(workdir, ".nax");
   if (!existsSync20(naxDir)) {
     throw new Error(`.nax directory not found. Run 'nax init' first in ${workdir}`);
   }
-  const featureDir = join41(naxDir, "features", feature);
-  const prdPath = join41(featureDir, "prd.json");
+  const featureDir = join42(naxDir, "features", feature);
+  const prdPath = join42(featureDir, "prd.json");
   if (!existsSync20(prdPath)) {
     throw new Error(`Feature "${feature}" not found or missing prd.json`);
   }
@@ -87033,10 +87366,10 @@ ${frontmatter}---
 
 ${ctx.prompt}`;
     if (outputDir) {
-      const promptFile = join41(outputDir, `${story.id}.prompt.md`);
+      const promptFile = join42(outputDir, `${story.id}.prompt.md`);
       await Bun.write(promptFile, fullOutput);
       if (ctx.contextMarkdown) {
-        const contextFile = join41(outputDir, `${story.id}.context.md`);
+        const contextFile = join42(outputDir, `${story.id}.context.md`);
         const contextOutput = `---
 ${frontmatter}---
 
@@ -87064,7 +87397,7 @@ ${"=".repeat(80)}`);
 // src/cli/prompts-init.ts
 init_role_task();
 import { existsSync as existsSync21, mkdirSync as mkdirSync4 } from "fs";
-import { join as join42 } from "path";
+import { join as join43 } from "path";
 var TEMPLATE_ROLES = [
   { file: "test-writer.md", role: "test-writer" },
   { file: "implementer.md", role: "implementer", variant: "standard" },
@@ -87088,9 +87421,9 @@ var TEMPLATE_HEADER = `<!--
 `;
 async function promptsInitCommand(options) {
   const { workdir, force = false, autoWireConfig = true } = options;
-  const templatesDir = join42(workdir, ".nax", "templates");
+  const templatesDir = join43(workdir, ".nax", "templates");
   mkdirSync4(templatesDir, { recursive: true });
-  const existingFiles = TEMPLATE_ROLES.map((t) => t.file).filter((f) => existsSync21(join42(templatesDir, f)));
+  const existingFiles = TEMPLATE_ROLES.map((t) => t.file).filter((f) => existsSync21(join43(templatesDir, f)));
   if (existingFiles.length > 0 && !force) {
     console.warn(`[WARN] nax/templates/ already contains files: ${existingFiles.join(", ")}. No files overwritten.
        Pass --force to overwrite existing templates.`);
@@ -87098,7 +87431,7 @@ async function promptsInitCommand(options) {
   }
   const written = [];
   for (const template of TEMPLATE_ROLES) {
-    const filePath = join42(templatesDir, template.file);
+    const filePath = join43(templatesDir, template.file);
     const roleBody = template.role === "implementer" ? buildRoleTaskSection(template.role, template.variant) : buildRoleTaskSection(template.role);
     const content = TEMPLATE_HEADER + roleBody;
     await Bun.write(filePath, content);
@@ -87114,7 +87447,7 @@ async function promptsInitCommand(options) {
   return written;
 }
 async function autoWirePromptsConfig(workdir) {
-  const configPath = join42(workdir, "nax.config.json");
+  const configPath = join43(workdir, "nax.config.json");
   if (!existsSync21(configPath)) {
     const exampleConfig = JSON.stringify({
       prompts: {
@@ -87280,7 +87613,7 @@ init_config();
 init_logger2();
 init_prd();
 import { existsSync as existsSync23, readdirSync as readdirSync6 } from "fs";
-import { join as join46 } from "path";
+import { join as join47 } from "path";
 
 // src/cli/diagnose-analysis.ts
 function detectFailurePattern(story, _prd, status) {
@@ -87479,7 +87812,7 @@ function isProcessAlive2(pid) {
   }
 }
 async function loadStatusFile2(workdir) {
-  const statusPath = join46(workdir, ".nax", "status.json");
+  const statusPath = join47(workdir, ".nax", "status.json");
   if (!existsSync23(statusPath))
     return null;
   try {
@@ -87507,7 +87840,7 @@ async function countCommitsSince(workdir, since) {
   }
 }
 async function checkLock(workdir) {
-  const lockFile = Bun.file(join46(workdir, "nax.lock"));
+  const lockFile = Bun.file(join47(workdir, "nax.lock"));
   if (!await lockFile.exists())
     return { lockPresent: false };
   try {
@@ -87525,8 +87858,8 @@ async function diagnoseCommand(options = {}) {
   const logger = getLogger();
   const workdir = options.workdir ?? process.cwd();
   const naxSubdir = findProjectDir(workdir);
-  let projectDir = naxSubdir ? join46(naxSubdir, "..") : null;
-  if (!projectDir && existsSync23(join46(workdir, ".nax"))) {
+  let projectDir = naxSubdir ? join47(naxSubdir, "..") : null;
+  if (!projectDir && existsSync23(join47(workdir, ".nax"))) {
     projectDir = workdir;
   }
   if (!projectDir)
@@ -87537,7 +87870,7 @@ async function diagnoseCommand(options = {}) {
     if (status2) {
       feature = status2.run.feature;
     } else {
-      const featuresDir = join46(projectDir, ".nax", "features");
+      const featuresDir = join47(projectDir, ".nax", "features");
       if (!existsSync23(featuresDir))
         throw new Error("No features found in project");
       const features = readdirSync6(featuresDir, { withFileTypes: true }).filter((e) => e.isDirectory()).map((e) => e.name);
@@ -87547,8 +87880,8 @@ async function diagnoseCommand(options = {}) {
       logger.info("diagnose", "No feature specified, using first found", { feature });
     }
   }
-  const featureDir = join46(projectDir, ".nax", "features", feature);
-  const prdPath = join46(featureDir, "prd.json");
+  const featureDir = join47(projectDir, ".nax", "features", feature);
+  const prdPath = join47(featureDir, "prd.json");
   if (!existsSync23(prdPath))
     throw new Error(`Feature not found: ${feature}`);
   const prd = await loadPRD(prdPath);
@@ -87592,7 +87925,7 @@ init_source();
 init_loader();
 init_generator2();
 import { existsSync as existsSync24 } from "fs";
-import { join as join47 } from "path";
+import { join as join48 } from "path";
 var VALID_AGENTS = ["claude", "codex", "opencode", "cursor", "windsurf", "aider", "gemini"];
 async function generateCommand(options) {
   const workdir = options.dir ?? process.cwd();
@@ -87635,7 +87968,7 @@ async function generateCommand(options) {
     return;
   }
   if (options.package) {
-    const packageDir = join47(workdir, options.package);
+    const packageDir = join48(workdir, options.package);
     if (dryRun) {
       console.log(source_default.yellow("\u26A0 Dry run \u2014 no files will be written"));
     }
@@ -87655,8 +87988,8 @@ async function generateCommand(options) {
       process.exit(1);
     return;
   }
-  const contextPath = options.context ? join47(workdir, options.context) : join47(workdir, ".nax/context.md");
-  const outputDir = options.output ? join47(workdir, options.output) : workdir;
+  const contextPath = options.context ? join48(workdir, options.context) : join48(workdir, ".nax/context.md");
+  const outputDir = options.output ? join48(workdir, options.output) : workdir;
   const autoInject = !options.noAutoInject;
   if (!existsSync24(contextPath)) {
     console.error(source_default.red(`\u2717 Context file not found: ${contextPath}`));
@@ -87762,7 +88095,7 @@ async function generateCommand(options) {
 // src/cli/config-display.ts
 init_loader();
 import { existsSync as existsSync26 } from "fs";
-import { join as join49 } from "path";
+import { join as join50 } from "path";
 
 // src/cli/config-descriptions.ts
 var FIELD_DESCRIPTIONS = {
@@ -88003,7 +88336,7 @@ function deepEqual(a, b) {
 init_defaults();
 init_loader();
 import { existsSync as existsSync25 } from "fs";
-import { join as join48 } from "path";
+import { join as join49 } from "path";
 async function loadConfigFile(path15) {
   if (!existsSync25(path15))
     return null;
@@ -88025,7 +88358,7 @@ async function loadProjectConfig() {
   const projectDir = findProjectDir();
   if (!projectDir)
     return null;
-  const projectPath = join48(projectDir, "config.json");
+  const projectPath = join49(projectDir, "config.json");
   return await loadConfigFile(projectPath);
 }
 
@@ -88085,7 +88418,7 @@ async function configCommand(config2, options = {}) {
 function determineConfigSources() {
   const globalPath = globalConfigPath();
   const projectDir = findProjectDir();
-  const projectPath = projectDir ? join49(projectDir, "config.json") : null;
+  const projectPath = projectDir ? join50(projectDir, "config.json") : null;
   return {
     global: fileExists(globalPath) ? globalPath : null,
     project: projectPath && fileExists(projectPath) ? projectPath : null
@@ -88234,15 +88567,15 @@ init_paths();
 init_profile();
 import { mkdirSync as mkdirSync5 } from "fs";
 import { readdirSync as readdirSync7 } from "fs";
-import { join as join50 } from "path";
+import { join as join51 } from "path";
 var _profileCLIDeps = {
   env: process.env
 };
 var SENSITIVE_KEY_PATTERN = /key|token|secret|password|credential/i;
 var VAR_PATTERN = /\$[A-Za-z_][A-Za-z0-9_]*/;
 async function profileListCommand(startDir) {
-  const globalProfilesDir = join50(globalConfigDir(), "profiles");
-  const projectProfilesDir = join50(projectConfigDir(startDir), "profiles");
+  const globalProfilesDir = join51(globalConfigDir(), "profiles");
+  const projectProfilesDir = join51(projectConfigDir(startDir), "profiles");
   const globalProfiles = scanProfileDir(globalProfilesDir);
   const projectProfiles = scanProfileDir(projectProfilesDir);
   const activeProfile = await resolveProfileName({}, _profileCLIDeps.env, startDir);
@@ -88301,7 +88634,7 @@ function maskProfileValues(obj) {
   return result;
 }
 async function profileUseCommand(profileName, startDir) {
-  const configPath = join50(projectConfigDir(startDir), "config.json");
+  const configPath = join51(projectConfigDir(startDir), "config.json");
   const configFile = Bun.file(configPath);
   let existing = {};
   if (await configFile.exists()) {
@@ -88320,8 +88653,8 @@ async function profileCurrentCommand(startDir) {
   return resolveProfileName({}, _profileCLIDeps.env, startDir);
 }
 async function profileCreateCommand(profileName, startDir) {
-  const profilesDir = join50(projectConfigDir(startDir), "profiles");
-  const profilePath = join50(profilesDir, `${profileName}.json`);
+  const profilesDir = join51(projectConfigDir(startDir), "profiles");
+  const profilePath = join51(profilesDir, `${profileName}.json`);
   const profileFile = Bun.file(profilePath);
   if (await profileFile.exists()) {
     throw new Error(`Profile "${profileName}" already exists at ${profilePath}`);
@@ -88443,7 +88776,7 @@ async function contextInspectCommand(options) {
 init_canonical_loader();
 init_errors();
 import { mkdir as mkdir9 } from "fs/promises";
-import { basename as basename8, join as join51 } from "path";
+import { basename as basename8, join as join52 } from "path";
 var _rulesCLIDeps = {
   readFile: async (path15) => Bun.file(path15).text(),
   writeFile: async (path15, content) => {
@@ -88452,7 +88785,7 @@ var _rulesCLIDeps = {
   fileExists: async (path15) => Bun.file(path15).exists(),
   globInDir: (dir) => {
     try {
-      return [...new Bun.Glob("*.md").scanSync({ cwd: dir })].sort().map((f) => join51(dir, f));
+      return [...new Bun.Glob("*.md").scanSync({ cwd: dir })].sort().map((f) => join52(dir, f));
     } catch {
       return [];
     }
@@ -88501,7 +88834,7 @@ ${r.content}`).join(`
 `);
   const shimContent = `${header + body}
 `;
-  const shimPath = join51(workdir, shimFileName);
+  const shimPath = join52(workdir, shimFileName);
   if (options.dryRun) {
     console.log(`[dry-run] Would write ${shimPath} (${shimContent.length} bytes)`);
     return;
@@ -88530,14 +88863,14 @@ function neutralizeContent(content) {
 }
 async function collectMigrationSources(workdir) {
   const sources = [];
-  const claudeMdPath = join51(workdir, "CLAUDE.md");
+  const claudeMdPath = join52(workdir, "CLAUDE.md");
   if (await _rulesCLIDeps.fileExists(claudeMdPath)) {
     const content = await _rulesCLIDeps.readFile(claudeMdPath);
     if (content.trim()) {
       sources.push({ sourcePath: claudeMdPath, targetFileName: "project-conventions.md", content });
     }
   }
-  const rulesDir = join51(workdir, ".claude", "rules");
+  const rulesDir = join52(workdir, ".claude", "rules");
   const ruleFiles = _rulesCLIDeps.globInDir(rulesDir);
   for (const filePath of ruleFiles) {
     try {
@@ -88557,7 +88890,7 @@ async function rulesMigrateCommand(options) {
     console.log("[WARN] No source files found (checked CLAUDE.md and .claude/rules/*.md). Nothing to migrate.");
     return;
   }
-  const targetDir = join51(workdir, CANONICAL_RULES_DIR);
+  const targetDir = join52(workdir, CANONICAL_RULES_DIR);
   if (!options.dryRun) {
     try {
       await _rulesCLIDeps.mkdir(targetDir);
@@ -88568,7 +88901,7 @@ async function rulesMigrateCommand(options) {
   let written = 0;
   let skipped = 0;
   for (const { sourcePath, targetFileName, content } of sources) {
-    const targetPath = join51(targetDir, targetFileName);
+    const targetPath = join52(targetDir, targetFileName);
     if (!force && !options.dryRun && await _rulesCLIDeps.fileExists(targetPath)) {
       console.log(`[skip] ${targetFileName} already exists (use --force to overwrite)`);
       skipped++;
@@ -88607,7 +88940,7 @@ function collectCanonicalRuleRoots(workdir) {
     const packageRel = normalized.slice(0, idx);
     if (!packageRel)
       continue;
-    roots.add(join51(workdir, packageRel));
+    roots.add(join52(workdir, packageRel));
   }
   return [...roots].sort();
 }
@@ -88628,7 +88961,7 @@ init_config();
 init_logger2();
 init_detect2();
 init_workspace();
-import { join as join52 } from "path";
+import { join as join53 } from "path";
 function resolveEffective(detected, configPatterns) {
   if (configPatterns !== undefined)
     return "config";
@@ -88713,7 +89046,7 @@ async function detectCommand(options) {
   const rootDetected = detectionMap[""] ?? { patterns: [], confidence: "empty", sources: [] };
   const pkgEntries = await Promise.all(packageDirs.map(async (dir) => {
     const det = detectionMap[dir] ?? { patterns: [], confidence: "empty", sources: [] };
-    const pkgConfigPath = join52(workdir, ".nax", "mono", dir, "config.json");
+    const pkgConfigPath = join53(workdir, ".nax", "mono", dir, "config.json");
     const pkgRaw = await loadRawConfig(pkgConfigPath);
     const pkgPatterns = deepGet(pkgRaw, TEST_PATTERNS_KEY);
     const effective = Array.isArray(pkgPatterns) ? pkgPatterns : undefined;
@@ -88767,13 +89100,13 @@ async function detectCommand(options) {
     if (rootDetected.confidence === "empty") {
       console.log(source_default.yellow("  root: skipped (empty detection)"));
     } else {
-      const rootConfigPath = join52(workdir, ".nax", "config.json");
+      const rootConfigPath = join53(workdir, ".nax", "config.json");
       try {
         const status = await applyToConfig(rootConfigPath, rootDetected.patterns, options.force ?? false);
         if (status === "skipped") {
           console.log(source_default.dim("  root: skipped (testFilePatterns already set; use --force to overwrite)"));
         } else {
-          console.log(source_default.green(`  root: ${status} \u2192 ${join52(".nax", "config.json")}`));
+          console.log(source_default.green(`  root: ${status} \u2192 ${join53(".nax", "config.json")}`));
         }
       } catch (err) {
         console.error(source_default.red(`  root: write failed \u2014 ${err.message}`));
@@ -88786,13 +89119,13 @@ async function detectCommand(options) {
         console.log(source_default.dim(`  ${dir}: skipped (empty detection)`));
         continue;
       }
-      const pkgConfigPath = join52(workdir, ".nax", "mono", dir, "config.json");
+      const pkgConfigPath = join53(workdir, ".nax", "mono", dir, "config.json");
       try {
         const status = await applyToConfig(pkgConfigPath, det.patterns, options.force ?? false);
         if (status === "skipped") {
           console.log(source_default.dim(`  ${dir}: skipped (already set)`));
         } else {
-          console.log(source_default.green(`  ${dir}: ${status} \u2192 ${join52(".nax", "mono", dir, "config.json")}`));
+          console.log(source_default.green(`  ${dir}: ${status} \u2192 ${join53(".nax", "mono", dir, "config.json")}`));
         }
       } catch (err) {
         console.error(source_default.red(`  ${dir}: write failed \u2014 ${err.message}`));
@@ -88814,24 +89147,24 @@ async function diagnose(options) {
 
 // src/commands/logs.ts
 import { existsSync as existsSync28 } from "fs";
-import { join as join56 } from "path";
+import { join as join57 } from "path";
 
 // src/commands/logs-formatter.ts
 init_source();
 init_formatter();
 import { readdirSync as readdirSync9 } from "fs";
-import { join as join55 } from "path";
+import { join as join56 } from "path";
 
 // src/commands/logs-reader.ts
 import { existsSync as existsSync27, readdirSync as readdirSync8 } from "fs";
 import { readdir as readdir4 } from "fs/promises";
-import { join as join54 } from "path";
+import { join as join55 } from "path";
 
 // src/utils/paths.ts
 import { homedir as homedir4 } from "os";
-import { join as join53 } from "path";
+import { join as join54 } from "path";
 function getRunsDir() {
-  return process.env.NAX_RUNS_DIR ?? join53(homedir4(), ".nax", "runs");
+  return process.env.NAX_RUNS_DIR ?? join54(homedir4(), ".nax", "runs");
 }
 
 // src/commands/logs-reader.ts
@@ -88848,7 +89181,7 @@ async function resolveRunFileFromRegistry(runId) {
   }
   let matched = null;
   for (const entry of entries) {
-    const metaPath = join54(runsDir, entry, "meta.json");
+    const metaPath = join55(runsDir, entry, "meta.json");
     try {
       const meta3 = await Bun.file(metaPath).json();
       if (meta3.runId === runId || meta3.runId.startsWith(runId)) {
@@ -88870,14 +89203,14 @@ async function resolveRunFileFromRegistry(runId) {
     return null;
   }
   const specificFile = files.find((f) => f === `${matched.runId}.jsonl`);
-  return join54(matched.eventsDir, specificFile ?? files[0]);
+  return join55(matched.eventsDir, specificFile ?? files[0]);
 }
 async function selectRunFile(runsDir) {
   const files = readdirSync8(runsDir).filter((f) => f.endsWith(".jsonl") && f !== "latest.jsonl").sort().reverse();
   if (files.length === 0) {
     return null;
   }
-  return join54(runsDir, files[0]);
+  return join55(runsDir, files[0]);
 }
 async function extractRunSummary(filePath) {
   const file3 = Bun.file(filePath);
@@ -88962,7 +89295,7 @@ Runs:
   console.log(source_default.gray("  Timestamp            Stories  Duration  Cost      Status"));
   console.log(source_default.gray("  \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500"));
   for (const file3 of files) {
-    const filePath = join55(runsDir, file3);
+    const filePath = join56(runsDir, file3);
     const summary = await extractRunSummary(filePath);
     const timestamp = file3.replace(".jsonl", "");
     const stories = summary ? `${summary.passed}/${summary.total}` : "?/?";
@@ -89076,7 +89409,7 @@ async function logsCommand(options) {
     return;
   }
   const resolved = resolveProject({ dir: options.dir });
-  const naxDir = join56(resolved.projectDir, ".nax");
+  const naxDir = join57(resolved.projectDir, ".nax");
   const configPath = resolved.configPath;
   const configFile = Bun.file(configPath);
   const config2 = await configFile.json();
@@ -89084,8 +89417,8 @@ async function logsCommand(options) {
   if (!featureName) {
     throw new Error("No feature specified in config.json");
   }
-  const featureDir = join56(naxDir, "features", featureName);
-  const runsDir = join56(featureDir, "runs");
+  const featureDir = join57(naxDir, "features", featureName);
+  const runsDir = join57(featureDir, "runs");
   if (!existsSync28(runsDir)) {
     throw new Error(`No runs directory found for feature: ${featureName}`);
   }
@@ -89110,7 +89443,7 @@ init_config();
 init_prd();
 init_precheck();
 import { existsSync as existsSync29 } from "fs";
-import { join as join57 } from "path";
+import { join as join58 } from "path";
 async function precheckCommand(options) {
   const resolved = resolveProject({
     dir: options.dir,
@@ -89132,9 +89465,9 @@ async function precheckCommand(options) {
       process.exit(1);
     }
   }
-  const naxDir = join57(resolved.projectDir, ".nax");
-  const featureDir = join57(naxDir, "features", featureName);
-  const prdPath = join57(featureDir, "prd.json");
+  const naxDir = join58(resolved.projectDir, ".nax");
+  const featureDir = join58(naxDir, "features", featureName);
+  const prdPath = join58(featureDir, "prd.json");
   if (!existsSync29(featureDir)) {
     console.error(source_default.red(`Feature not found: ${featureName}`));
     process.exit(1);
@@ -89156,7 +89489,7 @@ async function precheckCommand(options) {
 // src/commands/runs.ts
 init_source();
 import { readdir as readdir5 } from "fs/promises";
-import { join as join58 } from "path";
+import { join as join59 } from "path";
 var DEFAULT_LIMIT = 20;
 var _runsCmdDeps = {
   getRunsDir
@@ -89211,7 +89544,7 @@ async function runsCommand(options = {}) {
   }
   const rows = [];
   for (const entry of entries) {
-    const metaPath = join58(runsDir, entry, "meta.json");
+    const metaPath = join59(runsDir, entry, "meta.json");
     let meta3;
     try {
       meta3 = await Bun.file(metaPath).json();
@@ -89288,7 +89621,7 @@ async function runsCommand(options = {}) {
 
 // src/commands/unlock.ts
 init_source();
-import { join as join59 } from "path";
+import { join as join60 } from "path";
 function isProcessAlive3(pid) {
   try {
     process.kill(pid, 0);
@@ -89303,7 +89636,7 @@ function formatLockAge(ageMs) {
 }
 async function unlockCommand(options) {
   const workdir = options.dir ?? process.cwd();
-  const lockPath = join59(workdir, "nax.lock");
+  const lockPath = join60(workdir, "nax.lock");
   const lockFile = Bun.file(lockPath);
   const exists = await lockFile.exists();
   if (!exists) {
@@ -95285,8 +95618,8 @@ class Ink {
     }
   }
   async waitUntilExit() {
-    this.exitPromise ||= new Promise((resolve16, reject2) => {
-      this.resolveExitPromise = resolve16;
+    this.exitPromise ||= new Promise((resolve17, reject2) => {
+      this.resolveExitPromise = resolve17;
       this.rejectExitPromise = reject2;
     });
     if (!this.beforeExitHandler) {
@@ -97115,7 +97448,7 @@ async function promptForConfirmation(question) {
   if (!process.stdin.isTTY) {
     return true;
   }
-  return new Promise((resolve16) => {
+  return new Promise((resolve17) => {
     process.stdout.write(source_default.bold(`${question} [Y/n] `));
     process.stdin.setRawMode(true);
     process.stdin.resume();
@@ -97128,9 +97461,9 @@ async function promptForConfirmation(question) {
       process.stdout.write(`
 `);
       if (answer === "n") {
-        resolve16(false);
+        resolve17(false);
       } else {
-        resolve16(true);
+        resolve17(true);
       }
     };
     process.stdin.on("data", handler);
@@ -97159,15 +97492,15 @@ Next: nax generate --package ${options.package}`));
     }
     return;
   }
-  const naxDir = join73(workdir, ".nax");
+  const naxDir = join74(workdir, ".nax");
   if (existsSync34(naxDir) && !options.force) {
     console.log(source_default.yellow("nax already initialized. Use --force to overwrite."));
     return;
   }
-  mkdirSync7(join73(naxDir, "features"), { recursive: true });
-  mkdirSync7(join73(naxDir, "hooks"), { recursive: true });
-  await Bun.write(join73(naxDir, "config.json"), JSON.stringify(DEFAULT_CONFIG, null, 2));
-  await Bun.write(join73(naxDir, "hooks.json"), JSON.stringify({
+  mkdirSync7(join74(naxDir, "features"), { recursive: true });
+  mkdirSync7(join74(naxDir, "hooks"), { recursive: true });
+  await Bun.write(join74(naxDir, "config.json"), JSON.stringify(DEFAULT_CONFIG, null, 2));
+  await Bun.write(join74(naxDir, "hooks.json"), JSON.stringify({
     hooks: {
       "on-start": { command: 'echo "nax started: $NAX_FEATURE"', enabled: false },
       "on-complete": { command: 'echo "nax complete: $NAX_FEATURE"', enabled: false },
@@ -97175,12 +97508,12 @@ Next: nax generate --package ${options.package}`));
       "on-error": { command: 'echo "nax error: $NAX_REASON"', enabled: false }
     }
   }, null, 2));
-  await Bun.write(join73(naxDir, ".gitignore"), `# nax temp files
+  await Bun.write(join74(naxDir, ".gitignore"), `# nax temp files
 *.tmp
 .paused.json
 .nax-verifier-verdict.json
 `);
-  await Bun.write(join73(naxDir, "context.md"), `# Project Context
+  await Bun.write(join74(naxDir, "context.md"), `# Project Context
 
 This document defines coding standards, architectural decisions, and forbidden patterns for this project.
 Run \`nax generate\` to regenerate agent config files (CLAUDE.md, AGENTS.md, .cursorrules, etc.) from this file.
@@ -97310,8 +97643,8 @@ program2.command("run").description("Run the orchestration loop for a feature").
     console.error(source_default.red("nax not initialized. Run: nax init"));
     process.exit(1);
   }
-  const featureDir = join73(naxDir, "features", options.feature);
-  const prdPath = join73(featureDir, "prd.json");
+  const featureDir = join74(naxDir, "features", options.feature);
+  const prdPath = join74(featureDir, "prd.json");
   if (options.plan && options.from) {
     if (existsSync34(prdPath) && !options.force) {
       console.error(source_default.red(`Error: prd.json already exists for feature "${options.feature}".`));
@@ -97333,10 +97666,10 @@ program2.command("run").description("Run the orchestration loop for a feature").
       }
     }
     try {
-      const planLogDir = join73(featureDir, "plan");
+      const planLogDir = join74(featureDir, "plan");
       mkdirSync7(planLogDir, { recursive: true });
       const planLogId = new Date().toISOString().replace(/:/g, "-").replace(/\..+/, "");
-      const planLogPath = join73(planLogDir, `${planLogId}.jsonl`);
+      const planLogPath = join74(planLogDir, `${planLogId}.jsonl`);
       initLogger({ level: "info", filePath: planLogPath, useChalk: false, headless: true });
       console.log(source_default.dim(`   [Plan log: ${planLogPath}]`));
       console.log(source_default.dim("   [Planning phase: generating PRD from spec]"));
@@ -97380,10 +97713,10 @@ program2.command("run").description("Run the orchestration loop for a feature").
     process.exit(1);
   }
   resetLogger();
-  const runsDir = join73(featureDir, "runs");
+  const runsDir = join74(featureDir, "runs");
   mkdirSync7(runsDir, { recursive: true });
   const runId = new Date().toISOString().replace(/:/g, "-").replace(/\..+/, "");
-  const logFilePath = join73(runsDir, `${runId}.jsonl`);
+  const logFilePath = join74(runsDir, `${runId}.jsonl`);
   const isTTY = process.stdout.isTTY ?? false;
   const headlessFlag = options.headless ?? false;
   const headlessEnv = process.env.NAX_HEADLESS === "1";
@@ -97400,7 +97733,7 @@ program2.command("run").description("Run the orchestration loop for a feature").
     config2.agent.default = options.agent;
   }
   config2.execution.maxIterations = Number.parseInt(options.maxIterations, 10);
-  const globalNaxDir = join73(homedir8(), ".nax");
+  const globalNaxDir = join74(homedir8(), ".nax");
   const hooks = await loadHooksConfig(naxDir, globalNaxDir);
   const eventEmitter = new PipelineEventEmitter;
   let tuiInstance;
@@ -97423,7 +97756,7 @@ program2.command("run").description("Run the orchestration loop for a feature").
   } else {
     console.log(source_default.dim("   [Headless mode \u2014 pipe output]"));
   }
-  const statusFilePath = join73(workdir, ".nax", "status.json");
+  const statusFilePath = join74(workdir, ".nax", "status.json");
   let parallel;
   if (options.parallel !== undefined) {
     parallel = Number.parseInt(options.parallel, 10);
@@ -97449,7 +97782,7 @@ program2.command("run").description("Run the orchestration loop for a feature").
     headless: useHeadless,
     skipPrecheck: options.skipPrecheck ?? false
   });
-  const latestSymlink = join73(runsDir, "latest.jsonl");
+  const latestSymlink = join74(runsDir, "latest.jsonl");
   try {
     if (existsSync34(latestSymlink)) {
       Bun.spawnSync(["rm", latestSymlink]);
@@ -97487,9 +97820,9 @@ features.command("create <name>").description("Create a new feature").option("-d
     console.error(source_default.red("nax not initialized. Run: nax init"));
     process.exit(1);
   }
-  const featureDir = join73(naxDir, "features", name);
+  const featureDir = join74(naxDir, "features", name);
   mkdirSync7(featureDir, { recursive: true });
-  await Bun.write(join73(featureDir, "spec.md"), `# Feature: ${name}
+  await Bun.write(join74(featureDir, "spec.md"), `# Feature: ${name}
 
 ## Overview
 
@@ -97522,7 +97855,7 @@ features.command("create <name>").description("Create a new feature").option("-d
 
 <!-- What this feature explicitly does NOT cover. -->
 `);
-  await Bun.write(join73(featureDir, "progress.txt"), `# Progress: ${name}
+  await Bun.write(join74(featureDir, "progress.txt"), `# Progress: ${name}
 
 Created: ${new Date().toISOString()}
 
@@ -97548,7 +97881,7 @@ features.command("list").description("List all features").option("-d, --dir <pat
     console.error(source_default.red("nax not initialized."));
     process.exit(1);
   }
-  const featuresDir = join73(naxDir, "features");
+  const featuresDir = join74(naxDir, "features");
   if (!existsSync34(featuresDir)) {
     console.log(source_default.dim("No features yet."));
     return;
@@ -97563,7 +97896,7 @@ features.command("list").description("List all features").option("-d, --dir <pat
 Features:
 `));
   for (const name of entries) {
-    const prdPath = join73(featuresDir, name, "prd.json");
+    const prdPath = join74(featuresDir, name, "prd.json");
     if (existsSync34(prdPath)) {
       const prd = await loadPRD(prdPath);
       const c = countStories(prd);
@@ -97598,10 +97931,10 @@ Use: nax plan -f <feature> --from <spec>`));
     cliOverrides.profile = options.profile;
   }
   const config2 = await loadConfig(workdir, cliOverrides);
-  const featureLogDir = join73(naxDir, "features", options.feature, "plan");
+  const featureLogDir = join74(naxDir, "features", options.feature, "plan");
   mkdirSync7(featureLogDir, { recursive: true });
   const planLogId = new Date().toISOString().replace(/:/g, "-").replace(/\..+/, "");
-  const planLogPath = join73(featureLogDir, `${planLogId}.jsonl`);
+  const planLogPath = join74(featureLogDir, `${planLogId}.jsonl`);
   initLogger({ level: "info", filePath: planLogPath, useChalk: false, headless: true });
   console.log(source_default.dim(`   [Plan log: ${planLogPath}]`));
   try {