@nathapp/nax 0.36.1 → 0.36.2

package/dist/nax.js

@@ -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();
@@ -20657,7 +20673,7 @@ var package_default;
 var init_package = __esm(() => {
   package_default = {
     name: "@nathapp/nax",
-    version: "0.36.1",
+    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("b241bab"))
-        return "b241bab";
+      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
     };
   });
 }
@@ -22227,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;
@@ -22946,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
@@ -27456,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)
@@ -27473,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 = {
@@ -27544,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,
@@ -27595,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();
@@ -29244,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);
@@ -29345,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()
   };
 }
@@ -29364,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";
@@ -29387,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];
@@ -29442,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,
@@ -29452,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);
   }
@@ -29465,6 +29538,7 @@ async function handleTierEscalation(ctx) {
     prd: updatedPrd
   };
 }
+var _tierEscalationDeps;
 var init_tier_escalation = __esm(() => {
   init_hooks();
   init_logger2();
@@ -29474,6 +29548,9 @@ var init_tier_escalation = __esm(() => {
   init_helpers();
   init_progress();
   init_tier_outcome();
+  _tierEscalationDeps = {
+    savePRD
+  };
 });
 
 // src/execution/escalation/index.ts
@@ -30075,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";
 
@@ -30219,6 +30300,11 @@ var init_manager = __esm(() => {
 });
 
 // src/worktree/merge.ts
+var exports_merge = {};
+__export(exports_merge, {
+  MergeEngine: () => MergeEngine
+});
+
 class MergeEngine {
   worktreeManager;
   constructor(worktreeManager) {
@@ -30497,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) {
@@ -30513,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)}`
       });
@@ -30528,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
@@ -30575,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}`, {
@@ -30591,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
@@ -30602,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,
@@ -30623,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,
@@ -30639,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
     });
   }
@@ -30650,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();
@@ -30742,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 {
@@ -30766,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", {
@@ -30784,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: {
@@ -30810,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,
@@ -30859,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(() => {
@@ -30872,7 +31137,9 @@ var init_parallel_executor = __esm(() => {
   init_helpers();
   init_parallel();
   _parallelExecutorDeps = {
-    fireHook
+    fireHook,
+    executeParallel,
+    rectifyConflictedStory
   };
 });
 
@@ -31114,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"
@@ -31136,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"
@@ -31158,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"
@@ -31236,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
@@ -31268,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({
@@ -31276,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
@@ -31357,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;
@@ -31399,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,
@@ -31412,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({
@@ -66499,7 +66769,8 @@ init_story_context();
 init_escalation();
 init_escalation();
 var _runnerDeps = {
-  fireHook
+  fireHook,
+  runParallelExecution: null
 };
 async function run(options) {
   const {
@@ -66601,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,
@@ -66626,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,
@@ -66656,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));