@nathapp/nax 0.60.0-canary.1 → 0.60.1

package/dist/nax.js

@@ -18334,7 +18334,11 @@ var init_schemas3 = __esm(() => {
       fixModel: "balanced",
       strategy: "diagnose-first",
       maxRetries: 2
-    })
+    }),
+    suggestedTestPath: exports_external.string().min(1).optional(),
+    hardening: exports_external.object({
+      enabled: exports_external.boolean().default(true)
+    }).optional().default({ enabled: true })
   });
   TestCoverageConfigSchema = exports_external.object({
     enabled: exports_external.boolean().default(true),
@@ -18650,7 +18654,7 @@ var init_schemas3 = __esm(() => {
     }),
     acceptance: AcceptanceConfigSchema.default({
       enabled: true,
-      maxRetries: 2,
+      maxRetries: 3,
       generateTests: true,
       testPath: ".nax-acceptance.test.ts",
       model: "fast",
@@ -18663,7 +18667,8 @@ var init_schemas3 = __esm(() => {
         fixModel: "balanced",
         strategy: "diagnose-first",
         maxRetries: 2
-      }
+      },
+      hardening: { enabled: true }
     }),
     context: ContextConfigSchema.default({
       fileInjection: "disabled",
@@ -21929,6 +21934,130 @@ ${c.output}`).join(`
   buildDebaterLabel(debater) {
     return debater.persona ? `${debater.agent} (${debater.persona})` : debater.agent;
   }
+  buildReviewPrompt(diff, story) {
+    const criteria = story.acceptanceCriteria.map((c) => `- ${c}`).join(`
+`);
+    return [
+      `Review the following code diff for story ${story.id}: ${story.title}`,
+      "",
+      "## Acceptance Criteria",
+      criteria,
+      "",
+      "## Diff",
+      diff,
+      "",
+      "Also flag any changes in the diff not required by the acceptance criteria above as out-of-scope findings.",
+      "Respond with JSON: { passed: boolean, findings: [...], findingReasoning: { [id]: string } }"
+    ].join(`
+`);
+  }
+  buildReReviewPrompt(updatedDiff, previousFindings) {
+    const findingsList = previousFindings.length > 0 ? previousFindings.map((f) => `- ${f.ruleId}: ${f.message}`).join(`
+`) : "(none)";
+    return [
+      "This is a follow-up re-review. Please review the updated diff below.",
+      "",
+      "## Previous Findings",
+      findingsList,
+      "",
+      "## Updated Diff",
+      updatedDiff,
+      "",
+      "Respond with JSON: { passed: boolean, findings: [...], findingReasoning: { [id]: string }, deltaSummary: string }",
+      "deltaSummary should describe which previous findings are resolved vs still present."
+    ].join(`
+`);
+  }
+  buildResolverPrompt(proposals, critiques, diff, story, resolverContext) {
+    const criteria = story.acceptanceCriteria.map((c) => `- ${c}`).join(`
+`);
+    const framing = this.buildResolverFraming(resolverContext);
+    const voteTally = this.buildVoteTallyLine(resolverContext);
+    const proposalsSection = this.buildLabeledProposalsSection(proposals);
+    const critiquesSection = this.buildLabeledCritiquesSection(critiques);
+    return [
+      framing,
+      "",
+      `## Story ${story.id}: ${story.title}`,
+      "",
+      "## Acceptance Criteria",
+      criteria,
+      "",
+      "## Debater Proposals",
+      proposalsSection,
+      critiquesSection,
+      "",
+      "## Diff",
+      diff,
+      voteTally,
+      "",
+      "Respond with JSON: { passed: boolean, findings: [...], findingReasoning: { [id]: string } }"
+    ].filter((line) => line !== undefined).join(`
+`);
+  }
+  buildReResolverPrompt(proposals, critiques, updatedDiff, previousFindings, resolverContext) {
+    const framing = this.buildResolverFraming(resolverContext);
+    const findingsList = previousFindings.length > 0 ? previousFindings.map((f) => `- ${f.ruleId}: ${f.message}`).join(`
+`) : "(none)";
+    const proposalsSection = this.buildLabeledProposalsSection(proposals);
+    const critiquesSection = this.buildLabeledCritiquesSection(critiques);
+    return [
+      `${framing} This is a re-review after implementer changes.`,
+      "",
+      "## Previous Findings",
+      findingsList,
+      "",
+      "## Updated Debater Proposals",
+      proposalsSection,
+      critiquesSection,
+      "",
+      "## Updated Diff",
+      updatedDiff,
+      "",
+      "Respond with JSON: { passed: boolean, findings: [...], findingReasoning: { [id]: string }, deltaSummary: string }",
+      "deltaSummary should describe which previous findings are resolved vs still present."
+    ].filter((line) => line !== undefined).join(`
+`);
+  }
+  buildResolverFraming(ctx) {
+    switch (ctx.resolverType) {
+      case "majority-fail-closed":
+      case "majority-fail-open":
+        return "You are the authoritative reviewer resolving a debate. A preliminary vote was taken \u2014 see tally below. Verify disputed findings using tools (READ files, GREP for usage) and give your final verdict.";
+      case "synthesis":
+        return "You are a synthesis reviewer. Synthesize the debater proposals into a single, coherent, tool-verified verdict. Use READ and GREP to verify claims before ruling.";
+      case "custom":
+        return "You are the judge. Evaluate the debater proposals independently. Verify claims with tools (READ, GREP) and give your final authoritative verdict.";
+      default:
+        return "You are the reviewer. Evaluate the debater proposals and give your final authoritative verdict.";
+    }
+  }
+  buildVoteTallyLine(ctx) {
+    if (!ctx.majorityVote)
+      return "";
+    const { passCount, failCount } = ctx.majorityVote;
+    const failOpenNote = ctx.resolverType === "majority-fail-open" ? " (unparseable proposals count as pass)" : " (unparseable proposals count as fail)";
+    return `
+
+The preliminary majority vote is: **${passCount} passed, ${failCount} failed**${failOpenNote}. Verify the failing findings with tools before giving your authoritative verdict.`;
+  }
+  buildLabeledProposalsSection(proposals) {
+    return proposals.map((p) => `### ${p.debater}
+${p.output}`).join(`
+
+`);
+  }
+  buildLabeledCritiquesSection(critiques) {
+    if (critiques.length === 0)
+      return "";
+    return `
+
+## Critiques
+${critiques.map((c, i) => `### Critique ${i + 1}
+${c}`).join(`
+
+`)}`;
+  }
 }
 var init_prompt_builder = __esm(() => {
   init_personas();
@@ -22566,7 +22695,20 @@ Do NOT output the JSON to the conversation. Write the file, then reply with a br
     logger?.warn("debate", "hybrid mode requires sessionMode: stateful for plan \u2014 running as panel");
   }
   const resolverTimeoutMs = (ctx.stageConfig.timeoutSeconds ?? 600) * 1000;
-  const planSynthesisSuffix = "IMPORTANT: Your response must be a single valid JSON object in PRD format (with project, feature, branchName, userStories array, etc.). Do NOT wrap it in markdown fences. Output raw JSON only.";
+  const specAnchor = opts.specContent ? `
+
+## Original Spec
+
+${opts.specContent}
+
+## Synthesis Rules \u2014 Acceptance Criteria
+
+The spec above is the authoritative source for acceptance criteria.
+- Each story's \`acceptanceCriteria\` array MUST contain only criteria that are explicitly stated or directly implied by the spec.
+- If a debater proposed criteria beyond the spec (edge cases, error handling, implementation details), place those in a separate \`suggestedCriteria\` array on the same story object.
+- Never silently merge debater-invented criteria into \`acceptanceCriteria\`. The distinction matters: \`acceptanceCriteria\` drives automated testing; \`suggestedCriteria\` is logged for human review.
+- Preserve the spec's AC wording. You may refine for clarity but must not change semantics.` : "";
+  const planSynthesisSuffix = `IMPORTANT: Your response must be a single valid JSON object in PRD format (with project, feature, branchName, userStories array, etc.). Do NOT wrap it in markdown fences. Output raw JSON only.${specAnchor}`;
   const outcome = await resolveOutcome(proposalOutputs, critiqueOutputs, ctx.stageConfig, ctx.config, ctx.storyId, resolverTimeoutMs, opts.workdir, opts.feature, undefined, undefined, planSynthesisSuffix, successful.map((p) => p.debater));
   const winningOutput = outcome.output ?? successful[0].output;
   const proposals = successful.map((p) => ({ debater: p.debater, output: p.output }));
@@ -24929,6 +25071,24 @@ function resolveAcceptanceTestCandidates(options) {
     return [];
   return [resolveAcceptanceFeatureTestPath(options.featureDir, options.testPathConfig, options.language)];
 }
+function suggestedTestFilename(language) {
+  switch (language?.toLowerCase()) {
+    case "go":
+      return ".nax-suggested_test.go";
+    case "python":
+      return ".nax-suggested.test.py";
+    case "rust":
+      return ".nax-suggested.rs";
+    default:
+      return ".nax-suggested.test.ts";
+  }
+}
+function resolveSuggestedTestFile(language, testPathConfig) {
+  return testPathConfig ?? suggestedTestFilename(language);
+}
+function resolveSuggestedPackageFeatureTestPath(packageDir, featureName, testPathConfig, language) {
+  return path.join(packageDir, ".nax", "features", featureName, resolveSuggestedTestFile(language, testPathConfig));
+}
 async function findExistingAcceptanceTestPath(options) {
   const candidates = resolveAcceptanceTestCandidates(options);
   for (const testPath of candidates) {
@@ -25795,7 +25955,7 @@ Rules:
 - Every test MUST have real assertions that PASS when the feature is correctly implemented and FAIL when it is broken
 - **Prefer behavioral tests** \u2014 import functions and call them rather than reading source files. For example, to verify "getPostRunActions() returns empty array", import PluginRegistry and call getPostRunActions(), don't grep the source file for the method name.
 - **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: \`${join16(options.workdir, ".nax", "features", options.featureName, resolveAcceptanceTestFile2(options.language, options.config?.acceptance?.testPath))}\`. Import from package sources using relative paths like \`../../../src/...\` (3 levels up from \`.nax/features/<name>/\` to the package root).
+- **Path anchor (CRITICAL)**: Write the test file to this exact path: \`${options.targetTestFile ?? join16(options.workdir, ".nax", "features", options.featureName, resolveAcceptanceTestFile2(options.language, options.config?.acceptance?.testPath))}\`. 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.`;
   const implementationSection = options.implementationContext && options.implementationContext.length > 0 ? `
 
@@ -25828,7 +25988,7 @@ Previous test failed because: ${options.previousFailure}` : "";
     outputPreview: rawOutput.slice(0, 300)
   });
   if (!testCode) {
-    const targetPath = join16(options.workdir, ".nax", "features", options.featureName, resolveAcceptanceTestFile2(options.language, options.config?.acceptance?.testPath));
+    const targetPath = options.targetTestFile ?? join16(options.workdir, ".nax", "features", options.featureName, resolveAcceptanceTestFile2(options.language, options.config?.acceptance?.testPath));
     const backupPath = `${targetPath}.llm-recovery.bak`;
     let recoveryFailed = false;
     logger.debug("acceptance", "BUG-076 recovery: checking for agent-written file", {
@@ -26193,10 +26353,304 @@ function logTestOutput(logger, stage, output, opts = {}) {
   });
 }
 
+// src/acceptance/refinement.ts
+var exports_refinement = {};
+__export(exports_refinement, {
+  refineAcceptanceCriteria: () => refineAcceptanceCriteria,
+  parseRefinementResponse: () => parseRefinementResponse,
+  buildRefinementPrompt: () => buildRefinementPrompt,
+  _refineDeps: () => _refineDeps
+});
+function buildRefinementPrompt(criteria, codebaseContext, options) {
+  const criteriaList = criteria.map((c, i) => `${i + 1}. ${c}`).join(`
+`);
+  const strategySection = buildStrategySection(options);
+  const refinedExample = buildRefinedExample(options?.testStrategy);
+  const codebaseSection = codebaseContext ? `CODEBASE CONTEXT:
+${codebaseContext}
+` : "";
+  const core2 = `You are an acceptance criteria refinement assistant. Your task is to convert raw acceptance criteria into concrete, machine-verifiable assertions.
+
+${codebaseSection}${strategySection}ACCEPTANCE CRITERIA TO REFINE:
+${criteriaList}
+
+For each criterion, produce a refined version that is concrete and automatically testable where possible.
+Respond with a JSON array:
+[{
+  "original": "<exact original criterion text>",
+  "refined": "<concrete, machine-verifiable description>",
+  "testable": true,
+  "storyId": ""
+}]
+
+Rules:
+- "original" must match the input criterion text exactly
+- "refined" must be a concrete assertion (e.g., ${refinedExample})
+- "testable" is false only if the criterion cannot be automatically verified (e.g., "UX feels responsive", "design looks good")
+- "storyId" leave as empty string \u2014 it will be assigned by the caller`;
+  return wrapJsonPrompt(core2);
+}
+function buildStrategySection(options) {
+  if (!options?.testStrategy) {
+    return "";
+  }
+  const framework = options.testFramework ? ` Use ${options.testFramework} testing library syntax.` : "";
+  switch (options.testStrategy) {
+    case "component":
+      return `
+TEST STRATEGY: component
+Focus assertions on rendered output visible on screen \u2014 text content, visible elements, and screen state.
+Assert what the user sees rendered in the component, not what internal functions produce.${framework}
+`;
+    case "cli":
+      return `
+TEST STRATEGY: cli
+Focus assertions on stdout and stderr text output from the CLI command.
+Assert about terminal output content, exit codes, and standard output/standard error streams.${framework}
+`;
+    case "e2e":
+      return `
+TEST STRATEGY: e2e
+Focus assertions on HTTP response content \u2014 status codes, response bodies, and endpoint behavior.
+Assert about HTTP responses, status codes, and API endpoint output.${framework}
+`;
+    default:
+      return framework ? `
+TEST FRAMEWORK: ${options.testFramework}
+` : "";
+  }
+}
+function buildRefinedExample(testStrategy) {
+  switch (testStrategy) {
+    case "component":
+      return '"Text content visible on screen matches expected", "Rendered output contains expected element"';
+    case "cli":
+      return '"stdout contains expected text", "stderr is empty on success", "exit code is 0"';
+    case "e2e":
+      return '"HTTP status 200 returned", "Response body contains expected field", "Endpoint returns JSON"';
+    default:
+      return '"Array of length N returned", "HTTP status 200 returned"';
+  }
+}
+function parseRefinementResponse(response, criteria) {
+  if (!response || !response.trim()) {
+    return fallbackCriteria(criteria);
+  }
+  try {
+    const fromFence = extractJsonFromMarkdown(response);
+    const cleaned = stripTrailingCommas(fromFence !== response ? fromFence : response);
+    const parsed = JSON.parse(cleaned);
+    if (!Array.isArray(parsed)) {
+      return fallbackCriteria(criteria);
+    }
+    return parsed.map((item, i) => ({
+      original: typeof item.original === "string" && item.original.length > 0 ? item.original : criteria[i] ?? "",
+      refined: typeof item.refined === "string" && item.refined.length > 0 ? item.refined : criteria[i] ?? "",
+      testable: typeof item.testable === "boolean" ? item.testable : true,
+      storyId: typeof item.storyId === "string" ? item.storyId : ""
+    }));
+  } catch {
+    return fallbackCriteria(criteria);
+  }
+}
+async function refineAcceptanceCriteria(criteria, context) {
+  if (criteria.length === 0) {
+    return [];
+  }
+  const { storyId, featureName, workdir, codebaseContext, config: config2, testStrategy, testFramework } = context;
+  const logger = getLogger();
+  const modelTier = config2.acceptance?.model ?? "fast";
+  const modelDef = resolveModelForAgent(config2.models, config2.autoMode.defaultAgent, modelTier, config2.autoMode.defaultAgent);
+  const prompt = buildRefinementPrompt(criteria, codebaseContext, { testStrategy, testFramework });
+  let response;
+  try {
+    const completeResult = await _refineDeps.adapter.complete(prompt, {
+      jsonMode: true,
+      maxTokens: 4096,
+      model: modelDef.model,
+      config: config2,
+      featureName,
+      storyId,
+      workdir,
+      sessionRole: "refine",
+      timeoutMs: config2.acceptance?.timeoutMs ?? 120000
+    });
+    response = typeof completeResult === "string" ? completeResult : completeResult.output;
+  } catch (error48) {
+    const reason = errorMessage(error48);
+    logger.warn("refinement", "adapter.complete() failed, falling back to original criteria", {
+      storyId,
+      error: reason
+    });
+    return fallbackCriteria(criteria, storyId);
+  }
+  const parsed = parseRefinementResponse(response, criteria);
+  return parsed.map((item) => ({
+    ...item,
+    storyId: item.storyId || storyId
+  }));
+}
+function fallbackCriteria(criteria, storyId = "") {
+  return criteria.map((c) => ({
+    original: c,
+    refined: c,
+    testable: true,
+    storyId
+  }));
+}
+var _refineDeps;
+var init_refinement = __esm(() => {
+  init_registry();
+  init_config();
+  init_logger2();
+  _refineDeps = {
+    adapter: {
+      complete: async (...args) => {
+        const options = args[1];
+        const config2 = options?.config;
+        if (!config2)
+          throw new Error("Refinement adapter requires config");
+        const adapter = createAgentRegistry(config2).getAgent(config2.autoMode.defaultAgent);
+        if (!adapter)
+          throw new Error(`Agent "${config2.autoMode.defaultAgent}" not found`);
+        return adapter.complete(...args);
+      }
+    }
+  };
+});
+
+// src/acceptance/hardening.ts
+var exports_hardening = {};
+__export(exports_hardening, {
+  runHardeningPass: () => runHardeningPass,
+  _hardeningDeps: () => _hardeningDeps
+});
+async function runHardeningPass(ctx) {
+  const logger = getSafeLogger();
+  const result = { promoted: [], discarded: [], costUsd: 0 };
+  const storiesWithSuggested = ctx.prd.userStories.filter((s) => s.suggestedCriteria && s.suggestedCriteria.length > 0);
+  if (storiesWithSuggested.length === 0)
+    return result;
+  logger?.info("acceptance", "Starting hardening pass", {
+    storyId: storiesWithSuggested[0].id,
+    storiesWithSuggested: storiesWithSuggested.length,
+    totalSuggestedACs: storiesWithSuggested.reduce((n, s) => n + (s.suggestedCriteria?.length ?? 0), 0)
+  });
+  try {
+    const allRefined = [];
+    for (const story of storiesWithSuggested) {
+      const criteria = story.suggestedCriteria ?? [];
+      const refined = await _hardeningDeps.refine(criteria, {
+        storyId: story.id,
+        featureName: ctx.prd.feature,
+        workdir: ctx.workdir,
+        codebaseContext: "",
+        config: ctx.config
+      });
+      allRefined.push(...refined);
+    }
+    const language = ctx.config.project?.language;
+    const suggestedTestPath = resolveSuggestedPackageFeatureTestPath(ctx.workdir, ctx.prd.feature, ctx.config.acceptance?.suggestedTestPath, language);
+    let modelDef;
+    try {
+      modelDef = resolveModelForAgent(ctx.config.models, ctx.config.autoMode?.defaultAgent ?? "claude", ctx.config.acceptance?.model ?? "fast", ctx.config.autoMode?.defaultAgent ?? "claude");
+    } catch {
+      modelDef = { provider: "anthropic", model: "claude-haiku-4-5-20251001" };
+    }
+    const genResult = await _hardeningDeps.generate(storiesWithSuggested, allRefined, {
+      featureName: ctx.prd.feature,
+      workdir: ctx.workdir,
+      featureDir: ctx.featureDir,
+      codebaseContext: "",
+      modelTier: ctx.config.acceptance?.model ?? "fast",
+      modelDef,
+      config: ctx.config,
+      language,
+      targetTestFile: suggestedTestPath
+    });
+    if (genResult.testCode) {
+      await _hardeningDeps.writeFile(suggestedTestPath, genResult.testCode);
+    }
+    const testCmd = buildAcceptanceRunCommand(suggestedTestPath, ctx.config.project?.testFramework, ctx.config.acceptance?.command);
+    const proc = _hardeningDeps.spawn(testCmd, {
+      cwd: ctx.workdir,
+      stdout: "pipe",
+      stderr: "pipe"
+    });
+    const [exitCode, stdout, stderr] = await Promise.all([
+      proc.exited,
+      new Response(proc.stdout).text(),
+      new Response(proc.stderr).text()
+    ]);
+    const output = `${stdout}
+${stderr}`;
+    const failedACs = parseTestFailures(output);
+    const failedSet = new Set(failedACs.map((ac) => ac.toUpperCase()));
+    let acIndex = 0;
+    for (const story of storiesWithSuggested) {
+      const suggested = story.suggestedCriteria ?? [];
+      const toPromote = [];
+      const toDiscard = [];
+      for (const criterion of suggested) {
+        acIndex++;
+        const acId = `AC-${acIndex}`;
+        if (failedSet.has(acId) || exitCode !== 0 && failedACs.length === 0) {
+          toDiscard.push(criterion);
+        } else {
+          toPromote.push(criterion);
+        }
+      }
+      if (toPromote.length > 0) {
+        story.acceptanceCriteria = [...story.acceptanceCriteria, ...toPromote];
+        result.promoted.push(...toPromote);
+      }
+      result.discarded.push(...toDiscard);
+      story.suggestedCriteria = toDiscard.length > 0 ? toDiscard : undefined;
+    }
+    if (result.promoted.length > 0) {
+      await _hardeningDeps.savePRD(ctx.prd, ctx.prdPath);
+    }
+    logger?.info("acceptance", "Hardening pass complete", {
+      storyId: storiesWithSuggested[0].id,
+      promoted: result.promoted.length,
+      discarded: result.discarded.length,
+      costUsd: result.costUsd
+    });
+  } catch (err) {
+    logger?.warn("acceptance", "Hardening pass failed (non-blocking)", {
+      storyId: storiesWithSuggested[0].id,
+      error: err instanceof Error ? err.message : String(err)
+    });
+  }
+  return result;
+}
+var _hardeningDeps;
+var init_hardening = __esm(() => {
+  init_config();
+  init_logger2();
+  init_acceptance();
+  init_prd();
+  init_generator();
+  init_generator();
+  init_refinement();
+  init_test_path();
+  _hardeningDeps = {
+    refine: refineAcceptanceCriteria,
+    generate: generateFromPRD,
+    savePRD,
+    spawn: Bun.spawn,
+    writeFile: async (p, c) => {
+      await Bun.write(p, c);
+    }
+  };
+});
+
 // src/pipeline/stages/acceptance.ts
 var exports_acceptance = {};
 __export(exports_acceptance, {
-  acceptanceStage: () => acceptanceStage
+  parseTestFailures: () => parseTestFailures,
+  acceptanceStage: () => acceptanceStage,
+  _acceptanceStageDeps: () => _acceptanceStageDeps
 });
 function parseTestFailures(output) {
   const failedACs = [];
@@ -26220,12 +26674,18 @@ function areAllStoriesComplete(ctx) {
   const totalComplete = counts.passed + counts.failed + counts.skipped;
   return totalComplete === counts.total;
 }
-var acceptanceStage;
+var _acceptanceStageDeps, acceptanceStage;
 var init_acceptance = __esm(() => {
   init_generator();
   init_test_path();
   init_logger2();
   init_prd();
+  _acceptanceStageDeps = {
+    runHardeningPass: async (ctx) => {
+      const { runHardeningPass: runHardeningPass2 } = await Promise.resolve().then(() => (init_hardening(), exports_hardening));
+      return runHardeningPass2(ctx);
+    }
+  };
   acceptanceStage = {
     name: "acceptance",
     enabled(ctx) {
@@ -26323,6 +26783,31 @@ ${stderr}`;
 `);
       if (allFailedACs.length === 0) {
         logger.info("acceptance", "All acceptance tests passed", { storyId: ctx.story.id });
+        const hardeningEnabled = ctx.config.acceptance?.hardening?.enabled !== false;
+        const hasAnySuggested = ctx.prd.userStories.some((s) => s.suggestedCriteria && s.suggestedCriteria.length > 0);
+        if (hardeningEnabled && hasAnySuggested && ctx.featureDir) {
+          try {
+            const prdPath = ctx.prdPath ?? `${ctx.featureDir}/prd.json`;
+            const result = await _acceptanceStageDeps.runHardeningPass({
+              prd: ctx.prd,
+              prdPath,
+              featureDir: ctx.featureDir,
+              workdir: ctx.workdir,
+              config: ctx.config,
+              agentGetFn: ctx.agentGetFn
+            });
+            logger.info("acceptance", "Hardening pass complete", {
+              storyId: ctx.story.id,
+              promoted: result.promoted.length,
+              discarded: result.discarded.length
+            });
+          } catch (err) {
+            logger.warn("acceptance", "Hardening pass failed (non-blocking)", {
+              storyId: ctx.story.id,
+              error: err instanceof Error ? err.message : String(err)
+            });
+          }
+        }
         return { action: "continue" };
       }
       ctx.acceptanceFailures = {
@@ -26343,172 +26828,6 @@ ${stderr}`;
   };
 });
 
-// src/acceptance/refinement.ts
-var exports_refinement = {};
-__export(exports_refinement, {
-  refineAcceptanceCriteria: () => refineAcceptanceCriteria,
-  parseRefinementResponse: () => parseRefinementResponse,
-  buildRefinementPrompt: () => buildRefinementPrompt,
-  _refineDeps: () => _refineDeps
-});
-function buildRefinementPrompt(criteria, codebaseContext, options) {
-  const criteriaList = criteria.map((c, i) => `${i + 1}. ${c}`).join(`
-`);
-  const strategySection = buildStrategySection(options);
-  const refinedExample = buildRefinedExample(options?.testStrategy);
-  const codebaseSection = codebaseContext ? `CODEBASE CONTEXT:
-${codebaseContext}
-` : "";
-  const core2 = `You are an acceptance criteria refinement assistant. Your task is to convert raw acceptance criteria into concrete, machine-verifiable assertions.
-
-${codebaseSection}${strategySection}ACCEPTANCE CRITERIA TO REFINE:
-${criteriaList}
-
-For each criterion, produce a refined version that is concrete and automatically testable where possible.
-Respond with a JSON array:
-[{
-  "original": "<exact original criterion text>",
-  "refined": "<concrete, machine-verifiable description>",
-  "testable": true,
-  "storyId": ""
-}]
-
-Rules:
-- "original" must match the input criterion text exactly
-- "refined" must be a concrete assertion (e.g., ${refinedExample})
-- "testable" is false only if the criterion cannot be automatically verified (e.g., "UX feels responsive", "design looks good")
-- "storyId" leave as empty string \u2014 it will be assigned by the caller`;
-  return wrapJsonPrompt(core2);
-}
-function buildStrategySection(options) {
-  if (!options?.testStrategy) {
-    return "";
-  }
-  const framework = options.testFramework ? ` Use ${options.testFramework} testing library syntax.` : "";
-  switch (options.testStrategy) {
-    case "component":
-      return `
-TEST STRATEGY: component
-Focus assertions on rendered output visible on screen \u2014 text content, visible elements, and screen state.
-Assert what the user sees rendered in the component, not what internal functions produce.${framework}
-`;
-    case "cli":
-      return `
-TEST STRATEGY: cli
-Focus assertions on stdout and stderr text output from the CLI command.
-Assert about terminal output content, exit codes, and standard output/standard error streams.${framework}
-`;
-    case "e2e":
-      return `
-TEST STRATEGY: e2e
-Focus assertions on HTTP response content \u2014 status codes, response bodies, and endpoint behavior.
-Assert about HTTP responses, status codes, and API endpoint output.${framework}
-`;
-    default:
-      return framework ? `
-TEST FRAMEWORK: ${options.testFramework}
-` : "";
-  }
-}
-function buildRefinedExample(testStrategy) {
-  switch (testStrategy) {
-    case "component":
-      return '"Text content visible on screen matches expected", "Rendered output contains expected element"';
-    case "cli":
-      return '"stdout contains expected text", "stderr is empty on success", "exit code is 0"';
-    case "e2e":
-      return '"HTTP status 200 returned", "Response body contains expected field", "Endpoint returns JSON"';
-    default:
-      return '"Array of length N returned", "HTTP status 200 returned"';
-  }
-}
-function parseRefinementResponse(response, criteria) {
-  if (!response || !response.trim()) {
-    return fallbackCriteria(criteria);
-  }
-  try {
-    const fromFence = extractJsonFromMarkdown(response);
-    const cleaned = stripTrailingCommas(fromFence !== response ? fromFence : response);
-    const parsed = JSON.parse(cleaned);
-    if (!Array.isArray(parsed)) {
-      return fallbackCriteria(criteria);
-    }
-    return parsed.map((item, i) => ({
-      original: typeof item.original === "string" && item.original.length > 0 ? item.original : criteria[i] ?? "",
-      refined: typeof item.refined === "string" && item.refined.length > 0 ? item.refined : criteria[i] ?? "",
-      testable: typeof item.testable === "boolean" ? item.testable : true,
-      storyId: typeof item.storyId === "string" ? item.storyId : ""
-    }));
-  } catch {
-    return fallbackCriteria(criteria);
-  }
-}
-async function refineAcceptanceCriteria(criteria, context) {
-  if (criteria.length === 0) {
-    return [];
-  }
-  const { storyId, featureName, workdir, codebaseContext, config: config2, testStrategy, testFramework } = context;
-  const logger = getLogger();
-  const modelTier = config2.acceptance?.model ?? "fast";
-  const modelDef = resolveModelForAgent(config2.models, config2.autoMode.defaultAgent, modelTier, config2.autoMode.defaultAgent);
-  const prompt = buildRefinementPrompt(criteria, codebaseContext, { testStrategy, testFramework });
-  let response;
-  try {
-    const completeResult = await _refineDeps.adapter.complete(prompt, {
-      jsonMode: true,
-      maxTokens: 4096,
-      model: modelDef.model,
-      config: config2,
-      featureName,
-      storyId,
-      workdir,
-      sessionRole: "refine",
-      timeoutMs: config2.acceptance?.timeoutMs ?? 120000
-    });
-    response = typeof completeResult === "string" ? completeResult : completeResult.output;
-  } catch (error48) {
-    const reason = errorMessage(error48);
-    logger.warn("refinement", "adapter.complete() failed, falling back to original criteria", {
-      storyId,
-      error: reason
-    });
-    return fallbackCriteria(criteria, storyId);
-  }
-  const parsed = parseRefinementResponse(response, criteria);
-  return parsed.map((item) => ({
-    ...item,
-    storyId: item.storyId || storyId
-  }));
-}
-function fallbackCriteria(criteria, storyId = "") {
-  return criteria.map((c) => ({
-    original: c,
-    refined: c,
-    testable: true,
-    storyId
-  }));
-}
-var _refineDeps;
-var init_refinement = __esm(() => {
-  init_registry();
-  init_config();
-  init_logger2();
-  _refineDeps = {
-    adapter: {
-      complete: async (...args) => {
-        const options = args[1];
-        const config2 = options?.config;
-        if (!config2)
-          throw new Error("Refinement adapter requires config");
-        const adapter = createAgentRegistry(config2).getAgent(config2.autoMode.defaultAgent);
-        if (!adapter)
-          throw new Error(`Agent "${config2.autoMode.defaultAgent}" not found`);
-        return adapter.complete(...args);
-      }
-    }
-  };
-});
-
 // src/pipeline/stages/acceptance-setup.ts
 var exports_acceptance_setup = {};
 __export(exports_acceptance_setup, {
@@ -26734,7 +27053,8 @@ ${stderr}` };
             testStrategy: ctx.config.acceptance.testStrategy,
             testFramework: ctx.config.acceptance.testFramework,
             adapter: agent ?? undefined,
-            ..."implementationContext" in ctx && ctx.implementationContext ? { implementationContext: ctx.implementationContext } : {}
+            ..."implementationContext" in ctx && ctx.implementationContext ? { implementationContext: ctx.implementationContext } : {},
+            ..."previousFailure" in ctx && ctx.previousFailure ? { previousFailure: ctx.previousFailure } : {}
           });
           await _acceptanceSetupDeps.writeFile(testPath, result.testCode);
         }
@@ -27132,132 +27452,6 @@ var init_agents = __esm(() => {
   init_errors();
 });
 
-// src/review/dialogue-prompts.ts
-function buildReviewPrompt(diff, story, _semanticConfig) {
-  const criteria = story.acceptanceCriteria.map((c) => `- ${c}`).join(`
-`);
-  return [
-    `Review the following code diff for story ${story.id}: ${story.title}`,
-    "",
-    "## Acceptance Criteria",
-    criteria,
-    "",
-    "## Diff",
-    diff,
-    "",
-    "Also flag any changes in the diff not required by the acceptance criteria above as out-of-scope findings.",
-    "Respond with JSON: { passed: boolean, findings: [...], findingReasoning: { [id]: string } }"
-  ].join(`
-`);
-}
-function buildReReviewPrompt(updatedDiff, previousFindings) {
-  const findingsList = previousFindings.length > 0 ? previousFindings.map((f) => `- ${f.ruleId}: ${f.message}`).join(`
-`) : "(none)";
-  return [
-    "This is a follow-up re-review. Please review the updated diff below.",
-    "",
-    "## Previous Findings",
-    findingsList,
-    "",
-    "## Updated Diff",
-    updatedDiff,
-    "",
-    "Respond with JSON: { passed: boolean, findings: [...], findingReasoning: { [id]: string }, deltaSummary: string }",
-    "deltaSummary should describe which previous findings are resolved vs still present."
-  ].join(`
-`);
-}
-function buildProposalsSection2(proposals) {
-  return proposals.map((p) => `### ${p.debater}
-${p.output}`).join(`
-
-`);
-}
-function buildCritiquesSection(critiques) {
-  if (critiques.length === 0)
-    return "";
-  return `
-
-## Critiques
-${critiques.map((c, i) => `### Critique ${i + 1}
-${c}`).join(`
-
-`)}`;
-}
-function buildVoteTallyLine(ctx) {
-  if (!ctx.majorityVote)
-    return "";
-  const { passCount, failCount } = ctx.majorityVote;
-  const failOpenNote = ctx.resolverType === "majority-fail-open" ? " (unparseable proposals count as pass)" : " (unparseable proposals count as fail)";
-  return `
-
-The preliminary majority vote is: **${passCount} passed, ${failCount} failed**${failOpenNote}. Verify the failing findings with tools before giving your authoritative verdict.`;
-}
-function buildResolverFraming(ctx) {
-  switch (ctx.resolverType) {
-    case "majority-fail-closed":
-    case "majority-fail-open":
-      return "You are the authoritative reviewer resolving a debate. A preliminary vote was taken \u2014 see tally below. Verify disputed findings using tools (READ files, GREP for usage) and give your final verdict.";
-    case "synthesis":
-      return "You are a synthesis reviewer. Synthesize the debater proposals into a single, coherent, tool-verified verdict. Use READ and GREP to verify claims before ruling.";
-    case "custom":
-      return "You are the judge. Evaluate the debater proposals independently. Verify claims with tools (READ, GREP) and give your final authoritative verdict.";
-    default:
-      return "You are the reviewer. Evaluate the debater proposals and give your final authoritative verdict.";
-  }
-}
-function buildDebateResolverPrompt(proposals, critiques, diff, story, _semanticConfig, resolverContext) {
-  const criteria = story.acceptanceCriteria.map((c) => `- ${c}`).join(`
-`);
-  const framing = buildResolverFraming(resolverContext);
-  const voteTally = buildVoteTallyLine(resolverContext);
-  const proposalsSection = buildProposalsSection2(proposals);
-  const critiquesSection = buildCritiquesSection(critiques);
-  return [
-    framing,
-    "",
-    `## Story ${story.id}: ${story.title}`,
-    "",
-    "## Acceptance Criteria",
-    criteria,
-    "",
-    "## Debater Proposals",
-    proposalsSection,
-    critiquesSection,
-    "",
-    "## Diff",
-    diff,
-    voteTally,
-    "",
-    "Respond with JSON: { passed: boolean, findings: [...], findingReasoning: { [id]: string } }"
-  ].filter((line) => line !== undefined).join(`
-`);
-}
-function buildDebateReReviewPrompt(proposals, critiques, updatedDiff, previousFindings, resolverContext) {
-  const framing = buildResolverFraming(resolverContext);
-  const findingsList = previousFindings.length > 0 ? previousFindings.map((f) => `- ${f.ruleId}: ${f.message}`).join(`
-`) : "(none)";
-  const proposalsSection = buildProposalsSection2(proposals);
-  const critiquesSection = buildCritiquesSection(critiques);
-  return [
-    `${framing} This is a re-review after implementer changes.`,
-    "",
-    "## Previous Findings",
-    findingsList,
-    "",
-    "## Updated Debater Proposals",
-    proposalsSection,
-    critiquesSection,
-    "",
-    "## Updated Diff",
-    updatedDiff,
-    "",
-    "Respond with JSON: { passed: boolean, findings: [...], findingReasoning: { [id]: string }, deltaSummary: string }",
-    "deltaSummary should describe which previous findings are resolved vs still present."
-  ].filter((line) => line !== undefined).join(`
-`);
-}
-
 // src/review/dialogue.ts
 function extractDeltaSummary(rawOutput, previousFindings, newFindings) {
   const parsed = tryParseLLMJson(rawOutput);
@@ -27333,6 +27527,7 @@ function createReviewerSession(agent, storyId, workdir, featureName, _config) {
     generation: 1,
     pendingCompactionContext: null
   };
+  const promptBuilder = new DebatePromptBuilder({ taskContext: "", outputFormat: "", stage: "review" }, { debaters: [], sessionMode: "stateful" });
   function resolveRunParams(semanticConfig) {
     const modelTier = semanticConfig.modelTier;
     const defaultAgent = _config.autoMode?.defaultAgent ?? "claude";
@@ -27367,7 +27562,7 @@ ${prompt}`,
       if (!active) {
         throw new NaxError(`[dialogue] ReviewerSession for story ${storyId} has been destroyed`, "REVIEWER_SESSION_DESTROYED", { stage: "review", storyId, featureName });
       }
-      const prompt = buildReviewPrompt(diff, story, semanticConfig);
+      const prompt = promptBuilder.buildReviewPrompt(diff, story);
       const { modelTier, modelDef, timeoutSeconds } = resolveRunParams(semanticConfig);
       const { effectivePrompt, acpSessionName } = buildEffectiveRunArgs(prompt);
       const result = await agent.run({
@@ -27405,7 +27600,7 @@ ${prompt}`,
         });
       }
       const previousFindings = lastCheckResult.checkResult.findings;
-      const prompt = buildReReviewPrompt(updatedDiff, previousFindings);
+      const prompt = promptBuilder.buildReReviewPrompt(updatedDiff, previousFindings);
       const { modelTier, modelDef, timeoutSeconds } = resolveRunParams(lastSemanticConfig);
       const { effectivePrompt, acpSessionName } = buildEffectiveRunArgs(prompt);
       const result = await agent.run({
@@ -27465,7 +27660,7 @@ ${prompt}`,
       if (!active) {
         throw new NaxError(`[dialogue] ReviewerSession for story ${storyId} has been destroyed`, "REVIEWER_SESSION_DESTROYED", { stage: "review", storyId, featureName });
       }
-      const prompt = buildDebateResolverPrompt(proposals, critiques, diff, story, semanticConfig, resolverContext);
+      const prompt = promptBuilder.buildResolverPrompt(proposals, critiques, diff, story, resolverContext);
       const { modelTier, modelDef, timeoutSeconds } = resolveRunParams(semanticConfig);
       const { effectivePrompt, acpSessionName } = buildEffectiveRunArgs(prompt);
       const result = await agent.run({
@@ -27500,7 +27695,7 @@ ${prompt}`,
         throw new NaxError(`[dialogue] reReviewDebate() called before any resolveDebate() on story ${storyId}`, "NO_REVIEW_RESULT", { stage: "review", storyId });
       }
       const previousFindings = lastCheckResult.checkResult.findings;
-      const prompt = buildDebateReReviewPrompt(proposals, critiques, updatedDiff, previousFindings, resolverContext);
+      const prompt = promptBuilder.buildReResolverPrompt(proposals, critiques, updatedDiff, previousFindings, resolverContext);
       const { modelTier, modelDef, timeoutSeconds } = resolveRunParams(lastSemanticConfig);
       const { effectivePrompt, acpSessionName } = buildEffectiveRunArgs(prompt);
       const result = await agent.run({
@@ -27552,6 +27747,7 @@ ${prompt}`,
   };
 }
 var init_dialogue = __esm(() => {
+  init_prompt_builder();
   init_errors();
 });
 
@@ -36376,7 +36572,7 @@ var package_default;
 var init_package = __esm(() => {
   package_default = {
     name: "@nathapp/nax",
-    version: "0.60.0-canary.1",
+    version: "0.60.1",
     description: "AI Coding Agent Orchestrator \u2014 loops until done",
     type: "module",
     bin: {
@@ -36456,8 +36652,8 @@ var init_version = __esm(() => {
   NAX_VERSION = package_default.version;
   NAX_COMMIT = (() => {
     try {
-      if (/^[0-9a-f]{6,10}$/.test("1de1f9cc"))
-        return "1de1f9cc";
+      if (/^[0-9a-f]{6,10}$/.test("2b74a9ef"))
+        return "2b74a9ef";
     } catch {}
     try {
       const result = Bun.spawnSync(["git", "rev-parse", "--short", "HEAD"], {
@@ -36773,196 +36969,6 @@ var init_crash_recovery = __esm(() => {
   init_crash_heartbeat();
 });
 
-// src/acceptance/fix-generator.ts
-function findRelatedStories(failedAC, prd) {
-  const relatedStoryIds = [];
-  for (const story of prd.userStories) {
-    for (const ac of story.acceptanceCriteria) {
-      if (ac.includes(failedAC)) {
-        relatedStoryIds.push(story.id);
-        break;
-      }
-    }
-  }
-  if (relatedStoryIds.length > 0) {
-    return relatedStoryIds;
-  }
-  const passedStories = prd.userStories.filter((s) => s.status === "passed").map((s) => s.id);
-  return passedStories.slice(0, 5);
-}
-function groupACsByRelatedStories(failedACs, prd) {
-  const groups = new Map;
-  for (const ac of failedACs) {
-    const related = findRelatedStories(ac, prd);
-    const key = [...related].sort().join(",");
-    if (!groups.has(key)) {
-      groups.set(key, { acs: [], relatedStories: related });
-    }
-    groups.get(key)?.acs.push(ac);
-  }
-  const result = Array.from(groups.values());
-  while (result.length > MAX_FIX_STORIES) {
-    result.sort((a, b) => a.acs.length - b.acs.length);
-    const smallest = result.shift();
-    if (!smallest)
-      break;
-    result[0].acs.push(...smallest.acs);
-    for (const s of smallest.relatedStories) {
-      if (!result[0].relatedStories.includes(s)) {
-        result[0].relatedStories.push(s);
-      }
-    }
-  }
-  return result;
-}
-function buildFixPrompt(batchedACs, acTextMap, testOutput, relatedStories, prd, testFilePath) {
-  const acList = batchedACs.map((ac) => `${ac}: ${acTextMap[ac] || "No description available"}`).join(`
-`);
-  const relatedStoriesText = relatedStories.map((id) => {
-    const story = prd.userStories.find((s) => s.id === id);
-    if (!story)
-      return "";
-    return `${story.id}: ${story.title}
-  ${story.description}`;
-  }).filter(Boolean).join(`
-
-`);
-  const testFileSection = testFilePath ? `
-ACCEPTANCE TEST FILE: ${testFilePath}
-(Read this file first to understand what each test expects)
-` : "";
-  return `You are a debugging expert. Feature acceptance tests have failed.${testFileSection}
-FAILED ACCEPTANCE CRITERIA (${batchedACs.length} total):
-${acList}
-
-TEST FAILURE OUTPUT:
-${testOutput.slice(0, 2000)}
-
-RELATED STORIES (implemented this functionality):
-${relatedStoriesText}
-
-Your task: Generate a fix description that will make these acceptance tests pass.
-
-Requirements:
-1. Read the acceptance test file first to understand what each failing test expects
-2. Identify the root cause based on the test failure output
-3. Find and fix the relevant implementation code (do NOT modify the test file)
-4. Write a clear, actionable fix description (2-4 sentences)
-5. Reference the relevant story IDs if needed
-
-Respond with ONLY the fix description (no JSON, no markdown, just the description text).`;
-}
-async function generateFixStories(adapter, options) {
-  const { failedACs, testOutput, prd, specContent, modelDef, testFilePath } = options;
-  const logger = getLogger();
-  const acTextMap = parseACTextFromSpec(specContent);
-  const groups = groupACsByRelatedStories(failedACs, prd);
-  const fixStories = [];
-  for (let i = 0;i < groups.length; i++) {
-    const { acs: batchedACs, relatedStories } = groups[i];
-    if (relatedStories.length === 0) {
-      logger.warn("acceptance", "[WARN] No related stories found for AC group \u2014 skipping", { batchedACs });
-      continue;
-    }
-    logger.info("acceptance", "Generating fix for AC group", { batchedACs });
-    const prompt = buildFixPrompt(batchedACs, acTextMap, testOutput, relatedStories, prd, testFilePath);
-    const relatedStory = prd.userStories.find((s) => relatedStories.includes(s.id) && s.workdir);
-    const workdir = relatedStory?.workdir;
-    try {
-      const fixResult = await adapter.complete(prompt, {
-        model: modelDef.model,
-        config: options.config,
-        featureName: options.prd.feature,
-        workdir: options.workdir,
-        sessionRole: "fix-gen",
-        timeoutMs: options.timeoutMs ?? options.config?.acceptance?.timeoutMs ?? 1800000
-      });
-      fixStories.push({
-        id: `US-FIX-${String(i + 1).padStart(3, "0")}`,
-        title: `Fix: ${batchedACs.join(", ")} \u2014 ${(acTextMap[batchedACs[0]] || "").slice(0, 40)}`,
-        failedAC: batchedACs[0],
-        batchedACs,
-        testOutput,
-        relatedStories,
-        description: typeof fixResult === "string" ? fixResult : fixResult.output,
-        testFilePath,
-        workdir
-      });
-      logger.info("acceptance", "[OK] Generated fix story", { storyId: fixStories[fixStories.length - 1].id });
-    } catch (error48) {
-      logger.warn("acceptance", "[WARN] Error generating fix", {
-        batchedACs,
-        error: error48.message
-      });
-      fixStories.push({
-        id: `US-FIX-${String(i + 1).padStart(3, "0")}`,
-        title: `Fix: ${batchedACs.join(", ")}`,
-        failedAC: batchedACs[0],
-        batchedACs,
-        testOutput,
-        relatedStories,
-        description: `Fix the implementation to make ${batchedACs.join(", ")} pass. Related stories: ${relatedStories.join(", ")}.`,
-        testFilePath,
-        workdir
-      });
-    }
-  }
-  return fixStories;
-}
-function parseACTextFromSpec(specContent) {
-  const map2 = {};
-  const lines = specContent.split(`
-`);
-  for (const line of lines) {
-    const acMatch = line.match(/^\s*-?\s*(?:\[.\])?\s*(AC-\d+):\s*(.+)$/i);
-    if (acMatch) {
-      const id = acMatch[1].toUpperCase();
-      const text = acMatch[2].trim();
-      map2[id] = text;
-    }
-  }
-  return map2;
-}
-function convertFixStoryToUserStory(fixStory) {
-  const batchedACs = fixStory.batchedACs ?? [fixStory.failedAC];
-  const acList = batchedACs.join(", ");
-  const truncatedOutput = fixStory.testOutput.slice(0, 1000);
-  const testFilePath = fixStory.testFilePath ?? resolveAcceptanceTestFile();
-  const enrichedDescription = [
-    fixStory.description,
-    "",
-    `ACCEPTANCE TEST FILE: ${testFilePath}`,
-    `FAILED ACCEPTANCE CRITERIA: ${acList}`,
-    "",
-    "TEST FAILURE OUTPUT:",
-    truncatedOutput,
-    "",
-    "Instructions: Read the acceptance test file first to understand what each failing test expects.",
-    "Then find the relevant source code and fix the implementation.",
-    "Do NOT modify the test file."
-  ].join(`
-`);
-  return {
-    id: fixStory.id,
-    title: fixStory.title,
-    description: enrichedDescription,
-    acceptanceCriteria: batchedACs.map((ac) => `Fix ${ac}`),
-    tags: ["fix", "acceptance-failure"],
-    dependencies: fixStory.relatedStories,
-    status: "pending",
-    passes: false,
-    escalations: [],
-    attempts: 0,
-    contextFiles: [],
-    workdir: fixStory.workdir
-  };
-}
-var MAX_FIX_STORIES = 8;
-var init_fix_generator = __esm(() => {
-  init_logger2();
-  init_test_path();
-});
-
 // src/acceptance/content-loader.ts
 async function loadAcceptanceTestContent(pathsOrFallback) {
   if (!pathsOrFallback)
@@ -36984,13 +36990,6 @@ async function loadAcceptanceTestContent(pathsOrFallback) {
   return [];
 }
 
-// src/acceptance/index.ts
-var init_acceptance4 = __esm(() => {
-  init_refinement();
-  init_generator();
-  init_fix_generator();
-});
-
 // src/acceptance/fix-diagnosis.ts
 function parseImportStatements(content) {
   const importRegex = /import\s+(?:{[^}]+}|[^;]+)\s+from\s+["']([^"']+)["']/g;
@@ -37040,6 +37039,13 @@ ${f.content}
 SEMANTIC VERDICTS:
 ${lines.join(`
 `)}
+`;
+  }
+  let previousFailureSection = "";
+  if (options.previousFailure && options.previousFailure.length > 0) {
+    previousFailureSection = `
+PREVIOUS FIX ATTEMPTS:
+${options.previousFailure}
 `;
   }
   return `You are a debugging expert. An acceptance test has failed.
@@ -37056,7 +37062,7 @@ ${options.testFileContent}
 
 SOURCE FILES (auto-detected from imports, up to ${MAX_FILE_LINES} lines each):
 ${sourceFilesSection}
-${verdictSection}
+${verdictSection}${previousFailureSection}
 Respond with ONLY a JSON object in this exact format (no markdown, no extra text):
 {
   "verdict": "source_bug" | "test_bug" | "both",
@@ -37082,7 +37088,8 @@ async function diagnoseAcceptanceFailure(agent, options) {
     testOutput,
     testFileContent,
     sourceFiles: validSourceFiles,
-    semanticVerdicts: options.semanticVerdicts
+    semanticVerdicts: options.semanticVerdicts,
+    previousFailure: options.previousFailure
   });
   try {
     const timeoutSeconds = (config2.acceptance?.timeoutMs ?? 120000) / 1000;
@@ -37167,7 +37174,7 @@ async function executeSourceFix(agent, options) {
   if (!agent) {
     throw new Error("[fix-executor] agent is required");
   }
-  const { testOutput, testFileContent, diagnosis, config: config2, workdir, featureName, storyId, acceptanceTestPath } = options;
+  const { config: config2, workdir, featureName, storyId } = options;
   const modelDef = resolveModelForAgent(config2.models, config2.autoMode.defaultAgent, config2.acceptance.fix.fixModel, config2.autoMode.defaultAgent);
   const sessionName = buildSessionName(workdir, featureName, storyId, "source-fix");
   const prompt = buildSourceFixPrompt(options);
@@ -37191,23 +37198,77 @@ async function executeSourceFix(agent, options) {
     cost: result.estimatedCost
   };
 }
+function buildTestFixPrompt(options) {
+  const { testOutput, diagnosis, acceptanceTestPath, testFileContent, failedACs, previousFailure } = options;
+  let prompt = `ACCEPTANCE TEST BUG \u2014 surgical fix required.
+
+`;
+  prompt += `FAILING ACS: ${failedACs.join(", ")}
+
+`;
+  prompt += `TEST OUTPUT:
+${testOutput}
+
+`;
+  if (diagnosis.reasoning) {
+    prompt += `DIAGNOSIS:
+${diagnosis.reasoning}
+
+`;
+  }
+  if (previousFailure && previousFailure.length > 0) {
+    prompt += `PREVIOUS FAILED ATTEMPTS:
+${previousFailure}
+
+`;
+  }
+  prompt += `ACCEPTANCE TEST FILE: ${acceptanceTestPath}
+
+`;
+  prompt += `\`\`\`typescript
+${testFileContent}
+\`\`\`
+
+`;
+  prompt += "Fix ONLY the failing test assertions for the ACs listed above. ";
+  prompt += "Do NOT modify passing tests. Do NOT modify source code. ";
+  prompt += "Edit the test file in place.";
+  return prompt;
+}
+async function executeTestFix(agent, options) {
+  if (!agent) {
+    throw new Error("[fix-executor] agent is required");
+  }
+  const { config: config2, workdir, featureName, storyId } = options;
+  const modelDef = resolveModelForAgent(config2.models, config2.autoMode.defaultAgent, config2.acceptance.fix.fixModel, config2.autoMode.defaultAgent);
+  const sessionName = buildSessionName(workdir, featureName, storyId, "test-fix");
+  const prompt = buildTestFixPrompt(options);
+  const timeoutSeconds = config2.execution?.sessionTimeoutSeconds ?? 3600;
+  const runOptions = {
+    prompt,
+    workdir,
+    modelTier: undefined,
+    modelDef,
+    timeoutSeconds,
+    sessionRole: "test-fix",
+    acpSessionName: sessionName,
+    featureName,
+    storyId,
+    config: config2,
+    pipelineStage: "acceptance"
+  };
+  const result = await agent.run(runOptions);
+  return {
+    success: result.success,
+    cost: result.estimatedCost
+  };
+}
 var init_fix_executor = __esm(() => {
   init_adapter();
 });
 
-// src/execution/lifecycle/acceptance-loop.ts
-var exports_acceptance_loop = {};
-__export(exports_acceptance_loop, {
-  runFixRouting: () => runFixRouting,
-  runAcceptanceLoop: () => runAcceptanceLoop,
-  regenerateAcceptanceTest: () => regenerateAcceptanceTest,
-  loadAcceptanceTestContent: () => loadAcceptanceTestContent2,
-  isTestLevelFailure: () => isTestLevelFailure,
-  isStubTestFile: () => isStubTestFile,
-  _regenerateDeps: () => _regenerateDeps,
-  _acceptanceLoopDeps: () => _acceptanceLoopDeps
-});
-import path15, { join as join43 } from "path";
+// src/execution/lifecycle/acceptance-helpers.ts
+import path15 from "path";
 function isStubTestFile(content) {
   return /expect\s*\(\s*true\s*\)\s*\.\s*toBe\s*\(\s*(?:false|true)\s*\)/.test(content);
 }
@@ -37254,73 +37315,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 generateAndAddFixStories(ctx, failures, prd) {
-  const logger = getSafeLogger();
-  const agent = (ctx.agentGetFn ?? _acceptanceLoopDeps.getAgent)(ctx.config.autoMode.defaultAgent);
-  if (!agent) {
-    logger?.error("acceptance", "Agent not found, cannot generate fix stories");
-    return null;
-  }
-  const modelDef = resolveModelForAgent(ctx.config.models, ctx.config.autoMode.defaultAgent, ctx.config.analyze.model, ctx.config.autoMode.defaultAgent);
-  const testFilePath = ctx.featureDir ? resolveAcceptanceFeatureTestPath(ctx.featureDir, ctx.config.acceptance.testPath, ctx.config.project?.language) : undefined;
-  const fixStories = await generateFixStories(agent, {
-    failedACs: failures.failedACs,
-    testOutput: failures.testOutput,
-    prd,
-    specContent: await loadSpecContent(ctx.featureDir),
-    workdir: ctx.workdir,
-    modelDef,
-    config: ctx.config,
-    testFilePath,
-    timeoutMs: ctx.config.acceptance?.timeoutMs
-  });
-  if (fixStories.length === 0) {
-    logger?.error("acceptance", "Failed to generate fix stories");
-    return null;
-  }
-  logger?.info("acceptance", `Generated ${fixStories.length} fix stories`);
-  for (const fixStory of fixStories) {
-    const userStory = convertFixStoryToUserStory(fixStory);
-    prd.userStories.push(userStory);
-    logger?.debug("acceptance", `Fix story added: ${userStory.id}: ${userStory.title}`);
-  }
-  return fixStories;
-}
-async function executeFixStory(ctx, story, prd, iterations) {
-  const logger = getSafeLogger();
-  const routing = await resolveRouting(story, ctx.config, ctx.pluginRegistry);
-  logger?.info("acceptance", `Starting fix story: ${story.id}`, { storyId: story.id, storyTitle: story.title });
-  await fireHook(ctx.hooks, "on-story-start", hookCtx(ctx.feature, {
-    storyId: story.id,
-    model: routing.modelTier,
-    agent: ctx.config.autoMode.defaultAgent,
-    iteration: iterations
-  }), ctx.workdir);
-  const fixEffectiveConfig = story.workdir ? await loadConfigForWorkdir(join43(ctx.workdir, ".nax", "config.json"), story.workdir) : ctx.config;
-  const fixContext = {
-    config: fixEffectiveConfig,
-    rootConfig: ctx.config,
-    prd,
-    story,
-    stories: [story],
-    routing,
-    projectDir: ctx.workdir,
-    workdir: story.workdir ? join43(ctx.workdir, story.workdir) : ctx.workdir,
-    featureDir: ctx.featureDir,
-    hooks: ctx.hooks,
-    plugins: ctx.pluginRegistry,
-    storyStartTime: new Date().toISOString(),
-    agentGetFn: ctx.agentGetFn
-  };
-  const result = await runPipeline(defaultPipeline, fixContext, ctx.eventEmitter);
-  logger?.info("acceptance", `Fix story ${story.id} ${result.success ? "passed" : "failed"}`);
-  return {
-    success: result.success,
-    cost: result.context.agentResult?.estimatedCost || 0,
-    metrics: result.context.storyMetrics
-  };
-}
-async function regenerateAcceptanceTest(testPath, acceptanceContext) {
+async function regenerateAcceptanceTest(testPath, acceptanceContext, previousFailure) {
   const logger = getSafeLogger();
   const bakPath = `${testPath}.bak`;
   const content = await Bun.file(testPath).text();
@@ -37364,7 +37359,8 @@ async function regenerateAcceptanceTest(testPath, acceptanceContext) {
   }
   const contextForSetup = {
     ...acceptanceContext,
-    ...implementationContext ? { implementationContext } : {}
+    ...implementationContext ? { implementationContext } : {},
+    ...previousFailure ? { previousFailure } : {}
   };
   await _regenerateDeps.acceptanceSetupExecute(contextForSetup);
   if (!await Bun.file(testPath).exists()) {
@@ -37374,300 +37370,179 @@ async function regenerateAcceptanceTest(testPath, acceptanceContext) {
   logger?.info("acceptance", "Acceptance test regenerated successfully");
   return true;
 }
-async function runFixRouting(options) {
+var _regenerateDeps;
+var init_acceptance_helpers = __esm(() => {
+  init_logger2();
+  _regenerateDeps = {
+    spawnGitDiff: async (workdir, gitRef) => {
+      const proc = Bun.spawn(["git", "diff", "--name-only", gitRef], {
+        cwd: workdir,
+        stdout: "pipe",
+        stderr: "pipe"
+      });
+      const [, stdout] = await Promise.all([proc.exited, new Response(proc.stdout).text()]);
+      return stdout.trim();
+    },
+    readFile: async (filePath) => Bun.file(filePath).text(),
+    acceptanceSetupExecute: async (ctx) => {
+      const { acceptanceSetupStage: acceptanceSetupStage2 } = await Promise.resolve().then(() => (init_acceptance_setup(), exports_acceptance_setup));
+      await acceptanceSetupStage2.execute(ctx);
+    }
+  };
+});
+
+// src/execution/lifecycle/acceptance-fix.ts
+async function resolveAcceptanceDiagnosis(opts) {
   const logger = getSafeLogger();
-  const { ctx, failures, acceptanceContext } = options;
-  const prd = options.prd ?? ctx.prd;
-  const semanticVerdicts = options.semanticVerdicts;
-  if (semanticVerdicts && semanticVerdicts.length > 0 && semanticVerdicts.every((v) => v.passed)) {
-    const verdictCount = semanticVerdicts.length;
-    const storyId2 = acceptanceContext?.story?.id ?? prd?.userStories?.[0]?.id ?? "unknown";
-    logger?.info("acceptance", "All semantic verdicts passed \u2014 routing to test regeneration", {
-      storyId: storyId2,
-      verdictCount
+  const { agent, failures, totalACs, strategy, semanticVerdicts, diagnosisOpts, previousFailure } = opts;
+  const storyId = diagnosisOpts.storyId;
+  if (strategy === "implement-only") {
+    logger?.info("acceptance.diagnosis", "Fast path: implement-only strategy \u2192 source_bug", { storyId });
+    return {
+      verdict: "source_bug",
+      reasoning: "implement-only strategy \u2014 skipping diagnosis",
+      confidence: 1
+    };
+  }
+  if (semanticVerdicts.length > 0 && semanticVerdicts.every((v) => v.passed)) {
+    logger?.info("acceptance.diagnosis", "Fast path: all semantic verdicts passed \u2192 test_bug", {
+      storyId,
+      verdictCount: semanticVerdicts.length
+    });
+    return {
+      verdict: "test_bug",
+      reasoning: `Semantic review confirmed all ${semanticVerdicts.length} ACs are implemented \u2014 failure is a test generation issue`,
+      confidence: 1
+    };
+  }
+  if (isTestLevelFailure(failures.failedACs, totalACs)) {
+    logger?.info("acceptance.diagnosis", "Fast path: test-level failure heuristic \u2192 test_bug", {
+      storyId,
+      failedCount: failures.failedACs.length,
+      totalACs
     });
-    if (!ctx.featureDir || !acceptanceContext) {
-      logger?.warn("acceptance", "Cannot regenerate test \u2014 featureDir or acceptanceContext missing", { storyId: storyId2 });
-      return {
-        fixed: false,
-        cost: 0,
-        prdDirty: false,
-        verdict: "test_bug",
-        confidence: 1,
-        reasoning: "Semantic review confirmed all ACs are implemented \u2014 acceptance test failure is a test generation issue"
-      };
-    }
-    const regenOutcome = await _acceptanceLoopDeps.executeTestRegen(ctx, acceptanceContext);
-    logger?.info("acceptance.test-regen", "Test regeneration completed", { storyId: storyId2, outcome: regenOutcome });
-    if (regenOutcome === "passed") {
-      return { fixed: true, cost: 0, prdDirty: true };
-    }
     return {
-      fixed: false,
-      cost: 0,
-      prdDirty: regenOutcome !== "no_test_file",
       verdict: "test_bug",
-      confidence: 1,
-      reasoning: "Semantic review confirmed all ACs are implemented \u2014 acceptance test failure is a test generation issue"
+      reasoning: `Test-level failure: ${failures.failedACs.length}/${totalACs} ACs failed (>80% threshold or AC-ERROR sentinel)`,
+      confidence: 0.9
     };
   }
+  return await diagnoseAcceptanceFailure(agent, {
+    ...diagnosisOpts,
+    semanticVerdicts,
+    previousFailure
+  });
+}
+async function applyFix(opts) {
+  const logger = getSafeLogger();
+  const { ctx, failures, diagnosis, previousFailure } = opts;
+  const storyId = ctx.prd.userStories[0]?.id ?? "unknown";
   const agentName = ctx.config.autoMode.defaultAgent;
-  const agent = (ctx.agentGetFn ?? _acceptanceLoopDeps.getAgent)(agentName);
-  const strategy = ctx.config.acceptance.fix?.strategy ?? "diagnose-first";
-  const fixMaxRetries = ctx.config.acceptance.fix?.maxRetries ?? 2;
+  const agent = (ctx.agentGetFn ?? _applyFixDeps.getAgent)(agentName);
+  if (!agent) {
+    logger?.error("acceptance.applyFix", "Agent not found", { storyId, agentName });
+    return { cost: 0 };
+  }
   const testPaths = ctx.acceptanceTestPaths;
-  let testEntries;
+  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);
-    testEntries = moduleEntries.map((e) => ({ content: e.content, path: e.testPath }));
-  } else {
-    const fallbackPath = ctx.featureDir ? resolveAcceptanceFeatureTestPath(ctx.featureDir, ctx.config.acceptance.testPath, ctx.config.project?.language) : undefined;
-    const moduleEntries = await loadAcceptanceTestContent(fallbackPath);
-    testEntries = moduleEntries.map((e) => ({ content: e.content, path: e.testPath }));
-  }
-  const primaryEntry = testEntries[0] ?? { content: "", path: "" };
-  const testFileContent = primaryEntry.content;
-  const acceptanceTestPath = primaryEntry.path;
-  const firstStory = prd?.userStories?.[0];
-  const storyId = firstStory?.id ?? "unknown";
-  if (failures.failedACs.length === 0) {
-    return { fixed: true, cost: 0, prdDirty: false };
-  }
-  if (strategy === "implement-only") {
-    logger?.info("acceptance", "Strategy is implement-only \u2014 executing source fix directly");
-    if (!agent) {
-      logger?.error("acceptance", "Agent not found for fix routing");
-      return { fixed: false, cost: 0, prdDirty: false };
-    }
-    let fixAttempts = 0;
-    while (fixAttempts < fixMaxRetries) {
-      fixAttempts++;
-      logger?.info("acceptance", `Source fix attempt ${fixAttempts}/${fixMaxRetries}`);
-      const defaultDiagnosis = {
-        verdict: "source_bug",
-        reasoning: "implement-only strategy \u2014 skipping diagnosis",
-        confidence: 1
-      };
-      const fixResult = await executeSourceFix(agent, {
-        testOutput: failures.testOutput,
-        testFileContent,
-        diagnosis: defaultDiagnosis,
-        config: ctx.config,
-        workdir: ctx.workdir,
-        featureName: ctx.feature,
-        storyId,
-        acceptanceTestPath
-      });
-      logger?.info("acceptance.source-fix", "Source fix completed", {
-        success: fixResult.success,
-        cost: fixResult.cost,
-        attempt: fixAttempts
-      });
-      if (fixResult.success) {
-        return { fixed: true, cost: fixResult.cost, prdDirty: false };
-      }
-      logger?.warn("acceptance.source-fix", "Source fix attempt failed", {
-        attempt: fixAttempts,
-        maxRetries: fixMaxRetries,
-        cost: fixResult.cost,
-        willRetry: fixAttempts < fixMaxRetries
-      });
-      if (fixAttempts >= fixMaxRetries) {
-        logger?.error("acceptance", `Source fix failed after ${fixMaxRetries} attempts`);
-        break;
-      }
+    if (moduleEntries.length > 0) {
+      testFileContent = moduleEntries[0].content;
+      acceptanceTestPath = moduleEntries[0].testPath;
     }
-    return { fixed: false, cost: 0, prdDirty: false };
-  }
-  logger?.info("acceptance", "Strategy is diagnose-first \u2014 running diagnosis");
-  const diagnosis = await diagnoseAcceptanceFailure(agent, {
-    testOutput: failures.testOutput,
-    testFileContent,
-    config: ctx.config,
-    workdir: ctx.workdir,
-    featureName: ctx.feature,
-    storyId,
-    semanticVerdicts: options.semanticVerdicts
-  });
-  const diagnosisCost = diagnosis.cost ?? 0;
-  logger?.info("acceptance.diagnosis", "Diagnosis complete", {
-    verdict: diagnosis.verdict,
-    confidence: diagnosis.confidence,
-    reasoning: diagnosis.reasoning
-  });
-  if (diagnosis.verdict === "source_bug") {
-    logger?.info("acceptance", "Diagnosis: source_bug \u2014 executing source fix");
-    if (!agent) {
-      logger?.error("acceptance", "Agent not found for source fix execution");
-      return { fixed: false, cost: diagnosisCost, prdDirty: false };
-    }
-    let fixAttempts = 0;
-    while (fixAttempts < fixMaxRetries) {
-      fixAttempts++;
-      logger?.info("acceptance", `Source fix attempt ${fixAttempts}/${fixMaxRetries}`);
-      const fixResult = await executeSourceFix(agent, {
-        testOutput: failures.testOutput,
-        testFileContent,
-        diagnosis,
-        config: ctx.config,
-        workdir: ctx.workdir,
-        featureName: ctx.feature,
-        storyId,
-        acceptanceTestPath
-      });
-      logger?.info("acceptance.source-fix", "Source fix completed", {
-        success: fixResult.success,
-        cost: fixResult.cost,
-        attempt: fixAttempts
-      });
-      if (fixResult.success) {
-        return { fixed: true, cost: fixResult.cost + diagnosisCost, prdDirty: false };
-      }
-      logger?.warn("acceptance.source-fix", "Source fix attempt failed", {
-        attempt: fixAttempts,
-        maxRetries: fixMaxRetries,
-        cost: fixResult.cost,
-        willRetry: fixAttempts < fixMaxRetries
-      });
-      if (fixAttempts >= fixMaxRetries) {
-        logger?.error("acceptance", `Source fix failed after ${fixMaxRetries} attempts`);
-        break;
-      }
+  } 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;
     }
-    return { fixed: false, cost: diagnosisCost, prdDirty: false };
   }
-  if (diagnosis.verdict === "test_bug") {
-    logger?.info("acceptance", "Diagnosis: test_bug \u2014 regenerating acceptance test");
-    if (!ctx.featureDir) {
-      logger?.error("acceptance", "Cannot regenerate test without featureDir");
-      return { fixed: false, cost: diagnosisCost, prdDirty: false };
-    }
-    const testPath = await findExistingAcceptanceTestPath({
-      acceptanceTestPaths: ctx.acceptanceTestPaths,
-      featureDir: ctx.featureDir,
-      testPathConfig: ctx.config.acceptance.testPath,
-      language: ctx.config.project?.language
+  let totalCost = 0;
+  if (diagnosis.verdict === "source_bug" || diagnosis.verdict === "both") {
+    logger?.info("acceptance.applyFix", "Applying source fix", { storyId, verdict: diagnosis.verdict });
+    const sourceResult = await _applyFixDeps.executeSourceFix(agent, {
+      testOutput: failures.testOutput,
+      testFileContent,
+      diagnosis,
+      config: ctx.config,
+      workdir: ctx.workdir,
+      featureName: ctx.feature,
+      storyId,
+      acceptanceTestPath
     });
-    if (!testPath) {
-      logger?.error("acceptance", "Acceptance test file not found for regeneration", {
-        candidates: resolveAcceptanceTestCandidates({
-          acceptanceTestPaths: ctx.acceptanceTestPaths,
-          featureDir: ctx.featureDir,
-          testPathConfig: ctx.config.acceptance.testPath,
-          language: ctx.config.project?.language
-        })
-      });
-      return { fixed: false, cost: diagnosisCost, prdDirty: false };
-    }
-    const regenerated = await regenerateAcceptanceTest(testPath, acceptanceContext);
-    logger?.info("acceptance.test-regen", "Test regeneration completed", {
-      outcome: regenerated ? "success" : "failure"
+    totalCost += sourceResult.cost;
+    logger?.info("acceptance.source-fix", "Source fix completed", {
+      storyId,
+      success: sourceResult.success,
+      cost: sourceResult.cost
     });
-    if (!regenerated) {
-      return { fixed: false, cost: diagnosisCost, prdDirty: false };
-    }
-    const { acceptanceStage: acceptanceStage2 } = await Promise.resolve().then(() => (init_acceptance(), exports_acceptance));
-    const acceptanceResult = await acceptanceStage2.execute(acceptanceContext);
-    if (acceptanceResult.action === "continue") {
-      logger?.info("acceptance", "Acceptance passed after test regeneration");
-      return { fixed: true, cost: diagnosisCost, prdDirty: true };
-    }
-    logger?.warn("acceptance", "Acceptance still failing after test regeneration");
-    return { fixed: false, cost: diagnosisCost, prdDirty: true };
   }
-  if (diagnosis.verdict === "both") {
-    logger?.info("acceptance", "Diagnosis: both \u2014 executing source fix then regenerating test if needed");
-    if (!agent) {
-      logger?.error("acceptance", "Agent not found for source fix execution");
-      return { fixed: false, cost: diagnosisCost, prdDirty: false };
-    }
-    let sourceFixSuccess = false;
-    let sourceFixCost = 0;
-    let fixAttempts = 0;
-    while (fixAttempts < fixMaxRetries && !sourceFixSuccess) {
-      fixAttempts++;
-      logger?.info("acceptance", `Source fix attempt ${fixAttempts}/${fixMaxRetries}`);
-      const fixResult = await executeSourceFix(agent, {
-        testOutput: failures.testOutput,
-        testFileContent,
-        diagnosis,
-        config: ctx.config,
-        workdir: ctx.workdir,
-        featureName: ctx.feature,
-        storyId,
-        acceptanceTestPath
-      });
-      logger?.info("acceptance.source-fix", "Source fix completed", {
-        success: fixResult.success,
-        cost: fixResult.cost,
-        attempt: fixAttempts
-      });
-      sourceFixSuccess = fixResult.success;
-      sourceFixCost += fixResult.cost;
-      if (fixResult.success) {
-        break;
-      }
-      logger?.warn("acceptance.source-fix", "Source fix attempt failed", {
-        attempt: fixAttempts,
-        maxRetries: fixMaxRetries,
-        cost: fixResult.cost,
-        willRetry: fixAttempts < fixMaxRetries
-      });
-      if (fixAttempts >= fixMaxRetries) {
-        logger?.error("acceptance", `Source fix failed after ${fixMaxRetries} attempts`);
-        break;
-      }
-    }
-    if (!sourceFixSuccess) {
-      return { fixed: false, cost: sourceFixCost + diagnosisCost, prdDirty: false };
-    }
-    logger?.info("acceptance", "Source fix succeeded \u2014 re-running acceptance to verify");
-    const { acceptanceStage: acceptanceStage2 } = await Promise.resolve().then(() => (init_acceptance(), exports_acceptance));
-    const acceptanceResult = await acceptanceStage2.execute(acceptanceContext);
-    if (acceptanceResult.action === "continue") {
-      logger?.info("acceptance", "Acceptance passed after source fix");
-      return { fixed: true, cost: sourceFixCost + diagnosisCost, prdDirty: false };
-    }
-    logger?.info("acceptance", "Acceptance still failing after source fix \u2014 regenerating test");
-    if (!ctx.featureDir) {
-      logger?.error("acceptance", "Cannot regenerate test without featureDir");
-      return { fixed: false, cost: sourceFixCost + diagnosisCost, prdDirty: false };
-    }
-    const testPath = await findExistingAcceptanceTestPath({
-      acceptanceTestPaths: ctx.acceptanceTestPaths,
-      featureDir: ctx.featureDir,
-      testPathConfig: ctx.config.acceptance.testPath,
-      language: ctx.config.project?.language
+  if (diagnosis.verdict === "test_bug" || diagnosis.verdict === "both") {
+    logger?.info("acceptance.applyFix", "Applying test fix", { storyId, verdict: diagnosis.verdict });
+    const testResult = await _applyFixDeps.executeTestFix(agent, {
+      testOutput: failures.testOutput,
+      testFileContent,
+      failedACs: failures.failedACs,
+      diagnosis,
+      config: ctx.config,
+      workdir: ctx.workdir,
+      featureName: ctx.feature,
+      storyId,
+      acceptanceTestPath,
+      previousFailure
     });
-    if (!testPath) {
-      logger?.error("acceptance", "Acceptance test file not found for regeneration", {
-        candidates: resolveAcceptanceTestCandidates({
-          acceptanceTestPaths: ctx.acceptanceTestPaths,
-          featureDir: ctx.featureDir,
-          testPathConfig: ctx.config.acceptance.testPath,
-          language: ctx.config.project?.language
-        })
-      });
-      return { fixed: false, cost: sourceFixCost + diagnosisCost, prdDirty: false };
-    }
-    const regenerated = await regenerateAcceptanceTest(testPath, acceptanceContext);
-    logger?.info("acceptance.test-regen", "Test regeneration completed", {
-      outcome: regenerated ? "success" : "failure"
+    totalCost += testResult.cost;
+    logger?.info("acceptance.test-fix", "Test fix completed", {
+      storyId,
+      success: testResult.success,
+      cost: testResult.cost
     });
-    return { fixed: regenerated, cost: sourceFixCost + diagnosisCost, prdDirty: regenerated };
   }
-  return { fixed: false, cost: diagnosisCost, prdDirty: false };
+  return { cost: totalCost };
 }
+var _applyFixDeps;
+var init_acceptance_fix = __esm(() => {
+  init_fix_diagnosis();
+  init_fix_executor();
+  init_test_path();
+  init_registry();
+  init_logger2();
+  init_acceptance_helpers();
+  _applyFixDeps = {
+    getAgent,
+    executeSourceFix,
+    executeTestFix
+  };
+});
+
+// src/execution/lifecycle/acceptance-loop.ts
+var exports_acceptance_loop = {};
+__export(exports_acceptance_loop, {
+  runAcceptanceLoop: () => runAcceptanceLoop,
+  regenerateAcceptanceTest: () => regenerateAcceptanceTest,
+  loadSpecContent: () => loadSpecContent,
+  loadAcceptanceTestContent: () => loadAcceptanceTestContent2,
+  isTestLevelFailure: () => isTestLevelFailure,
+  isStubTestFile: () => isStubTestFile,
+  buildResult: () => buildResult,
+  _regenerateDeps: () => _regenerateDeps,
+  _acceptanceLoopDeps: () => _acceptanceLoopDeps
+});
 async function runAcceptanceLoop(ctx) {
   const logger = getSafeLogger();
   const maxRetries = ctx.config.acceptance.maxRetries;
   let acceptanceRetries = 0;
-  let prd = ctx.prd;
+  let stubRegenCount = 0;
+  let previousFailure = "";
+  const prd = ctx.prd;
   let totalCost = ctx.totalCost;
-  let iterations = ctx.iterations;
-  let storiesCompleted = ctx.storiesCompleted;
-  let prdDirty = false;
+  const iterations = ctx.iterations;
+  const storiesCompleted = ctx.storiesCompleted;
+  const prdDirty = false;
   logger?.info("acceptance", "All stories complete, running acceptance validation");
   while (acceptanceRetries < maxRetries) {
     const firstStory = prd.userStories[0];
@@ -37704,18 +37579,16 @@ async function runAcceptanceLoop(ctx) {
     const failures = acceptanceContext.acceptanceFailures;
     if (!failures || failures.failedACs.length === 0) {
       logger?.error("acceptance", "Acceptance tests failed but no specific failures detected");
-      logger?.warn("acceptance", "Manual intervention required");
       await fireHook(ctx.hooks, "on-pause", hookCtx(ctx.feature, { reason: "Acceptance tests failed (no failures detected)", cost: totalCost }), ctx.workdir);
       return buildResult(false, prd, totalCost, iterations, storiesCompleted, prdDirty);
     }
     acceptanceRetries++;
     logger?.warn("acceptance", `Acceptance retry ${acceptanceRetries}/${maxRetries}`, {
+      storyId: firstStory?.id,
       failedACs: failures.failedACs
     });
     if (acceptanceRetries >= maxRetries) {
-      logger?.error("acceptance", "Max acceptance retries reached");
-      logger?.warn("acceptance", "Manual intervention required");
-      logger?.debug("acceptance", 'Run: nax accept --override AC-N "reason" to skip specific ACs');
+      logger?.error("acceptance", "Max acceptance retries reached", { storyId: firstStory?.id });
       await fireHook(ctx.hooks, "on-pause", hookCtx(ctx.feature, {
         reason: `Acceptance validation failed after ${maxRetries} retries: ${failures.failedACs.join(", ")}`,
         cost: totalCost
@@ -37729,141 +37602,87 @@ async function runAcceptanceLoop(ctx) {
         testPathConfig: ctx.config.acceptance.testPath,
         language: ctx.config.project?.language
       });
-      if (existingStubPath) {
-        const testContent = await Bun.file(existingStubPath).text();
-        if (isStubTestFile(testContent)) {
-          logger?.warn("acceptance", "Stub tests detected \u2014 re-generating acceptance tests", {
-            testPath: existingStubPath
+      if (existingStubPath && isStubTestFile(await Bun.file(existingStubPath).text())) {
+        if (stubRegenCount >= MAX_STUB_REGENS) {
+          logger?.error("acceptance", "Acceptance test generator cannot produce real tests \u2014 giving up", {
+            storyId: firstStory?.id,
+            stubRegenCount
           });
-          const { unlink: unlink3 } = await import("fs/promises");
-          await unlink3(existingStubPath);
-          const { acceptanceSetupStage: acceptanceSetupStage2 } = await Promise.resolve().then(() => (init_acceptance_setup(), exports_acceptance_setup));
-          await acceptanceSetupStage2.execute(acceptanceContext);
-          const newContent = await Bun.file(existingStubPath).text();
-          if (isStubTestFile(newContent)) {
-            logger?.error("acceptance", "Acceptance test generation failed after retry \u2014 manual implementation required");
-            return buildResult(false, prd, totalCost, iterations, storiesCompleted, prdDirty, failures.failedACs, acceptanceRetries);
-          }
-          continue;
-        }
-      }
-    }
-    const totalACs = prd.userStories.filter((s) => !s.id.startsWith("US-FIX-")).flatMap((s) => s.acceptanceCriteria).length;
-    if (ctx.featureDir && isTestLevelFailure(failures.failedACs, totalACs)) {
-      logger?.warn("acceptance", `Test-level failure detected (${failures.failedACs.length}/${totalACs} ACs failed) \u2014 regenerating acceptance test`);
-      const testPath = await findExistingAcceptanceTestPath({
-        acceptanceTestPaths: ctx.acceptanceTestPaths,
-        featureDir: ctx.featureDir,
-        testPathConfig: ctx.config.acceptance.testPath,
-        language: ctx.config.project?.language
-      });
-      if (testPath) {
-        const regenerated = await regenerateAcceptanceTest(testPath, acceptanceContext);
-        if (!regenerated) {
           return buildResult(false, prd, totalCost, iterations, storiesCompleted, prdDirty, failures.failedACs, acceptanceRetries);
         }
+        stubRegenCount++;
+        logger?.warn("acceptance", "Stub test detected \u2014 full regen", {
+          storyId: firstStory?.id,
+          attempt: stubRegenCount,
+          maxStubRegens: MAX_STUB_REGENS
+        });
+        await regenerateAcceptanceTest(existingStubPath, acceptanceContext);
         continue;
       }
     }
-    const strategy = ctx.config.acceptance.fix?.strategy ?? "diagnose-first";
-    if (strategy === "diagnose-first" || strategy === "implement-only") {
-      logger?.info("acceptance", `Running fix routing with strategy: ${strategy}`);
-      const semanticVerdicts = ctx.featureDir ? await _acceptanceLoopDeps.loadSemanticVerdicts(ctx.featureDir) : [];
-      const fixResult = await runFixRouting({
-        ctx,
-        failures,
-        prd,
-        acceptanceContext,
-        semanticVerdicts
-      });
-      totalCost += fixResult.cost;
-      if (fixResult.fixed) {
-        logger?.info("acceptance", "Fix succeeded \u2014 re-running acceptance tests...");
-        continue;
-      }
-      logger?.error("acceptance", "Fix routing failed to resolve acceptance failures");
-      return buildResult(false, prd, totalCost, iterations, storiesCompleted, prdDirty, failures.failedACs, acceptanceRetries);
-    }
-    logger?.info("acceptance", "Generating fix stories...");
-    const fixStories = await generateAndAddFixStories(ctx, failures, prd);
-    if (!fixStories) {
+    const semanticVerdicts = ctx.featureDir ? await _acceptanceLoopDeps.loadSemanticVerdicts(ctx.featureDir) : [];
+    const totalACs = prd.userStories.filter((s) => !s.id.startsWith("US-FIX-")).flatMap((s) => s.acceptanceCriteria).length;
+    const agentName = ctx.config.autoMode.defaultAgent;
+    const agent = (ctx.agentGetFn ?? _acceptanceLoopDeps.getAgent)(agentName);
+    if (!agent) {
+      logger?.error("acceptance", "Agent not found for diagnosis", { storyId: firstStory?.id, agentName });
       return buildResult(false, prd, totalCost, iterations, storiesCompleted, prdDirty, failures.failedACs, acceptanceRetries);
     }
-    await savePRD(prd, ctx.prdPath);
-    prdDirty = true;
-    logger?.info("acceptance", "Running fix stories...");
-    for (const fixStory of fixStories) {
-      const userStory = prd.userStories.find((s) => s.id === fixStory.id);
-      if (!userStory || userStory.status !== "pending")
-        continue;
-      iterations++;
-      const result = await executeFixStory(ctx, userStory, prd, iterations);
-      prd = await loadPRD(ctx.prdPath);
-      if (result.success) {
-        storiesCompleted++;
-        totalCost += result.cost;
-        if (result.metrics)
-          ctx.allStoryMetrics.push(...result.metrics);
-      }
-      await savePRD(prd, ctx.prdPath);
-      prdDirty = true;
-    }
-    logger?.info("acceptance", "Re-running acceptance tests...");
+    const testEntries = ctx.acceptanceTestPaths ? await loadAcceptanceTestContent(ctx.acceptanceTestPaths.map((p) => p.testPath)) : [];
+    const testFileContent = testEntries[0]?.content ?? "";
+    const strategy = ctx.config.acceptance.fix?.strategy ?? "diagnose-first";
+    const diagnosis = await resolveAcceptanceDiagnosis({
+      agent,
+      failures,
+      totalACs,
+      strategy,
+      semanticVerdicts,
+      diagnosisOpts: {
+        testOutput: failures.testOutput,
+        testFileContent,
+        config: ctx.config,
+        workdir: ctx.workdir,
+        featureName: ctx.feature,
+        storyId: firstStory?.id
+      },
+      previousFailure
+    });
+    logger?.info("acceptance.diagnosis", "Diagnosis resolved", {
+      storyId: firstStory?.id,
+      verdict: diagnosis.verdict,
+      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(", ")}
+`;
   }
   return buildResult(false, prd, totalCost, iterations, storiesCompleted, prdDirty);
 }
-var _acceptanceLoopDeps, _regenerateDeps;
+var _acceptanceLoopDeps, MAX_STUB_REGENS = 2;
 var init_acceptance_loop = __esm(() => {
-  init_acceptance4();
-  init_fix_diagnosis();
-  init_fix_executor();
   init_semantic_verdict();
   init_test_path();
   init_registry();
-  init_config();
-  init_loader();
   init_hooks();
   init_logger2();
-  init_runner();
-  init_stages();
-  init_prd();
-  init_routing();
   init_helpers();
+  init_acceptance_fix();
+  init_acceptance_helpers();
+  init_acceptance_helpers();
   _acceptanceLoopDeps = {
     getAgent,
-    loadSemanticVerdicts,
-    executeTestRegen: async (ctx, acceptanceContext) => {
-      const testPath = await findExistingAcceptanceTestPath({
-        acceptanceTestPaths: ctx.acceptanceTestPaths,
-        featureDir: ctx.featureDir,
-        testPathConfig: ctx.config.acceptance.testPath,
-        language: ctx.config.project?.language
-      });
-      if (!testPath)
-        return "no_test_file";
-      const regenerated = await regenerateAcceptanceTest(testPath, acceptanceContext);
-      if (!regenerated)
-        return "failed";
-      const { acceptanceStage: acceptanceStage2 } = await Promise.resolve().then(() => (init_acceptance(), exports_acceptance));
-      const result = await acceptanceStage2.execute(acceptanceContext);
-      return result.action === "continue" ? "passed" : "failed";
-    }
-  };
-  _regenerateDeps = {
-    spawnGitDiff: async (workdir, gitRef) => {
-      const proc = Bun.spawn(["git", "diff", "--name-only", gitRef], {
-        cwd: workdir,
-        stdout: "pipe",
-        stderr: "pipe"
-      });
-      const [, stdout] = await Promise.all([proc.exited, new Response(proc.stdout).text()]);
-      return stdout.trim();
-    },
-    readFile: async (filePath) => Bun.file(filePath).text(),
-    acceptanceSetupExecute: async (ctx) => {
-      const { acceptanceSetupStage: acceptanceSetupStage2 } = await Promise.resolve().then(() => (init_acceptance_setup(), exports_acceptance_setup));
-      await acceptanceSetupStage2.execute(ctx);
-    }
+    loadSemanticVerdicts
   };
 });
 
@@ -38347,12 +38166,12 @@ var init_headless_formatter = __esm(() => {
 // src/pipeline/subscribers/events-writer.ts
 import { appendFile as appendFile3, mkdir as mkdir3 } from "fs/promises";
 import { homedir as homedir5 } from "os";
-import { basename as basename6, join as join44 } from "path";
+import { basename as basename6, join as join43 } from "path";
 function wireEventsWriter(bus, feature, runId, workdir) {
   const logger = getSafeLogger();
   const project = basename6(workdir);
-  const eventsDir = join44(homedir5(), ".nax", "events", project);
-  const eventsFile = join44(eventsDir, "events.jsonl");
+  const eventsDir = join43(homedir5(), ".nax", "events", project);
+  const eventsFile = join43(eventsDir, "events.jsonl");
   let dirReady = false;
   const write = (line) => {
     return (async () => {
@@ -38533,12 +38352,12 @@ var init_interaction2 = __esm(() => {
 // src/pipeline/subscribers/registry.ts
 import { mkdir as mkdir4, writeFile } from "fs/promises";
 import { homedir as homedir6 } from "os";
-import { basename as basename7, join as join45 } from "path";
+import { basename as basename7, join as join44 } from "path";
 function wireRegistry(bus, feature, runId, workdir) {
   const logger = getSafeLogger();
   const project = basename7(workdir);
-  const runDir = join45(homedir6(), ".nax", "runs", `${project}-${feature}-${runId}`);
-  const metaFile = join45(runDir, "meta.json");
+  const runDir = join44(homedir6(), ".nax", "runs", `${project}-${feature}-${runId}`);
+  const metaFile = join44(runDir, "meta.json");
   const unsub = bus.on("run:started", (_ev) => {
     return (async () => {
       try {
@@ -38548,8 +38367,8 @@ function wireRegistry(bus, feature, runId, workdir) {
           project,
           feature,
           workdir,
-          statusPath: join45(workdir, ".nax", "features", feature, "status.json"),
-          eventsDir: join45(workdir, ".nax", "features", feature, "runs"),
+          statusPath: join44(workdir, ".nax", "features", feature, "status.json"),
+          eventsDir: join44(workdir, ".nax", "features", feature, "runs"),
           registeredAt: new Date().toISOString()
         };
         await writeFile(metaFile, JSON.stringify(meta3, null, 2));
@@ -39206,7 +39025,7 @@ var init_pipeline_result_handler = __esm(() => {
 });
 
 // src/execution/iteration-runner.ts
-import { join as join46 } from "path";
+import { join as join45 } from "path";
 async function runIteration(ctx, prd, selection, iterations, totalCost, allStoryMetrics) {
   const logger = getSafeLogger();
   const { story, storiesToExecute, routing, isBatchExecution } = selection;
@@ -39241,7 +39060,7 @@ async function runIteration(ctx, prd, selection, iterations, totalCost, allStory
     }
   }
   const accumulatedAttemptCost = (story.priorFailures || []).reduce((sum, f) => sum + (f.cost || 0), 0);
-  const effectiveConfig = story.workdir ? await _iterationRunnerDeps.loadConfigForWorkdir(join46(ctx.workdir, ".nax", "config.json"), story.workdir) : ctx.config;
+  const effectiveConfig = story.workdir ? await _iterationRunnerDeps.loadConfigForWorkdir(join45(ctx.workdir, ".nax", "config.json"), story.workdir) : ctx.config;
   const pipelineContext = {
     config: effectiveConfig,
     rootConfig: ctx.config,
@@ -39250,7 +39069,7 @@ async function runIteration(ctx, prd, selection, iterations, totalCost, allStory
     stories: storiesToExecute,
     routing,
     projectDir: ctx.workdir,
-    workdir: story.workdir ? join46(ctx.workdir, story.workdir) : ctx.workdir,
+    workdir: story.workdir ? join45(ctx.workdir, story.workdir) : ctx.workdir,
     prdPath: ctx.prdPath,
     featureDir: ctx.featureDir,
     hooks: ctx.hooks,
@@ -39406,7 +39225,7 @@ __export(exports_parallel_worker, {
   executeStoryInWorktree: () => executeStoryInWorktree,
   executeParallelBatch: () => executeParallelBatch
 });
-import { join as join47 } from "path";
+import { join as join46 } from "path";
 async function executeStoryInWorktree(story, worktreePath, context, routing, eventEmitter) {
   const logger = getSafeLogger();
   try {
@@ -39426,7 +39245,7 @@ async function executeStoryInWorktree(story, worktreePath, context, routing, eve
       story,
       stories: [story],
       projectDir: context.projectDir,
-      workdir: story.workdir ? join47(worktreePath, story.workdir) : worktreePath,
+      workdir: story.workdir ? join46(worktreePath, story.workdir) : worktreePath,
       routing,
       storyGitRef: storyGitRef ?? undefined
     };
@@ -39515,13 +39334,13 @@ __export(exports_manager, {
 });
 import { existsSync as existsSync29, symlinkSync } from "fs";
 import { mkdir as mkdir5 } from "fs/promises";
-import { join as join48 } from "path";
+import { join as join47 } from "path";
 
 class WorktreeManager {
   async ensureGitExcludes(projectRoot) {
     const logger = getSafeLogger();
-    const infoDir = join48(projectRoot, ".git", "info");
-    const excludePath = join48(infoDir, "exclude");
+    const infoDir = join47(projectRoot, ".git", "info");
+    const excludePath = join47(infoDir, "exclude");
     try {
       await mkdir5(infoDir, { recursive: true });
       let existing = "";
@@ -39548,7 +39367,7 @@ ${missing.join(`
   }
   async create(projectRoot, storyId) {
     validateStoryId(storyId);
-    const worktreePath = join48(projectRoot, ".nax-wt", storyId);
+    const worktreePath = join47(projectRoot, ".nax-wt", storyId);
     const branchName = `nax/${storyId}`;
     try {
       const pruneProc = _managerDeps.spawn(["git", "worktree", "prune"], {
@@ -39589,9 +39408,9 @@ ${missing.join(`
       }
       throw new Error(`Failed to create worktree: ${String(error48)}`);
     }
-    const nodeModulesSource = join48(projectRoot, "node_modules");
+    const nodeModulesSource = join47(projectRoot, "node_modules");
     if (existsSync29(nodeModulesSource)) {
-      const nodeModulesTarget = join48(worktreePath, "node_modules");
+      const nodeModulesTarget = join47(worktreePath, "node_modules");
       try {
         symlinkSync(nodeModulesSource, nodeModulesTarget, "dir");
       } catch (error48) {
@@ -39599,9 +39418,9 @@ ${missing.join(`
         throw new Error(`Failed to symlink node_modules: ${errorMessage(error48)}`);
       }
     }
-    const envSource = join48(projectRoot, ".env");
+    const envSource = join47(projectRoot, ".env");
     if (existsSync29(envSource)) {
-      const envTarget = join48(worktreePath, ".env");
+      const envTarget = join47(worktreePath, ".env");
       try {
         symlinkSync(envSource, envTarget, "file");
       } catch (error48) {
@@ -39612,7 +39431,7 @@ ${missing.join(`
   }
   async remove(projectRoot, storyId) {
     validateStoryId(storyId);
-    const worktreePath = join48(projectRoot, ".nax-wt", storyId);
+    const worktreePath = join47(projectRoot, ".nax-wt", storyId);
     const branchName = `nax/${storyId}`;
     try {
       const proc = _managerDeps.spawn(["git", "worktree", "remove", worktreePath, "--force"], {
@@ -40554,16 +40373,16 @@ var init_unified_executor = __esm(() => {
 });
 
 // src/project/detector.ts
-import { join as join49 } from "path";
+import { join as join48 } from "path";
 async function detectLanguage(workdir, pkg) {
   const deps = _detectorDeps;
-  if (await deps.fileExists(join49(workdir, "go.mod")))
+  if (await deps.fileExists(join48(workdir, "go.mod")))
     return "go";
-  if (await deps.fileExists(join49(workdir, "Cargo.toml")))
+  if (await deps.fileExists(join48(workdir, "Cargo.toml")))
     return "rust";
-  if (await deps.fileExists(join49(workdir, "pyproject.toml")))
+  if (await deps.fileExists(join48(workdir, "pyproject.toml")))
     return "python";
-  if (await deps.fileExists(join49(workdir, "requirements.txt")))
+  if (await deps.fileExists(join48(workdir, "requirements.txt")))
     return "python";
   if (pkg != null) {
     const allDeps = {
@@ -40623,18 +40442,18 @@ async function detectLintTool(workdir, language) {
   if (language === "python")
     return "ruff";
   const deps = _detectorDeps;
-  if (await deps.fileExists(join49(workdir, "biome.json")))
+  if (await deps.fileExists(join48(workdir, "biome.json")))
     return "biome";
-  if (await deps.fileExists(join49(workdir, ".eslintrc")))
+  if (await deps.fileExists(join48(workdir, ".eslintrc")))
     return "eslint";
-  if (await deps.fileExists(join49(workdir, ".eslintrc.js")))
+  if (await deps.fileExists(join48(workdir, ".eslintrc.js")))
     return "eslint";
-  if (await deps.fileExists(join49(workdir, ".eslintrc.json")))
+  if (await deps.fileExists(join48(workdir, ".eslintrc.json")))
     return "eslint";
   return;
 }
 async function detectProjectProfile(workdir, existing) {
-  const pkg = await _detectorDeps.readJson(join49(workdir, "package.json"));
+  const pkg = await _detectorDeps.readJson(join48(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);
@@ -40730,7 +40549,7 @@ async function writeStatusFile(filePath, status) {
 var init_status_file = () => {};
 
 // src/execution/status-writer.ts
-import { join as join50 } from "path";
+import { join as join49 } from "path";
 
 class StatusWriter {
   statusFile;
@@ -40844,7 +40663,7 @@ class StatusWriter {
     if (!this._prd)
       return;
     const safeLogger = getSafeLogger();
-    const featureStatusPath = join50(featureDir, "status.json");
+    const featureStatusPath = join49(featureDir, "status.json");
     const write = async () => {
       try {
         const base = this.getSnapshot(totalCost, iterations);
@@ -41055,7 +40874,7 @@ __export(exports_run_initialization, {
   initializeRun: () => initializeRun,
   _reconcileDeps: () => _reconcileDeps
 });
-import { join as join51 } from "path";
+import { join as join50 } from "path";
 async function reconcileState(prd, prdPath, workdir, config2) {
   const logger = getSafeLogger();
   let reconciledCount = 0;
@@ -41073,7 +40892,7 @@ async function reconcileState(prd, prdPath, workdir, config2) {
       });
       continue;
     }
-    const effectiveWorkdir = story.workdir ? join51(workdir, story.workdir) : workdir;
+    const effectiveWorkdir = story.workdir ? join50(workdir, story.workdir) : workdir;
     try {
       const reviewResult = await _reconcileDeps.runReview(config2.review, effectiveWorkdir, config2.execution);
       if (!reviewResult.success) {
@@ -72288,7 +72107,7 @@ var require_jsx_dev_runtime = __commonJS((exports, module) => {
 init_source();
 import { existsSync as existsSync31, mkdirSync as mkdirSync7 } from "fs";
 import { homedir as homedir8 } from "os";
-import { join as join53 } from "path";
+import { join as join52 } from "path";
 
 // node_modules/commander/esm.mjs
 var import__ = __toESM(require_commander(), 1);
@@ -73029,6 +72848,20 @@ function validateStory(raw, index, allIds) {
       throw new Error(`[schema] story[${index}].acceptanceCriteria[${i}] must be a string`);
     }
   }
+  let suggestedCriteria;
+  if (s.suggestedCriteria !== undefined && s.suggestedCriteria !== null) {
+    if (!Array.isArray(s.suggestedCriteria)) {
+      throw new Error(`[schema] story[${index}].suggestedCriteria must be an array when present`);
+    }
+    if (s.suggestedCriteria.length > 0) {
+      for (let i = 0;i < s.suggestedCriteria.length; i++) {
+        if (typeof s.suggestedCriteria[i] !== "string") {
+          throw new Error(`[schema] story[${index}].suggestedCriteria[${i}] must be a string`);
+        }
+      }
+      suggestedCriteria = s.suggestedCriteria;
+    }
+  }
   const routing = typeof s.routing === "object" && s.routing !== null ? s.routing : {};
   const rawComplexity = routing.complexity ?? s.complexity;
   if (rawComplexity === undefined || rawComplexity === null) {
@@ -73096,7 +72929,8 @@ function validateStory(raw, index, allIds) {
       ...noTestJustification !== undefined ? { noTestJustification } : {}
     },
     ...workdir !== undefined ? { workdir } : {},
-    ...contextFiles.length > 0 ? { contextFiles } : {}
+    ...contextFiles.length > 0 ? { contextFiles } : {},
+    ...suggestedCriteria !== undefined ? { suggestedCriteria } : {}
   };
 }
 function sanitizeInvalidEscapes(text) {
@@ -73234,7 +73068,8 @@ async function planCommand(workdir, config2, options) {
       outputDir,
       timeoutSeconds,
       dangerouslySkipPermissions: resolvedPerm.skipPermissions,
-      maxInteractionTurns: config2?.agent?.maxInteractionTurns
+      maxInteractionTurns: config2?.agent?.maxInteractionTurns,
+      specContent
     });
     if (debateResult.outcome !== "failed" && debateResult.output) {
       rawResponse = debateResult.output;
@@ -84304,15 +84139,15 @@ Next: nax generate --package ${options.package}`));
     }
     return;
   }
-  const naxDir = join53(workdir, ".nax");
+  const naxDir = join52(workdir, ".nax");
   if (existsSync31(naxDir) && !options.force) {
     console.log(source_default.yellow("nax already initialized. Use --force to overwrite."));
     return;
   }
-  mkdirSync7(join53(naxDir, "features"), { recursive: true });
-  mkdirSync7(join53(naxDir, "hooks"), { recursive: true });
-  await Bun.write(join53(naxDir, "config.json"), JSON.stringify(DEFAULT_CONFIG, null, 2));
-  await Bun.write(join53(naxDir, "hooks.json"), JSON.stringify({
+  mkdirSync7(join52(naxDir, "features"), { recursive: true });
+  mkdirSync7(join52(naxDir, "hooks"), { recursive: true });
+  await Bun.write(join52(naxDir, "config.json"), JSON.stringify(DEFAULT_CONFIG, null, 2));
+  await Bun.write(join52(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 },
@@ -84320,12 +84155,12 @@ Next: nax generate --package ${options.package}`));
       "on-error": { command: 'echo "nax error: $NAX_REASON"', enabled: false }
     }
   }, null, 2));
-  await Bun.write(join53(naxDir, ".gitignore"), `# nax temp files
+  await Bun.write(join52(naxDir, ".gitignore"), `# nax temp files
 *.tmp
 .paused.json
 .nax-verifier-verdict.json
 `);
-  await Bun.write(join53(naxDir, "context.md"), `# Project Context
+  await Bun.write(join52(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.
@@ -84455,8 +84290,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 = join53(naxDir, "features", options.feature);
-  const prdPath = join53(featureDir, "prd.json");
+  const featureDir = join52(naxDir, "features", options.feature);
+  const prdPath = join52(featureDir, "prd.json");
   if (options.plan && options.from) {
     if (existsSync31(prdPath) && !options.force) {
       console.error(source_default.red(`Error: prd.json already exists for feature "${options.feature}".`));
@@ -84478,10 +84313,10 @@ program2.command("run").description("Run the orchestration loop for a feature").
       }
     }
     try {
-      const planLogDir = join53(featureDir, "plan");
+      const planLogDir = join52(featureDir, "plan");
       mkdirSync7(planLogDir, { recursive: true });
       const planLogId = new Date().toISOString().replace(/:/g, "-").replace(/\..+/, "");
-      const planLogPath = join53(planLogDir, `${planLogId}.jsonl`);
+      const planLogPath = join52(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]"));
@@ -84525,10 +84360,10 @@ program2.command("run").description("Run the orchestration loop for a feature").
     process.exit(1);
   }
   resetLogger();
-  const runsDir = join53(featureDir, "runs");
+  const runsDir = join52(featureDir, "runs");
   mkdirSync7(runsDir, { recursive: true });
   const runId = new Date().toISOString().replace(/:/g, "-").replace(/\..+/, "");
-  const logFilePath = join53(runsDir, `${runId}.jsonl`);
+  const logFilePath = join52(runsDir, `${runId}.jsonl`);
   const isTTY = process.stdout.isTTY ?? false;
   const headlessFlag = options.headless ?? false;
   const headlessEnv = process.env.NAX_HEADLESS === "1";
@@ -84544,7 +84379,7 @@ program2.command("run").description("Run the orchestration loop for a feature").
     config2.autoMode.defaultAgent = options.agent;
   }
   config2.execution.maxIterations = Number.parseInt(options.maxIterations, 10);
-  const globalNaxDir = join53(homedir8(), ".nax");
+  const globalNaxDir = join52(homedir8(), ".nax");
   const hooks = await loadHooksConfig(naxDir, globalNaxDir);
   const eventEmitter = new PipelineEventEmitter;
   let tuiInstance;
@@ -84567,7 +84402,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 = join53(workdir, ".nax", "status.json");
+  const statusFilePath = join52(workdir, ".nax", "status.json");
   let parallel;
   if (options.parallel !== undefined) {
     parallel = Number.parseInt(options.parallel, 10);
@@ -84593,7 +84428,7 @@ program2.command("run").description("Run the orchestration loop for a feature").
     headless: useHeadless,
     skipPrecheck: options.skipPrecheck ?? false
   });
-  const latestSymlink = join53(runsDir, "latest.jsonl");
+  const latestSymlink = join52(runsDir, "latest.jsonl");
   try {
     if (existsSync31(latestSymlink)) {
       Bun.spawnSync(["rm", latestSymlink]);
@@ -84631,9 +84466,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 = join53(naxDir, "features", name);
+  const featureDir = join52(naxDir, "features", name);
   mkdirSync7(featureDir, { recursive: true });
-  await Bun.write(join53(featureDir, "spec.md"), `# Feature: ${name}
+  await Bun.write(join52(featureDir, "spec.md"), `# Feature: ${name}
 
 ## Overview
 
@@ -84666,7 +84501,7 @@ features.command("create <name>").description("Create a new feature").option("-d
 
 <!-- What this feature explicitly does NOT cover. -->
 `);
-  await Bun.write(join53(featureDir, "progress.txt"), `# Progress: ${name}
+  await Bun.write(join52(featureDir, "progress.txt"), `# Progress: ${name}
 
 Created: ${new Date().toISOString()}
 
@@ -84692,7 +84527,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 = join53(naxDir, "features");
+  const featuresDir = join52(naxDir, "features");
   if (!existsSync31(featuresDir)) {
     console.log(source_default.dim("No features yet."));
     return;
@@ -84707,7 +84542,7 @@ features.command("list").description("List all features").option("-d, --dir <pat
 Features:
 `));
   for (const name of entries) {
-    const prdPath = join53(featuresDir, name, "prd.json");
+    const prdPath = join52(featuresDir, name, "prd.json");
     if (existsSync31(prdPath)) {
       const prd = await loadPRD(prdPath);
       const c = countStories(prd);
@@ -84742,10 +84577,10 @@ Use: nax plan -f <feature> --from <spec>`));
     cliOverrides.profile = options.profile;
   }
   const config2 = await loadConfig(workdir, cliOverrides);
-  const featureLogDir = join53(naxDir, "features", options.feature, "plan");
+  const featureLogDir = join52(naxDir, "features", options.feature, "plan");
   mkdirSync7(featureLogDir, { recursive: true });
   const planLogId = new Date().toISOString().replace(/:/g, "-").replace(/\..+/, "");
-  const planLogPath = join53(featureLogDir, `${planLogId}.jsonl`);
+  const planLogPath = join52(featureLogDir, `${planLogId}.jsonl`);
   initLogger({ level: "info", filePath: planLogPath, useChalk: false, headless: true });
   console.log(source_default.dim(`   [Plan log: ${planLogPath}]`));
   try {