@nathapp/nax 0.36.0 → 0.36.2

package/dist/nax.js

@@ -3914,7 +3914,7 @@ ${output.slice(0, 500)}`);
       acceptanceCriteria: Array.isArray(record.acceptanceCriteria) ? record.acceptanceCriteria : ["Implementation complete"],
       tags: Array.isArray(record.tags) ? record.tags : [],
       dependencies: Array.isArray(record.dependencies) ? record.dependencies : [],
-      complexity: validateComplexity(record.complexity),
+      complexity: coerceComplexity(record.complexity),
       contextFiles: Array.isArray(record.contextFiles) ? record.contextFiles : Array.isArray(record.relevantFiles) ? record.relevantFiles : [],
       relevantFiles: Array.isArray(record.relevantFiles) ? record.relevantFiles : [],
       reasoning: String(record.reasoning || "No reasoning provided"),
@@ -3928,7 +3928,7 @@ ${output.slice(0, 500)}`);
   }
   return stories;
 }
-function validateComplexity(value) {
+function coerceComplexity(value) {
   if (value === "simple" || value === "medium" || value === "complex" || value === "expert") {
     return value;
   }
@@ -19471,7 +19471,7 @@ Your complexity classification will determine the execution strategy:
 Respond with ONLY this JSON (no markdown, no explanation):
 {"complexity":"simple|medium|complex|expert","modelTier":"fast|balanced|powerful","reasoning":"<one line>"}`;
 }
-function buildBatchPrompt(stories, config2) {
+function buildBatchRoutingPrompt(stories, config2) {
   const storyBlocks = stories.map((story, idx) => {
     const criteria = story.acceptanceCriteria.map((c, i) => `   ${i + 1}. ${c}`).join(`
 `);
@@ -19651,7 +19651,7 @@ async function routeBatch(stories, context) {
     throw new Error("No agent adapter available for batch routing (AA-003)");
   }
   const modelTier = llmConfig.model ?? "fast";
-  const prompt = buildBatchPrompt(stories, config2);
+  const prompt = buildBatchRoutingPrompt(stories, config2);
   try {
     const output = await callLlm(adapter, modelTier, prompt, config2);
     const decisions = parseBatchResponse(output, stories, config2);
@@ -20063,6 +20063,22 @@ function computeStoryContentHash(story) {
 }
 
 // src/routing/index.ts
+var exports_routing = {};
+__export(exports_routing, {
+  tryLlmBatchRoute: () => tryLlmBatchRoute,
+  routeTask: () => routeTask,
+  routeStory: () => routeStory,
+  manualStrategy: () => manualStrategy,
+  loadCustomStrategy: () => loadCustomStrategy,
+  llmStrategy: () => llmStrategy,
+  keywordStrategy: () => keywordStrategy,
+  determineTestStrategy: () => determineTestStrategy2,
+  computeStoryContentHash: () => computeStoryContentHash,
+  complexityToModelTier: () => complexityToModelTier2,
+  classifyComplexity: () => classifyComplexity2,
+  buildStrategyChain: () => buildStrategyChain,
+  StrategyChain: () => StrategyChain
+});
 var init_routing = __esm(() => {
   init_router();
   init_chain();
@@ -20073,7 +20089,7 @@ var init_routing = __esm(() => {
 });
 
 // src/decompose/validators/complexity.ts
-function validateComplexity2(substories, maxComplexity) {
+function validateComplexity(substories, maxComplexity) {
   const errors3 = [];
   const warnings = [];
   const maxOrder = COMPLEXITY_ORDER[maxComplexity];
@@ -20385,7 +20401,7 @@ function runAllValidators(originalStory, substories, existingStories, config2) {
   const results = [
     validateOverlap(substories, existingStories),
     validateCoverage(originalStory, substories),
-    validateComplexity2(substories, maxComplexity),
+    validateComplexity(substories, maxComplexity),
     validateDependencies(substories, existingIds)
   ];
   const errors3 = results.flatMap((r) => r.errors);
@@ -20657,7 +20673,7 @@ var package_default;
 var init_package = __esm(() => {
   package_default = {
     name: "@nathapp/nax",
-    version: "0.36.0",
+    version: "0.36.2",
     description: "AI Coding Agent Orchestrator \u2014 loops until done",
     type: "module",
     bin: {
@@ -20718,8 +20734,8 @@ var init_version = __esm(() => {
   NAX_VERSION = package_default.version;
   NAX_COMMIT = (() => {
     try {
-      if (/^[0-9a-f]{6,10}$/.test("78b52b0"))
-        return "78b52b0";
+      if (/^[0-9a-f]{6,10}$/.test("eb77e7d"))
+        return "eb77e7d";
     } catch {}
     try {
       const result = Bun.spawnSync(["git", "rev-parse", "--short", "HEAD"], {
@@ -20791,9 +20807,10 @@ function collectStoryMetrics(ctx, storyStartTime) {
   const routing = ctx.routing;
   const agentResult = ctx.agentResult;
   const escalationCount = story.escalations?.length || 0;
-  const attempts = Math.max(1, story.attempts || 1);
+  const priorFailureCount = story.priorFailures?.length || 0;
+  const attempts = priorFailureCount + Math.max(1, story.attempts || 1);
   const finalTier = escalationCount > 0 ? story.escalations[escalationCount - 1].toTier : routing.modelTier;
-  const firstPassSuccess = agentResult?.success === true && escalationCount === 0;
+  const firstPassSuccess = agentResult?.success === true && escalationCount === 0 && priorFailureCount === 0;
   const modelEntry = ctx.config.models[routing.modelTier];
   const modelDef = modelEntry ? resolveModel(modelEntry) : null;
   const modelUsed = modelDef?.model || routing.modelTier;
@@ -20809,12 +20826,13 @@ function collectStoryMetrics(ctx, storyStartTime) {
     attempts,
     finalTier,
     success: agentResult?.success || false,
-    cost: agentResult?.estimatedCost || 0,
+    cost: (ctx.accumulatedAttemptCost ?? 0) + (agentResult?.estimatedCost || 0),
     durationMs: agentResult?.durationMs || 0,
     firstPassSuccess,
     startedAt: storyStartTime,
     completedAt: new Date().toISOString(),
-    fullSuiteGatePassed
+    fullSuiteGatePassed,
+    runtimeCrashes: ctx.storyRuntimeCrashes ?? 0
   };
 }
 function collectBatchMetrics(ctx, storyStartTime) {
@@ -20844,7 +20862,8 @@ function collectBatchMetrics(ctx, storyStartTime) {
       firstPassSuccess: true,
       startedAt: storyStartTime,
       completedAt: new Date().toISOString(),
-      fullSuiteGatePassed: false
+      fullSuiteGatePassed: false,
+      runtimeCrashes: 0
     };
   });
 }
@@ -21092,6 +21111,12 @@ class InteractionChain {
   async prompt(request) {
     await this.send(request);
     const response = await this.receive(request.id, request.timeout);
+    if (response.action === "choose" && response.value && request.options) {
+      const matched = request.options.find((o) => o.key === response.value);
+      if (matched) {
+        return { ...response, action: matched.key };
+      }
+    }
     return response;
   }
   async cancel(requestId) {
@@ -22221,6 +22246,11 @@ var init_interaction = __esm(() => {
 });
 
 // src/pipeline/runner.ts
+var exports_runner = {};
+__export(exports_runner, {
+  runPipeline: () => runPipeline,
+  MAX_STAGE_RETRIES: () => MAX_STAGE_RETRIES
+});
 async function runPipeline(stages, context, eventEmitter) {
   const logger = getLogger();
   const retryCountMap = new Map;
@@ -22681,9 +22711,17 @@ class ReviewOrchestrator {
         const changedFiles = await getChangedFiles(workdir);
         const pluginResults = [];
         for (const reviewer of reviewers) {
-          logger?.info("review", `Running plugin reviewer: ${reviewer.name}`);
+          logger?.info("review", `Running plugin reviewer: ${reviewer.name}`, {
+            changedFiles: changedFiles.length
+          });
           try {
             const result = await reviewer.check(workdir, changedFiles);
+            logger?.info("review", `Plugin reviewer result: ${reviewer.name}`, {
+              passed: result.passed,
+              exitCode: result.exitCode,
+              output: result.output?.slice(0, 500),
+              findings: result.findings?.length ?? 0
+            });
             pluginResults.push({
               name: reviewer.name,
               passed: result.passed,
@@ -22702,6 +22740,7 @@ class ReviewOrchestrator {
             }
           } catch (error48) {
             const errorMsg = error48 instanceof Error ? error48.message : String(error48);
+            logger?.warn("review", `Plugin reviewer threw error: ${reviewer.name}`, { error: errorMsg });
             pluginResults.push({ name: reviewer.name, passed: false, output: "", error: errorMsg });
             builtIn.pluginReviewers = pluginResults;
             return {
@@ -22931,7 +22970,7 @@ var init_completion = __esm(() => {
           storyId: completedStory.id,
           story: completedStory,
           passed: true,
-          durationMs: storyMetric?.durationMs ?? 0,
+          runElapsedMs: storyMetric?.durationMs ?? 0,
           cost: costPerStory,
           modelTier: ctx.routing?.modelTier,
           testStrategy: ctx.routing?.testStrategy
@@ -22959,12 +22998,14 @@ var init_completion = __esm(() => {
   };
 });
 
+// src/optimizer/types.ts
+function estimateTokens(text) {
+  return Math.ceil(text.length / 4);
+}
+
 // src/constitution/loader.ts
 import { existsSync as existsSync13 } from "fs";
 import { join as join14 } from "path";
-function estimateTokens(text) {
-  return Math.ceil(text.length / 3);
-}
 function truncateToTokens(text, maxTokens) {
   const maxChars = maxTokens * 3;
   if (text.length <= maxChars) {
@@ -23214,32 +23255,29 @@ var init_auto_detect = __esm(() => {
 });
 
 // src/context/elements.ts
-function estimateTokens2(text) {
-  return Math.ceil(text.length / CHARS_PER_TOKEN);
-}
 function createStoryContext(story, priority) {
   const content = formatStoryAsText(story);
-  return { type: "story", storyId: story.id, content, priority, tokens: estimateTokens2(content) };
+  return { type: "story", storyId: story.id, content, priority, tokens: estimateTokens(content) };
 }
 function createDependencyContext(story, priority) {
   const content = formatStoryAsText(story);
-  return { type: "dependency", storyId: story.id, content, priority, tokens: estimateTokens2(content) };
+  return { type: "dependency", storyId: story.id, content, priority, tokens: estimateTokens(content) };
 }
 function createErrorContext(errorMessage, priority) {
-  return { type: "error", content: errorMessage, priority, tokens: estimateTokens2(errorMessage) };
+  return { type: "error", content: errorMessage, priority, tokens: estimateTokens(errorMessage) };
 }
 function createProgressContext(progressText, priority) {
-  return { type: "progress", content: progressText, priority, tokens: estimateTokens2(progressText) };
+  return { type: "progress", content: progressText, priority, tokens: estimateTokens(progressText) };
 }
 function createFileContext(filePath, content, priority) {
-  return { type: "file", filePath, content, priority, tokens: estimateTokens2(content) };
+  return { type: "file", filePath, content, priority, tokens: estimateTokens(content) };
 }
 function createTestCoverageContext(content, tokens, priority) {
   return { type: "test-coverage", content, priority, tokens };
 }
 function createPriorFailuresContext(failures, priority) {
   const content = formatPriorFailures(failures);
-  return { type: "prior-failures", content, priority, tokens: estimateTokens2(content) };
+  return { type: "prior-failures", content, priority, tokens: estimateTokens(content) };
 }
 function formatPriorFailures(failures) {
   if (!failures || failures.length === 0) {
@@ -23310,7 +23348,6 @@ function formatStoryAsText(story) {
   return parts.join(`
 `);
 }
-var CHARS_PER_TOKEN = 3;
 var init_elements = __esm(() => {
   init_logger2();
 });
@@ -23467,7 +23504,7 @@ function truncateToTokenBudget(files, maxTokens, preferredDetail) {
   for (let i = startIndex;i < detailLevels.length; i++) {
     const detail = detailLevels[i];
     const summary = formatTestSummary(files, detail);
-    const tokens = estimateTokens2(summary);
+    const tokens = estimateTokens(summary);
     if (tokens <= maxTokens) {
       return { summary, detail, truncated: i !== startIndex };
     }
@@ -23477,7 +23514,7 @@ function truncateToTokenBudget(files, maxTokens, preferredDetail) {
     truncatedFiles = truncatedFiles.slice(0, truncatedFiles.length - 1);
     const summary = `${formatTestSummary(truncatedFiles, "names-only")}
 ... and ${files.length - truncatedFiles.length} more test files`;
-    if (estimateTokens2(summary) <= maxTokens) {
+    if (estimateTokens(summary) <= maxTokens) {
       return { summary, detail: "names-only", truncated: true };
     }
   }
@@ -23500,13 +23537,12 @@ async function generateTestCoverageSummary(options) {
   }
   const totalTests = files.reduce((sum, f) => sum + f.testCount, 0);
   const { summary } = truncateToTokenBudget(files, maxTokens, detail);
-  const tokens = estimateTokens2(summary);
+  const tokens = estimateTokens(summary);
   return { files, totalTests, summary, tokens };
 }
 var COMMON_TEST_DIRS;
 var init_test_scanner = __esm(() => {
   init_logger2();
-  init_builder3();
   COMMON_TEST_DIRS = ["test", "tests", "__tests__", "src/__tests__", "spec"];
 });
 
@@ -24758,7 +24794,7 @@ var init_cleanup = __esm(() => {
 });
 
 // src/tdd/prompts.ts
-function buildImplementerRectificationPrompt(failures, story, contextMarkdown, config2) {
+function buildImplementerRectificationPrompt(failures, story, _contextMarkdown, config2) {
   return createRectificationPrompt(failures, story, config2);
 }
 var init_prompts = __esm(() => {
@@ -24908,9 +24944,9 @@ var init_rectification_gate = __esm(() => {
 function buildConventionsSection() {
   return `# Conventions
 
-` + `Follow existing code patterns and conventions. Write idiomatic, maintainable code.
+Follow existing code patterns and conventions. Write idiomatic, maintainable code.
 
-` + "When running tests, run ONLY test files related to your changes (e.g. `bun test ./test/specific.test.ts`). " + "NEVER run `bun test` without a file filter \u2014 full suite output will flood your context window and cause failures.\n\n" + "Commit your changes when done using conventional commit format (e.g. `feat:`, `fix:`, `test:`).";
+Commit your changes when done using conventional commit format (e.g. \`feat:\`, \`fix:\`, \`test:\`).`;
 }
 
 // src/prompts/sections/isolation.ts
@@ -24919,29 +24955,39 @@ function buildIsolationSection(roleOrMode, mode) {
     return buildIsolationSection("test-writer", roleOrMode);
   }
   const role = roleOrMode;
-  const header = `# Isolation Rules
-
-`;
+  const header = "# Isolation Rules";
   const footer = `
 
 ${TEST_FILTER_RULE}`;
   if (role === "test-writer") {
     const m = mode ?? "strict";
     if (m === "strict") {
-      return `${header}isolation scope: Only create or modify files in the test/ directory. Tests must fail because the feature is not yet implemented. Do NOT modify any source files in src/.${footer}`;
+      return `${header}
+
+isolation scope: Only create or modify files in the test/ directory. Tests must fail because the feature is not yet implemented. Do NOT modify any source files in src/.${footer}`;
     }
-    return `${header}isolation scope: Create test files in test/. MAY read src/ files and MAY import from src/ to ensure correct types/interfaces. May create minimal stubs in src/ if needed to make imports work, but do NOT implement real logic.${footer}`;
+    return `${header}
+
+isolation scope: Create test files in test/. MAY read src/ files and MAY import from src/ to ensure correct types/interfaces. May create minimal stubs in src/ if needed to make imports work, but do NOT implement real logic.${footer}`;
   }
   if (role === "implementer") {
-    return `${header}isolation scope: Implement source code in src/ to make tests pass. Do not modify test files. Run tests frequently to track progress.${footer}`;
+    return `${header}
+
+isolation scope: Implement source code in src/ to make tests pass. Do not modify test files. Run tests frequently to track progress.${footer}`;
   }
   if (role === "verifier") {
-    return `${header}isolation scope: Read-only inspection. Review all test results, implementation code, and acceptance criteria compliance. You MAY write a verdict file (.nax-verifier-verdict.json) and apply legitimate fixes if needed.${footer}`;
+    return `${header}
+
+isolation scope: Read-only inspection. Review all test results, implementation code, and acceptance criteria compliance. You MAY write a verdict file (.nax-verifier-verdict.json) and apply legitimate fixes if needed.${footer}`;
   }
   if (role === "single-session") {
-    return `${header}isolation scope: Create test files in test/ directory, then implement source code in src/ to make tests pass. Both directories are in scope for this session.${footer}`;
+    return `${header}
+
+isolation scope: Create test files in test/ directory, then implement source code in src/ to make tests pass. Both directories are in scope for this session.${footer}`;
   }
-  return `${header}isolation scope: You may modify both src/ and test/ files. Write failing tests FIRST, then implement to make them pass.`;
+  return `${header}
+
+isolation scope: You may modify both src/ and test/ files. Write failing tests FIRST, then implement to make them pass.`;
 }
 var TEST_FILTER_RULE;
 var init_isolation2 = __esm(() => {
@@ -24959,76 +25005,76 @@ function buildRoleTaskSection(roleOrVariant, variant) {
     if (v === "standard") {
       return `# Role: Implementer
 
-` + `Your task: make failing tests pass.
+Your task: make failing tests pass.
 
-` + `Instructions:
-` + `- Implement source code in src/ to make tests pass
-` + `- Do NOT modify test files
-` + `- Run tests frequently to track progress
-` + `- When all tests are green, stage and commit ALL changed files with: git commit -m 'feat: <description>'
-` + "- Goal: all tests green, all changes committed";
+Instructions:
+- Implement source code in src/ to make tests pass
+- Do NOT modify test files
+- Run tests frequently to track progress
+- When all tests are green, stage and commit ALL changed files with: git commit -m 'feat: <description>'
+- Goal: all tests green, all changes committed`;
     }
     return `# Role: Implementer (Lite)
 
-` + `Your task: Write tests AND implement the feature in a single session.
+Your task: Write tests AND implement the feature in a single session.
 
-` + `Instructions:
-` + `- Write tests first (test/ directory), then implement (src/ directory)
-` + `- All tests must pass by the end
-` + `- Use Bun test (describe/test/expect)
-` + `- When all tests are green, stage and commit ALL changed files with: git commit -m 'feat: <description>'
-` + "- Goal: all tests green, all criteria met, all changes committed";
+Instructions:
+- Write tests first (test/ directory), then implement (src/ directory)
+- All tests must pass by the end
+- Use Bun test (describe/test/expect)
+- When all tests are green, stage and commit ALL changed files with: git commit -m 'feat: <description>'
+- Goal: all tests green, all criteria met, all changes committed`;
   }
   if (role === "test-writer") {
     return `# Role: Test-Writer
 
-` + `Your task: Write comprehensive failing tests for the feature.
+Your task: Write comprehensive failing tests for the feature.
 
-` + `Instructions:
-` + `- Create test files in test/ directory that cover acceptance criteria
-` + `- Tests must fail initially (RED phase) \u2014 the feature is not yet implemented
-` + `- Use Bun test (describe/test/expect)
-` + `- Write clear test names that document expected behavior
-` + `- Focus on behavior, not implementation details
-` + "- Goal: comprehensive test suite ready for implementation";
+Instructions:
+- Create test files in test/ directory that cover acceptance criteria
+- Tests must fail initially (RED phase) \u2014 the feature is not yet implemented
+- Use Bun test (describe/test/expect)
+- Write clear test names that document expected behavior
+- Focus on behavior, not implementation details
+- Goal: comprehensive test suite ready for implementation`;
   }
   if (role === "verifier") {
     return `# Role: Verifier
 
-` + `Your task: Review and verify the implementation against acceptance criteria.
+Your task: Review and verify the implementation against acceptance criteria.
 
-` + `Instructions:
-` + `- Review all test results \u2014 verify tests pass
-` + `- Check that implementation meets all acceptance criteria
-` + `- Inspect code quality, error handling, and edge cases
-` + `- Verify test modifications (if any) are legitimate fixes
-` + `- Write a detailed verdict with reasoning
-` + "- Goal: provide comprehensive verification and quality assurance";
+Instructions:
+- Review all test results \u2014 verify tests pass
+- Check that implementation meets all acceptance criteria
+- Inspect code quality, error handling, and edge cases
+- Verify test modifications (if any) are legitimate fixes
+- Write a detailed verdict with reasoning
+- Goal: provide comprehensive verification and quality assurance`;
   }
   if (role === "single-session") {
     return `# Role: Single-Session
 
-` + `Your task: Write tests AND implement the feature in a single focused session.
+Your task: Write tests AND implement the feature in a single focused session.
 
-` + `Instructions:
-` + `- Phase 1: Write comprehensive tests (test/ directory)
-` + `- Phase 2: Implement to make all tests pass (src/ directory)
-` + `- Use Bun test (describe/test/expect)
-` + `- Run tests frequently throughout implementation
-` + `- When all tests are green, stage and commit ALL changed files with: git commit -m 'feat: <description>'
-` + "- Goal: all tests passing, all changes committed, full story complete";
+Instructions:
+- Phase 1: Write comprehensive tests (test/ directory)
+- Phase 2: Implement to make all tests pass (src/ directory)
+- Use Bun test (describe/test/expect)
+- Run tests frequently throughout implementation
+- When all tests are green, stage and commit ALL changed files with: git commit -m 'feat: <description>'
+- Goal: all tests passing, all changes committed, full story complete`;
   }
   return `# Role: TDD-Simple
 
-` + `Your task: Write failing tests FIRST, then implement to make them pass.
+Your task: Write failing tests FIRST, then implement to make them pass.
 
-` + `Instructions:
-` + `- RED phase: Write failing tests FIRST for the acceptance criteria
-` + `- RED phase: Run the tests to confirm they fail
-` + `- GREEN phase: Implement the minimum code to make tests pass
-` + `- REFACTOR phase: Refactor while keeping tests green
-` + `- When all tests are green, stage and commit ALL changed files with: git commit -m 'feat: <description>'
-` + "- Goal: all tests passing, feature complete, all changes committed";
+Instructions:
+- RED phase: Write failing tests FIRST for the acceptance criteria
+- RED phase: Run the tests to confirm they fail
+- GREEN phase: Implement the minimum code to make tests pass
+- REFACTOR phase: Refactor while keeping tests green
+- When all tests are green, stage and commit ALL changed files with: git commit -m 'feat: <description>'
+- Goal: all tests passing, feature complete, all changes committed`;
 }
 
 // src/prompts/sections/story.ts
@@ -25046,6 +25092,69 @@ ${story.description}
 ${criteria}`;
 }
 
+// src/prompts/sections/verdict.ts
+function buildVerdictSection(story) {
+  return `# Verdict Instructions
+
+## Write Verdict File
+
+After completing your verification, you **MUST** write a verdict file at the **project root**:
+
+**File:** \`.nax-verifier-verdict.json\`
+
+Set \`approved: true\` when ALL of these conditions are met:
+- All tests pass
+- Implementation is clean and follows conventions
+- All acceptance criteria met
+- Any test modifications by implementer are legitimate fixes
+
+Set \`approved: false\` when ANY of these conditions are true:
+- Tests are failing and you cannot fix them
+- The implementer loosened test assertions to mask bugs
+- Critical acceptance criteria are not met
+- Code quality is poor (security issues, severe bugs, etc.)
+
+**Full JSON schema example** (fill in all fields with real values):
+
+\`\`\`json
+{
+  "version": 1,
+  "approved": true,
+  "tests": {
+    "allPassing": true,
+    "passCount": 42,
+    "failCount": 0
+  },
+  "testModifications": {
+    "detected": false,
+    "files": [],
+    "legitimate": true,
+    "reasoning": "No test files were modified by the implementer"
+  },
+  "acceptanceCriteria": {
+    "allMet": true,
+    "criteria": [
+      { "criterion": "Example criterion", "met": true }
+    ]
+  },
+  "quality": {
+    "rating": "good",
+    "issues": []
+  },
+  "fixes": [],
+  "reasoning": "All tests pass, implementation is clean, all acceptance criteria are met."
+}
+\`\`\`
+
+**Field notes:**
+- \`quality.rating\` must be one of: \`"good"\`, \`"acceptable"\`, \`"poor"\`
+- \`testModifications.files\` \u2014 list any test files the implementer changed
+- \`fixes\` \u2014 list any fixes you applied yourself during this verification session
+- \`reasoning\` \u2014 brief summary of your overall assessment
+
+When done, commit any fixes with message: "fix: verify and adjust ${story.title}"`;
+}
+
 // src/prompts/loader.ts
 var exports_loader = {};
 __export(exports_loader, {
@@ -25121,6 +25230,9 @@ ${this._constitution}`);
     if (this._story) {
       sections.push(buildStorySection(this._story));
     }
+    if (this._role === "verifier" && this._story) {
+      sections.push(buildVerdictSection(this._story));
+    }
     const isolation = this._options.isolation;
     sections.push(buildIsolationSection(this._role, isolation));
     if (this._contextMd) {
@@ -25209,7 +25321,7 @@ async function rollbackToRef(workdir, ref) {
   }
   logger.info("tdd", "Successfully rolled back git changes", { ref });
 }
-async function runTddSession(role, agent, story, config2, workdir, modelTier, beforeRef, contextMarkdown, lite = false, skipIsolation = false) {
+async function runTddSession(role, agent, story, config2, workdir, modelTier, beforeRef, contextMarkdown, lite = false, skipIsolation = false, constitution) {
   const startTime = Date.now();
   let prompt;
   switch (role) {
@@ -25217,7 +25329,7 @@ async function runTddSession(role, agent, story, config2, workdir, modelTier, be
       prompt = await PromptBuilder.for("test-writer", { isolation: lite ? "lite" : "strict" }).withLoader(workdir, config2).story(story).context(contextMarkdown).build();
       break;
     case "implementer":
-      prompt = await PromptBuilder.for("implementer", { variant: lite ? "lite" : "standard" }).withLoader(workdir, config2).story(story).context(contextMarkdown).build();
+      prompt = await PromptBuilder.for("implementer", { variant: lite ? "lite" : "standard" }).withLoader(workdir, config2).story(story).context(contextMarkdown).constitution(constitution).build();
       break;
     case "verifier":
       prompt = await PromptBuilder.for("verifier").withLoader(workdir, config2).story(story).context(contextMarkdown).build();
@@ -25361,7 +25473,7 @@ function isValidVerdict(obj) {
 function coerceVerdict(obj) {
   try {
     const verdictStr = String(obj.verdict ?? "").toUpperCase();
-    const approved = verdictStr === "PASS" || verdictStr === "APPROVED" || obj.approved === true;
+    const approved = verdictStr === "PASS" || verdictStr === "APPROVED" || verdictStr.startsWith("VERIFIED") || verdictStr.includes("ALL ACCEPTANCE CRITERIA MET") || obj.approved === true;
     let passCount = 0;
     let failCount = 0;
     let allPassing = approved;
@@ -25456,13 +25568,24 @@ async function readVerdict(workdir) {
     if (!exists) {
       return null;
     }
+    let rawText;
+    try {
+      rawText = await file2.text();
+    } catch (readErr) {
+      logger.warn("tdd", "Failed to read verifier verdict file", {
+        path: verdictPath,
+        error: String(readErr)
+      });
+      return null;
+    }
     let parsed;
     try {
-      parsed = await file2.json();
+      parsed = JSON.parse(rawText);
     } catch (parseErr) {
       logger.warn("tdd", "Verifier verdict file is not valid JSON \u2014 ignoring", {
         path: verdictPath,
-        error: String(parseErr)
+        error: String(parseErr),
+        rawContent: rawText.slice(0, 1000)
       });
       return null;
     }
@@ -25564,6 +25687,7 @@ async function runThreeSessionTdd(options) {
     workdir,
     modelTier,
     contextMarkdown,
+    constitution,
     dryRun = false,
     lite = false,
     _recursionDepth = 0
@@ -25625,7 +25749,7 @@ async function runThreeSessionTdd(options) {
   let session1;
   if (!isRetry) {
     const testWriterTier = config2.tdd.sessionTiers?.testWriter ?? "balanced";
-    session1 = await runTddSession("test-writer", agent, story, config2, workdir, testWriterTier, session1Ref, contextMarkdown, lite, lite);
+    session1 = await runTddSession("test-writer", agent, story, config2, workdir, testWriterTier, session1Ref, contextMarkdown, lite, lite, constitution);
     sessions.push(session1);
   }
   if (session1 && !session1.success) {
@@ -25687,7 +25811,7 @@ async function runThreeSessionTdd(options) {
   });
   const session2Ref = await captureGitRef(workdir) ?? "HEAD";
   const implementerTier = config2.tdd.sessionTiers?.implementer ?? modelTier;
-  const session2 = await runTddSession("implementer", agent, story, config2, workdir, implementerTier, session2Ref, contextMarkdown, lite, lite);
+  const session2 = await runTddSession("implementer", agent, story, config2, workdir, implementerTier, session2Ref, contextMarkdown, lite, lite, constitution);
   sessions.push(session2);
   if (!session2.success) {
     needsHumanReview = true;
@@ -25706,7 +25830,7 @@ async function runThreeSessionTdd(options) {
   const fullSuiteGatePassed = await runFullSuiteGate(story, config2, workdir, agent, implementerTier, contextMarkdown, lite, logger);
   const session3Ref = await captureGitRef(workdir) ?? "HEAD";
   const verifierTier = config2.tdd.sessionTiers?.verifier ?? "fast";
-  const session3 = await runTddSession("verifier", agent, story, config2, workdir, verifierTier, session3Ref, undefined, false, false);
+  const session3 = await runTddSession("verifier", agent, story, config2, workdir, verifierTier, session3Ref, undefined, false, false, constitution);
   sessions.push(session3);
   const verdict = await readVerdict(workdir);
   await cleanupVerdict(workdir);
@@ -25886,6 +26010,7 @@ var init_execution = __esm(() => {
           workdir: ctx.workdir,
           modelTier: ctx.routing.modelTier,
           contextMarkdown: ctx.contextMarkdown,
+          constitution: ctx.constitution?.content,
           dryRun: false,
           lite: isLiteMode
         });
@@ -25909,6 +26034,28 @@ var init_execution = __esm(() => {
               lite: tddResult.lite,
               failureCategory: tddResult.failureCategory
             });
+            if (ctx.interaction) {
+              try {
+                await ctx.interaction.send({
+                  id: `human-review-${ctx.story.id}-${Date.now()}`,
+                  type: "notify",
+                  featureName: ctx.featureDir ? ctx.featureDir.split("/").pop() ?? "unknown" : "unknown",
+                  storyId: ctx.story.id,
+                  stage: "execution",
+                  summary: `\u26A0\uFE0F Human review needed: ${ctx.story.id}`,
+                  detail: `Story: ${ctx.story.title}
+Reason: ${tddResult.reviewReason ?? "No reason provided"}
+Category: ${tddResult.failureCategory ?? "unknown"}`,
+                  fallback: "continue",
+                  createdAt: Date.now()
+                });
+              } catch (notifyErr) {
+                logger.warn("execution", "Failed to send human review notification", {
+                  storyId: ctx.story.id,
+                  error: String(notifyErr)
+                });
+              }
+            }
           }
           return routeTddFailure(tddResult.failureCategory, isLiteMode, ctx, tddResult.reviewReason);
         }
@@ -25979,16 +26126,11 @@ var init_execution = __esm(() => {
   };
 });
 
-// src/optimizer/types.ts
-function estimateTokens4(text) {
-  return Math.ceil(text.length / 4);
-}
-
 // src/optimizer/noop.optimizer.ts
 class NoopOptimizer {
   name = "noop";
   async optimize(input) {
-    const tokens = estimateTokens4(input.prompt);
+    const tokens = estimateTokens(input.prompt);
     return {
       prompt: input.prompt,
       originalTokens: tokens,
@@ -26004,7 +26146,7 @@ var init_noop_optimizer = () => {};
 class RuleBasedOptimizer {
   name = "rule-based";
   async optimize(input) {
-    const originalTokens = estimateTokens4(input.prompt);
+    const originalTokens = estimateTokens(input.prompt);
     const appliedRules = [];
     let optimized = input.prompt;
     const config2 = {
@@ -26033,13 +26175,13 @@ class RuleBasedOptimizer {
       }
     }
     if (config2.maxPromptTokens) {
-      const currentTokens = estimateTokens4(optimized);
+      const currentTokens = estimateTokens(optimized);
       if (currentTokens > config2.maxPromptTokens) {
         optimized = this.trimToMaxTokens(optimized, config2.maxPromptTokens);
         appliedRules.push("maxPromptTokens");
       }
     }
-    const optimizedTokens = estimateTokens4(optimized);
+    const optimizedTokens = estimateTokens(optimized);
     const savings = originalTokens > 0 ? (originalTokens - optimizedTokens) / originalTokens : 0;
     return {
       prompt: optimized,
@@ -26082,7 +26224,7 @@ ${newContextSection}`);
     return prompt;
   }
   trimToMaxTokens(prompt, maxTokens) {
-    const currentTokens = estimateTokens4(prompt);
+    const currentTokens = estimateTokens(prompt);
     if (currentTokens <= maxTokens) {
       return prompt;
     }
@@ -26221,7 +26363,7 @@ var init_optimizer2 = __esm(() => {
 });
 
 // src/execution/prompts.ts
-function buildBatchPrompt2(stories, contextMarkdown, constitution) {
+function buildBatchPrompt(stories, contextMarkdown, constitution) {
   const storyPrompts = stories.map((story, idx) => {
     return `## Story ${idx + 1}: ${story.id} \u2014 ${story.title}
 
@@ -26279,7 +26421,7 @@ var init_prompt = __esm(() => {
       const isBatch = ctx.stories.length > 1;
       let prompt;
       if (isBatch) {
-        prompt = buildBatchPrompt2(ctx.stories, ctx.contextMarkdown, ctx.constitution);
+        prompt = buildBatchPrompt(ctx.stories, ctx.contextMarkdown, ctx.constitution);
       } else {
         const role = ctx.routing.testStrategy === "tdd-simple" ? "tdd-simple" : "single-session";
         const builder = PromptBuilder.for(role).withLoader(ctx.workdir, ctx.config).story(ctx.story).context(ctx.contextMarkdown).constitution(ctx.constitution?.content);
@@ -26567,7 +26709,6 @@ ${rectificationPrompt}`;
 var init_rectification_loop = __esm(() => {
   init_agents();
   init_config();
-  init_progress();
   init_test_output_parser();
   init_logger2();
   init_prd();
@@ -27339,6 +27480,22 @@ var init_routing2 = __esm(() => {
   };
 });
 
+// src/verification/crash-detector.ts
+function detectRuntimeCrash(output) {
+  if (!output)
+    return false;
+  return CRASH_PATTERNS.some((pattern) => output.includes(pattern));
+}
+var CRASH_PATTERNS;
+var init_crash_detector = __esm(() => {
+  CRASH_PATTERNS = [
+    "panic(main thread)",
+    "Segmentation fault",
+    "Bun has crashed",
+    "oh no: Bun has crashed"
+  ];
+});
+
 // src/pipeline/stages/verify.ts
 function coerceSmartTestRunner(val) {
   if (val === undefined || val === true)
@@ -27356,6 +27513,7 @@ function buildScopedCommand2(testFiles, baseCommand, testScopedTemplate) {
 var DEFAULT_SMART_RUNNER_CONFIG2, verifyStage, _verifyDeps;
 var init_verify = __esm(() => {
   init_logger2();
+  init_crash_detector();
   init_runners();
   init_smart_runner();
   DEFAULT_SMART_RUNNER_CONFIG2 = {
@@ -27427,7 +27585,7 @@ var init_verify = __esm(() => {
       });
       ctx.verifyResult = {
         success: result.success,
-        status: result.status === "TIMEOUT" ? "TIMEOUT" : result.success ? "PASS" : "TEST_FAILURE",
+        status: result.status === "TIMEOUT" ? "TIMEOUT" : result.success ? "PASS" : detectRuntimeCrash(result.output) ? "RUNTIME_CRASH" : "TEST_FAILURE",
         storyId: ctx.story.id,
         strategy: "scoped",
         passCount: result.passCount ?? 0,
@@ -27478,6 +27636,25 @@ var init_verify = __esm(() => {
 });
 
 // src/pipeline/stages/index.ts
+var exports_stages = {};
+__export(exports_stages, {
+  verifyStage: () => verifyStage,
+  routingStage: () => routingStage,
+  reviewStage: () => reviewStage,
+  regressionStage: () => regressionStage,
+  rectifyStage: () => rectifyStage,
+  queueCheckStage: () => queueCheckStage,
+  promptStage: () => promptStage,
+  postRunPipeline: () => postRunPipeline,
+  optimizerStage: () => optimizerStage,
+  executionStage: () => executionStage,
+  defaultPipeline: () => defaultPipeline,
+  contextStage: () => contextStage,
+  constitutionStage: () => constitutionStage,
+  completionStage: () => completionStage,
+  autofixStage: () => autofixStage,
+  acceptanceStage: () => acceptanceStage
+});
 var defaultPipeline, postRunPipeline;
 var init_stages = __esm(() => {
   init_acceptance2();
@@ -29127,11 +29304,12 @@ var init_crash_recovery = __esm(() => {
 
 // src/execution/escalation/escalation.ts
 function escalateTier(currentTier, tierOrder) {
-  const currentIndex = tierOrder.findIndex((t) => t.tier === currentTier);
+  const getName = (t) => t.tier ?? t.name ?? null;
+  const currentIndex = tierOrder.findIndex((t) => getName(t) === currentTier);
   if (currentIndex === -1 || currentIndex === tierOrder.length - 1) {
     return null;
   }
-  return tierOrder[currentIndex + 1].tier;
+  return getName(tierOrder[currentIndex + 1]);
 }
 function calculateMaxIterations(tierOrder) {
   return tierOrder.reduce((sum, t) => sum + t.attempts, 0);
@@ -29228,13 +29406,14 @@ var init_tier_outcome = __esm(() => {
 });
 
 // src/execution/escalation/tier-escalation.ts
-function buildEscalationFailure(story, currentTier, reviewFindings) {
+function buildEscalationFailure(story, currentTier, reviewFindings, cost) {
   return {
     attempt: (story.attempts ?? 0) + 1,
     modelTier: currentTier,
     stage: "escalation",
     summary: `Failed with tier ${currentTier}, escalating to next tier`,
     reviewFindings: reviewFindings && reviewFindings.length > 0 ? reviewFindings : undefined,
+    cost: cost ?? 0,
     timestamp: new Date().toISOString()
   };
 }
@@ -29247,6 +29426,8 @@ function resolveMaxAttemptsOutcome(failureCategory) {
     case "verifier-rejected":
     case "greenfield-no-tests":
       return "pause";
+    case "runtime-crash":
+      return "pause";
     case "session-failure":
     case "tests-failing":
       return "fail";
@@ -29270,8 +29451,17 @@ async function tryLlmBatchRoute2(config2, stories, label = "routing") {
     });
   }
 }
+function shouldRetrySameTier(verifyResult) {
+  return verifyResult?.status === "RUNTIME_CRASH";
+}
 async function handleTierEscalation(ctx) {
   const logger = getSafeLogger();
+  if (shouldRetrySameTier(ctx.verifyResult)) {
+    logger?.warn("escalation", "Runtime crash detected \u2014 retrying same tier (transient, not a code issue)", {
+      storyId: ctx.story.id
+    });
+    return { outcome: "retry-same", prdDirty: false, prd: ctx.prd };
+  }
   const nextTier = escalateTier(ctx.routing.modelTier, ctx.config.autoMode.escalation.tierOrder);
   const escalateWholeBatch = ctx.config.autoMode.escalation.escalateEntireBatch ?? true;
   const storiesToEscalate = ctx.isBatchExecution && escalateWholeBatch ? ctx.storiesToExecute : [ctx.story];
@@ -29325,7 +29515,7 @@ async function handleTierEscalation(ctx) {
       const currentStoryTier = s.routing?.modelTier ?? ctx.routing.modelTier;
       const isChangingTier = currentStoryTier !== nextTier;
       const shouldResetAttempts = isChangingTier || shouldSwitchToTestAfter;
-      const escalationFailure = buildEscalationFailure(s, currentStoryTier, escalateReviewFindings);
+      const escalationFailure = buildEscalationFailure(s, currentStoryTier, escalateReviewFindings, ctx.attemptCost);
       return {
         ...s,
         attempts: shouldResetAttempts ? 0 : (s.attempts ?? 0) + 1,
@@ -29335,7 +29525,7 @@ async function handleTierEscalation(ctx) {
       };
     })
   };
-  await savePRD(updatedPrd, ctx.prdPath);
+  await _tierEscalationDeps.savePRD(updatedPrd, ctx.prdPath);
   for (const story of storiesToEscalate) {
     clearCacheForStory(story.id);
   }
@@ -29348,6 +29538,7 @@ async function handleTierEscalation(ctx) {
     prd: updatedPrd
   };
 }
+var _tierEscalationDeps;
 var init_tier_escalation = __esm(() => {
   init_hooks();
   init_logger2();
@@ -29357,6 +29548,9 @@ var init_tier_escalation = __esm(() => {
   init_helpers();
   init_progress();
   init_tier_outcome();
+  _tierEscalationDeps = {
+    savePRD
+  };
 });
 
 // src/execution/escalation/index.ts
@@ -29958,6 +30152,10 @@ var init_headless_formatter = __esm(() => {
 });
 
 // src/worktree/manager.ts
+var exports_manager = {};
+__export(exports_manager, {
+  WorktreeManager: () => WorktreeManager
+});
 import { existsSync as existsSync26, symlinkSync } from "fs";
 import { join as join32 } from "path";
 
@@ -30102,6 +30300,11 @@ var init_manager = __esm(() => {
 });
 
 // src/worktree/merge.ts
+var exports_merge = {};
+__export(exports_merge, {
+  MergeEngine: () => MergeEngine
+});
+
 class MergeEngine {
   worktreeManager;
   constructor(worktreeManager) {
@@ -30380,10 +30583,12 @@ async function executeParallelBatch(stories, projectRoot, config2, prd, context,
   const logger = getSafeLogger();
   const worktreeManager = new WorktreeManager;
   const results = {
-    successfulStories: [],
-    failedStories: [],
+    pipelinePassed: [],
+    merged: [],
+    failed: [],
     totalCost: 0,
-    conflictedStories: []
+    mergeConflicts: [],
+    storyCosts: new Map
   };
   const worktreeSetup = [];
   for (const story of stories) {
@@ -30396,7 +30601,7 @@ async function executeParallelBatch(stories, projectRoot, config2, prd, context,
         worktreePath
       });
     } catch (error48) {
-      results.failedStories.push({
+      results.failed.push({
         story,
         error: `Failed to create worktree: ${error48 instanceof Error ? error48.message : String(error48)}`
       });
@@ -30411,14 +30616,15 @@ async function executeParallelBatch(stories, projectRoot, config2, prd, context,
     const routing = routeTask(story.title, story.description, story.acceptanceCriteria, story.tags, config2);
     const executePromise = executeStoryInWorktree(story, worktreePath, context, routing, eventEmitter).then((result) => {
       results.totalCost += result.cost;
+      results.storyCosts.set(story.id, result.cost);
       if (result.success) {
-        results.successfulStories.push(story);
+        results.pipelinePassed.push(story);
         logger?.info("parallel", "Story execution succeeded", {
           storyId: story.id,
           cost: result.cost
         });
       } else {
-        results.failedStories.push({ story, error: result.error || "Unknown error" });
+        results.failed.push({ story, error: result.error || "Unknown error" });
         logger?.error("parallel", "Story execution failed", {
           storyId: story.id,
           error: result.error
@@ -30458,6 +30664,7 @@ async function executeParallel(stories, prdPath, projectRoot, config2, hooks, pl
   let storiesCompleted = 0;
   let totalCost = 0;
   const currentPrd = prd;
+  const allMergeConflicts = [];
   for (let batchIndex = 0;batchIndex < batches.length; batchIndex++) {
     const batch = batches[batchIndex];
     logger?.info("parallel", `Executing batch ${batchIndex + 1}/${batches.length}`, {
@@ -30474,8 +30681,8 @@ async function executeParallel(stories, prdPath, projectRoot, config2, hooks, pl
     };
     const batchResult = await executeParallelBatch(batch, projectRoot, config2, currentPrd, baseContext, maxConcurrency, eventEmitter);
     totalCost += batchResult.totalCost;
-    if (batchResult.successfulStories.length > 0) {
-      const successfulIds = batchResult.successfulStories.map((s) => s.id);
+    if (batchResult.pipelinePassed.length > 0) {
+      const successfulIds = batchResult.pipelinePassed.map((s) => s.id);
       const deps = buildDependencyMap(batch);
       logger?.info("parallel", "Merging successful stories", {
         storyIds: successfulIds
@@ -30485,15 +30692,19 @@ async function executeParallel(stories, prdPath, projectRoot, config2, hooks, pl
         if (mergeResult.success) {
           markStoryPassed(currentPrd, mergeResult.storyId);
           storiesCompleted++;
+          const mergedStory = batchResult.pipelinePassed.find((s) => s.id === mergeResult.storyId);
+          if (mergedStory)
+            batchResult.merged.push(mergedStory);
           logger?.info("parallel", "Story merged successfully", {
             storyId: mergeResult.storyId,
             retryCount: mergeResult.retryCount
           });
         } else {
           markStoryFailed(currentPrd, mergeResult.storyId);
-          batchResult.conflictedStories.push({
+          batchResult.mergeConflicts.push({
             storyId: mergeResult.storyId,
-            conflictFiles: mergeResult.conflictFiles || []
+            conflictFiles: mergeResult.conflictFiles || [],
+            originalCost: batchResult.storyCosts.get(mergeResult.storyId) ?? 0
           });
           logger?.error("parallel", "Merge conflict", {
             storyId: mergeResult.storyId,
@@ -30506,7 +30717,7 @@ async function executeParallel(stories, prdPath, projectRoot, config2, hooks, pl
         }
       }
     }
-    for (const { story, error: error48 } of batchResult.failedStories) {
+    for (const { story, error: error48 } of batchResult.failed) {
       markStoryFailed(currentPrd, story.id);
       logger?.error("parallel", "Cleaning up failed story worktree", {
         storyId: story.id,
@@ -30522,10 +30733,12 @@ async function executeParallel(stories, prdPath, projectRoot, config2, hooks, pl
       }
     }
     await savePRD(currentPrd, prdPath);
+    allMergeConflicts.push(...batchResult.mergeConflicts);
     logger?.info("parallel", `Batch ${batchIndex + 1} complete`, {
-      successful: batchResult.successfulStories.length,
-      failed: batchResult.failedStories.length,
-      conflicts: batchResult.conflictedStories.length,
+      pipelinePassed: batchResult.pipelinePassed.length,
+      merged: batchResult.merged.length,
+      failed: batchResult.failed.length,
+      mergeConflicts: batchResult.mergeConflicts.length,
       batchCost: batchResult.totalCost
     });
   }
@@ -30533,7 +30746,7 @@ async function executeParallel(stories, prdPath, projectRoot, config2, hooks, pl
     storiesCompleted,
     totalCost
   });
-  return { storiesCompleted, totalCost, updatedPrd: currentPrd };
+  return { storiesCompleted, totalCost, updatedPrd: currentPrd, mergeConflicts: allMergeConflicts };
 }
 var init_parallel = __esm(() => {
   init_logger2();
@@ -30625,6 +30838,123 @@ __export(exports_parallel_executor, {
 });
 import * as os5 from "os";
 import path15 from "path";
+async function rectifyConflictedStory(options) {
+  const { storyId, workdir, config: config2, hooks, pluginRegistry, prd, eventEmitter } = options;
+  const logger = getSafeLogger();
+  logger?.info("parallel", "Rectifying story on updated base", { storyId, attempt: "rectification" });
+  try {
+    const { WorktreeManager: WorktreeManager2 } = await Promise.resolve().then(() => (init_manager(), exports_manager));
+    const { MergeEngine: MergeEngine2 } = await Promise.resolve().then(() => (init_merge(), exports_merge));
+    const { runPipeline: runPipeline2 } = await Promise.resolve().then(() => (init_runner(), exports_runner));
+    const { defaultPipeline: defaultPipeline2 } = await Promise.resolve().then(() => (init_stages(), exports_stages));
+    const { routeTask: routeTask2 } = await Promise.resolve().then(() => (init_routing(), exports_routing));
+    const worktreeManager = new WorktreeManager2;
+    const mergeEngine = new MergeEngine2(worktreeManager);
+    try {
+      await worktreeManager.remove(workdir, storyId);
+    } catch {}
+    await worktreeManager.create(workdir, storyId);
+    const worktreePath = path15.join(workdir, ".nax-wt", storyId);
+    const story = prd.userStories.find((s) => s.id === storyId);
+    if (!story) {
+      return { success: false, storyId, cost: 0, finalConflict: false, pipelineFailure: true };
+    }
+    const routing = routeTask2(story.title, story.description, story.acceptanceCriteria, story.tags, config2);
+    const pipelineContext = {
+      config: config2,
+      prd,
+      story,
+      stories: [story],
+      workdir: worktreePath,
+      featureDir: undefined,
+      hooks,
+      plugins: pluginRegistry,
+      storyStartTime: new Date().toISOString(),
+      routing
+    };
+    const pipelineResult = await runPipeline2(defaultPipeline2, pipelineContext, eventEmitter);
+    const cost = pipelineResult.context.agentResult?.estimatedCost ?? 0;
+    if (!pipelineResult.success) {
+      logger?.info("parallel", "Rectification failed - preserving worktree", { storyId });
+      return { success: false, storyId, cost, finalConflict: false, pipelineFailure: true };
+    }
+    const mergeResults = await mergeEngine.mergeAll(workdir, [storyId], { [storyId]: [] });
+    const mergeResult = mergeResults[0];
+    if (!mergeResult || !mergeResult.success) {
+      const conflictFiles = mergeResult?.conflictFiles ?? [];
+      logger?.info("parallel", "Rectification failed - preserving worktree", { storyId });
+      return { success: false, storyId, cost, finalConflict: true, conflictFiles };
+    }
+    logger?.info("parallel", "Rectification succeeded - story merged", {
+      storyId,
+      originalCost: options.originalCost,
+      rectificationCost: cost
+    });
+    return { success: true, storyId, cost };
+  } catch (error48) {
+    logger?.error("parallel", "Rectification failed - preserving worktree", {
+      storyId,
+      error: error48 instanceof Error ? error48.message : String(error48)
+    });
+    return { success: false, storyId, cost: 0, finalConflict: false, pipelineFailure: true };
+  }
+}
+async function runRectificationPass(conflictedStories, options, prd) {
+  const logger = getSafeLogger();
+  const { workdir, config: config2, hooks, pluginRegistry, eventEmitter } = options;
+  const rectificationMetrics = [];
+  let rectifiedCount = 0;
+  let stillConflictingCount = 0;
+  let additionalCost = 0;
+  logger?.info("parallel", "Starting merge conflict rectification", {
+    stories: conflictedStories.map((s) => s.storyId),
+    totalConflicts: conflictedStories.length
+  });
+  for (const conflictInfo of conflictedStories) {
+    const result = await _parallelExecutorDeps.rectifyConflictedStory({
+      ...conflictInfo,
+      workdir,
+      config: config2,
+      hooks,
+      pluginRegistry,
+      prd,
+      eventEmitter
+    });
+    additionalCost += result.cost;
+    if (result.success) {
+      markStoryPassed(prd, result.storyId);
+      rectifiedCount++;
+      rectificationMetrics.push({
+        storyId: result.storyId,
+        complexity: "unknown",
+        modelTier: "parallel",
+        modelUsed: "parallel",
+        attempts: 1,
+        finalTier: "parallel",
+        success: true,
+        cost: result.cost,
+        durationMs: 0,
+        firstPassSuccess: false,
+        startedAt: new Date().toISOString(),
+        completedAt: new Date().toISOString(),
+        source: "rectification",
+        rectifiedFromConflict: true,
+        originalCost: conflictInfo.originalCost,
+        rectificationCost: result.cost
+      });
+    } else {
+      const isFinalConflict = result.finalConflict === true;
+      if (isFinalConflict) {
+        stillConflictingCount++;
+      }
+    }
+  }
+  logger?.info("parallel", "Rectification complete", {
+    rectified: rectifiedCount,
+    stillConflicting: stillConflictingCount
+  });
+  return { rectifiedCount, stillConflictingCount, additionalCost, updatedPrd: prd, rectificationMetrics };
+}
 async function runParallelExecution(options, initialPrd) {
   const logger = getSafeLogger();
   const {
@@ -30649,7 +30979,14 @@ async function runParallelExecution(options, initialPrd) {
   const readyStories = getAllReadyStories(prd);
   if (readyStories.length === 0) {
     logger?.info("parallel", "No stories ready for parallel execution");
-    return { prd, totalCost, storiesCompleted, completed: false };
+    return {
+      prd,
+      totalCost,
+      storiesCompleted,
+      completed: false,
+      storyMetrics: [],
+      rectificationStats: { rectified: 0, stillConflicting: 0 }
+    };
   }
   const maxConcurrency = parallelCount === 0 ? os5.cpus().length : Math.max(1, parallelCount);
   logger?.info("parallel", "Starting parallel execution mode", {
@@ -30667,15 +31004,45 @@ async function runParallelExecution(options, initialPrd) {
       }))
     }
   });
+  const initialPassedIds = new Set(initialPrd.userStories.filter((s) => s.status === "passed").map((s) => s.id));
+  const batchStartedAt = new Date().toISOString();
+  const batchStartMs = Date.now();
+  const batchStoryMetrics = [];
+  let conflictedStories = [];
   try {
-    const parallelResult = await executeParallel(readyStories, prdPath, workdir, config2, hooks, pluginRegistry, prd, featureDir, parallelCount, eventEmitter);
+    const parallelResult = await _parallelExecutorDeps.executeParallel(readyStories, prdPath, workdir, config2, hooks, pluginRegistry, prd, featureDir, parallelCount, eventEmitter);
+    const batchDurationMs = Date.now() - batchStartMs;
+    const batchCompletedAt = new Date().toISOString();
     prd = parallelResult.updatedPrd;
     storiesCompleted += parallelResult.storiesCompleted;
     totalCost += parallelResult.totalCost;
-    logger?.info("parallel", "Parallel execution complete", {
-      storiesCompleted: parallelResult.storiesCompleted,
-      totalCost: parallelResult.totalCost
-    });
+    conflictedStories = parallelResult.mergeConflicts ?? [];
+    const newlyPassedStories = prd.userStories.filter((s) => s.status === "passed" && !initialPassedIds.has(s.id));
+    const costPerStory = newlyPassedStories.length > 0 ? parallelResult.totalCost / newlyPassedStories.length : 0;
+    for (const story of newlyPassedStories) {
+      batchStoryMetrics.push({
+        storyId: story.id,
+        complexity: "unknown",
+        modelTier: "parallel",
+        modelUsed: "parallel",
+        attempts: 1,
+        finalTier: "parallel",
+        success: true,
+        cost: costPerStory,
+        durationMs: batchDurationMs,
+        firstPassSuccess: true,
+        startedAt: batchStartedAt,
+        completedAt: batchCompletedAt,
+        source: "parallel"
+      });
+    }
+    allStoryMetrics.push(...batchStoryMetrics);
+    for (const conflict of conflictedStories) {
+      logger?.info("parallel", "Merge conflict detected - scheduling for rectification", {
+        storyId: conflict.storyId,
+        conflictFiles: conflict.conflictFiles
+      });
+    }
     statusWriter.setPrd(prd);
     await statusWriter.update(totalCost, iterations, {
       parallel: {
@@ -30693,6 +31060,19 @@ async function runParallelExecution(options, initialPrd) {
     });
     throw error48;
   }
+  let rectificationStats = { rectified: 0, stillConflicting: 0 };
+  if (conflictedStories.length > 0) {
+    const rectResult = await runRectificationPass(conflictedStories, options, prd);
+    prd = rectResult.updatedPrd;
+    storiesCompleted += rectResult.rectifiedCount;
+    totalCost += rectResult.additionalCost;
+    rectificationStats = {
+      rectified: rectResult.rectifiedCount,
+      stillConflicting: rectResult.stillConflictingCount
+    };
+    batchStoryMetrics.push(...rectResult.rectificationMetrics);
+    allStoryMetrics.push(...rectResult.rectificationMetrics);
+  }
   if (isComplete(prd)) {
     logger?.info("execution", "All stories complete!", {
       feature,
@@ -30742,10 +31122,12 @@ async function runParallelExecution(options, initialPrd) {
       totalCost,
       storiesCompleted,
       completed: true,
-      durationMs
+      durationMs,
+      storyMetrics: batchStoryMetrics,
+      rectificationStats
     };
   }
-  return { prd, totalCost, storiesCompleted, completed: false };
+  return { prd, totalCost, storiesCompleted, completed: false, storyMetrics: batchStoryMetrics, rectificationStats };
 }
 var _parallelExecutorDeps;
 var init_parallel_executor = __esm(() => {
@@ -30755,7 +31137,9 @@ var init_parallel_executor = __esm(() => {
   init_helpers();
   init_parallel();
   _parallelExecutorDeps = {
-    fireHook
+    fireHook,
+    executeParallel,
+    rectifyConflictedStory
   };
 });
 
@@ -30997,7 +31381,7 @@ function wireReporters(bus, pluginRegistry, runId, startTime) {
               runId,
               storyId: ev.storyId,
               status: "completed",
-              durationMs: ev.durationMs,
+              runElapsedMs: ev.runElapsedMs,
               cost: ev.cost ?? 0,
               tier: ev.modelTier ?? "balanced",
               testStrategy: ev.testStrategy ?? "test-after"
@@ -31019,7 +31403,7 @@ function wireReporters(bus, pluginRegistry, runId, startTime) {
               runId,
               storyId: ev.storyId,
               status: "failed",
-              durationMs: Date.now() - startTime,
+              runElapsedMs: Date.now() - startTime,
               cost: 0,
               tier: "balanced",
               testStrategy: "test-after"
@@ -31041,7 +31425,7 @@ function wireReporters(bus, pluginRegistry, runId, startTime) {
               runId,
               storyId: ev.storyId,
               status: "paused",
-              durationMs: Date.now() - startTime,
+              runElapsedMs: Date.now() - startTime,
               cost: 0,
               tier: "balanced",
               testStrategy: "test-after"
@@ -31119,7 +31503,7 @@ async function handleDryRun(ctx) {
       storyId: s.id,
       story: s,
       passed: true,
-      durationMs: 0,
+      runElapsedMs: 0,
       cost: 0,
       modelTier: ctx.routing.modelTier,
       testStrategy: ctx.routing.testStrategy
@@ -31151,7 +31535,7 @@ async function handlePipelineSuccess(ctx, pipelineResult) {
       storyId: completedStory.id,
       storyTitle: completedStory.title,
       totalCost: ctx.totalCost + costDelta,
-      durationMs: now - ctx.startTime,
+      runElapsedMs: now - ctx.startTime,
       storyDurationMs: ctx.storyStartTime ? now - ctx.storyStartTime : undefined
     });
     pipelineEventBus.emit({
@@ -31159,7 +31543,7 @@ async function handlePipelineSuccess(ctx, pipelineResult) {
       storyId: completedStory.id,
       story: completedStory,
       passed: true,
-      durationMs: Date.now() - ctx.startTime,
+      runElapsedMs: Date.now() - ctx.startTime,
       cost: costDelta,
       modelTier: ctx.routing.modelTier,
       testStrategy: ctx.routing.testStrategy
@@ -31240,7 +31624,8 @@ async function handlePipelineFailure(ctx, pipelineResult) {
         hooks: ctx.hooks,
         feature: ctx.feature,
         totalCost: ctx.totalCost,
-        workdir: ctx.workdir
+        workdir: ctx.workdir,
+        attemptCost: pipelineResult.context.agentResult?.estimatedCost || 0
       });
       prd = escalationResult.prd;
       prdDirty = escalationResult.prdDirty;
@@ -31282,6 +31667,7 @@ async function runIteration(ctx, prd, selection, iterations, totalCost, allStory
   }
   const storyStartTime = Date.now();
   const storyGitRef = await captureGitRef(ctx.workdir);
+  const accumulatedAttemptCost = (story.priorFailures || []).reduce((sum, f) => sum + (f.cost || 0), 0);
   const pipelineContext = {
     config: ctx.config,
     prd,
@@ -31295,7 +31681,8 @@ async function runIteration(ctx, prd, selection, iterations, totalCost, allStory
     plugins: ctx.pluginRegistry,
     storyStartTime: new Date().toISOString(),
     storyGitRef: storyGitRef ?? undefined,
-    interaction: ctx.interactionChain ?? undefined
+    interaction: ctx.interactionChain ?? undefined,
+    accumulatedAttemptCost: accumulatedAttemptCost > 0 ? accumulatedAttemptCost : undefined
   };
   ctx.statusWriter.setPrd(prd);
   ctx.statusWriter.setCurrentStory({
@@ -66382,7 +66769,8 @@ init_story_context();
 init_escalation();
 init_escalation();
 var _runnerDeps = {
-  fireHook
+  fireHook,
+  runParallelExecution: null
 };
 async function run(options) {
   const {
@@ -66484,7 +66872,7 @@ async function run(options) {
       await tryLlmBatchRoute(config2, getAllReadyStories(prd), "routing");
     }
     if (options.parallel !== undefined) {
-      const { runParallelExecution: runParallelExecution2 } = await Promise.resolve().then(() => (init_parallel_executor(), exports_parallel_executor));
+      const runParallelExecution2 = _runnerDeps.runParallelExecution ?? (await Promise.resolve().then(() => (init_parallel_executor(), exports_parallel_executor))).runParallelExecution;
       const parallelResult = await runParallelExecution2({
         prdPath,
         workdir,
@@ -66509,6 +66897,7 @@ async function run(options) {
       prd = parallelResult.prd;
       totalCost = parallelResult.totalCost;
       storiesCompleted = parallelResult.storiesCompleted;
+      allStoryMetrics.push(...parallelResult.storyMetrics);
       if (parallelResult.completed && parallelResult.durationMs !== undefined) {
         return {
           success: true,
@@ -66539,8 +66928,8 @@ async function run(options) {
     }, prd);
     prd = sequentialResult.prd;
     iterations = sequentialResult.iterations;
-    storiesCompleted = sequentialResult.storiesCompleted;
-    totalCost = sequentialResult.totalCost;
+    totalCost += sequentialResult.totalCost;
+    storiesCompleted += sequentialResult.storiesCompleted;
     allStoryMetrics.push(...sequentialResult.allStoryMetrics);
     if (config2.acceptance.enabled && isComplete(prd)) {
       const { runAcceptanceLoop: runAcceptanceLoop2 } = await Promise.resolve().then(() => (init_acceptance_loop(), exports_acceptance_loop));