@nathapp/nax 0.60.0 → 0.60.1

package/dist/nax.js

@@ -18654,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",
@@ -27053,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);
         }
@@ -36571,7 +36572,7 @@ var package_default;
 var init_package = __esm(() => {
   package_default = {
     name: "@nathapp/nax",
-    version: "0.60.0",
+    version: "0.60.1",
     description: "AI Coding Agent Orchestrator \u2014 loops until done",
     type: "module",
     bin: {
@@ -36651,8 +36652,8 @@ var init_version = __esm(() => {
   NAX_VERSION = package_default.version;
   NAX_COMMIT = (() => {
     try {
-      if (/^[0-9a-f]{6,10}$/.test("73c9c082"))
-        return "73c9c082";
+      if (/^[0-9a-f]{6,10}$/.test("2b74a9ef"))
+        return "2b74a9ef";
     } catch {}
     try {
       const result = Bun.spawnSync(["git", "rev-parse", "--short", "HEAD"], {
@@ -36968,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)
@@ -37179,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;
@@ -37235,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.
@@ -37251,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",
@@ -37277,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;
@@ -37362,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);
@@ -37386,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);
 }
@@ -37449,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();
@@ -37559,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()) {
@@ -37569,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
     });
-    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: `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
+    });
+    return {
+      verdict: "test_bug",
+      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];
@@ -37899,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
@@ -37924,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
   };
 });
 
@@ -38542,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 () => {
@@ -38728,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 {
@@ -38743,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));
@@ -39401,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;
@@ -39436,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,
@@ -39445,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,
@@ -39601,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 {
@@ -39621,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
     };
@@ -39710,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 = "";
@@ -39743,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"], {
@@ -39784,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) {
@@ -39794,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) {
@@ -39807,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"], {
@@ -40749,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 = {
@@ -40818,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);
@@ -40925,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;
@@ -41039,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);
@@ -41250,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;
@@ -41268,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) {
@@ -72483,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);
@@ -84515,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 },
@@ -84531,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.
@@ -84666,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}".`));
@@ -84689,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]"));
@@ -84736,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";
@@ -84755,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;
@@ -84778,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);
@@ -84804,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]);
@@ -84842,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
 
@@ -84877,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()}
 
@@ -84903,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;
@@ -84918,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);
@@ -84953,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 {