@nathapp/nax 0.21.0 → 0.22.0

package/src/execution/escalation/tier-outcome.ts

@@ -3,13 +3,14 @@
  *
  * Extracted from tier-escalation.ts: handles outcomes when escalation
  * is not possible (no tier available or max attempts reached).
+ *
+ * Phase 3 (ADR-005): Replaced direct fireHook() calls with event bus emissions.
  */
 
-import { fireHook } from "../../hooks";
 import { getSafeLogger } from "../../logger";
+import { pipelineEventBus } from "../../pipeline/event-bus";
 import { markStoryFailed, markStoryPaused, savePRD } from "../../prd";
 import type { FailureCategory } from "../../tdd/types";
-import { hookCtx } from "../helpers";
 import { appendProgress } from "../progress";
 import type { EscalationHandlerContext, EscalationHandlerResult } from "./tier-escalation";
 import { resolveMaxAttemptsOutcome } from "./tier-escalation";
@@ -43,16 +44,12 @@ export async function handleNoTierAvailable(
       );
     }
 
-    await fireHook(
-      ctx.hooks,
-      "on-pause",
-      hookCtx(ctx.feature, {
-        storyId: ctx.story.id,
-        reason: `Execution stopped (${failureCategory ?? "unknown"} requires human review)`,
-        cost: ctx.totalCost,
-      }),
-      ctx.workdir,
-    );
+    pipelineEventBus.emit({
+      type: "story:paused",
+      storyId: ctx.story.id,
+      reason: `Execution stopped (${failureCategory ?? "unknown"} requires human review)`,
+      cost: ctx.totalCost,
+    });
 
     return { outcome: "paused", prdDirty: true, prd: pausedPrd };
   }
@@ -70,17 +67,13 @@ export async function handleNoTierAvailable(
     await appendProgress(ctx.featureDir, ctx.story.id, "failed", `${ctx.story.title} — Execution failed`);
   }
 
-  await fireHook(
-    ctx.hooks,
-    "on-story-fail",
-    hookCtx(ctx.feature, {
-      storyId: ctx.story.id,
-      status: "failed",
-      reason: "Execution failed",
-      cost: ctx.totalCost,
-    }),
-    ctx.workdir,
-  );
+  pipelineEventBus.emit({
+    type: "story:failed",
+    storyId: ctx.story.id,
+    story: ctx.story,
+    reason: "Execution failed",
+    countsTowardEscalation: true,
+  });
 
   return { outcome: "failed", prdDirty: true, prd: failedPrd };
 }
@@ -114,16 +107,12 @@ export async function handleMaxAttemptsReached(
       );
     }
 
-    await fireHook(
-      ctx.hooks,
-      "on-pause",
-      hookCtx(ctx.feature, {
-        storyId: ctx.story.id,
-        reason: `Max attempts reached (${failureCategory ?? "unknown"} requires human review)`,
-        cost: ctx.totalCost,
-      }),
-      ctx.workdir,
-    );
+    pipelineEventBus.emit({
+      type: "story:paused",
+      storyId: ctx.story.id,
+      reason: `Max attempts reached (${failureCategory ?? "unknown"} requires human review)`,
+      cost: ctx.totalCost,
+    });
 
     return { outcome: "paused", prdDirty: true, prd: pausedPrd };
   }
@@ -142,17 +131,13 @@ export async function handleMaxAttemptsReached(
     await appendProgress(ctx.featureDir, ctx.story.id, "failed", `${ctx.story.title} — Max attempts reached`);
   }
 
-  await fireHook(
-    ctx.hooks,
-    "on-story-fail",
-    hookCtx(ctx.feature, {
-      storyId: ctx.story.id,
-      status: "failed",
-      reason: "Max attempts reached",
-      cost: ctx.totalCost,
-    }),
-    ctx.workdir,
-  );
+  pipelineEventBus.emit({
+    type: "story:failed",
+    storyId: ctx.story.id,
+    story: ctx.story,
+    reason: "Max attempts reached",
+    countsTowardEscalation: true,
+  });
 
   return { outcome: "failed", prdDirty: true, prd: failedPrd };
 }

package/src/execution/executor-types.ts

@@ -0,0 +1,65 @@
+/**
+ * Sequential Executor Types (ADR-005, Phase 4)
+ *
+ * Extracted from sequential-executor.ts to slim it below 200 lines.
+ */
+
+import type { NaxConfig } from "../config";
+import type { LoadedHooksConfig } from "../hooks";
+import type { InteractionChain } from "../interaction/chain";
+import type { StoryMetrics } from "../metrics";
+import type { PipelineEventEmitter } from "../pipeline/events";
+import type { RoutingResult } from "../pipeline/types";
+import type { PluginRegistry } from "../plugins";
+import type { PRD, UserStory } from "../prd/types";
+import type { StoryBatch } from "./batching";
+import type { StatusWriter } from "./status-writer";
+
+export interface SequentialExecutionContext {
+  prdPath: string;
+  workdir: string;
+  config: NaxConfig;
+  hooks: LoadedHooksConfig;
+  feature: string;
+  featureDir?: string;
+  dryRun: boolean;
+  useBatch: boolean;
+  pluginRegistry: PluginRegistry;
+  eventEmitter?: PipelineEventEmitter;
+  statusWriter: StatusWriter;
+  logFilePath?: string;
+  runId: string;
+  startTime: number;
+  batchPlan: StoryBatch[];
+  interactionChain?: InteractionChain | null;
+}
+
+export interface SequentialExecutionResult {
+  prd: PRD;
+  iterations: number;
+  storiesCompleted: number;
+  totalCost: number;
+  allStoryMetrics: StoryMetrics[];
+  exitReason: "completed" | "cost-limit" | "max-iterations" | "stalled" | "no-stories";
+}
+
+/**
+ * Build a preview routing from cached story.routing or config defaults.
+ * The pipeline routing stage performs full classification and overwrites ctx.routing.
+ * This preview is used only for logging, status display, and event emission.
+ */
+export function buildPreviewRouting(story: UserStory, config: NaxConfig): RoutingResult {
+  const cached = story.routing;
+  const defaultComplexity = "medium" as const;
+  const defaultTier = "balanced" as const;
+  const defaultStrategy = "test-after" as const;
+  return {
+    complexity: (cached?.complexity as RoutingResult["complexity"]) ?? defaultComplexity,
+    modelTier:
+      (cached?.modelTier as RoutingResult["modelTier"]) ??
+      (config.autoMode.complexityRouting?.[defaultComplexity] as RoutingResult["modelTier"]) ??
+      defaultTier,
+    testStrategy: (cached?.testStrategy as RoutingResult["testStrategy"]) ?? defaultStrategy,
+    reasoning: cached ? "cached from story.routing" : "preview (pending pipeline routing stage)",
+  };
+}

package/src/execution/index.ts

@@ -5,23 +5,6 @@ export { appendProgress } from "./progress";
 export { buildSingleSessionPrompt, buildBatchPrompt } from "./prompts";
 export { groupStoriesIntoBatches, type StoryBatch } from "./batching";
 export { escalateTier, getTierConfig, calculateMaxIterations } from "./escalation";
-export {
-  verifyAssets,
-  executeWithTimeout,
-  parseTestOutput,
-  getEnvironmentalEscalationThreshold,
-  normalizeEnvironment,
-  buildTestCommand,
-  appendOpenHandlesFlag,
-  appendForceExitFlag,
-  runVerification,
-  type VerificationResult,
-  type VerificationStatus,
-  type TestOutputAnalysis,
-  type AssetVerificationResult,
-  type TimeoutExecutionResult,
-} from "./verification";
-export { runPostAgentVerification, type PostVerifyOptions, type PostVerifyResult } from "./post-verify";
 export { readQueueFile, clearQueueFile } from "./queue-handler";
 export {
   hookCtx,

package/src/execution/iteration-runner.ts

@@ -0,0 +1,132 @@
+/**
+ * Iteration Runner (ADR-005, Phase 4)
+ *
+ * Runs a single story through the pipeline.
+ * Extracted from sequential-executor.ts to slim it below 120 lines.
+ */
+
+import { getSafeLogger } from "../logger";
+import type { StoryMetrics } from "../metrics";
+import { runPipeline } from "../pipeline/runner";
+import type { PipelineRunResult } from "../pipeline/runner";
+import { defaultPipeline } from "../pipeline/stages";
+import type { PipelineContext } from "../pipeline/types";
+import type { PRD } from "../prd/types";
+import { captureGitRef } from "../utils/git";
+import { handleDryRun } from "./dry-run";
+import type { SequentialExecutionContext } from "./executor-types";
+import { handlePipelineFailure, handlePipelineSuccess } from "./pipeline-result-handler";
+import type { StorySelection } from "./story-selector";
+
+export interface IterationResult {
+  prd: PRD;
+  storiesCompletedDelta: number;
+  costDelta: number;
+  prdDirty: boolean;
+  finalAction?: string;
+  reason?: string;
+}
+
+export async function runIteration(
+  ctx: SequentialExecutionContext,
+  prd: PRD,
+  selection: StorySelection,
+  iterations: number,
+  totalCost: number,
+  allStoryMetrics: StoryMetrics[],
+): Promise<IterationResult> {
+  const logger = getSafeLogger();
+  const { story, storiesToExecute, routing, isBatchExecution } = selection;
+
+  if (ctx.dryRun) {
+    const dryRunResult = await handleDryRun({
+      prd,
+      prdPath: ctx.prdPath,
+      storiesToExecute,
+      routing,
+      statusWriter: ctx.statusWriter,
+      pluginRegistry: ctx.pluginRegistry,
+      runId: ctx.runId,
+      totalCost,
+      iterations,
+    });
+    return {
+      prd,
+      storiesCompletedDelta: dryRunResult.storiesCompletedDelta,
+      costDelta: 0,
+      prdDirty: dryRunResult.prdDirty,
+    };
+  }
+
+  const storyGitRef = await captureGitRef(ctx.workdir);
+  const pipelineContext: PipelineContext = {
+    config: ctx.config,
+    prd,
+    story,
+    stories: storiesToExecute,
+    routing,
+    workdir: ctx.workdir,
+    featureDir: ctx.featureDir,
+    hooks: ctx.hooks,
+    plugins: ctx.pluginRegistry,
+    storyStartTime: new Date().toISOString(),
+    storyGitRef: storyGitRef ?? undefined,
+    interaction: ctx.interactionChain ?? undefined,
+  };
+
+  ctx.statusWriter.setPrd(prd);
+  ctx.statusWriter.setCurrentStory({
+    storyId: story.id,
+    title: story.title,
+    complexity: routing.complexity,
+    tddStrategy: routing.testStrategy,
+    model: routing.modelTier,
+    attempt: (story.attempts ?? 0) + 1,
+    phase: "routing",
+  });
+  await ctx.statusWriter.update(totalCost, iterations);
+
+  const pipelineResult = await runPipeline(defaultPipeline, pipelineContext, ctx.eventEmitter);
+  const currentPrd = pipelineResult.context.prd;
+
+  const handlerCtx = {
+    config: ctx.config,
+    prd: currentPrd,
+    prdPath: ctx.prdPath,
+    workdir: ctx.workdir,
+    featureDir: ctx.featureDir,
+    hooks: ctx.hooks,
+    feature: ctx.feature,
+    totalCost,
+    startTime: ctx.startTime,
+    runId: ctx.runId,
+    pluginRegistry: ctx.pluginRegistry,
+    story,
+    storiesToExecute,
+    routing: pipelineResult.context.routing ?? routing,
+    isBatchExecution,
+    allStoryMetrics,
+    storyGitRef,
+    interactionChain: ctx.interactionChain,
+  };
+
+  if (pipelineResult.success) {
+    const r = await handlePipelineSuccess(handlerCtx, pipelineResult);
+    return {
+      prd: r.prd,
+      storiesCompletedDelta: r.storiesCompletedDelta,
+      costDelta: r.costDelta,
+      prdDirty: r.prdDirty,
+      finalAction: pipelineResult.finalAction,
+    };
+  }
+  const r = await handlePipelineFailure(handlerCtx, pipelineResult);
+  return {
+    prd: r.prd,
+    storiesCompletedDelta: 0,
+    costDelta: 0,
+    prdDirty: r.prdDirty,
+    finalAction: pipelineResult.finalAction,
+    reason: pipelineResult.reason,
+  };
+}

package/src/execution/lifecycle/index.ts

@@ -3,7 +3,6 @@
  */
 
 export { runAcceptanceLoop, type AcceptanceLoopContext, type AcceptanceLoopResult } from "./acceptance-loop";
-export { emitStoryComplete, type StoryCompleteEvent } from "./story-hooks";
 export { outputRunHeader, outputRunFooter, type RunHeaderOptions, type RunFooterOptions } from "./headless-formatter";
 export { handleParallelCompletion, type ParallelCompletionOptions } from "./parallel-lifecycle";
 export { handleRunCompletion, type RunCompletionOptions, type RunCompletionResult } from "./run-completion";

package/src/execution/lifecycle/run-regression.ts

@@ -14,16 +14,16 @@ import type { PRD, UserStory } from "../../prd";
 import { countStories } from "../../prd";
 import { hasCommitsForStory } from "../../utils/git";
 import { parseBunTestOutput } from "../../verification";
+import { runRectificationLoop } from "../../verification/rectification-loop";
+import { fullSuite } from "../../verification/runners";
 import { reverseMapTestToSource } from "../../verification/smart-runner";
-import { runRectificationLoop } from "../post-verify-rectification";
-import { runVerification } from "../verification";
 
 /**
  * Injectable dependencies for testing (avoids mock.module() which leaks in Bun 1.x).
  * @internal - test use only.
  */
 export const _regressionDeps = {
-  runVerification,
+  runVerification: fullSuite,
   runRectificationLoop,
   parseBunTestOutput,
   reverseMapTestToSource,
@@ -133,7 +133,7 @@ export async function runDeferredRegression(options: DeferredRegressionOptions):
 
   // Step 1: Run full test suite
   const fullSuiteResult = await _regressionDeps.runVerification({
-    workingDirectory: workdir,
+    workdir: workdir,
     command: testCommand,
     timeoutSeconds,
     forceExit: config.quality.forceExit,
@@ -268,7 +268,7 @@ export async function runDeferredRegression(options: DeferredRegressionOptions):
   // Step 4: Re-run full suite to confirm
   logger?.info("regression", "Re-running full suite after rectification");
   const retryResult = await _regressionDeps.runVerification({
-    workingDirectory: workdir,
+    workdir: workdir,
     command: testCommand,
     timeoutSeconds,
     forceExit: config.quality.forceExit,