@nathapp/nax 0.36.0 → 0.36.2

package/src/execution/parallel-executor.ts

@@ -4,6 +4,8 @@
  * Handles the full parallel execution flow:
  * - Status updates with parallel info
  * - Execute parallel stories
+ * - Rectify merge conflicts (MFX-005): re-run conflicted stories sequentially
+ *   on the updated base branch so each sees all previously merged stories
  * - Handle completion or continue to sequential
  */
 
@@ -17,17 +19,147 @@ import type { StoryMetrics } from "../metrics";
 import type { PipelineEventEmitter } from "../pipeline/events";
 import type { PluginRegistry } from "../plugins/registry";
 import type { PRD } from "../prd";
-import { countStories, isComplete } from "../prd";
+import { countStories, isComplete, markStoryPassed } from "../prd";
 import { getAllReadyStories, hookCtx } from "./helpers";
 import { executeParallel } from "./parallel";
 import type { StatusWriter } from "./status-writer";
 
+/** StoryMetrics extended with execution-path source */
+export type ParallelStoryMetrics = StoryMetrics & {
+  source: "parallel" | "sequential" | "rectification";
+  rectifiedFromConflict?: boolean;
+  originalCost?: number;
+  rectificationCost?: number;
+};
+
+/** A story that conflicted during the initial parallel merge pass */
+export interface ConflictedStoryInfo {
+  storyId: string;
+  conflictFiles: string[];
+  originalCost: number;
+}
+
+/** Result from attempting to rectify a single conflicted story */
+export type RectificationResult =
+  | { success: true; storyId: string; cost: number }
+  | {
+      success: false;
+      storyId: string;
+      cost: number;
+      finalConflict: boolean;
+      pipelineFailure?: boolean;
+      conflictFiles?: string[];
+    };
+
+/** Options passed to rectifyConflictedStory */
+export interface RectifyConflictedStoryOptions extends ConflictedStoryInfo {
+  workdir: string;
+  config: NaxConfig;
+  hooks: LoadedHooksConfig;
+  pluginRegistry: PluginRegistry;
+  prd: PRD;
+  eventEmitter?: PipelineEventEmitter;
+}
+
+/**
+ * Actual implementation of rectifyConflictedStory.
+ *
+ * Steps:
+ * 1. Remove the old worktree
+ * 2. Create a fresh worktree from current HEAD (post-merge state)
+ * 3. Re-run the full story pipeline
+ * 4. Attempt merge on the updated base
+ * 5. Return success/finalConflict
+ */
+async function rectifyConflictedStory(options: RectifyConflictedStoryOptions): Promise<RectificationResult> {
+  const { storyId, workdir, config, hooks, pluginRegistry, prd, eventEmitter } = options;
+  const logger = getSafeLogger();
+
+  logger?.info("parallel", "Rectifying story on updated base", { storyId, attempt: "rectification" });
+
+  try {
+    const { WorktreeManager } = await import("../worktree/manager");
+    const { MergeEngine } = await import("../worktree/merge");
+    const { runPipeline } = await import("../pipeline/runner");
+    const { defaultPipeline } = await import("../pipeline/stages");
+    const { routeTask } = await import("../routing");
+
+    const worktreeManager = new WorktreeManager();
+    const mergeEngine = new MergeEngine(worktreeManager);
+
+    // Step 1: Remove old worktree
+    try {
+      await worktreeManager.remove(workdir, storyId);
+    } catch {
+      // Ignore — worktree may have already been removed
+    }
+
+    // Step 2: Create fresh worktree from current HEAD
+    await worktreeManager.create(workdir, storyId);
+    const worktreePath = path.join(workdir, ".nax-wt", storyId);
+
+    // Step 3: Re-run the story pipeline
+    const story = prd.userStories.find((s) => s.id === storyId);
+    if (!story) {
+      return { success: false, storyId, cost: 0, finalConflict: false, pipelineFailure: true };
+    }
+
+    const routing = routeTask(story.title, story.description, story.acceptanceCriteria, story.tags, config);
+
+    const pipelineContext = {
+      config,
+      prd,
+      story,
+      stories: [story],
+      workdir: worktreePath,
+      featureDir: undefined,
+      hooks,
+      plugins: pluginRegistry,
+      storyStartTime: new Date().toISOString(),
+      routing: routing as import("../pipeline/types").RoutingResult,
+    };
+
+    const pipelineResult = await runPipeline(defaultPipeline, 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 };
+    }
+
+    // Step 4: Attempt merge on updated base
+    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 (error) {
+    logger?.error("parallel", "Rectification failed - preserving worktree", {
+      storyId,
+      error: error instanceof Error ? error.message : String(error),
+    });
+    return { success: false, storyId, cost: 0, finalConflict: false, pipelineFailure: true };
+  }
+}
+
 /**
  * Injectable dependencies for testing (avoids mock.module() which leaks in Bun 1.x).
  * @internal - test use only.
  */
 export const _parallelExecutorDeps = {
   fireHook,
+  executeParallel,
+  rectifyConflictedStory,
 };
 
 export interface ParallelExecutorOptions {
@@ -52,12 +184,101 @@ export interface ParallelExecutorOptions {
   headless: boolean;
 }
 
+export interface RectificationStats {
+  rectified: number;
+  stillConflicting: number;
+}
+
 export interface ParallelExecutorResult {
   prd: PRD;
   totalCost: number;
   storiesCompleted: number;
   completed: boolean;
   durationMs?: number;
+  /** Per-story metrics for stories completed via the parallel path */
+  storyMetrics: ParallelStoryMetrics[];
+  /** Stats from the merge-conflict rectification pass (MFX-005) */
+  rectificationStats: RectificationStats;
+}
+
+/**
+ * Run the rectification pass: sequentially re-run each conflicted story on
+ * the updated base (which already includes all clean merges from the first pass).
+ */
+async function runRectificationPass(
+  conflictedStories: ConflictedStoryInfo[],
+  options: ParallelExecutorOptions,
+  prd: PRD,
+): Promise<{
+  rectifiedCount: number;
+  stillConflictingCount: number;
+  additionalCost: number;
+  updatedPrd: PRD;
+  rectificationMetrics: ParallelStoryMetrics[];
+}> {
+  const logger = getSafeLogger();
+  const { workdir, config, hooks, pluginRegistry, eventEmitter } = options;
+  const rectificationMetrics: ParallelStoryMetrics[] = [];
+  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,
+  });
+
+  // Sequential — each story sees all previously rectified stories in the base
+  for (const conflictInfo of conflictedStories) {
+    const result = await _parallelExecutorDeps.rectifyConflictedStory({
+      ...conflictInfo,
+      workdir,
+      config,
+      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" as const,
+        rectifiedFromConflict: true,
+        originalCost: conflictInfo.originalCost,
+        rectificationCost: result.cost,
+      });
+    } else {
+      const isFinalConflict = result.finalConflict === true;
+      if (isFinalConflict) {
+        stillConflictingCount++;
+      }
+      // pipelineFailure — not counted as structural conflict, story remains failed
+    }
+  }
+
+  logger?.info("parallel", "Rectification complete", {
+    rectified: rectifiedCount,
+    stillConflicting: stillConflictingCount,
+  });
+
+  return { rectifiedCount, stillConflictingCount, additionalCost, updatedPrd: prd, rectificationMetrics };
 }
 
 /**
@@ -92,7 +313,14 @@ export async function runParallelExecution(
   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 ? os.cpus().length : Math.max(1, parallelCount);
@@ -115,8 +343,16 @@ export async function runParallelExecution(
     },
   });
 
+  // Track which stories were already passed before this batch
+  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: ParallelStoryMetrics[] = [];
+
+  let conflictedStories: ConflictedStoryInfo[] = [];
+
   try {
-    const parallelResult = await executeParallel(
+    const parallelResult = await _parallelExecutorDeps.executeParallel(
       readyStories,
       prdPath,
       workdir,
@@ -129,14 +365,44 @@ export async function runParallelExecution(
       eventEmitter,
     );
 
+    const batchDurationMs = Date.now() - batchStartMs;
+    const batchCompletedAt = new Date().toISOString();
+
     prd = parallelResult.updatedPrd;
     storiesCompleted += parallelResult.storiesCompleted;
     totalCost += parallelResult.totalCost;
+    conflictedStories = parallelResult.mergeConflicts ?? [];
 
-    logger?.info("parallel", "Parallel execution complete", {
-      storiesCompleted: parallelResult.storiesCompleted,
-      totalCost: parallelResult.totalCost,
-    });
+    // BUG-066: Build per-story metrics for stories newly completed by this parallel batch
+    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" as const,
+      });
+    }
+
+    allStoryMetrics.push(...batchStoryMetrics);
+
+    // Log each conflict before scheduling rectification
+    for (const conflict of conflictedStories) {
+      logger?.info("parallel", "Merge conflict detected - scheduling for rectification", {
+        storyId: conflict.storyId,
+        conflictFiles: conflict.conflictFiles,
+      });
+    }
 
     // Clear parallel status
     statusWriter.setPrd(prd);
@@ -160,7 +426,23 @@ export async function runParallelExecution(
     throw error;
   }
 
-  // Check if all stories are complete after parallel execution
+  // ── MFX-005: Rectification pass ────────────────────────────────────────────
+  let rectificationStats: 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);
+  }
+
+  // Check if all stories are complete after parallel execution + rectification
   if (isComplete(prd)) {
     logger?.info("execution", "All stories complete!", {
       feature,
@@ -228,8 +510,10 @@ export async function runParallelExecution(
       storiesCompleted,
       completed: true,
       durationMs,
+      storyMetrics: batchStoryMetrics,
+      rectificationStats,
     };
   }
 
-  return { prd, totalCost, storiesCompleted, completed: false };
+  return { prd, totalCost, storiesCompleted, completed: false, storyMetrics: batchStoryMetrics, rectificationStats };
 }

package/src/execution/parallel.ts

@@ -26,14 +26,18 @@ import { MergeEngine, type StoryDependencies } from "../worktree/merge";
  * Result from parallel execution of a batch of stories
  */
 export interface ParallelBatchResult {
-  /** Stories that completed successfully */
-  successfulStories: UserStory[];
-  /** Stories that failed */
-  failedStories: Array<{ story: UserStory; error: string }>;
+  /** Stories that passed the TDD pipeline (pre-merge) */
+  pipelinePassed: UserStory[];
+  /** Stories that were actually merged to the base branch */
+  merged: UserStory[];
+  /** Stories that failed the pipeline */
+  failed: Array<{ story: UserStory; error: string }>;
   /** Total cost accumulated */
   totalCost: number;
-  /** Stories with merge conflicts */
-  conflictedStories: Array<{ storyId: string; conflictFiles: string[] }>;
+  /** Stories with merge conflicts (includes per-story original cost for rectification) */
+  mergeConflicts: Array<{ storyId: string; conflictFiles: string[]; originalCost: number }>;
+  /** Per-story execution costs for successful stories */
+  storyCosts: Map<string, number>;
 }
 
 /**
@@ -148,10 +152,12 @@ async function executeParallelBatch(
   const logger = getSafeLogger();
   const worktreeManager = new WorktreeManager();
   const results: ParallelBatchResult = {
-    successfulStories: [],
-    failedStories: [],
+    pipelinePassed: [],
+    merged: [],
+    failed: [],
     totalCost: 0,
-    conflictedStories: [],
+    mergeConflicts: [],
+    storyCosts: new Map(),
   };
 
   // Create worktrees for all stories in batch
@@ -168,7 +174,7 @@ async function executeParallelBatch(
         worktreePath,
       });
     } catch (error) {
-      results.failedStories.push({
+      results.failed.push({
         story,
         error: `Failed to create worktree: ${error instanceof Error ? error.message : String(error)}`,
       });
@@ -188,15 +194,16 @@ async function executeParallelBatch(
     const executePromise = executeStoryInWorktree(story, worktreePath, context, routing as RoutingResult, 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,
@@ -257,7 +264,12 @@ export async function executeParallel(
   featureDir: string | undefined,
   parallel: number,
   eventEmitter?: PipelineEventEmitter,
-): Promise<{ storiesCompleted: number; totalCost: number; updatedPrd: PRD }> {
+): Promise<{
+  storiesCompleted: number;
+  totalCost: number;
+  updatedPrd: PRD;
+  mergeConflicts: Array<{ storyId: string; conflictFiles: string[]; originalCost: number }>;
+}> {
   const logger = getSafeLogger();
   const maxConcurrency = resolveMaxConcurrency(parallel);
   const worktreeManager = new WorktreeManager();
@@ -278,6 +290,7 @@ export async function executeParallel(
   let storiesCompleted = 0;
   let totalCost = 0;
   const currentPrd = prd;
+  const allMergeConflicts: Array<{ storyId: string; conflictFiles: string[]; originalCost: number }> = [];
 
   // Execute each batch sequentially (stories within each batch run in parallel)
   for (let batchIndex = 0; batchIndex < batches.length; batchIndex++) {
@@ -311,8 +324,8 @@ export async function executeParallel(
     totalCost += batchResult.totalCost;
 
     // Merge successful stories in topological order
-    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", {
@@ -327,6 +340,8 @@ export async function executeParallel(
           // Update PRD: mark story as passed
           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,
@@ -335,9 +350,10 @@ export async function executeParallel(
         } else {
           // Merge conflict — mark story as failed
           markStoryFailed(currentPrd, mergeResult.storyId);
-          batchResult.conflictedStories.push({
+          batchResult.mergeConflicts.push({
             storyId: mergeResult.storyId,
             conflictFiles: mergeResult.conflictFiles || [],
+            originalCost: batchResult.storyCosts.get(mergeResult.storyId) ?? 0,
           });
 
           logger?.error("parallel", "Merge conflict", {
@@ -355,7 +371,7 @@ export async function executeParallel(
     }
 
     // Mark failed stories in PRD and clean up their worktrees
-    for (const { story, error } of batchResult.failedStories) {
+    for (const { story, error } of batchResult.failed) {
       markStoryFailed(currentPrd, story.id);
 
       logger?.error("parallel", "Cleaning up failed story worktree", {
@@ -376,10 +392,13 @@ export async function executeParallel(
     // Save PRD after each batch
     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,
     });
   }
@@ -389,5 +408,5 @@ export async function executeParallel(
     totalCost,
   });
 
-  return { storiesCompleted, totalCost, updatedPrd: currentPrd };
+  return { storiesCompleted, totalCost, updatedPrd: currentPrd, mergeConflicts: allMergeConflicts };
 }

package/src/execution/pipeline-result-handler.ts

@@ -68,7 +68,7 @@ export async function handlePipelineSuccess(
       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,
     });
 
@@ -77,7 +77,7 @@ export async function handlePipelineSuccess(
       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,
@@ -177,6 +177,7 @@ export async function handlePipelineFailure(
         feature: ctx.feature,
         totalCost: ctx.totalCost,
         workdir: ctx.workdir,
+        attemptCost: pipelineResult.context.agentResult?.estimatedCost || 0,
       });
       prd = escalationResult.prd;
       prdDirty = escalationResult.prdDirty;

package/src/execution/runner.ts

@@ -21,6 +21,7 @@ import { clearCache as clearLlmCache, routeBatch as llmRouteBatch } from "../rou
 import { precomputeBatchPlan } from "./batching";
 import { stopHeartbeat, writeExitSummary } from "./crash-recovery";
 import { getAllReadyStories } from "./helpers";
+import type { ParallelExecutorOptions, ParallelExecutorResult } from "./parallel-executor";
 import { hookCtx } from "./story-context";
 
 /**
@@ -29,6 +30,10 @@ import { hookCtx } from "./story-context";
  */
 export const _runnerDeps = {
   fireHook,
+  // Injectable for tests — avoids dynamic-import module-cache issues in bun test (bun 1.3.9+)
+  runParallelExecution: null as
+    | null
+    | ((options: ParallelExecutorOptions, prd: import("../prd").PRD) => Promise<ParallelExecutorResult>),
 };
 
 // Re-export for backward compatibility
@@ -202,7 +207,8 @@ export async function run(options: RunOptions): Promise<RunResult> {
 
     // ── Parallel Execution Path (when --parallel is set) ──────────────────────
     if (options.parallel !== undefined) {
-      const { runParallelExecution } = await import("./parallel-executor");
+      const runParallelExecution =
+        _runnerDeps.runParallelExecution ?? (await import("./parallel-executor")).runParallelExecution;
       const parallelResult = await runParallelExecution(
         {
           prdPath,
@@ -231,6 +237,8 @@ export async function run(options: RunOptions): Promise<RunResult> {
       prd = parallelResult.prd;
       totalCost = parallelResult.totalCost;
       storiesCompleted = parallelResult.storiesCompleted;
+      // BUG-066: merge parallel story metrics into the running accumulator
+      allStoryMetrics.push(...parallelResult.storyMetrics);
 
       // If parallel execution completed everything, return early
       if (parallelResult.completed && parallelResult.durationMs !== undefined) {
@@ -269,8 +277,10 @@ export async function run(options: RunOptions): Promise<RunResult> {
 
     prd = sequentialResult.prd;
     iterations = sequentialResult.iterations;
-    storiesCompleted = sequentialResult.storiesCompleted;
-    totalCost = sequentialResult.totalCost;
+    // BUG-064: accumulate (not overwrite) totalCost from sequential path
+    totalCost += sequentialResult.totalCost;
+    // BUG-065: accumulate (not overwrite) storiesCompleted from sequential path
+    storiesCompleted += sequentialResult.storiesCompleted;
     allStoryMetrics.push(...sequentialResult.allStoryMetrics);
 
     // After main loop: Check if we need acceptance retry loop

package/src/interaction/chain.ts

@@ -86,11 +86,27 @@ export class InteractionChain {
   }
 
   /**
-   * Send and receive in one call (convenience method)
+   * Send and receive in one call (convenience method).
+   *
+   * Normalizes "choose" type responses: when the plugin returns
+   * `action: "choose"` + `value: "<key>"`, remaps action to the selected
+   * option key so all consumers can switch on action directly without
+   * needing to inspect value themselves.
    */
   async prompt(request: InteractionRequest): Promise<InteractionResponse> {
     await this.send(request);
     const response = await this.receive(request.id, request.timeout);
+
+    // Normalize choose responses: action="choose" means the user picked an option;
+    // the actual selection is in value. Remap to the selected key if it matches
+    // one of the declared options.
+    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 as InteractionResponse["action"] };
+      }
+    }
+
     return response;
   }
 

package/src/metrics/tracker.ts

@@ -44,14 +44,16 @@ export function collectStoryMetrics(ctx: PipelineContext, storyStartTime: string
   const agentResult = ctx.agentResult;
 
   // Calculate attempts (initial + escalations)
+  // BUG-067: priorFailures captures cross-tier attempts that story.escalations never records
   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);
 
   // Determine final tier (from last escalation or initial routing)
   const finalTier = escalationCount > 0 ? story.escalations[escalationCount - 1].toTier : routing.modelTier;
 
-  // First pass success = succeeded with no escalations
-  const firstPassSuccess = agentResult?.success === true && escalationCount === 0;
+  // First pass success = succeeded with no prior failures and no escalations (BUG-067)
+  const firstPassSuccess = agentResult?.success === true && escalationCount === 0 && priorFailureCount === 0;
 
   // Extract model name from config
   const modelEntry = ctx.config.models[routing.modelTier];
@@ -76,12 +78,13 @@ export function collectStoryMetrics(ctx: PipelineContext, storyStartTime: string
     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,
+    runtimeCrashes: ctx.storyRuntimeCrashes ?? 0,
   };
 }
 
@@ -139,6 +142,7 @@ export function collectBatchMetrics(ctx: PipelineContext, storyStartTime: string
       startedAt: storyStartTime,
       completedAt: new Date().toISOString(),
       fullSuiteGatePassed: false, // batches are not TDD-gated
+      runtimeCrashes: 0, // batch stories don't have individual crash tracking
     };
   });
 }

package/src/metrics/types.ts

@@ -34,6 +34,8 @@ export interface StoryMetrics {
   startedAt: string;
   /** Timestamp when completed */
   completedAt: string;
+  /** Number of runtime crashes (RUNTIME_CRASH verify status) encountered for this story (BUG-070) */
+  runtimeCrashes?: number;
   /** Whether TDD full-suite gate passed (only true for TDD strategies when gate passes) */
   fullSuiteGatePassed?: boolean;
 }