@nathapp/nax 0.54.7 → 0.54.9

package/dist/nax.js

@@ -3004,7 +3004,7 @@ ${JSON.stringify(entry.data, null, 2)}`;
   }
   close() {}
 }
-function initLogger(options) {
+function initLogger(options = { level: "warn" }) {
   if (instance) {
     throw new Error("Logger already initialized. Call getLogger() to access existing instance.");
   }
@@ -17805,7 +17805,7 @@ var init_zod = __esm(() => {
 });
 
 // src/config/schemas.ts
-var TokenPricingSchema, ModelDefSchema, ModelEntrySchema, ModelMapSchema, ModelTierSchema, TierConfigSchema, AutoModeConfigSchema, RectificationConfigSchema, RegressionGateConfigSchema, SmartTestRunnerConfigSchema, SMART_TEST_RUNNER_DEFAULT, smartTestRunnerFieldSchema, ExecutionConfigSchema, QualityConfigSchema, TddConfigSchema, ConstitutionConfigSchema, AnalyzeConfigSchema, SemanticReviewConfigSchema, ReviewConfigSchema, PlanConfigSchema, AcceptanceConfigSchema, TestCoverageConfigSchema, ContextAutoDetectConfigSchema, ContextConfigSchema, LlmRoutingConfigSchema, RoutingConfigSchema, OptimizerConfigSchema, PluginConfigEntrySchema, HooksConfigSchema, InteractionConfigSchema, StorySizeGateConfigSchema, AgentConfigSchema, PrecheckConfigSchema, PromptsConfigSchema, DecomposeConfigSchema, ProjectProfileSchema, NaxConfigSchema;
+var TokenPricingSchema, ModelDefSchema, ModelEntrySchema, ModelMapSchema, ModelTierSchema, TierConfigSchema, AutoModeConfigSchema, RectificationConfigSchema, RegressionGateConfigSchema, SmartTestRunnerConfigSchema, SMART_TEST_RUNNER_DEFAULT, smartTestRunnerFieldSchema, ExecutionConfigSchema, QualityConfigSchema, TddConfigSchema, ConstitutionConfigSchema, AnalyzeConfigSchema, SemanticReviewConfigSchema, ReviewConfigSchema, PlanConfigSchema, AcceptanceConfigSchema, TestCoverageConfigSchema, ContextAutoDetectConfigSchema, ContextConfigSchema, LlmRoutingConfigSchema, RoutingConfigSchema, OptimizerConfigSchema, PluginConfigEntrySchema, HooksConfigSchema, InteractionConfigSchema, StorySizeGateConfigSchema, AgentConfigSchema, PrecheckConfigSchema, PromptsConfigSchema, DecomposeConfigSchema, ProjectProfileSchema, VALID_AGENT_TYPES, GenerateConfigSchema, NaxConfigSchema;
 var init_schemas3 = __esm(() => {
   init_zod();
   TokenPricingSchema = exports_external.object({
@@ -17982,7 +17982,8 @@ var init_schemas3 = __esm(() => {
   SemanticReviewConfigSchema = exports_external.object({
     modelTier: ModelTierSchema.default("balanced"),
     rules: exports_external.array(exports_external.string()).default([]),
-    timeoutMs: exports_external.number().int().positive().default(600000)
+    timeoutMs: exports_external.number().int().positive().default(600000),
+    excludePatterns: exports_external.array(exports_external.string()).default([":!test/", ":!tests/", ":!*_test.go", ":!*.test.ts", ":!*.spec.ts", ":!**/__tests__/"])
   });
   ReviewConfigSchema = exports_external.object({
     enabled: exports_external.boolean(),
@@ -18106,6 +18107,10 @@ var init_schemas3 = __esm(() => {
     testFramework: exports_external.string().optional(),
     lintTool: exports_external.string().optional()
   });
+  VALID_AGENT_TYPES = ["claude", "codex", "opencode", "cursor", "windsurf", "aider", "gemini"];
+  GenerateConfigSchema = exports_external.object({
+    agents: exports_external.array(exports_external.enum(VALID_AGENT_TYPES)).optional()
+  });
   NaxConfigSchema = exports_external.object({
     version: exports_external.number(),
     models: ModelMapSchema,
@@ -18129,6 +18134,7 @@ var init_schemas3 = __esm(() => {
     precheck: PrecheckConfigSchema.optional(),
     prompts: PromptsConfigSchema.optional(),
     decompose: DecomposeConfigSchema.optional(),
+    generate: GenerateConfigSchema.optional(),
     project: ProjectProfileSchema.optional()
   }).refine((data) => data.version === 1, {
     message: "Invalid version: expected 1",
@@ -18278,7 +18284,8 @@ var init_defaults = __esm(() => {
       semantic: {
         modelTier: "balanced",
         rules: [],
-        timeoutMs: 600000
+        timeoutMs: 600000,
+        excludePatterns: [":!test/", ":!tests/", ":!*_test.go", ":!*.test.ts", ":!*.spec.ts", ":!**/__tests__/"]
       }
     },
     plan: {
@@ -19927,14 +19934,13 @@ function extractQuestion(output) {
   const text = output.trim();
   if (!text)
     return null;
-  const sentences = text.split(/(?<=[.!?])\s+/);
-  const questionSentences = sentences.filter((s) => s.trim().endsWith("?"));
-  if (questionSentences.length > 0) {
-    const q = questionSentences[questionSentences.length - 1].trim();
-    if (q.length > 10)
-      return q;
-  }
-  const lower = text.toLowerCase();
+  const lines = text.split(`
+`).filter((l) => l.trim().length > 0);
+  const lastLine = lines.at(-1)?.trim() ?? "";
+  if (lastLine.endsWith("?") && lastLine.length > 10) {
+    return lastLine;
+  }
+  const lower = lastLine.toLowerCase();
   const markers = [
     "please confirm",
     "please specify",
@@ -19946,7 +19952,7 @@ function extractQuestion(output) {
   ];
   for (const marker of markers) {
     if (lower.includes(marker)) {
-      return text.slice(-200).trim();
+      return lastLine;
     }
   }
   return null;
@@ -20133,7 +20139,19 @@ class AcpAgentAdapter {
     };
   }
   async complete(prompt, _options) {
-    const model = _options?.model ?? "default";
+    let model = _options?.model;
+    if (!model && _options?.modelTier && _options?.config?.models) {
+      const tier = _options.modelTier;
+      const { resolveModel: resolveModel2 } = await Promise.resolve().then(() => (init_schema(), exports_schema));
+      const models = _options.config.models;
+      const entry = models[tier] ?? models.balanced;
+      if (entry) {
+        try {
+          model = resolveModel2(entry).model;
+        } catch {}
+      }
+    }
+    model ??= "default";
     const timeoutMs = _options?.timeoutMs ?? 120000;
     const permissionMode = resolvePermissions(_options?.config, "complete").mode;
     const workdir = _options?.workdir;
@@ -21088,7 +21106,7 @@ var init_paths = () => {};
 
 // src/config/loader.ts
 import { existsSync as existsSync5 } from "fs";
-import { dirname, join as join6, resolve as resolve3 } from "path";
+import { basename, dirname, join as join6, resolve as resolve3 } from "path";
 function globalConfigPath() {
   return join6(globalConfigDir(), "config.json");
 }
@@ -21141,14 +21159,14 @@ function applyBatchModeCompat(conf) {
   }
   return conf;
 }
-async function loadConfig(projectDir, cliOverrides) {
+async function loadConfig(startDir, cliOverrides) {
   let rawConfig = structuredClone(DEFAULT_CONFIG);
   const globalConfRaw = await loadJsonFile(globalConfigPath(), "config");
   if (globalConfRaw) {
     const globalConf = applyBatchModeCompat(applyRemovedStrategyCompat(globalConfRaw));
     rawConfig = deepMergeConfig(rawConfig, globalConf);
   }
-  const projDir = projectDir ?? findProjectDir();
+  const projDir = startDir ? basename(startDir) === PROJECT_NAX_DIR ? startDir : findProjectDir(startDir) : findProjectDir();
   if (projDir) {
     const projConf = await loadJsonFile(join6(projDir, "config.json"), "config");
     if (projConf) {
@@ -22352,7 +22370,7 @@ var package_default;
 var init_package = __esm(() => {
   package_default = {
     name: "@nathapp/nax",
-    version: "0.54.7",
+    version: "0.54.9",
     description: "AI Coding Agent Orchestrator \u2014 loops until done",
     type: "module",
     bin: {
@@ -22364,8 +22382,10 @@ var init_package = __esm(() => {
       build: 'bun build bin/nax.ts --outdir dist --target bun --define "GIT_COMMIT=\\"$(git rev-parse --short HEAD)\\""',
       typecheck: "bun x tsc --noEmit",
       lint: "bun x biome check src/ bin/",
+      "lint:fix": "bun x biome lint --write src/ bin/",
       release: "bun scripts/release.ts",
       test: "bun test test/unit/ --timeout=60000 && bun test test/integration/ --timeout=60000 && bun test test/ui/ --timeout=60000",
+      "test:bail": "bun test test/unit/ --timeout=60000 --bail && bun test test/integration/ --timeout=60000 --bail && bun test test/ui/ --timeout=60000 --bail",
       "test:watch": "bun test --watch",
       "test:unit": "bun test ./test/unit/ --timeout=60000",
       "test:integration": "bun test ./test/integration/ --timeout=60000",
@@ -22429,8 +22449,8 @@ var init_version = __esm(() => {
   NAX_VERSION = package_default.version;
   NAX_COMMIT = (() => {
     try {
-      if (/^[0-9a-f]{6,10}$/.test("ccfd70c"))
-        return "ccfd70c";
+      if (/^[0-9a-f]{6,10}$/.test("3852fac"))
+        return "3852fac";
     } catch {}
     try {
       const result = Bun.spawnSync(["git", "rev-parse", "--short", "HEAD"], {
@@ -22478,7 +22498,7 @@ function buildInteractionBridge(chain, context, timeoutMs = DEFAULT_INTERACTION_
 }
 var QUESTION_PATTERNS, DEFAULT_INTERACTION_TIMEOUT_MS = 120000;
 var init_bridge_builder = __esm(() => {
-  QUESTION_PATTERNS = [/\?/, /\bwhich\b/i, /\bshould i\b/i, /\bunclear\b/i, /\bplease clarify\b/i];
+  QUESTION_PATTERNS = [/\?\s*$/, /\bwhich\b/i, /\bshould i\b/i, /\bunclear\b/i, /\bplease clarify\b/i];
 });
 
 // src/interaction/chain.ts
@@ -24705,6 +24725,36 @@ async function captureGitRef(workdir) {
     return;
   }
 }
+async function isGitRefValid(workdir, ref) {
+  try {
+    const { exitCode } = await gitWithTimeout(["cat-file", "-e", `${ref}^{commit}`], workdir);
+    return exitCode === 0;
+  } catch {
+    return false;
+  }
+}
+async function getMergeBase(workdir) {
+  for (const branch of ["origin/main", "origin/master"]) {
+    try {
+      const { stdout, exitCode } = await gitWithTimeout(["merge-base", "HEAD", branch], workdir);
+      if (exitCode === 0) {
+        const sha = stdout.trim();
+        if (sha)
+          return sha;
+      }
+    } catch {}
+  }
+  try {
+    const { stdout, exitCode } = await gitWithTimeout(["rev-list", "--max-parents=0", "HEAD"], workdir);
+    if (exitCode === 0) {
+      const sha = stdout.trim().split(`
+`)[0];
+      if (sha)
+        return sha;
+    }
+  } catch {}
+  return;
+}
 async function hasCommitsForStory(workdir, storyId, maxCommits = 20) {
   try {
     const { stdout, exitCode } = await gitWithTimeout(["log", `-${maxCommits}`, "--oneline", "--grep", storyId], workdir);
@@ -24853,9 +24903,13 @@ var init_language_commands = __esm(() => {
 
 // src/review/semantic.ts
 var {spawn: spawn2 } = globalThis.Bun;
-async function collectDiff(workdir, storyGitRef) {
+async function collectDiff(workdir, storyGitRef, excludePatterns) {
+  const cmd = ["git", "diff", "--unified=3", `${storyGitRef}..HEAD`];
+  if (excludePatterns.length > 0) {
+    cmd.push("--", ".", ...excludePatterns);
+  }
   const proc = _semanticDeps.spawn({
-    cmd: ["git", "diff", "--unified=3", `${storyGitRef}..HEAD`],
+    cmd,
     cwd: workdir,
     stdout: "pipe",
     stderr: "pipe"
@@ -24901,15 +24955,13 @@ ${stat}
 }
 function buildPrompt(story, semanticConfig, diff) {
   const acList = story.acceptanceCriteria.map((ac, i) => `${i + 1}. ${ac}`).join(`
-`);
-  const defaultRulesText = DEFAULT_RULES.map((r, i) => `${i + 1}. ${r}`).join(`
 `);
   const customRulesSection = semanticConfig.rules.length > 0 ? `
-## Custom Rules
+## Additional Review Rules
 ${semanticConfig.rules.map((r, i) => `${i + 1}. ${r}`).join(`
 `)}
 ` : "";
-  return `You are a code reviewer. Review the following git diff against the story requirements and rules.
+  return `You are a semantic code reviewer. Your job is to verify that the implementation satisfies the story's acceptance criteria (ACs). You are NOT a linter or style checker \u2014 lint, typecheck, and convention checks are handled separately.
 
 ## Story: ${story.title}
 
@@ -24918,27 +24970,29 @@ ${story.description}
 
 ### Acceptance Criteria
 ${acList}
-
-## Review Rules
-
-### Default Rules
-${defaultRulesText}
 ${customRulesSection}
-## Git Diff
+## Git Diff (production code only \u2014 test files excluded)
 
 \`\`\`diff
 ${diff}\`\`\`
 
 ## Instructions
 
-Respond with JSON only. No markdown fences around the JSON response itself.
-Format:
+For each acceptance criterion, verify the diff implements it correctly. Flag issues only when:
+1. An AC is not implemented or partially implemented
+2. The implementation contradicts what the AC specifies
+3. New code has dead paths that will never execute (stubs, noops, unreachable branches)
+4. New code is not wired into callers/exports (written but never used)
+
+Do NOT flag: style issues, naming conventions, import ordering, file length, or anything lint handles.
+
+Respond in JSON format:
 {
   "passed": boolean,
   "findings": [
     {
       "severity": "error" | "warn" | "info",
-      "file": "path/to/file.ts",
+      "file": "path/to/file",
       "line": 42,
       "issue": "description of the issue",
       "suggestion": "how to fix it"
@@ -24946,7 +25000,7 @@ Format:
   ]
 }
 
-If the implementation looks correct, respond with { "passed": true, "findings": [] }.`;
+If all ACs are correctly implemented, respond with { "passed": true, "findings": [] }.`;
 }
 function parseLLMResponse(raw) {
   try {
@@ -24989,10 +25043,24 @@ function toReviewFindings(findings) {
     source: "semantic-review"
   }));
 }
-async function runSemanticReview(workdir, storyGitRef, story, semanticConfig, modelResolver) {
+async function runSemanticReview(workdir, storyGitRef, story, semanticConfig, modelResolver, naxConfig) {
   const startTime = Date.now();
   const logger = getSafeLogger();
-  if (!storyGitRef) {
+  let effectiveRef;
+  if (storyGitRef && await _semanticDeps.isGitRefValid(workdir, storyGitRef)) {
+    effectiveRef = storyGitRef;
+  } else {
+    const fallback = await _semanticDeps.getMergeBase(workdir);
+    if (fallback) {
+      logger?.info("review", "storyGitRef missing or invalid \u2014 using merge-base fallback", {
+        storyId: story.id,
+        storyGitRef,
+        fallback
+      });
+      effectiveRef = fallback;
+    }
+  }
+  if (!effectiveRef) {
     return {
       check: "semantic",
       success: true,
@@ -25002,10 +25070,14 @@ async function runSemanticReview(workdir, storyGitRef, story, semanticConfig, mo
       durationMs: Date.now() - startTime
     };
   }
-  logger?.info("review", "Running semantic check", { storyId: story.id, modelTier: semanticConfig.modelTier });
-  const rawDiff = await collectDiff(workdir, storyGitRef);
+  logger?.info("review", "Running semantic check", {
+    storyId: story.id,
+    modelTier: semanticConfig.modelTier,
+    configProvided: !!naxConfig
+  });
+  const rawDiff = await collectDiff(workdir, effectiveRef, semanticConfig.excludePatterns);
   const needsTruncation = rawDiff.length > DIFF_CAP_BYTES;
-  const stat = needsTruncation ? await collectDiffStat(workdir, storyGitRef) : undefined;
+  const stat = needsTruncation ? await collectDiffStat(workdir, effectiveRef) : undefined;
   const diff = truncateDiff(rawDiff, stat);
   const agent = modelResolver(semanticConfig.modelTier);
   if (!agent) {
@@ -25027,7 +25099,9 @@ async function runSemanticReview(workdir, storyGitRef, story, semanticConfig, mo
     rawResponse = await agent.complete(prompt, {
       sessionName: `nax-semantic-${story.id}`,
       workdir,
-      timeoutMs: semanticConfig.timeoutMs
+      timeoutMs: semanticConfig.timeoutMs,
+      modelTier: semanticConfig.modelTier,
+      config: naxConfig
     });
   } catch (err) {
     logger?.warn("semantic", "LLM call failed \u2014 fail-open", { cause: String(err) });
@@ -25108,19 +25182,15 @@ ${formatFindings(parsed.findings)}`;
     durationMs
   };
 }
-var _semanticDeps, DIFF_CAP_BYTES = 102400, DEFAULT_RULES;
+var _semanticDeps, DIFF_CAP_BYTES = 51200;
 var init_semantic = __esm(() => {
   init_logger2();
+  init_git();
   _semanticDeps = {
-    spawn: spawn2
-  };
-  DEFAULT_RULES = [
-    "No stubs or noops left in production code paths",
-    "No placeholder values (TODO, FIXME, hardcoded dummy data)",
-    "No unrelated changes outside the story scope",
-    "All new code is properly wired into callers and exports",
-    "No silent error swallowing (catch blocks that discard errors without logging)"
-  ];
+    spawn: spawn2,
+    isGitRefValid,
+    getMergeBase
+  };
 });
 
 // src/review/runner.ts
@@ -25267,7 +25337,7 @@ async function getUncommittedFilesImpl(workdir) {
     return [];
   }
 }
-async function runReview(config2, workdir, executionConfig, qualityCommands, storyId, storyGitRef, story, modelResolver) {
+async function runReview(config2, workdir, executionConfig, qualityCommands, storyId, storyGitRef, story, modelResolver, naxConfig) {
   const startTime = Date.now();
   const logger = getSafeLogger();
   const checks3 = [];
@@ -25317,9 +25387,10 @@ Stage and commit these files before running review.`
       const semanticCfg = config2.semantic ?? {
         modelTier: "balanced",
         rules: [],
-        timeoutMs: 600000
+        timeoutMs: 600000,
+        excludePatterns: [":!test/", ":!tests/", ":!*_test.go", ":!*.test.ts", ":!*.spec.ts", ":!**/__tests__/"]
       };
-      const result2 = await _reviewSemanticDeps.runSemanticReview(workdir, storyGitRef, semanticStory, semanticCfg, modelResolver ?? (() => null));
+      const result2 = await _reviewSemanticDeps.runSemanticReview(workdir, storyGitRef, semanticStory, semanticCfg, modelResolver ?? (() => null), naxConfig);
       checks3.push(result2);
       if (!result2.success && !firstFailure) {
         firstFailure = `${checkName} failed`;
@@ -25401,9 +25472,9 @@ async function getChangedFiles(workdir, baseRef) {
 }
 
 class ReviewOrchestrator {
-  async review(reviewConfig, workdir, executionConfig, plugins, storyGitRef, scopePrefix, qualityCommands, storyId, story, modelResolver) {
+  async review(reviewConfig, workdir, executionConfig, plugins, storyGitRef, scopePrefix, qualityCommands, storyId, story, modelResolver, naxConfig) {
     const logger = getSafeLogger();
-    const builtIn = await runReview(reviewConfig, workdir, executionConfig, qualityCommands, storyId, storyGitRef, story, modelResolver);
+    const builtIn = await runReview(reviewConfig, workdir, executionConfig, qualityCommands, storyId, storyGitRef, story, modelResolver, naxConfig);
     if (!builtIn.success) {
       return { builtIn, success: false, failureReason: builtIn.failureReason, pluginFailed: false };
     }
@@ -25502,7 +25573,7 @@ var init_review = __esm(() => {
         title: ctx.story.title,
         description: ctx.story.description,
         acceptanceCriteria: ctx.story.acceptanceCriteria
-      }, modelResolver);
+      }, modelResolver, ctx.config);
       ctx.reviewResult = result.builtIn;
       if (!result.success) {
         const pluginFindings = result.builtIn.pluginReviewers?.flatMap((pr) => pr.findings ?? []) ?? [];
@@ -26242,8 +26313,8 @@ function extractTestStructure(source) {
 function deriveTestPatterns(contextFiles) {
   const patterns = new Set;
   for (const filePath of contextFiles) {
-    const basename = path6.basename(filePath);
-    const basenameNoExt = basename.replace(/\.(ts|js|tsx|jsx)$/, "");
+    const basename2 = path6.basename(filePath);
+    const basenameNoExt = basename2.replace(/\.(ts|js|tsx|jsx)$/, "");
     patterns.add(`${basenameNoExt}.test.ts`);
     patterns.add(`${basenameNoExt}.test.js`);
     patterns.add(`${basenameNoExt}.test.tsx`);
@@ -26296,8 +26367,8 @@ async function scanTestFiles(options) {
   const files = [];
   for await (const filePath of glob.scan({ cwd: scanDir, absolute: false })) {
     if (allowedBasenames !== null) {
-      const basename = path6.basename(filePath);
-      if (!allowedBasenames.has(basename)) {
+      const basename2 = path6.basename(filePath);
+      if (!allowedBasenames.has(basename2)) {
         continue;
       }
     }
@@ -30286,8 +30357,8 @@ function extractSearchTerms(sourceFile) {
   const withoutSrc = sourceFile.replace(/^src\//, "");
   const withoutExt = withoutSrc.replace(/\.ts$/, "");
   const parts = withoutExt.split("/");
-  const basename = parts[parts.length - 1];
-  return [`/${basename}`, withoutExt];
+  const basename2 = parts[parts.length - 1];
+  return [`/${basename2}`, withoutExt];
 }
 async function importGrepFallback(sourceFiles, workdir, testFilePatterns) {
   if (sourceFiles.length === 0 || testFilePatterns.length === 0)
@@ -31060,7 +31131,7 @@ __export(exports_init_context, {
 });
 import { existsSync as existsSync20 } from "fs";
 import { mkdir } from "fs/promises";
-import { basename as basename2, join as join30 } from "path";
+import { basename as basename3, join as join30 } from "path";
 async function findFiles(dir, maxFiles = 200) {
   try {
     const proc = Bun.spawnSync([
@@ -31148,7 +31219,7 @@ async function scanProject(projectRoot) {
   const readmeSnippet = await readReadmeSnippet(projectRoot);
   const entryPoints = await detectEntryPoints(projectRoot);
   const configFiles = await detectConfigFiles(projectRoot);
-  const projectName = packageManifest?.name || basename2(projectRoot);
+  const projectName = packageManifest?.name || basename3(projectRoot);
   return {
     projectName,
     fileTree,
@@ -31730,11 +31801,11 @@ function getSafeLogger6() {
   return getSafeLogger();
 }
 function extractPluginName(pluginPath) {
-  const basename4 = path12.basename(pluginPath);
-  if (basename4 === "index.ts" || basename4 === "index.js" || basename4 === "index.mjs") {
+  const basename5 = path12.basename(pluginPath);
+  if (basename5 === "index.ts" || basename5 === "index.js" || basename5 === "index.mjs") {
     return path12.basename(path12.dirname(pluginPath));
   }
-  return basename4.replace(/\.(ts|js|mjs)$/, "");
+  return basename5.replace(/\.(ts|js|mjs)$/, "");
 }
 async function loadPlugins(globalDir, projectDir, configPlugins, projectRoot, disabledPlugins) {
   const loadedPlugins = [];
@@ -33939,2119 +34010,1712 @@ var init_headless_formatter = __esm(() => {
   init_version();
 });
 
-// src/worktree/manager.ts
-var exports_manager = {};
-__export(exports_manager, {
-  _managerDeps: () => _managerDeps,
-  WorktreeManager: () => WorktreeManager
-});
-import { existsSync as existsSync32, symlinkSync } from "fs";
-import { join as join47 } from "path";
-
-class WorktreeManager {
-  async create(projectRoot, storyId) {
-    validateStoryId(storyId);
-    const worktreePath = join47(projectRoot, ".nax-wt", storyId);
-    const branchName = `nax/${storyId}`;
-    try {
-      const proc = _managerDeps.spawn(["git", "worktree", "add", worktreePath, "-b", branchName], {
-        cwd: projectRoot,
-        stdout: "pipe",
-        stderr: "pipe"
-      });
-      const exitCode = await proc.exited;
-      if (exitCode !== 0) {
-        const stderr = await new Response(proc.stderr).text();
-        throw new Error(`Failed to create worktree: ${stderr || "unknown error"}`);
-      }
-    } catch (error48) {
-      if (error48 instanceof Error) {
-        if (error48.message.includes("not a git repository")) {
-          throw new Error(`Not a git repository: ${projectRoot}`);
-        }
-        if (error48.message.includes("already exists")) {
-          throw new Error(`Worktree for story ${storyId} already exists at ${worktreePath}`);
-        }
-        throw error48;
-      }
-      throw new Error(`Failed to create worktree: ${String(error48)}`);
-    }
-    const nodeModulesSource = join47(projectRoot, "node_modules");
-    if (existsSync32(nodeModulesSource)) {
-      const nodeModulesTarget = join47(worktreePath, "node_modules");
-      try {
-        symlinkSync(nodeModulesSource, nodeModulesTarget, "dir");
-      } catch (error48) {
-        await this.remove(projectRoot, storyId);
-        throw new Error(`Failed to symlink node_modules: ${errorMessage(error48)}`);
-      }
-    }
-    const envSource = join47(projectRoot, ".env");
-    if (existsSync32(envSource)) {
-      const envTarget = join47(worktreePath, ".env");
+// src/pipeline/subscribers/events-writer.ts
+import { appendFile as appendFile2, mkdir as mkdir2 } from "fs/promises";
+import { homedir as homedir5 } from "os";
+import { basename as basename6, join as join47 } from "path";
+function wireEventsWriter(bus, feature, runId, workdir) {
+  const logger = getSafeLogger();
+  const project = basename6(workdir);
+  const eventsDir = join47(homedir5(), ".nax", "events", project);
+  const eventsFile = join47(eventsDir, "events.jsonl");
+  let dirReady = false;
+  const write = (line) => {
+    return (async () => {
       try {
-        symlinkSync(envSource, envTarget, "file");
-      } catch (error48) {
-        await this.remove(projectRoot, storyId);
-        throw new Error(`Failed to symlink .env: ${errorMessage(error48)}`);
-      }
-    }
-  }
-  async remove(projectRoot, storyId) {
-    validateStoryId(storyId);
-    const worktreePath = join47(projectRoot, ".nax-wt", storyId);
-    const branchName = `nax/${storyId}`;
-    try {
-      const proc = _managerDeps.spawn(["git", "worktree", "remove", worktreePath, "--force"], {
-        cwd: projectRoot,
-        stdout: "pipe",
-        stderr: "pipe"
-      });
-      const exitCode = await proc.exited;
-      if (exitCode !== 0) {
-        const stderr = await new Response(proc.stderr).text();
-        if (stderr.includes("not found") || stderr.includes("does not exist") || stderr.includes("no such worktree") || stderr.includes("is not a working tree")) {
-          throw new Error(`Worktree not found: ${worktreePath}`);
-        }
-        throw new Error(`Failed to remove worktree: ${stderr || "unknown error"}`);
-      }
-    } catch (error48) {
-      if (error48 instanceof Error) {
-        throw error48;
-      }
-      throw new Error(`Failed to remove worktree: ${String(error48)}`);
-    }
-    try {
-      const proc = _managerDeps.spawn(["git", "branch", "-D", branchName], {
-        cwd: projectRoot,
-        stdout: "pipe",
-        stderr: "pipe"
-      });
-      const exitCode = await proc.exited;
-      if (exitCode !== 0) {
-        const stderr = await new Response(proc.stderr).text();
-        if (!stderr.includes("not found")) {
-          const logger = getSafeLogger();
-          logger?.warn("worktree", `Failed to delete branch ${branchName}`, { stderr });
+        if (!dirReady) {
+          await mkdir2(eventsDir, { recursive: true });
+          dirReady = true;
         }
-      }
-    } catch (error48) {
-      const logger = getSafeLogger();
-      logger?.warn("worktree", `Failed to delete branch ${branchName}`, {
-        error: errorMessage(error48)
-      });
-    }
-  }
-  async list(projectRoot) {
-    try {
-      const proc = _managerDeps.spawn(["git", "worktree", "list", "--porcelain"], {
-        cwd: projectRoot,
-        stdout: "pipe",
-        stderr: "pipe"
-      });
-      const exitCode = await proc.exited;
-      if (exitCode !== 0) {
-        const stderr = await new Response(proc.stderr).text();
-        throw new Error(`Failed to list worktrees: ${stderr || "unknown error"}`);
-      }
-      const stdout = await new Response(proc.stdout).text();
-      return this.parseWorktreeList(stdout);
-    } catch (error48) {
-      if (error48 instanceof Error) {
-        throw error48;
-      }
-      throw new Error(`Failed to list worktrees: ${String(error48)}`);
-    }
-  }
-  parseWorktreeList(output) {
-    const worktrees = [];
-    const lines = output.trim().split(`
+        await appendFile2(eventsFile, `${JSON.stringify(line)}
 `);
-    let currentWorktree = {};
-    for (const line of lines) {
-      if (line.startsWith("worktree ")) {
-        currentWorktree.path = line.substring("worktree ".length);
-      } else if (line.startsWith("branch ")) {
-        currentWorktree.branch = line.substring("branch ".length).replace("refs/heads/", "");
-      } else if (line === "") {
-        if (currentWorktree.path && currentWorktree.branch) {
-          worktrees.push(currentWorktree);
-        }
-        currentWorktree = {};
+      } catch (err) {
+        logger?.warn("events-writer", "Failed to write event line (non-fatal)", {
+          event: line.event,
+          error: String(err)
+        });
       }
-    }
-    if (currentWorktree.path && currentWorktree.branch) {
-      worktrees.push(currentWorktree);
-    }
-    return worktrees;
-  }
+    })();
+  };
+  const unsubs = [];
+  unsubs.push(bus.on("run:started", (_ev) => {
+    return write({ ts: new Date().toISOString(), event: "run:started", runId, feature, project });
+  }));
+  unsubs.push(bus.on("story:started", (ev) => {
+    return write({
+      ts: new Date().toISOString(),
+      event: "story:started",
+      runId,
+      feature,
+      project,
+      storyId: ev.storyId
+    });
+  }));
+  unsubs.push(bus.on("story:completed", (ev) => {
+    return write({
+      ts: new Date().toISOString(),
+      event: "story:completed",
+      runId,
+      feature,
+      project,
+      storyId: ev.storyId
+    });
+  }));
+  unsubs.push(bus.on("story:decomposed", (ev) => {
+    return write({
+      ts: new Date().toISOString(),
+      event: "story:decomposed",
+      runId,
+      feature,
+      project,
+      storyId: ev.storyId,
+      data: { subStoryCount: ev.subStoryCount }
+    });
+  }));
+  unsubs.push(bus.on("story:failed", (ev) => {
+    return write({
+      ts: new Date().toISOString(),
+      event: "story:failed",
+      runId,
+      feature,
+      project,
+      storyId: ev.storyId
+    });
+  }));
+  unsubs.push(bus.on("run:completed", (_ev) => {
+    return write({ ts: new Date().toISOString(), event: "on-complete", runId, feature, project });
+  }));
+  unsubs.push(bus.on("run:paused", (ev) => {
+    return write({
+      ts: new Date().toISOString(),
+      event: "run:paused",
+      runId,
+      feature,
+      project,
+      ...ev.storyId !== undefined && { storyId: ev.storyId }
+    });
+  }));
+  return () => {
+    for (const u of unsubs)
+      u();
+  };
 }
-var _managerDeps;
-var init_manager = __esm(() => {
+var init_events_writer = __esm(() => {
   init_logger2();
-  init_bun_deps();
-  _managerDeps = {
-    spawn
-  };
 });
 
-// src/worktree/merge.ts
-var exports_merge = {};
-__export(exports_merge, {
-  _mergeDeps: () => _mergeDeps,
-  MergeEngine: () => MergeEngine
+// src/pipeline/subscribers/hooks.ts
+function wireHooks(bus, hooks, workdir, feature) {
+  const logger = getSafeLogger();
+  const safe = (name, fn) => {
+    return fn().catch((err) => logger?.warn("hooks-subscriber", `Hook "${name}" failed`, { error: String(err) })).catch(() => {});
+  };
+  const unsubs = [];
+  unsubs.push(bus.on("run:started", (ev) => {
+    return safe("on-start", () => fireHook(hooks, "on-start", hookCtx(feature, { status: "running" }), workdir));
+  }));
+  unsubs.push(bus.on("story:started", (ev) => {
+    return safe("on-story-start", () => fireHook(hooks, "on-story-start", hookCtx(feature, { storyId: ev.storyId, model: ev.modelTier, agent: ev.agent }), workdir));
+  }));
+  unsubs.push(bus.on("story:completed", (ev) => {
+    return safe("on-story-complete", () => fireHook(hooks, "on-story-complete", hookCtx(feature, { storyId: ev.storyId, status: "passed", cost: ev.cost }), workdir));
+  }));
+  unsubs.push(bus.on("story:decomposed", (ev) => {
+    return safe("on-story-complete (decomposed)", () => fireHook(hooks, "on-story-complete", hookCtx(feature, { storyId: ev.storyId, status: "decomposed", subStoryCount: ev.subStoryCount }), workdir));
+  }));
+  unsubs.push(bus.on("story:failed", (ev) => {
+    return safe("on-story-fail", () => fireHook(hooks, "on-story-fail", hookCtx(feature, { storyId: ev.storyId, status: "failed", reason: ev.reason }), workdir));
+  }));
+  unsubs.push(bus.on("story:paused", (ev) => {
+    return safe("on-pause (story)", () => fireHook(hooks, "on-pause", hookCtx(feature, { storyId: ev.storyId, reason: ev.reason, cost: ev.cost }), workdir));
+  }));
+  unsubs.push(bus.on("run:paused", (ev) => {
+    return safe("on-pause (run)", () => fireHook(hooks, "on-pause", hookCtx(feature, { storyId: ev.storyId, reason: ev.reason, cost: ev.cost }), workdir));
+  }));
+  unsubs.push(bus.on("run:completed", (ev) => {
+    return safe("on-complete", () => fireHook(hooks, "on-complete", hookCtx(feature, { status: "complete", cost: ev.totalCost ?? 0 }), workdir));
+  }));
+  unsubs.push(bus.on("run:resumed", (ev) => {
+    return safe("on-resume", () => fireHook(hooks, "on-resume", hookCtx(feature, { status: "running" }), workdir));
+  }));
+  unsubs.push(bus.on("story:completed", (ev) => {
+    return safe("on-session-end (completed)", () => fireHook(hooks, "on-session-end", hookCtx(feature, { storyId: ev.storyId, status: "passed" }), workdir));
+  }));
+  unsubs.push(bus.on("story:failed", (ev) => {
+    return safe("on-session-end (failed)", () => fireHook(hooks, "on-session-end", hookCtx(feature, { storyId: ev.storyId, status: "failed" }), workdir));
+  }));
+  unsubs.push(bus.on("run:errored", (ev) => {
+    return safe("on-error", () => fireHook(hooks, "on-error", hookCtx(feature, { reason: ev.reason }), workdir));
+  }));
+  return () => {
+    for (const u of unsubs)
+      u();
+  };
+}
+var init_hooks2 = __esm(() => {
+  init_story_context();
+  init_hooks();
+  init_logger2();
 });
 
-class MergeEngine {
-  worktreeManager;
-  constructor(worktreeManager) {
-    this.worktreeManager = worktreeManager;
-  }
-  async merge(projectRoot, storyId) {
-    const branchName = `nax/${storyId}`;
-    try {
-      const mergeProc = _mergeDeps.spawn(["git", "merge", "--no-ff", branchName, "-m", `Merge branch '${branchName}'`], {
-        cwd: projectRoot,
-        stdout: "pipe",
-        stderr: "pipe"
+// src/pipeline/subscribers/interaction.ts
+function wireInteraction(bus, interactionChain, config2) {
+  const logger = getSafeLogger();
+  const unsubs = [];
+  if (interactionChain && isTriggerEnabled("human-review", config2)) {
+    unsubs.push(bus.on("human-review:requested", (ev) => {
+      executeTrigger("human-review", {
+        featureName: ev.feature ?? "",
+        storyId: ev.storyId,
+        iteration: ev.attempts ?? 0,
+        reason: ev.reason
+      }, config2, interactionChain).catch((err) => {
+        logger?.warn("interaction-subscriber", "human-review trigger failed", {
+          storyId: ev.storyId,
+          error: String(err)
+        });
       });
-      const exitCode = await mergeProc.exited;
-      const stderr = await new Response(mergeProc.stderr).text();
-      const stdout = await new Response(mergeProc.stdout).text();
-      if (exitCode === 0) {
-        try {
-          await this.worktreeManager.remove(projectRoot, storyId);
-        } catch (error48) {
-          const logger = getSafeLogger();
-          logger?.warn("worktree", `Failed to cleanup worktree for ${storyId}`, {
-            error: errorMessage(error48)
+    }));
+  }
+  if (interactionChain && isTriggerEnabled("max-retries", config2)) {
+    unsubs.push(bus.on("story:failed", (ev) => {
+      if (!ev.countsTowardEscalation) {
+        return;
+      }
+      executeTrigger("max-retries", {
+        featureName: ev.feature ?? "",
+        storyId: ev.storyId,
+        iteration: ev.attempts ?? 0
+      }, config2, interactionChain).then((response) => {
+        if (response.action === "abort") {
+          logger?.warn("interaction-subscriber", "max-retries abort requested", {
+            storyId: ev.storyId
           });
         }
-        return { success: true };
-      }
-      const output = `${stdout}
-${stderr}`;
-      if (output.includes("CONFLICT") || output.includes("conflict") || output.includes("Automatic merge failed")) {
-        const conflictFiles = await this.getConflictFiles(projectRoot);
-        await this.abortMerge(projectRoot);
-        return {
-          success: false,
-          conflictFiles
-        };
-      }
-      throw new Error(`Merge failed: ${stderr || stdout || "unknown error"}`);
-    } catch (error48) {
-      if (error48 instanceof Error) {
-        throw error48;
-      }
-      throw new Error(`Failed to merge branch ${branchName}: ${String(error48)}`);
-    }
+      }).catch((err) => {
+        logger?.warn("interaction-subscriber", "max-retries trigger failed", {
+          storyId: ev.storyId,
+          error: String(err)
+        });
+      });
+    }));
   }
-  async mergeAll(projectRoot, storyIds, dependencies) {
-    const orderedStories = this.topologicalSort(storyIds, dependencies);
-    const results = [];
-    const failedStories = new Set;
-    for (const storyId of orderedStories) {
-      const deps = dependencies[storyId] || [];
-      const hasFailedDeps = deps.some((dep) => failedStories.has(dep));
-      if (hasFailedDeps) {
-        results.push({
-          success: false,
-          storyId,
-          conflictFiles: []
+  return () => {
+    for (const u of unsubs)
+      u();
+  };
+}
+var init_interaction2 = __esm(() => {
+  init_triggers();
+  init_logger2();
+});
+
+// src/pipeline/subscribers/registry.ts
+import { mkdir as mkdir3, writeFile } from "fs/promises";
+import { homedir as homedir6 } from "os";
+import { basename as basename7, join as join48 } from "path";
+function wireRegistry(bus, feature, runId, workdir) {
+  const logger = getSafeLogger();
+  const project = basename7(workdir);
+  const runDir = join48(homedir6(), ".nax", "runs", `${project}-${feature}-${runId}`);
+  const metaFile = join48(runDir, "meta.json");
+  const unsub = bus.on("run:started", (_ev) => {
+    return (async () => {
+      try {
+        await mkdir3(runDir, { recursive: true });
+        const meta3 = {
+          runId,
+          project,
+          feature,
+          workdir,
+          statusPath: join48(workdir, ".nax", "features", feature, "status.json"),
+          eventsDir: join48(workdir, ".nax", "features", feature, "runs"),
+          registeredAt: new Date().toISOString()
+        };
+        await writeFile(metaFile, JSON.stringify(meta3, null, 2));
+      } catch (err) {
+        logger?.warn("registry-writer", "Failed to write meta.json (non-fatal)", {
+          path: metaFile,
+          error: String(err)
         });
-        failedStories.add(storyId);
-        continue;
       }
-      let result = await this.merge(projectRoot, storyId);
-      if (!result.success && result.conflictFiles) {
-        try {
-          await this.rebaseWorktree(projectRoot, storyId);
-          result = await this.merge(projectRoot, storyId);
-          if (!result.success) {
-            results.push({
-              success: false,
-              storyId,
-              conflictFiles: result.conflictFiles,
-              retryCount: 1
+    })();
+  });
+  return unsub;
+}
+var init_registry3 = __esm(() => {
+  init_logger2();
+});
+
+// src/pipeline/subscribers/reporters.ts
+function wireReporters(bus, pluginRegistry, runId, startTime) {
+  const logger = getSafeLogger();
+  const safe = (name, fn) => {
+    return fn().catch((err) => logger?.warn("reporters-subscriber", `Reporter "${name}" error`, { error: String(err) })).catch(() => {});
+  };
+  const unsubs = [];
+  unsubs.push(bus.on("run:started", (ev) => {
+    return safe("onRunStart", async () => {
+      const reporters = pluginRegistry.getReporters();
+      for (const r of reporters) {
+        if (r.onRunStart) {
+          try {
+            await r.onRunStart({
+              runId,
+              feature: ev.feature,
+              totalStories: ev.totalStories,
+              startTime: new Date(startTime).toISOString()
             });
-            failedStories.add(storyId);
-            continue;
+          } catch (err) {
+            logger?.warn("plugins", `Reporter '${r.name}' onRunStart failed`, { error: err });
           }
-          results.push({
-            success: true,
-            storyId,
-            retryCount: 1
-          });
-        } catch (error48) {
-          results.push({
-            success: false,
-            storyId,
-            conflictFiles: result.conflictFiles,
-            retryCount: 1
-          });
-          failedStories.add(storyId);
         }
-      } else if (result.success) {
-        results.push({
-          success: true,
-          storyId,
-          retryCount: 0
-        });
-      } else {
-        results.push({
-          success: false,
-          storyId,
-          retryCount: 0
-        });
-        failedStories.add(storyId);
-      }
-    }
-    return results;
-  }
-  topologicalSort(storyIds, dependencies) {
-    const visited = new Set;
-    const sorted = [];
-    const visiting = new Set;
-    const visit = (storyId) => {
-      if (visited.has(storyId)) {
-        return;
-      }
-      if (visiting.has(storyId)) {
-        throw new Error(`Circular dependency detected involving ${storyId}`);
       }
-      visiting.add(storyId);
-      const deps = dependencies[storyId] || [];
-      for (const dep of deps) {
-        if (storyIds.includes(dep)) {
-          visit(dep);
+    });
+  }));
+  unsubs.push(bus.on("story:completed", (ev) => {
+    return safe("onStoryComplete(completed)", async () => {
+      const reporters = pluginRegistry.getReporters();
+      for (const r of reporters) {
+        if (r.onStoryComplete) {
+          try {
+            await r.onStoryComplete({
+              runId,
+              storyId: ev.storyId,
+              status: "completed",
+              runElapsedMs: ev.runElapsedMs,
+              cost: ev.cost ?? 0,
+              tier: ev.modelTier ?? "balanced",
+              testStrategy: ev.testStrategy ?? "test-after"
+            });
+          } catch (err) {
+            logger?.warn("plugins", `Reporter '${r.name}' onStoryComplete failed`, { error: err });
+          }
         }
       }
-      visiting.delete(storyId);
-      visited.add(storyId);
-      sorted.push(storyId);
-    };
-    for (const storyId of storyIds) {
-      visit(storyId);
-    }
-    return sorted;
-  }
-  async rebaseWorktree(projectRoot, storyId) {
-    const worktreePath = `${projectRoot}/.nax-wt/${storyId}`;
-    try {
-      const currentBranchProc = _mergeDeps.spawn(["git", "rev-parse", "--abbrev-ref", "HEAD"], {
-        cwd: projectRoot,
-        stdout: "pipe",
-        stderr: "pipe"
-      });
-      const exitCode = await currentBranchProc.exited;
-      if (exitCode !== 0) {
-        throw new Error("Failed to get current branch");
+    });
+  }));
+  unsubs.push(bus.on("story:failed", (ev) => {
+    return safe("onStoryComplete(failed)", async () => {
+      const reporters = pluginRegistry.getReporters();
+      for (const r of reporters) {
+        if (r.onStoryComplete) {
+          try {
+            await r.onStoryComplete({
+              runId,
+              storyId: ev.storyId,
+              status: "failed",
+              runElapsedMs: Date.now() - startTime,
+              cost: 0,
+              tier: "balanced",
+              testStrategy: "test-after"
+            });
+          } catch (err) {
+            logger?.warn("plugins", `Reporter '${r.name}' onStoryComplete failed`, { error: err });
+          }
+        }
       }
-      const currentBranch = (await new Response(currentBranchProc.stdout).text()).trim();
-      const rebaseProc = _mergeDeps.spawn(["git", "rebase", currentBranch], {
-        cwd: worktreePath,
-        stdout: "pipe",
-        stderr: "pipe"
-      });
-      const rebaseExitCode = await rebaseProc.exited;
-      if (rebaseExitCode !== 0) {
-        const stderr = await new Response(rebaseProc.stderr).text();
-        const abortProc = _mergeDeps.spawn(["git", "rebase", "--abort"], {
-          cwd: worktreePath,
-          stdout: "pipe",
-          stderr: "pipe"
-        });
-        await abortProc.exited;
-        throw new Error(`Rebase failed: ${stderr || "unknown error"}`);
+    });
+  }));
+  unsubs.push(bus.on("story:paused", (ev) => {
+    return safe("onStoryComplete(paused)", async () => {
+      const reporters = pluginRegistry.getReporters();
+      for (const r of reporters) {
+        if (r.onStoryComplete) {
+          try {
+            await r.onStoryComplete({
+              runId,
+              storyId: ev.storyId,
+              status: "paused",
+              runElapsedMs: Date.now() - startTime,
+              cost: 0,
+              tier: "balanced",
+              testStrategy: "test-after"
+            });
+          } catch (err) {
+            logger?.warn("plugins", `Reporter '${r.name}' onStoryComplete failed`, { error: err });
+          }
+        }
       }
-    } catch (error48) {
-      if (error48 instanceof Error) {
-        throw error48;
+    });
+  }));
+  unsubs.push(bus.on("run:completed", (ev) => {
+    return safe("onRunEnd", async () => {
+      const reporters = pluginRegistry.getReporters();
+      for (const r of reporters) {
+        if (r.onRunEnd) {
+          try {
+            await r.onRunEnd({
+              runId,
+              totalDurationMs: Date.now() - startTime,
+              totalCost: ev.totalCost ?? 0,
+              storySummary: {
+                completed: ev.passedStories,
+                failed: ev.failedStories,
+                skipped: 0,
+                paused: 0
+              }
+            });
+          } catch (err) {
+            logger?.warn("plugins", `Reporter '${r.name}' onRunEnd failed`, { error: err });
+          }
+        }
       }
-      throw new Error(`Failed to rebase worktree ${storyId}: ${String(error48)}`);
-    }
+    });
+  }));
+  return () => {
+    for (const u of unsubs)
+      u();
+  };
+}
+var init_reporters = __esm(() => {
+  init_logger2();
+});
+
+// src/execution/deferred-review.ts
+var {spawn: spawn5 } = globalThis.Bun;
+async function captureRunStartRef(workdir) {
+  try {
+    const proc = _deferredReviewDeps.spawn({
+      cmd: ["git", "rev-parse", "HEAD"],
+      cwd: workdir,
+      stdout: "pipe",
+      stderr: "pipe"
+    });
+    const [, stdout] = await Promise.all([proc.exited, new Response(proc.stdout).text()]);
+    return stdout.trim();
+  } catch {
+    return "";
   }
-  async getConflictFiles(projectRoot) {
-    try {
-      const proc = _mergeDeps.spawn(["git", "diff", "--name-only", "--diff-filter=U"], {
-        cwd: projectRoot,
-        stdout: "pipe",
-        stderr: "pipe"
-      });
-      const exitCode = await proc.exited;
-      if (exitCode !== 0) {
-        return [];
-      }
-      const stdout = await new Response(proc.stdout).text();
-      return stdout.trim().split(`
-`).filter((line) => line.length > 0);
-    } catch {
-      return [];
-    }
+}
+async function getChangedFilesForDeferred(workdir, baseRef) {
+  try {
+    const proc = _deferredReviewDeps.spawn({
+      cmd: ["git", "diff", "--name-only", `${baseRef}...HEAD`],
+      cwd: workdir,
+      stdout: "pipe",
+      stderr: "pipe"
+    });
+    const [, stdout] = await Promise.all([proc.exited, new Response(proc.stdout).text()]);
+    return stdout.trim().split(`
+`).filter(Boolean);
+  } catch {
+    return [];
   }
-  async abortMerge(projectRoot) {
+}
+async function runDeferredReview(workdir, reviewConfig, plugins, runStartRef) {
+  if (!reviewConfig || reviewConfig.pluginMode !== "deferred") {
+    return;
+  }
+  const reviewers = plugins.getReviewers();
+  if (reviewers.length === 0) {
+    return;
+  }
+  const changedFiles = await getChangedFilesForDeferred(workdir, runStartRef);
+  const reviewerResults = [];
+  let anyFailed = false;
+  for (const reviewer of reviewers) {
     try {
-      const proc = _mergeDeps.spawn(["git", "merge", "--abort"], {
-        cwd: projectRoot,
-        stdout: "pipe",
-        stderr: "pipe"
+      const result = await reviewer.check(workdir, changedFiles);
+      reviewerResults.push({
+        name: reviewer.name,
+        passed: result.passed,
+        output: result.output,
+        exitCode: result.exitCode
       });
-      await proc.exited;
+      if (!result.passed) {
+        anyFailed = true;
+      }
     } catch (error48) {
-      const logger = getSafeLogger();
-      logger?.warn("worktree", "Failed to abort merge", {
-        error: errorMessage(error48)
+      const errorMsg = error48 instanceof Error ? error48.message : String(error48);
+      reviewerResults.push({
+        name: reviewer.name,
+        passed: false,
+        output: "",
+        error: errorMsg
       });
+      anyFailed = true;
     }
   }
+  return { runStartRef, changedFiles, reviewerResults, anyFailed };
 }
-var _mergeDeps;
-var init_merge = __esm(() => {
-  init_logger2();
-  init_bun_deps();
-  _mergeDeps = {
-    spawn
-  };
+var _deferredReviewDeps;
+var init_deferred_review = __esm(() => {
+  _deferredReviewDeps = { spawn: spawn5 };
 });
 
-// src/execution/parallel-worker.ts
-async function executeStoryInWorktree(story, worktreePath, context, routing, eventEmitter) {
+// src/execution/executor-types.ts
+function buildPreviewRouting(story, config2) {
+  const cached2 = story.routing;
+  const defaultComplexity = "medium";
+  const defaultTier = "balanced";
+  const defaultStrategy = "test-after";
+  return {
+    complexity: cached2?.complexity ?? defaultComplexity,
+    modelTier: cached2?.modelTier ?? config2.autoMode.complexityRouting?.[defaultComplexity] ?? defaultTier,
+    testStrategy: cached2?.testStrategy ?? defaultStrategy,
+    reasoning: cached2 ? "cached from story.routing" : "preview (pending pipeline routing stage)"
+  };
+}
+
+// src/execution/dry-run.ts
+async function handleDryRun(ctx) {
   const logger = getSafeLogger();
-  try {
-    const pipelineContext = {
-      ...context,
-      effectiveConfig: context.effectiveConfig ?? context.config,
-      story,
-      stories: [story],
-      workdir: worktreePath,
-      routing
-    };
-    logger?.debug("parallel", "Executing story in worktree", {
-      storyId: story.id,
-      worktreePath
+  ctx.statusWriter.setPrd(ctx.prd);
+  ctx.statusWriter.setCurrentStory({
+    storyId: ctx.storiesToExecute[0].id,
+    title: ctx.storiesToExecute[0].title,
+    complexity: ctx.routing.complexity,
+    tddStrategy: ctx.routing.testStrategy,
+    model: ctx.routing.modelTier,
+    attempt: (ctx.storiesToExecute[0].attempts ?? 0) + 1,
+    phase: "routing"
+  });
+  await ctx.statusWriter.update(ctx.totalCost, ctx.iterations);
+  for (const s of ctx.storiesToExecute) {
+    logger?.info("execution", "[DRY RUN] Would execute agent here", {
+      storyId: s.id,
+      storyTitle: s.title,
+      modelTier: ctx.routing.modelTier,
+      complexity: ctx.routing.complexity,
+      testStrategy: ctx.routing.testStrategy
     });
-    const result = await runPipeline(defaultPipeline, pipelineContext, eventEmitter);
-    return {
-      success: result.success,
-      cost: result.context.agentResult?.estimatedCost || 0,
-      error: result.success ? undefined : result.reason
-    };
-  } catch (error48) {
-    return {
-      success: false,
-      cost: 0,
-      error: errorMessage(error48)
-    };
   }
-}
-async function executeParallelBatch(stories, projectRoot, config2, context, worktreePaths, maxConcurrency, eventEmitter, storyEffectiveConfigs) {
-  const logger = getSafeLogger();
-  const results = {
-    pipelinePassed: [],
-    merged: [],
-    failed: [],
-    totalCost: 0,
-    mergeConflicts: [],
-    storyCosts: new Map
-  };
-  const executing = new Set;
-  for (const story of stories) {
-    const worktreePath = worktreePaths.get(story.id);
-    if (!worktreePath) {
-      results.failed.push({
-        story,
-        error: "Worktree not created"
-      });
-      continue;
-    }
-    const routing = routeTask(story.title, story.description, story.acceptanceCriteria, story.tags, config2);
-    const storyConfig = storyEffectiveConfigs?.get(story.id);
-    const storyContext = storyConfig ? { ...context, effectiveConfig: storyConfig } : context;
-    const executePromise = executeStoryInWorktree(story, worktreePath, storyContext, routing, eventEmitter).then((result) => {
-      results.totalCost += result.cost;
-      results.storyCosts.set(story.id, result.cost);
-      if (result.success) {
-        results.pipelinePassed.push(story);
-        logger?.info("parallel", "Story execution succeeded", {
-          storyId: story.id,
-          cost: result.cost
-        });
-      } else {
-        results.failed.push({ story, error: result.error || "Unknown error" });
-        logger?.error("parallel", "Story execution failed", {
-          storyId: story.id,
-          error: result.error
-        });
-      }
-    }).finally(() => {
-      executing.delete(executePromise);
+  for (const s of ctx.storiesToExecute) {
+    markStoryPassed(ctx.prd, s.id);
+  }
+  await savePRD(ctx.prd, ctx.prdPath);
+  for (const s of ctx.storiesToExecute) {
+    pipelineEventBus.emit({
+      type: "story:completed",
+      storyId: s.id,
+      story: s,
+      passed: true,
+      runElapsedMs: 0,
+      cost: 0,
+      modelTier: ctx.routing.modelTier,
+      testStrategy: ctx.routing.testStrategy
     });
-    executing.add(executePromise);
-    if (executing.size >= maxConcurrency) {
-      await Promise.race(executing);
-    }
   }
-  await Promise.all(executing);
-  return results;
+  ctx.statusWriter.setPrd(ctx.prd);
+  ctx.statusWriter.setCurrentStory(null);
+  await ctx.statusWriter.update(ctx.totalCost, ctx.iterations);
+  return { storiesCompletedDelta: ctx.storiesToExecute.length, prdDirty: true };
 }
-var init_parallel_worker = __esm(() => {
+var init_dry_run = __esm(() => {
   init_logger2();
-  init_runner();
-  init_stages();
-  init_routing();
+  init_event_bus();
+  init_prd();
 });
 
-// src/execution/parallel-coordinator.ts
-import { existsSync as existsSync33, symlinkSync as symlinkSync2 } from "fs";
-import os3 from "os";
-import { join as join48 } from "path";
-function groupStoriesByDependencies(stories) {
-  const batches = [];
-  const processed = new Set;
-  const storyMap = new Map(stories.map((s) => [s.id, s]));
-  while (processed.size < stories.length) {
-    const batch = [];
-    for (const story of stories) {
-      if (processed.has(story.id))
-        continue;
-      const depsCompleted = story.dependencies.every((dep) => processed.has(dep) || !storyMap.has(dep));
-      if (depsCompleted) {
-        batch.push(story);
-      }
-    }
-    if (batch.length === 0) {
-      const remaining = stories.filter((s) => !processed.has(s.id));
-      const logger = getSafeLogger();
-      logger?.error("parallel", "Cannot resolve story dependencies", {
-        remainingStories: remaining.map((s) => s.id)
-      });
-      throw new Error("Circular dependency or missing dependency detected");
-    }
-    for (const story of batch) {
-      processed.add(story.id);
+// src/execution/escalation/tier-outcome.ts
+async function handleNoTierAvailable(ctx, failureCategory) {
+  const logger = getSafeLogger();
+  const outcome = resolveMaxAttemptsOutcome(failureCategory);
+  if (outcome === "pause") {
+    const pausedPrd = { ...ctx.prd };
+    markStoryPaused(pausedPrd, ctx.story.id);
+    await savePRD(pausedPrd, ctx.prdPath);
+    logger?.warn("execution", "Story paused - no tier available (needs human review)", {
+      storyId: ctx.story.id,
+      failureCategory
+    });
+    if (ctx.featureDir) {
+      await appendProgress(ctx.featureDir, ctx.story.id, "paused", `${ctx.story.title} \u2014 Execution stopped (needs human review)`);
     }
-    batches.push(batch);
-  }
-  return batches;
-}
-function buildDependencyMap(stories) {
-  const deps = {};
-  for (const story of stories) {
-    deps[story.id] = story.dependencies;
+    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 };
   }
-  return deps;
-}
-function resolveMaxConcurrency(parallel) {
-  if (parallel === 0) {
-    return os3.cpus().length;
+  const failedPrd = { ...ctx.prd };
+  markStoryFailed(failedPrd, ctx.story.id, failureCategory, undefined);
+  await savePRD(failedPrd, ctx.prdPath);
+  logger?.error("execution", "Story failed - execution failed", {
+    storyId: ctx.story.id
+  });
+  if (ctx.featureDir) {
+    await appendProgress(ctx.featureDir, ctx.story.id, "failed", `${ctx.story.title} \u2014 Execution failed`);
   }
-  return Math.max(1, parallel);
+  pipelineEventBus.emit({
+    type: "story:failed",
+    storyId: ctx.story.id,
+    story: ctx.story,
+    reason: "Execution failed",
+    countsTowardEscalation: true
+  });
+  return { outcome: "failed", prdDirty: true, prd: failedPrd };
 }
-async function executeParallel(stories, prdPath, projectRoot, config2, hooks, plugins, prd, featureDir, parallel, eventEmitter, agentGetFn, pidRegistry, interactionChain) {
+async function handleMaxAttemptsReached(ctx, failureCategory) {
   const logger = getSafeLogger();
-  const maxConcurrency = resolveMaxConcurrency(parallel);
-  const worktreeManager = new WorktreeManager;
-  const mergeEngine = new MergeEngine(worktreeManager);
-  logger?.info("parallel", "Starting parallel execution", {
-    totalStories: stories.length,
-    maxConcurrency
-  });
-  const batches = groupStoriesByDependencies(stories);
-  logger?.info("parallel", "Grouped stories into batches", {
-    batchCount: batches.length,
-    batches: batches.map((b, i) => ({ index: i, storyCount: b.length, storyIds: b.map((s) => s.id) }))
-  });
-  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}`, {
-      storyCount: batch.length,
-      storyIds: batch.map((s) => s.id)
+  const outcome = resolveMaxAttemptsOutcome(failureCategory);
+  if (outcome === "pause") {
+    const pausedPrd = { ...ctx.prd };
+    markStoryPaused(pausedPrd, ctx.story.id);
+    await savePRD(pausedPrd, ctx.prdPath);
+    logger?.warn("execution", "Story paused - max attempts reached (needs human review)", {
+      storyId: ctx.story.id,
+      failureCategory
     });
-    const baseContext = {
-      config: config2,
-      effectiveConfig: config2,
-      prd: currentPrd,
-      featureDir,
-      hooks,
-      plugins,
-      storyStartTime: new Date().toISOString(),
-      agentGetFn,
-      pidRegistry,
-      interaction: interactionChain ?? undefined
-    };
-    const worktreePaths = new Map;
-    const storyEffectiveConfigs = new Map;
-    for (const story of batch) {
-      const worktreePath = join48(projectRoot, ".nax-wt", story.id);
-      try {
-        await worktreeManager.create(projectRoot, story.id);
-        worktreePaths.set(story.id, worktreePath);
-        logger?.info("parallel", "Created worktree for story", {
-          storyId: story.id,
-          worktreePath
-        });
-        if (story.workdir) {
-          const pkgNodeModulesSrc = join48(projectRoot, story.workdir, "node_modules");
-          const pkgNodeModulesDst = join48(worktreePath, story.workdir, "node_modules");
-          if (existsSync33(pkgNodeModulesSrc) && !existsSync33(pkgNodeModulesDst)) {
-            try {
-              symlinkSync2(pkgNodeModulesSrc, pkgNodeModulesDst, "dir");
-              logger?.debug("parallel", "Symlinked package node_modules", {
-                storyId: story.id,
-                src: pkgNodeModulesSrc
-              });
-            } catch (symlinkError) {
-              logger?.warn("parallel", "Failed to symlink package node_modules \u2014 test runner may not find deps", {
-                storyId: story.id,
-                error: errorMessage(symlinkError)
-              });
-            }
-          }
-        }
-        const rootConfigPath = join48(projectRoot, ".nax", "config.json");
-        const effectiveConfig = story.workdir ? await loadConfigForWorkdir(rootConfigPath, story.workdir) : config2;
-        storyEffectiveConfigs.set(story.id, effectiveConfig);
-      } catch (error48) {
-        markStoryFailed(currentPrd, story.id, undefined, undefined);
-        logger?.error("parallel", "Failed to create worktree", {
-          storyId: story.id,
-          error: errorMessage(error48)
-        });
-      }
-    }
-    const batchResult = await executeParallelBatch(batch, projectRoot, config2, baseContext, worktreePaths, maxConcurrency, eventEmitter, storyEffectiveConfigs);
-    totalCost += batchResult.totalCost;
-    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
-      });
-      const mergeResults = await mergeEngine.mergeAll(projectRoot, successfulIds, deps);
-      for (const mergeResult of mergeResults) {
-        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, undefined, undefined);
-          batchResult.mergeConflicts.push({
-            storyId: mergeResult.storyId,
-            conflictFiles: mergeResult.conflictFiles || [],
-            originalCost: batchResult.storyCosts.get(mergeResult.storyId) ?? 0
-          });
-          logger?.error("parallel", "Merge conflict", {
-            storyId: mergeResult.storyId,
-            conflictFiles: mergeResult.conflictFiles
-          });
-          logger?.warn("parallel", "Worktree preserved for manual conflict resolution", {
-            storyId: mergeResult.storyId,
-            worktreePath: join48(projectRoot, ".nax-wt", mergeResult.storyId)
-          });
-        }
-      }
-    }
-    for (const { story, error: error48 } of batchResult.failed) {
-      markStoryFailed(currentPrd, story.id, undefined, undefined);
-      logger?.error("parallel", "Cleaning up failed story worktree", {
-        storyId: story.id,
-        error: error48
-      });
-      try {
-        await worktreeManager.remove(projectRoot, story.id);
-      } catch (cleanupError) {
-        logger?.warn("parallel", "Failed to clean up worktree", {
-          storyId: story.id,
-          error: cleanupError instanceof Error ? cleanupError.message : String(cleanupError)
-        });
-      }
+    if (ctx.featureDir) {
+      await appendProgress(ctx.featureDir, ctx.story.id, "paused", `${ctx.story.title} \u2014 Max attempts reached (needs human review)`);
     }
-    await savePRD(currentPrd, prdPath);
-    allMergeConflicts.push(...batchResult.mergeConflicts);
-    logger?.info("parallel", `Batch ${batchIndex + 1} complete`, {
-      pipelinePassed: batchResult.pipelinePassed.length,
-      merged: batchResult.merged.length,
-      failed: batchResult.failed.length,
-      mergeConflicts: batchResult.mergeConflicts.length,
-      batchCost: batchResult.totalCost
+    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 };
   }
-  logger?.info("parallel", "Parallel execution complete", {
-    storiesCompleted,
-    totalCost
+  const failedPrd = { ...ctx.prd };
+  markStoryFailed(failedPrd, ctx.story.id, failureCategory, undefined);
+  await savePRD(failedPrd, ctx.prdPath);
+  logger?.error("execution", "Story failed - max attempts reached", {
+    storyId: ctx.story.id,
+    failureCategory
+  });
+  if (ctx.featureDir) {
+    await appendProgress(ctx.featureDir, ctx.story.id, "failed", `${ctx.story.title} \u2014 Max attempts reached`);
+  }
+  pipelineEventBus.emit({
+    type: "story:failed",
+    storyId: ctx.story.id,
+    story: ctx.story,
+    reason: "Max attempts reached",
+    countsTowardEscalation: true
   });
-  return { storiesCompleted, totalCost, updatedPrd: currentPrd, mergeConflicts: allMergeConflicts };
+  return { outcome: "failed", prdDirty: true, prd: failedPrd };
 }
-var init_parallel_coordinator = __esm(() => {
-  init_loader();
+var init_tier_outcome = __esm(() => {
   init_logger2();
+  init_event_bus();
   init_prd();
-  init_manager();
-  init_merge();
-  init_parallel_worker();
-});
-
-// src/execution/parallel.ts
-var init_parallel = __esm(() => {
-  init_parallel_coordinator();
+  init_progress();
+  init_tier_escalation();
 });
 
-// src/execution/parallel-executor-rectify.ts
-var exports_parallel_executor_rectify = {};
-__export(exports_parallel_executor_rectify, {
-  rectifyConflictedStory: () => rectifyConflictedStory
-});
-import path15 from "path";
-async function rectifyConflictedStory(options) {
-  const { storyId, workdir, config: config2, hooks, pluginRegistry, prd, eventEmitter, agentGetFn } = 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,
-      effectiveConfig: config2,
-      prd,
-      story,
-      stories: [story],
-      workdir: worktreePath,
-      featureDir: undefined,
-      hooks,
-      plugins: pluginRegistry,
-      storyStartTime: new Date().toISOString(),
-      routing,
-      agentGetFn
-    };
-    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: errorMessage(error48)
-    });
-    return { success: false, storyId, cost: 0, finalConflict: false, pipelineFailure: true };
+// src/execution/escalation/tier-escalation.ts
+function buildEscalationFailure(story, currentTier, reviewFindings, cost) {
+  const stage = reviewFindings && reviewFindings.length > 0 ? "review" : "escalation";
+  return {
+    attempt: (story.attempts ?? 0) + 1,
+    modelTier: currentTier,
+    stage,
+    summary: `Failed with tier ${currentTier}, escalating to next tier`,
+    reviewFindings: reviewFindings && reviewFindings.length > 0 ? reviewFindings : undefined,
+    cost: cost ?? 0,
+    timestamp: new Date().toISOString()
+  };
+}
+function resolveMaxAttemptsOutcome(failureCategory) {
+  if (!failureCategory) {
+    return "fail";
+  }
+  switch (failureCategory) {
+    case "isolation-violation":
+    case "verifier-rejected":
+    case "greenfield-no-tests":
+      return "pause";
+    case "runtime-crash":
+      return "pause";
+    case "session-failure":
+    case "tests-failing":
+      return "fail";
+    default:
+      return "fail";
   }
 }
-var init_parallel_executor_rectify = __esm(() => {
-  init_logger2();
-});
-
-// src/execution/parallel-executor-rectification-pass.ts
-async function runRectificationPass(conflictedStories, options, prd, rectifyConflictedStory2) {
+function shouldRetrySameTier(verifyResult) {
+  return verifyResult?.status === "RUNTIME_CRASH";
+}
+async function handleTierEscalation(ctx) {
   const logger = getSafeLogger();
-  const { workdir, config: config2, hooks, pluginRegistry, eventEmitter, agentGetFn } = options;
-  const rectify = rectifyConflictedStory2 || (async (opts) => {
-    const { rectifyConflictedStory: importedRectify } = await Promise.resolve().then(() => (init_parallel_executor_rectify(), exports_parallel_executor_rectify));
-    return importedRectify(opts);
-  });
-  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 rectify({
-      ...conflictInfo,
-      workdir,
-      config: config2,
-      hooks,
-      pluginRegistry,
-      prd,
-      eventEmitter,
-      agentGetFn
+  if (shouldRetrySameTier(ctx.verifyResult)) {
+    logger?.warn("escalation", "Runtime crash detected \u2014 retrying same tier (transient, not a code issue)", {
+      storyId: ctx.story.id
     });
-    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
+    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];
+  const escalateRetryAsLite = ctx.pipelineResult.context.retryAsLite === true;
+  const escalateFailureCategory = ctx.pipelineResult.context.tddFailureCategory;
+  const escalateReviewFindings = ctx.pipelineResult.context.reviewFindings;
+  const escalateRetryAsTestAfter = escalateFailureCategory === "greenfield-no-tests";
+  const routingMode = ctx.config.routing.llm?.mode ?? "hybrid";
+  if (!nextTier || !ctx.config.autoMode.escalation.enabled) {
+    return await handleNoTierAvailable(ctx, escalateFailureCategory);
+  }
+  const maxAttempts = calculateMaxIterations(ctx.config.autoMode.escalation.tierOrder);
+  const canEscalate = storiesToEscalate.every((s) => (s.attempts ?? 0) < maxAttempts);
+  if (!canEscalate) {
+    return await handleMaxAttemptsReached(ctx, escalateFailureCategory);
+  }
+  for (const s of storiesToEscalate) {
+    const currentTestStrategy = s.routing?.testStrategy ?? ctx.routing.testStrategy;
+    const shouldSwitchToTestAfter = escalateRetryAsTestAfter && currentTestStrategy !== "test-after" && currentTestStrategy !== "no-test";
+    if (shouldSwitchToTestAfter) {
+      logger?.warn("escalation", "Switching strategy to test-after (greenfield-no-tests fallback)", {
+        storyId: s.id,
+        fromStrategy: currentTestStrategy,
+        toStrategy: "test-after"
       });
     } else {
-      const isFinalConflict = result.finalConflict === true;
-      if (isFinalConflict) {
-        stillConflictingCount++;
-      }
+      logger?.warn("escalation", "Escalating story to next tier", {
+        storyId: s.id,
+        nextTier,
+        retryAsLite: escalateRetryAsLite
+      });
     }
   }
-  logger?.info("parallel", "Rectification complete", {
-    rectified: rectifiedCount,
-    stillConflicting: stillConflictingCount
-  });
-  return { rectifiedCount, stillConflictingCount, additionalCost, updatedPrd: prd, rectificationMetrics };
+  const pipelineReason = ctx.pipelineResult.reason ? `: ${ctx.pipelineResult.reason}` : "";
+  const errorMessage2 = `Attempt ${ctx.story.attempts + 1} failed with model tier: ${ctx.routing.modelTier}${ctx.isBatchExecution ? " (in batch)" : ""}${pipelineReason}`;
+  const updatedPrd = {
+    ...ctx.prd,
+    userStories: ctx.prd.userStories.map((s) => {
+      const shouldEscalate = storiesToEscalate.some((story) => story.id === s.id);
+      if (!shouldEscalate)
+        return s;
+      const currentTestStrategy = s.routing?.testStrategy ?? ctx.routing.testStrategy;
+      const shouldSwitchToTestAfter = escalateRetryAsTestAfter && currentTestStrategy !== "test-after" && currentTestStrategy !== "no-test";
+      const baseRouting = s.routing ?? { ...ctx.routing };
+      const updatedRouting = {
+        ...baseRouting,
+        modelTier: shouldSwitchToTestAfter ? baseRouting.modelTier : nextTier,
+        ...escalateRetryAsLite ? { testStrategy: "three-session-tdd-lite" } : {},
+        ...shouldSwitchToTestAfter ? { testStrategy: "test-after" } : {}
+      };
+      const currentStoryTier = s.routing?.modelTier ?? ctx.routing.modelTier;
+      const isChangingTier = currentStoryTier !== nextTier;
+      const shouldResetAttempts = isChangingTier || shouldSwitchToTestAfter;
+      const escalationFailure = buildEscalationFailure(s, currentStoryTier, escalateReviewFindings, ctx.attemptCost);
+      return {
+        ...s,
+        attempts: shouldResetAttempts ? 0 : (s.attempts ?? 0) + 1,
+        routing: updatedRouting,
+        priorErrors: [...s.priorErrors || [], errorMessage2],
+        priorFailures: [...s.priorFailures || [], escalationFailure]
+      };
+    })
+  };
+  await _tierEscalationDeps.savePRD(updatedPrd, ctx.prdPath);
+  for (const story of storiesToEscalate) {
+    clearCacheForStory(story.id);
+  }
+  if (routingMode === "hybrid") {
+    await tryLlmBatchRoute(ctx.config, storiesToEscalate, "hybrid-re-route-pipeline");
+  }
+  return {
+    outcome: "escalated",
+    prdDirty: true,
+    prd: updatedPrd
+  };
 }
-var init_parallel_executor_rectification_pass = __esm(() => {
+var _tierEscalationDeps;
+var init_tier_escalation = __esm(() => {
+  init_hooks();
   init_logger2();
   init_prd();
+  init_routing();
+  init_llm();
+  init_escalation();
+  init_helpers();
+  init_progress();
+  init_tier_outcome();
+  _tierEscalationDeps = {
+    savePRD
+  };
 });
 
-// src/execution/lifecycle/parallel-lifecycle.ts
-var exports_parallel_lifecycle = {};
-__export(exports_parallel_lifecycle, {
-  handleParallelCompletion: () => handleParallelCompletion
+// src/execution/escalation/index.ts
+var init_escalation = __esm(() => {
+  init_tier_escalation();
 });
-async function handleParallelCompletion(options) {
+
+// src/execution/pipeline-result-handler.ts
+function filterOutputFiles(files) {
+  const NOISE = [
+    /\.test\.(ts|js|tsx|jsx)$/,
+    /\.spec\.(ts|js|tsx|jsx)$/,
+    /package-lock\.json$/,
+    /bun\.lock(b?)$/,
+    /\.gitignore$/,
+    /^nax\//
+  ];
+  return files.filter((f) => !NOISE.some((p) => p.test(f))).slice(0, 15);
+}
+async function handlePipelineSuccess(ctx, pipelineResult) {
   const logger = getSafeLogger();
-  const {
-    runId,
-    feature,
-    startedAt,
-    completedAt,
-    prd,
-    allStoryMetrics,
-    totalCost,
-    storiesCompleted,
-    durationMs,
-    workdir,
-    pluginRegistry
-  } = options;
-  const runMetrics = {
-    runId,
-    feature,
-    startedAt,
-    completedAt,
-    totalCost,
-    totalStories: allStoryMetrics.length,
-    storiesCompleted,
-    storiesFailed: countStories(prd).failed,
-    totalDurationMs: durationMs,
-    stories: allStoryMetrics
-  };
-  await saveRunMetrics(workdir, runMetrics);
-  const finalCounts = countStories(prd);
-  logger?.info("run.complete", "Feature execution completed", {
-    runId,
-    feature,
-    success: true,
-    totalStories: finalCounts.total,
-    storiesCompleted,
-    storiesFailed: finalCounts.failed,
-    storiesPending: finalCounts.pending,
-    totalCost,
-    durationMs
-  });
-  const reporters = pluginRegistry.getReporters();
-  for (const reporter of reporters) {
-    if (reporter.onRunEnd) {
+  const costDelta = pipelineResult.context.agentResult?.estimatedCost || 0;
+  const prd = ctx.prd;
+  if (pipelineResult.context.storyMetrics) {
+    ctx.allStoryMetrics.push(...pipelineResult.context.storyMetrics);
+  }
+  const storiesCompletedDelta = ctx.storiesToExecute.length;
+  for (const completedStory of ctx.storiesToExecute) {
+    const now = Date.now();
+    logger?.info("story.complete", "Story completed successfully", {
+      storyId: completedStory.id,
+      storyTitle: completedStory.title,
+      totalCost: ctx.totalCost + costDelta,
+      runElapsedMs: now - ctx.startTime,
+      storyDurationMs: ctx.storyStartTime ? now - ctx.storyStartTime : undefined
+    });
+  }
+  if (ctx.storyGitRef) {
+    for (const completedStory of ctx.storiesToExecute) {
       try {
-        await reporter.onRunEnd({
-          runId,
-          totalDurationMs: durationMs,
-          totalCost,
-          storySummary: {
-            completed: storiesCompleted,
-            failed: finalCounts.failed,
-            skipped: finalCounts.skipped,
-            paused: finalCounts.paused
-          }
+        const rawFiles = await captureOutputFiles(ctx.workdir, ctx.storyGitRef, completedStory.workdir);
+        const filtered = filterOutputFiles(rawFiles);
+        if (filtered.length > 0) {
+          completedStory.outputFiles = filtered;
+        }
+        const diffSummary = await captureDiffSummary(ctx.workdir, ctx.storyGitRef, completedStory.workdir);
+        if (diffSummary) {
+          completedStory.diffSummary = diffSummary;
+        }
+      } catch {}
+    }
+  }
+  const updatedCounts = countStories(prd);
+  logger?.info("progress", "Progress update", {
+    totalStories: updatedCounts.total,
+    passedStories: updatedCounts.passed,
+    failedStories: updatedCounts.failed,
+    pendingStories: updatedCounts.pending,
+    totalCost: ctx.totalCost + costDelta,
+    costLimit: ctx.config.execution.costLimit,
+    elapsedMs: Date.now() - ctx.startTime,
+    storyDurationMs: ctx.storyStartTime ? Date.now() - ctx.storyStartTime : undefined
+  });
+  return { storiesCompletedDelta, costDelta, prd, prdDirty: true };
+}
+async function handlePipelineFailure(ctx, pipelineResult) {
+  const logger = getSafeLogger();
+  let prd = ctx.prd;
+  let prdDirty = false;
+  const costDelta = pipelineResult.context.agentResult?.estimatedCost || 0;
+  switch (pipelineResult.finalAction) {
+    case "pause":
+      markStoryPaused(prd, ctx.story.id);
+      await savePRD(prd, ctx.prdPath);
+      prdDirty = true;
+      logger?.warn("pipeline", "Story paused", { storyId: ctx.story.id, reason: pipelineResult.reason });
+      pipelineEventBus.emit({
+        type: "story:paused",
+        storyId: ctx.story.id,
+        reason: pipelineResult.reason || "Pipeline paused",
+        cost: ctx.totalCost
+      });
+      break;
+    case "skip":
+      logger?.warn("pipeline", "Story skipped", { storyId: ctx.story.id, reason: pipelineResult.reason });
+      prdDirty = true;
+      break;
+    case "fail":
+      markStoryFailed(prd, ctx.story.id, pipelineResult.context.tddFailureCategory, pipelineResult.stoppedAtStage);
+      await savePRD(prd, ctx.prdPath);
+      prdDirty = true;
+      logger?.error("pipeline", "Story failed", { storyId: ctx.story.id, reason: pipelineResult.reason });
+      if (ctx.featureDir) {
+        await appendProgress(ctx.featureDir, ctx.story.id, "failed", `${ctx.story.title} \u2014 ${pipelineResult.reason}`);
+      }
+      pipelineEventBus.emit({
+        type: "story:failed",
+        storyId: ctx.story.id,
+        story: ctx.story,
+        reason: pipelineResult.reason || "Pipeline failed",
+        countsTowardEscalation: true,
+        feature: ctx.feature,
+        attempts: ctx.story.attempts
+      });
+      if (ctx.story.attempts !== undefined && ctx.story.attempts >= ctx.config.execution.rectification.maxRetries) {
+        await pipelineEventBus.emitAsync({
+          type: "human-review:requested",
+          storyId: ctx.story.id,
+          reason: pipelineResult.reason || "Max retries exceeded",
+          feature: ctx.feature,
+          attempts: ctx.story.attempts
         });
-      } catch (error48) {
-        logger?.warn("plugins", `Reporter '${reporter.name}' onRunEnd failed`, { error: error48 });
       }
+      break;
+    case "escalate": {
+      const escalationResult = await handleTierEscalation({
+        story: ctx.story,
+        storiesToExecute: ctx.storiesToExecute,
+        isBatchExecution: ctx.isBatchExecution,
+        routing: ctx.routing,
+        pipelineResult,
+        config: ctx.config,
+        prd,
+        prdPath: ctx.prdPath,
+        featureDir: ctx.featureDir,
+        hooks: ctx.hooks,
+        feature: ctx.feature,
+        totalCost: ctx.totalCost,
+        workdir: ctx.workdir,
+        attemptCost: pipelineResult.context.agentResult?.estimatedCost || 0
+      });
+      prd = escalationResult.prd;
+      prdDirty = escalationResult.prdDirty;
+      break;
     }
   }
+  return { prd, prdDirty, costDelta };
 }
-var init_parallel_lifecycle = __esm(() => {
+var init_pipeline_result_handler = __esm(() => {
   init_logger2();
-  init_metrics();
+  init_event_bus();
   init_prd();
+  init_git();
+  init_escalation();
+  init_progress();
 });
 
-// src/execution/parallel-executor.ts
-var exports_parallel_executor = {};
-__export(exports_parallel_executor, {
-  runParallelExecution: () => runParallelExecution,
-  _parallelExecutorDeps: () => _parallelExecutorDeps
-});
-import * as os4 from "os";
-import path16 from "path";
-async function runParallelExecution(options, initialPrd) {
+// src/execution/iteration-runner.ts
+import { join as join49 } from "path";
+async function runIteration(ctx, prd, selection, iterations, totalCost, allStoryMetrics) {
   const logger = getSafeLogger();
-  const {
-    prdPath,
-    workdir,
-    config: config2,
-    hooks,
-    feature,
-    featureDir,
-    parallelCount,
-    eventEmitter,
-    statusWriter,
-    runId,
-    startedAt,
-    startTime,
-    pluginRegistry,
-    formatterMode,
-    headless
-  } = options;
-  let { totalCost, iterations, storiesCompleted, allStoryMetrics } = options;
-  let prd = initialPrd;
-  const readyStories = getAllReadyStories(prd);
-  if (readyStories.length === 0) {
-    logger?.info("parallel", "No stories ready for parallel execution");
-    return {
-      prd,
-      totalCost,
-      storiesCompleted,
-      completed: false,
-      storyMetrics: [],
-      rectificationStats: { rectified: 0, stillConflicting: 0 }
-    };
-  }
-  const maxConcurrency = parallelCount === 0 ? os4.cpus().length : Math.max(1, parallelCount);
-  logger?.info("parallel", "Starting parallel execution mode", {
-    totalStories: readyStories.length,
-    maxConcurrency
-  });
-  statusWriter.setPrd(prd);
-  await statusWriter.update(totalCost, iterations, {
-    parallel: {
-      enabled: true,
-      maxConcurrency,
-      activeStories: readyStories.map((s) => ({
-        storyId: s.id,
-        worktreePath: path16.join(workdir, ".nax-wt", s.id)
-      }))
-    }
-  });
-  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 _parallelExecutorDeps.executeParallel(readyStories, prdPath, workdir, config2, hooks, pluginRegistry, prd, featureDir, parallelCount, eventEmitter, options.agentGetFn, options.pidRegistry, options.interactionChain);
-    const batchDurationMs = Date.now() - batchStartMs;
-    const batchCompletedAt = new Date().toISOString();
-    prd = parallelResult.updatedPrd;
-    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: {
-        enabled: true,
-        maxConcurrency,
-        activeStories: []
-      }
-    });
-  } catch (error48) {
-    logger?.error("parallel", "Parallel execution failed", {
-      error: errorMessage(error48)
-    });
-    await statusWriter.update(totalCost, iterations, {
-      parallel: undefined
-    });
-    throw error48;
-  }
-  let rectificationStats = { rectified: 0, stillConflicting: 0 };
-  if (conflictedStories.length > 0) {
-    const rectResult = await runRectificationPass(conflictedStories, options, prd, _parallelExecutorDeps.rectifyConflictedStory);
-    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,
-      totalCost
-    });
-    await _parallelExecutorDeps.fireHook(hooks, "on-all-stories-complete", hookCtx(feature, { status: "passed", cost: totalCost }), workdir);
-    await _parallelExecutorDeps.fireHook(hooks, "on-complete", hookCtx(feature, { status: "complete", cost: totalCost }), workdir);
-    const durationMs = Date.now() - startTime;
-    const runCompletedAt = new Date().toISOString();
-    const { handleParallelCompletion: handleParallelCompletion2 } = await Promise.resolve().then(() => (init_parallel_lifecycle(), exports_parallel_lifecycle));
-    await handleParallelCompletion2({
-      runId,
-      feature,
-      startedAt,
-      completedAt: runCompletedAt,
+  const { story, storiesToExecute, routing, isBatchExecution } = selection;
+  if (ctx.dryRun) {
+    const dryRunResult = await handleDryRun({
       prd,
-      allStoryMetrics,
+      prdPath: ctx.prdPath,
+      storiesToExecute,
+      routing,
+      statusWriter: ctx.statusWriter,
+      pluginRegistry: ctx.pluginRegistry,
+      runId: ctx.runId,
       totalCost,
-      storiesCompleted,
-      durationMs,
-      workdir,
-      pluginRegistry
+      iterations
     });
-    const finalCounts = countStories(prd);
-    statusWriter.setPrd(prd);
-    statusWriter.setCurrentStory(null);
-    statusWriter.setRunStatus("completed");
-    await statusWriter.update(totalCost, iterations);
-    if (headless && formatterMode !== "json") {
-      const { outputRunFooter: outputRunFooter2 } = await Promise.resolve().then(() => (init_headless_formatter(), exports_headless_formatter));
-      outputRunFooter2({
-        finalCounts: {
-          total: finalCounts.total,
-          passed: finalCounts.passed,
-          failed: finalCounts.failed,
-          skipped: finalCounts.skipped
-        },
-        durationMs,
-        totalCost,
-        startedAt,
-        completedAt: runCompletedAt,
-        formatterMode
-      });
-    }
     return {
       prd,
-      totalCost,
-      storiesCompleted,
-      completed: true,
-      durationMs,
-      storyMetrics: batchStoryMetrics,
-      rectificationStats
+      storiesCompletedDelta: dryRunResult.storiesCompletedDelta,
+      costDelta: 0,
+      prdDirty: dryRunResult.prdDirty
     };
   }
-  return { prd, totalCost, storiesCompleted, completed: false, storyMetrics: batchStoryMetrics, rectificationStats };
-}
-var _parallelExecutorDeps;
-var init_parallel_executor = __esm(() => {
-  init_hooks();
-  init_logger2();
-  init_prd();
-  init_helpers();
-  init_parallel();
-  init_parallel_executor_rectification_pass();
-  init_parallel_executor_rectify();
-  _parallelExecutorDeps = {
-    fireHook,
-    executeParallel,
-    rectifyConflictedStory
+  const storyStartTime = Date.now();
+  let storyGitRef;
+  if (story.storyGitRef && await isGitRefValid(ctx.workdir, story.storyGitRef)) {
+    storyGitRef = story.storyGitRef;
+  } else {
+    storyGitRef = await captureGitRef(ctx.workdir);
+    if (storyGitRef) {
+      story.storyGitRef = storyGitRef;
+      await savePRD(prd, ctx.prdPath);
+    }
+  }
+  const accumulatedAttemptCost = (story.priorFailures || []).reduce((sum, f) => sum + (f.cost || 0), 0);
+  const effectiveConfig = story.workdir ? await _iterationRunnerDeps.loadConfigForWorkdir(join49(ctx.workdir, ".nax", "config.json"), story.workdir) : ctx.config;
+  const pipelineContext = {
+    config: ctx.config,
+    effectiveConfig,
+    prd,
+    story,
+    stories: storiesToExecute,
+    routing,
+    workdir: ctx.workdir,
+    prdPath: ctx.prdPath,
+    featureDir: ctx.featureDir,
+    hooks: ctx.hooks,
+    plugins: ctx.pluginRegistry,
+    storyStartTime: new Date().toISOString(),
+    storyGitRef: storyGitRef ?? undefined,
+    interaction: ctx.interactionChain ?? undefined,
+    agentGetFn: ctx.agentGetFn,
+    pidRegistry: ctx.pidRegistry,
+    accumulatedAttemptCost: accumulatedAttemptCost > 0 ? accumulatedAttemptCost : undefined
   };
-});
-
-// src/pipeline/subscribers/events-writer.ts
-import { appendFile as appendFile2, mkdir as mkdir2 } from "fs/promises";
-import { homedir as homedir5 } from "os";
-import { basename as basename5, join as join49 } from "path";
-function wireEventsWriter(bus, feature, runId, workdir) {
-  const logger = getSafeLogger();
-  const project = basename5(workdir);
-  const eventsDir = join49(homedir5(), ".nax", "events", project);
-  const eventsFile = join49(eventsDir, "events.jsonl");
-  let dirReady = false;
-  const write = (line) => {
-    return (async () => {
-      try {
-        if (!dirReady) {
-          await mkdir2(eventsDir, { recursive: true });
-          dirReady = true;
-        }
-        await appendFile2(eventsFile, `${JSON.stringify(line)}
-`);
-      } catch (err) {
-        logger?.warn("events-writer", "Failed to write event line (non-fatal)", {
-          event: line.event,
-          error: String(err)
-        });
-      }
-    })();
-  };
-  const unsubs = [];
-  unsubs.push(bus.on("run:started", (_ev) => {
-    return write({ ts: new Date().toISOString(), event: "run:started", runId, feature, project });
-  }));
-  unsubs.push(bus.on("story:started", (ev) => {
-    return write({
-      ts: new Date().toISOString(),
-      event: "story:started",
-      runId,
-      feature,
-      project,
-      storyId: ev.storyId
-    });
-  }));
-  unsubs.push(bus.on("story:completed", (ev) => {
-    return write({
-      ts: new Date().toISOString(),
-      event: "story:completed",
-      runId,
-      feature,
-      project,
-      storyId: ev.storyId
-    });
-  }));
-  unsubs.push(bus.on("story:decomposed", (ev) => {
-    return write({
-      ts: new Date().toISOString(),
-      event: "story:decomposed",
-      runId,
-      feature,
-      project,
-      storyId: ev.storyId,
-      data: { subStoryCount: ev.subStoryCount }
-    });
-  }));
-  unsubs.push(bus.on("story:failed", (ev) => {
-    return write({
-      ts: new Date().toISOString(),
-      event: "story:failed",
-      runId,
-      feature,
-      project,
-      storyId: ev.storyId
-    });
-  }));
-  unsubs.push(bus.on("run:completed", (_ev) => {
-    return write({ ts: new Date().toISOString(), event: "on-complete", runId, feature, project });
-  }));
-  unsubs.push(bus.on("run:paused", (ev) => {
-    return write({
-      ts: new Date().toISOString(),
-      event: "run:paused",
-      runId,
-      feature,
-      project,
-      ...ev.storyId !== undefined && { storyId: ev.storyId }
-    });
-  }));
-  return () => {
-    for (const u of unsubs)
-      u();
-  };
-}
-var init_events_writer = __esm(() => {
-  init_logger2();
-});
-
-// src/pipeline/subscribers/hooks.ts
-function wireHooks(bus, hooks, workdir, feature) {
-  const logger = getSafeLogger();
-  const safe = (name, fn) => {
-    return fn().catch((err) => logger?.warn("hooks-subscriber", `Hook "${name}" failed`, { error: String(err) })).catch(() => {});
-  };
-  const unsubs = [];
-  unsubs.push(bus.on("run:started", (ev) => {
-    return safe("on-start", () => fireHook(hooks, "on-start", hookCtx(feature, { status: "running" }), workdir));
-  }));
-  unsubs.push(bus.on("story:started", (ev) => {
-    return safe("on-story-start", () => fireHook(hooks, "on-story-start", hookCtx(feature, { storyId: ev.storyId, model: ev.modelTier, agent: ev.agent }), workdir));
-  }));
-  unsubs.push(bus.on("story:completed", (ev) => {
-    return safe("on-story-complete", () => fireHook(hooks, "on-story-complete", hookCtx(feature, { storyId: ev.storyId, status: "passed", cost: ev.cost }), workdir));
-  }));
-  unsubs.push(bus.on("story:decomposed", (ev) => {
-    return safe("on-story-complete (decomposed)", () => fireHook(hooks, "on-story-complete", hookCtx(feature, { storyId: ev.storyId, status: "decomposed", subStoryCount: ev.subStoryCount }), workdir));
-  }));
-  unsubs.push(bus.on("story:failed", (ev) => {
-    return safe("on-story-fail", () => fireHook(hooks, "on-story-fail", hookCtx(feature, { storyId: ev.storyId, status: "failed", reason: ev.reason }), workdir));
-  }));
-  unsubs.push(bus.on("story:paused", (ev) => {
-    return safe("on-pause (story)", () => fireHook(hooks, "on-pause", hookCtx(feature, { storyId: ev.storyId, reason: ev.reason, cost: ev.cost }), workdir));
-  }));
-  unsubs.push(bus.on("run:paused", (ev) => {
-    return safe("on-pause (run)", () => fireHook(hooks, "on-pause", hookCtx(feature, { storyId: ev.storyId, reason: ev.reason, cost: ev.cost }), workdir));
-  }));
-  unsubs.push(bus.on("run:completed", (ev) => {
-    return safe("on-complete", () => fireHook(hooks, "on-complete", hookCtx(feature, { status: "complete", cost: ev.totalCost ?? 0 }), workdir));
-  }));
-  unsubs.push(bus.on("run:resumed", (ev) => {
-    return safe("on-resume", () => fireHook(hooks, "on-resume", hookCtx(feature, { status: "running" }), workdir));
-  }));
-  unsubs.push(bus.on("story:completed", (ev) => {
-    return safe("on-session-end (completed)", () => fireHook(hooks, "on-session-end", hookCtx(feature, { storyId: ev.storyId, status: "passed" }), workdir));
-  }));
-  unsubs.push(bus.on("story:failed", (ev) => {
-    return safe("on-session-end (failed)", () => fireHook(hooks, "on-session-end", hookCtx(feature, { storyId: ev.storyId, status: "failed" }), workdir));
-  }));
-  unsubs.push(bus.on("run:errored", (ev) => {
-    return safe("on-error", () => fireHook(hooks, "on-error", hookCtx(feature, { reason: ev.reason }), workdir));
-  }));
-  return () => {
-    for (const u of unsubs)
-      u();
-  };
-}
-var init_hooks2 = __esm(() => {
-  init_story_context();
-  init_hooks();
-  init_logger2();
-});
-
-// src/pipeline/subscribers/interaction.ts
-function wireInteraction(bus, interactionChain, config2) {
-  const logger = getSafeLogger();
-  const unsubs = [];
-  if (interactionChain && isTriggerEnabled("human-review", config2)) {
-    unsubs.push(bus.on("human-review:requested", (ev) => {
-      executeTrigger("human-review", {
-        featureName: ev.feature ?? "",
-        storyId: ev.storyId,
-        iteration: ev.attempts ?? 0,
-        reason: ev.reason
-      }, config2, interactionChain).catch((err) => {
-        logger?.warn("interaction-subscriber", "human-review trigger failed", {
-          storyId: ev.storyId,
-          error: String(err)
-        });
-      });
-    }));
-  }
-  if (interactionChain && isTriggerEnabled("max-retries", config2)) {
-    unsubs.push(bus.on("story:failed", (ev) => {
-      if (!ev.countsTowardEscalation) {
-        return;
-      }
-      executeTrigger("max-retries", {
-        featureName: ev.feature ?? "",
-        storyId: ev.storyId,
-        iteration: ev.attempts ?? 0
-      }, config2, interactionChain).then((response) => {
-        if (response.action === "abort") {
-          logger?.warn("interaction-subscriber", "max-retries abort requested", {
-            storyId: ev.storyId
-          });
-        }
-      }).catch((err) => {
-        logger?.warn("interaction-subscriber", "max-retries trigger failed", {
-          storyId: ev.storyId,
-          error: String(err)
-        });
-      });
-    }));
-  }
-  return () => {
-    for (const u of unsubs)
-      u();
-  };
-}
-var init_interaction2 = __esm(() => {
-  init_triggers();
-  init_logger2();
-});
-
-// src/pipeline/subscribers/registry.ts
-import { mkdir as mkdir3, writeFile } from "fs/promises";
-import { homedir as homedir6 } from "os";
-import { basename as basename6, join as join50 } from "path";
-function wireRegistry(bus, feature, runId, workdir) {
-  const logger = getSafeLogger();
-  const project = basename6(workdir);
-  const runDir = join50(homedir6(), ".nax", "runs", `${project}-${feature}-${runId}`);
-  const metaFile = join50(runDir, "meta.json");
-  const unsub = bus.on("run:started", (_ev) => {
-    return (async () => {
-      try {
-        await mkdir3(runDir, { recursive: true });
-        const meta3 = {
-          runId,
-          project,
-          feature,
-          workdir,
-          statusPath: join50(workdir, ".nax", "features", feature, "status.json"),
-          eventsDir: join50(workdir, ".nax", "features", feature, "runs"),
-          registeredAt: new Date().toISOString()
-        };
-        await writeFile(metaFile, JSON.stringify(meta3, null, 2));
-      } catch (err) {
-        logger?.warn("registry-writer", "Failed to write meta.json (non-fatal)", {
-          path: metaFile,
-          error: String(err)
-        });
-      }
-    })();
-  });
-  return unsub;
-}
-var init_registry3 = __esm(() => {
-  init_logger2();
-});
-
-// src/pipeline/subscribers/reporters.ts
-function wireReporters(bus, pluginRegistry, runId, startTime) {
-  const logger = getSafeLogger();
-  const safe = (name, fn) => {
-    return fn().catch((err) => logger?.warn("reporters-subscriber", `Reporter "${name}" error`, { error: String(err) })).catch(() => {});
-  };
-  const unsubs = [];
-  unsubs.push(bus.on("run:started", (ev) => {
-    return safe("onRunStart", async () => {
-      const reporters = pluginRegistry.getReporters();
-      for (const r of reporters) {
-        if (r.onRunStart) {
-          try {
-            await r.onRunStart({
-              runId,
-              feature: ev.feature,
-              totalStories: ev.totalStories,
-              startTime: new Date(startTime).toISOString()
-            });
-          } catch (err) {
-            logger?.warn("plugins", `Reporter '${r.name}' onRunStart failed`, { error: err });
-          }
-        }
-      }
-    });
-  }));
-  unsubs.push(bus.on("story:completed", (ev) => {
-    return safe("onStoryComplete(completed)", async () => {
-      const reporters = pluginRegistry.getReporters();
-      for (const r of reporters) {
-        if (r.onStoryComplete) {
-          try {
-            await r.onStoryComplete({
-              runId,
-              storyId: ev.storyId,
-              status: "completed",
-              runElapsedMs: ev.runElapsedMs,
-              cost: ev.cost ?? 0,
-              tier: ev.modelTier ?? "balanced",
-              testStrategy: ev.testStrategy ?? "test-after"
-            });
-          } catch (err) {
-            logger?.warn("plugins", `Reporter '${r.name}' onStoryComplete failed`, { error: err });
-          }
-        }
-      }
-    });
-  }));
-  unsubs.push(bus.on("story:failed", (ev) => {
-    return safe("onStoryComplete(failed)", async () => {
-      const reporters = pluginRegistry.getReporters();
-      for (const r of reporters) {
-        if (r.onStoryComplete) {
-          try {
-            await r.onStoryComplete({
-              runId,
-              storyId: ev.storyId,
-              status: "failed",
-              runElapsedMs: Date.now() - startTime,
-              cost: 0,
-              tier: "balanced",
-              testStrategy: "test-after"
-            });
-          } catch (err) {
-            logger?.warn("plugins", `Reporter '${r.name}' onStoryComplete failed`, { error: err });
-          }
-        }
-      }
-    });
-  }));
-  unsubs.push(bus.on("story:paused", (ev) => {
-    return safe("onStoryComplete(paused)", async () => {
-      const reporters = pluginRegistry.getReporters();
-      for (const r of reporters) {
-        if (r.onStoryComplete) {
-          try {
-            await r.onStoryComplete({
-              runId,
-              storyId: ev.storyId,
-              status: "paused",
-              runElapsedMs: Date.now() - startTime,
-              cost: 0,
-              tier: "balanced",
-              testStrategy: "test-after"
-            });
-          } catch (err) {
-            logger?.warn("plugins", `Reporter '${r.name}' onStoryComplete failed`, { error: err });
-          }
-        }
-      }
-    });
-  }));
-  unsubs.push(bus.on("run:completed", (ev) => {
-    return safe("onRunEnd", async () => {
-      const reporters = pluginRegistry.getReporters();
-      for (const r of reporters) {
-        if (r.onRunEnd) {
-          try {
-            await r.onRunEnd({
-              runId,
-              totalDurationMs: Date.now() - startTime,
-              totalCost: ev.totalCost ?? 0,
-              storySummary: {
-                completed: ev.passedStories,
-                failed: ev.failedStories,
-                skipped: 0,
-                paused: 0
-              }
-            });
-          } catch (err) {
-            logger?.warn("plugins", `Reporter '${r.name}' onRunEnd failed`, { error: err });
-          }
-        }
-      }
-    });
-  }));
-  return () => {
-    for (const u of unsubs)
-      u();
-  };
-}
-var init_reporters = __esm(() => {
-  init_logger2();
-});
-
-// src/execution/deferred-review.ts
-var {spawn: spawn5 } = globalThis.Bun;
-async function captureRunStartRef(workdir) {
-  try {
-    const proc = _deferredReviewDeps.spawn({
-      cmd: ["git", "rev-parse", "HEAD"],
-      cwd: workdir,
-      stdout: "pipe",
-      stderr: "pipe"
-    });
-    const [, stdout] = await Promise.all([proc.exited, new Response(proc.stdout).text()]);
-    return stdout.trim();
-  } catch {
-    return "";
-  }
-}
-async function getChangedFilesForDeferred(workdir, baseRef) {
-  try {
-    const proc = _deferredReviewDeps.spawn({
-      cmd: ["git", "diff", "--name-only", `${baseRef}...HEAD`],
-      cwd: workdir,
-      stdout: "pipe",
-      stderr: "pipe"
-    });
-    const [, stdout] = await Promise.all([proc.exited, new Response(proc.stdout).text()]);
-    return stdout.trim().split(`
-`).filter(Boolean);
-  } catch {
-    return [];
-  }
-}
-async function runDeferredReview(workdir, reviewConfig, plugins, runStartRef) {
-  if (!reviewConfig || reviewConfig.pluginMode !== "deferred") {
-    return;
-  }
-  const reviewers = plugins.getReviewers();
-  if (reviewers.length === 0) {
-    return;
-  }
-  const changedFiles = await getChangedFilesForDeferred(workdir, runStartRef);
-  const reviewerResults = [];
-  let anyFailed = false;
-  for (const reviewer of reviewers) {
-    try {
-      const result = await reviewer.check(workdir, changedFiles);
-      reviewerResults.push({
-        name: reviewer.name,
-        passed: result.passed,
-        output: result.output,
-        exitCode: result.exitCode
-      });
-      if (!result.passed) {
-        anyFailed = true;
-      }
-    } catch (error48) {
-      const errorMsg = error48 instanceof Error ? error48.message : String(error48);
-      reviewerResults.push({
-        name: reviewer.name,
-        passed: false,
-        output: "",
-        error: errorMsg
-      });
-      anyFailed = true;
-    }
-  }
-  return { runStartRef, changedFiles, reviewerResults, anyFailed };
-}
-var _deferredReviewDeps;
-var init_deferred_review = __esm(() => {
-  _deferredReviewDeps = { spawn: spawn5 };
-});
-
-// src/execution/dry-run.ts
-async function handleDryRun(ctx) {
-  const logger = getSafeLogger();
-  ctx.statusWriter.setPrd(ctx.prd);
+  ctx.statusWriter.setPrd(prd);
   ctx.statusWriter.setCurrentStory({
-    storyId: ctx.storiesToExecute[0].id,
-    title: ctx.storiesToExecute[0].title,
-    complexity: ctx.routing.complexity,
-    tddStrategy: ctx.routing.testStrategy,
-    model: ctx.routing.modelTier,
-    attempt: (ctx.storiesToExecute[0].attempts ?? 0) + 1,
+    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(ctx.totalCost, ctx.iterations);
-  for (const s of ctx.storiesToExecute) {
-    logger?.info("execution", "[DRY RUN] Would execute agent here", {
-      storyId: s.id,
-      storyTitle: s.title,
-      modelTier: ctx.routing.modelTier,
-      complexity: ctx.routing.complexity,
-      testStrategy: ctx.routing.testStrategy
-    });
-  }
-  for (const s of ctx.storiesToExecute) {
-    markStoryPassed(ctx.prd, s.id);
-  }
-  await savePRD(ctx.prd, ctx.prdPath);
-  for (const s of ctx.storiesToExecute) {
-    pipelineEventBus.emit({
-      type: "story:completed",
-      storyId: s.id,
-      story: s,
-      passed: true,
-      runElapsedMs: 0,
-      cost: 0,
-      modelTier: ctx.routing.modelTier,
-      testStrategy: ctx.routing.testStrategy
-    });
+  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,
+    storyStartTime
+  };
+  if (pipelineResult.success) {
+    const r2 = await handlePipelineSuccess(handlerCtx, pipelineResult);
+    return {
+      prd: r2.prd,
+      storiesCompletedDelta: r2.storiesCompletedDelta,
+      costDelta: r2.costDelta,
+      prdDirty: r2.prdDirty,
+      finalAction: pipelineResult.finalAction
+    };
   }
-  ctx.statusWriter.setPrd(ctx.prd);
-  ctx.statusWriter.setCurrentStory(null);
-  await ctx.statusWriter.update(ctx.totalCost, ctx.iterations);
-  return { storiesCompletedDelta: ctx.storiesToExecute.length, prdDirty: true };
+  const r = await handlePipelineFailure(handlerCtx, pipelineResult);
+  return {
+    prd: r.prd,
+    storiesCompletedDelta: 0,
+    costDelta: r.costDelta,
+    prdDirty: r.prdDirty,
+    finalAction: pipelineResult.finalAction,
+    reason: pipelineResult.reason,
+    subStoryCount: pipelineResult.subStoryCount
+  };
 }
-var init_dry_run = __esm(() => {
+var _iterationRunnerDeps;
+var init_iteration_runner = __esm(() => {
+  init_loader();
   init_logger2();
-  init_event_bus();
+  init_runner();
+  init_stages();
   init_prd();
+  init_git();
+  init_dry_run();
+  init_pipeline_result_handler();
+  _iterationRunnerDeps = {
+    loadConfigForWorkdir
+  };
 });
 
-// src/execution/escalation/tier-outcome.ts
-async function handleNoTierAvailable(ctx, failureCategory) {
-  const logger = getSafeLogger();
-  const outcome = resolveMaxAttemptsOutcome(failureCategory);
-  if (outcome === "pause") {
-    const pausedPrd = { ...ctx.prd };
-    markStoryPaused(pausedPrd, ctx.story.id);
-    await savePRD(pausedPrd, ctx.prdPath);
-    logger?.warn("execution", "Story paused - no tier available (needs human review)", {
-      storyId: ctx.story.id,
-      failureCategory
-    });
-    if (ctx.featureDir) {
-      await appendProgress(ctx.featureDir, ctx.story.id, "paused", `${ctx.story.title} \u2014 Execution stopped (needs human review)`);
+// src/execution/story-selector.ts
+function selectNextStories(prd, config2, batchPlan, currentBatchIndex, lastStoryId, useBatch) {
+  if (useBatch && currentBatchIndex < batchPlan.length) {
+    const batch = batchPlan[currentBatchIndex];
+    const storiesToExecute = batch.stories.filter((s) => !s.passes && s.status !== "passed" && s.status !== "skipped" && s.status !== "blocked" && s.status !== "failed" && s.status !== "paused" && s.status !== "decomposed");
+    if (storiesToExecute.length === 0) {
+      return { selection: null, nextBatchIndex: currentBatchIndex + 1 };
     }
-    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 };
-  }
-  const failedPrd = { ...ctx.prd };
-  markStoryFailed(failedPrd, ctx.story.id, failureCategory, undefined);
-  await savePRD(failedPrd, ctx.prdPath);
-  logger?.error("execution", "Story failed - execution failed", {
-    storyId: ctx.story.id
-  });
-  if (ctx.featureDir) {
-    await appendProgress(ctx.featureDir, ctx.story.id, "failed", `${ctx.story.title} \u2014 Execution failed`);
+    const story2 = storiesToExecute[0];
+    return {
+      selection: {
+        story: story2,
+        storiesToExecute,
+        routing: buildPreviewRouting(story2, config2),
+        isBatchExecution: batch.isBatch && storiesToExecute.length > 1
+      },
+      nextBatchIndex: currentBatchIndex + 1
+    };
   }
-  pipelineEventBus.emit({
-    type: "story:failed",
-    storyId: ctx.story.id,
-    story: ctx.story,
-    reason: "Execution failed",
-    countsTowardEscalation: true
-  });
-  return { outcome: "failed", prdDirty: true, prd: failedPrd };
+  const story = getNextStory(prd, lastStoryId, config2.execution.rectification?.maxRetries ?? 2);
+  if (!story)
+    return null;
+  return {
+    selection: {
+      story,
+      storiesToExecute: [story],
+      routing: buildPreviewRouting(story, config2),
+      isBatchExecution: false
+    },
+    nextBatchIndex: currentBatchIndex
+  };
 }
-async function handleMaxAttemptsReached(ctx, failureCategory) {
-  const logger = getSafeLogger();
-  const outcome = resolveMaxAttemptsOutcome(failureCategory);
-  if (outcome === "pause") {
-    const pausedPrd = { ...ctx.prd };
-    markStoryPaused(pausedPrd, ctx.story.id);
-    await savePRD(pausedPrd, ctx.prdPath);
-    logger?.warn("execution", "Story paused - max attempts reached (needs human review)", {
-      storyId: ctx.story.id,
-      failureCategory
+function selectIndependentBatch(stories, maxCount) {
+  const storyMap = new Map(stories.map((s) => [s.id, s]));
+  const result = [];
+  for (const story of stories) {
+    if (result.length >= maxCount)
+      break;
+    if (story.passes || story.status === "passed" || story.status === "skipped" || story.status === "failed" || story.status === "paused" || story.status === "decomposed")
+      continue;
+    const allDepsFulfilled = story.dependencies.every((depId) => {
+      const dep = storyMap.get(depId);
+      if (!dep)
+        return true;
+      return dep.passes || dep.status === "passed";
     });
-    if (ctx.featureDir) {
-      await appendProgress(ctx.featureDir, ctx.story.id, "paused", `${ctx.story.title} \u2014 Max attempts reached (needs human review)`);
+    if (allDepsFulfilled) {
+      result.push(story);
     }
-    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 };
   }
-  const failedPrd = { ...ctx.prd };
-  markStoryFailed(failedPrd, ctx.story.id, failureCategory, undefined);
-  await savePRD(failedPrd, ctx.prdPath);
-  logger?.error("execution", "Story failed - max attempts reached", {
-    storyId: ctx.story.id,
-    failureCategory
-  });
-  if (ctx.featureDir) {
-    await appendProgress(ctx.featureDir, ctx.story.id, "failed", `${ctx.story.title} \u2014 Max attempts reached`);
-  }
-  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 };
+  return result;
 }
-var init_tier_outcome = __esm(() => {
+var init_story_selector = __esm(() => {
   init_logger2();
-  init_event_bus();
   init_prd();
-  init_progress();
-  init_tier_escalation();
 });
 
-// src/execution/escalation/tier-escalation.ts
-function buildEscalationFailure(story, currentTier, reviewFindings, cost) {
-  const stage = reviewFindings && reviewFindings.length > 0 ? "review" : "escalation";
-  return {
-    attempt: (story.attempts ?? 0) + 1,
-    modelTier: currentTier,
-    stage,
-    summary: `Failed with tier ${currentTier}, escalating to next tier`,
-    reviewFindings: reviewFindings && reviewFindings.length > 0 ? reviewFindings : undefined,
-    cost: cost ?? 0,
-    timestamp: new Date().toISOString()
-  };
-}
-function resolveMaxAttemptsOutcome(failureCategory) {
-  if (!failureCategory) {
-    return "fail";
-  }
-  switch (failureCategory) {
-    case "isolation-violation":
-    case "verifier-rejected":
-    case "greenfield-no-tests":
-      return "pause";
-    case "runtime-crash":
-      return "pause";
-    case "session-failure":
-    case "tests-failing":
-      return "fail";
-    default:
-      return "fail";
+// src/execution/parallel-worker.ts
+var exports_parallel_worker = {};
+__export(exports_parallel_worker, {
+  executeStoryInWorktree: () => executeStoryInWorktree,
+  executeParallelBatch: () => executeParallelBatch
+});
+async function executeStoryInWorktree(story, worktreePath, context, routing, eventEmitter) {
+  const logger = getSafeLogger();
+  try {
+    const pipelineContext = {
+      ...context,
+      effectiveConfig: context.effectiveConfig ?? context.config,
+      story,
+      stories: [story],
+      workdir: worktreePath,
+      routing
+    };
+    logger?.debug("parallel", "Executing story in worktree", {
+      storyId: story.id,
+      worktreePath
+    });
+    const result = await runPipeline(defaultPipeline, pipelineContext, eventEmitter);
+    return {
+      success: result.success,
+      cost: result.context.agentResult?.estimatedCost || 0,
+      error: result.success ? undefined : result.reason,
+      pipelineResult: result
+    };
+  } catch (error48) {
+    return {
+      success: false,
+      cost: 0,
+      error: errorMessage(error48)
+    };
   }
 }
-function shouldRetrySameTier(verifyResult) {
-  return verifyResult?.status === "RUNTIME_CRASH";
-}
-async function handleTierEscalation(ctx) {
+async function executeParallelBatch(stories, projectRoot, config2, context, worktreePaths, maxConcurrency, eventEmitter, storyEffectiveConfigs) {
   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
+  const results = {
+    pipelinePassed: [],
+    merged: [],
+    failed: [],
+    totalCost: 0,
+    mergeConflicts: [],
+    storyCosts: new Map
+  };
+  const executing = new Set;
+  for (const story of stories) {
+    const worktreePath = worktreePaths.get(story.id);
+    if (!worktreePath) {
+      results.failed.push({
+        story,
+        error: "Worktree not created"
+      });
+      continue;
+    }
+    const routing = routeTask(story.title, story.description, story.acceptanceCriteria, story.tags, config2);
+    const storyConfig = storyEffectiveConfigs?.get(story.id);
+    const storyContext = storyConfig ? { ...context, effectiveConfig: storyConfig } : context;
+    const executePromise = executeStoryInWorktree(story, worktreePath, storyContext, routing, eventEmitter).then((result) => {
+      results.totalCost += result.cost;
+      results.storyCosts.set(story.id, result.cost);
+      if (result.success) {
+        results.pipelinePassed.push(story);
+        logger?.info("parallel", "Story execution succeeded", {
+          storyId: story.id,
+          cost: result.cost
+        });
+      } else {
+        results.failed.push({ story, error: result.error || "Unknown error", pipelineResult: result.pipelineResult });
+        logger?.error("parallel", "Story execution failed", {
+          storyId: story.id,
+          error: result.error
+        });
+      }
+    }).finally(() => {
+      executing.delete(executePromise);
     });
-    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];
-  const escalateRetryAsLite = ctx.pipelineResult.context.retryAsLite === true;
-  const escalateFailureCategory = ctx.pipelineResult.context.tddFailureCategory;
-  const escalateReviewFindings = ctx.pipelineResult.context.reviewFindings;
-  const escalateRetryAsTestAfter = escalateFailureCategory === "greenfield-no-tests";
-  const routingMode = ctx.config.routing.llm?.mode ?? "hybrid";
-  if (!nextTier || !ctx.config.autoMode.escalation.enabled) {
-    return await handleNoTierAvailable(ctx, escalateFailureCategory);
+    executing.add(executePromise);
+    if (executing.size >= maxConcurrency) {
+      await Promise.race(executing);
+    }
   }
-  const maxAttempts = calculateMaxIterations(ctx.config.autoMode.escalation.tierOrder);
-  const canEscalate = storiesToEscalate.every((s) => (s.attempts ?? 0) < maxAttempts);
-  if (!canEscalate) {
-    return await handleMaxAttemptsReached(ctx, escalateFailureCategory);
+  await Promise.all(executing);
+  return results;
+}
+var init_parallel_worker = __esm(() => {
+  init_logger2();
+  init_runner();
+  init_stages();
+  init_routing();
+});
+
+// src/worktree/manager.ts
+var exports_manager = {};
+__export(exports_manager, {
+  _managerDeps: () => _managerDeps,
+  WorktreeManager: () => WorktreeManager
+});
+import { existsSync as existsSync32, symlinkSync } from "fs";
+import { join as join50 } from "path";
+
+class WorktreeManager {
+  async create(projectRoot, storyId) {
+    validateStoryId(storyId);
+    const worktreePath = join50(projectRoot, ".nax-wt", storyId);
+    const branchName = `nax/${storyId}`;
+    try {
+      const proc = _managerDeps.spawn(["git", "worktree", "add", worktreePath, "-b", branchName], {
+        cwd: projectRoot,
+        stdout: "pipe",
+        stderr: "pipe"
+      });
+      const exitCode = await proc.exited;
+      if (exitCode !== 0) {
+        const stderr = await new Response(proc.stderr).text();
+        throw new Error(`Failed to create worktree: ${stderr || "unknown error"}`);
+      }
+    } catch (error48) {
+      if (error48 instanceof Error) {
+        if (error48.message.includes("not a git repository")) {
+          throw new Error(`Not a git repository: ${projectRoot}`);
+        }
+        if (error48.message.includes("already exists")) {
+          throw new Error(`Worktree for story ${storyId} already exists at ${worktreePath}`);
+        }
+        throw error48;
+      }
+      throw new Error(`Failed to create worktree: ${String(error48)}`);
+    }
+    const nodeModulesSource = join50(projectRoot, "node_modules");
+    if (existsSync32(nodeModulesSource)) {
+      const nodeModulesTarget = join50(worktreePath, "node_modules");
+      try {
+        symlinkSync(nodeModulesSource, nodeModulesTarget, "dir");
+      } catch (error48) {
+        await this.remove(projectRoot, storyId);
+        throw new Error(`Failed to symlink node_modules: ${errorMessage(error48)}`);
+      }
+    }
+    const envSource = join50(projectRoot, ".env");
+    if (existsSync32(envSource)) {
+      const envTarget = join50(worktreePath, ".env");
+      try {
+        symlinkSync(envSource, envTarget, "file");
+      } catch (error48) {
+        await this.remove(projectRoot, storyId);
+        throw new Error(`Failed to symlink .env: ${errorMessage(error48)}`);
+      }
+    }
   }
-  for (const s of storiesToEscalate) {
-    const currentTestStrategy = s.routing?.testStrategy ?? ctx.routing.testStrategy;
-    const shouldSwitchToTestAfter = escalateRetryAsTestAfter && currentTestStrategy !== "test-after" && currentTestStrategy !== "no-test";
-    if (shouldSwitchToTestAfter) {
-      logger?.warn("escalation", "Switching strategy to test-after (greenfield-no-tests fallback)", {
-        storyId: s.id,
-        fromStrategy: currentTestStrategy,
-        toStrategy: "test-after"
+  async remove(projectRoot, storyId) {
+    validateStoryId(storyId);
+    const worktreePath = join50(projectRoot, ".nax-wt", storyId);
+    const branchName = `nax/${storyId}`;
+    try {
+      const proc = _managerDeps.spawn(["git", "worktree", "remove", worktreePath, "--force"], {
+        cwd: projectRoot,
+        stdout: "pipe",
+        stderr: "pipe"
       });
-    } else {
-      logger?.warn("escalation", "Escalating story to next tier", {
-        storyId: s.id,
-        nextTier,
-        retryAsLite: escalateRetryAsLite
+      const exitCode = await proc.exited;
+      if (exitCode !== 0) {
+        const stderr = await new Response(proc.stderr).text();
+        if (stderr.includes("not found") || stderr.includes("does not exist") || stderr.includes("no such worktree") || stderr.includes("is not a working tree")) {
+          throw new Error(`Worktree not found: ${worktreePath}`);
+        }
+        throw new Error(`Failed to remove worktree: ${stderr || "unknown error"}`);
+      }
+    } catch (error48) {
+      if (error48 instanceof Error) {
+        throw error48;
+      }
+      throw new Error(`Failed to remove worktree: ${String(error48)}`);
+    }
+    try {
+      const proc = _managerDeps.spawn(["git", "branch", "-D", branchName], {
+        cwd: projectRoot,
+        stdout: "pipe",
+        stderr: "pipe"
+      });
+      const exitCode = await proc.exited;
+      if (exitCode !== 0) {
+        const stderr = await new Response(proc.stderr).text();
+        if (!stderr.includes("not found")) {
+          const logger = getSafeLogger();
+          logger?.warn("worktree", `Failed to delete branch ${branchName}`, { stderr });
+        }
+      }
+    } catch (error48) {
+      const logger = getSafeLogger();
+      logger?.warn("worktree", `Failed to delete branch ${branchName}`, {
+        error: errorMessage(error48)
       });
     }
   }
-  const pipelineReason = ctx.pipelineResult.reason ? `: ${ctx.pipelineResult.reason}` : "";
-  const errorMessage2 = `Attempt ${ctx.story.attempts + 1} failed with model tier: ${ctx.routing.modelTier}${ctx.isBatchExecution ? " (in batch)" : ""}${pipelineReason}`;
-  const updatedPrd = {
-    ...ctx.prd,
-    userStories: ctx.prd.userStories.map((s) => {
-      const shouldEscalate = storiesToEscalate.some((story) => story.id === s.id);
-      if (!shouldEscalate)
-        return s;
-      const currentTestStrategy = s.routing?.testStrategy ?? ctx.routing.testStrategy;
-      const shouldSwitchToTestAfter = escalateRetryAsTestAfter && currentTestStrategy !== "test-after" && currentTestStrategy !== "no-test";
-      const baseRouting = s.routing ?? { ...ctx.routing };
-      const updatedRouting = {
-        ...baseRouting,
-        modelTier: shouldSwitchToTestAfter ? baseRouting.modelTier : nextTier,
-        ...escalateRetryAsLite ? { testStrategy: "three-session-tdd-lite" } : {},
-        ...shouldSwitchToTestAfter ? { testStrategy: "test-after" } : {}
-      };
-      const currentStoryTier = s.routing?.modelTier ?? ctx.routing.modelTier;
-      const isChangingTier = currentStoryTier !== nextTier;
-      const shouldResetAttempts = isChangingTier || shouldSwitchToTestAfter;
-      const escalationFailure = buildEscalationFailure(s, currentStoryTier, escalateReviewFindings, ctx.attemptCost);
-      return {
-        ...s,
-        attempts: shouldResetAttempts ? 0 : (s.attempts ?? 0) + 1,
-        routing: updatedRouting,
-        priorErrors: [...s.priorErrors || [], errorMessage2],
-        priorFailures: [...s.priorFailures || [], escalationFailure]
-      };
-    })
-  };
-  await _tierEscalationDeps.savePRD(updatedPrd, ctx.prdPath);
-  for (const story of storiesToEscalate) {
-    clearCacheForStory(story.id);
+  async list(projectRoot) {
+    try {
+      const proc = _managerDeps.spawn(["git", "worktree", "list", "--porcelain"], {
+        cwd: projectRoot,
+        stdout: "pipe",
+        stderr: "pipe"
+      });
+      const exitCode = await proc.exited;
+      if (exitCode !== 0) {
+        const stderr = await new Response(proc.stderr).text();
+        throw new Error(`Failed to list worktrees: ${stderr || "unknown error"}`);
+      }
+      const stdout = await new Response(proc.stdout).text();
+      return this.parseWorktreeList(stdout);
+    } catch (error48) {
+      if (error48 instanceof Error) {
+        throw error48;
+      }
+      throw new Error(`Failed to list worktrees: ${String(error48)}`);
+    }
   }
-  if (routingMode === "hybrid") {
-    await tryLlmBatchRoute(ctx.config, storiesToEscalate, "hybrid-re-route-pipeline");
+  parseWorktreeList(output) {
+    const worktrees = [];
+    const lines = output.trim().split(`
+`);
+    let currentWorktree = {};
+    for (const line of lines) {
+      if (line.startsWith("worktree ")) {
+        currentWorktree.path = line.substring("worktree ".length);
+      } else if (line.startsWith("branch ")) {
+        currentWorktree.branch = line.substring("branch ".length).replace("refs/heads/", "");
+      } else if (line === "") {
+        if (currentWorktree.path && currentWorktree.branch) {
+          worktrees.push(currentWorktree);
+        }
+        currentWorktree = {};
+      }
+    }
+    if (currentWorktree.path && currentWorktree.branch) {
+      worktrees.push(currentWorktree);
+    }
+    return worktrees;
   }
-  return {
-    outcome: "escalated",
-    prdDirty: true,
-    prd: updatedPrd
-  };
 }
-var _tierEscalationDeps;
-var init_tier_escalation = __esm(() => {
-  init_hooks();
+var _managerDeps;
+var init_manager = __esm(() => {
   init_logger2();
-  init_prd();
-  init_routing();
-  init_llm();
-  init_escalation();
-  init_helpers();
-  init_progress();
-  init_tier_outcome();
-  _tierEscalationDeps = {
-    savePRD
+  init_bun_deps();
+  _managerDeps = {
+    spawn
   };
 });
 
-// src/execution/escalation/index.ts
-var init_escalation = __esm(() => {
-  init_tier_escalation();
+// src/worktree/merge.ts
+var exports_merge = {};
+__export(exports_merge, {
+  _mergeDeps: () => _mergeDeps,
+  MergeEngine: () => MergeEngine
 });
 
-// src/execution/pipeline-result-handler.ts
-function filterOutputFiles(files) {
-  const NOISE = [
-    /\.test\.(ts|js|tsx|jsx)$/,
-    /\.spec\.(ts|js|tsx|jsx)$/,
-    /package-lock\.json$/,
-    /bun\.lock(b?)$/,
-    /\.gitignore$/,
-    /^nax\//
-  ];
-  return files.filter((f) => !NOISE.some((p) => p.test(f))).slice(0, 15);
-}
-async function handlePipelineSuccess(ctx, pipelineResult) {
-  const logger = getSafeLogger();
-  const costDelta = pipelineResult.context.agentResult?.estimatedCost || 0;
-  const prd = ctx.prd;
-  if (pipelineResult.context.storyMetrics) {
-    ctx.allStoryMetrics.push(...pipelineResult.context.storyMetrics);
+class MergeEngine {
+  worktreeManager;
+  constructor(worktreeManager) {
+    this.worktreeManager = worktreeManager;
   }
-  const storiesCompletedDelta = ctx.storiesToExecute.length;
-  for (const completedStory of ctx.storiesToExecute) {
-    const now = Date.now();
-    logger?.info("story.complete", "Story completed successfully", {
-      storyId: completedStory.id,
-      storyTitle: completedStory.title,
-      totalCost: ctx.totalCost + costDelta,
-      runElapsedMs: now - ctx.startTime,
-      storyDurationMs: ctx.storyStartTime ? now - ctx.storyStartTime : undefined
-    });
+  async merge(projectRoot, storyId) {
+    const branchName = `nax/${storyId}`;
+    try {
+      const mergeProc = _mergeDeps.spawn(["git", "merge", "--no-ff", branchName, "-m", `Merge branch '${branchName}'`], {
+        cwd: projectRoot,
+        stdout: "pipe",
+        stderr: "pipe"
+      });
+      const exitCode = await mergeProc.exited;
+      const stderr = await new Response(mergeProc.stderr).text();
+      const stdout = await new Response(mergeProc.stdout).text();
+      if (exitCode === 0) {
+        try {
+          await this.worktreeManager.remove(projectRoot, storyId);
+        } catch (error48) {
+          const logger = getSafeLogger();
+          logger?.warn("worktree", `Failed to cleanup worktree for ${storyId}`, {
+            error: errorMessage(error48)
+          });
+        }
+        return { success: true };
+      }
+      const output = `${stdout}
+${stderr}`;
+      if (output.includes("CONFLICT") || output.includes("conflict") || output.includes("Automatic merge failed")) {
+        const conflictFiles = await this.getConflictFiles(projectRoot);
+        await this.abortMerge(projectRoot);
+        return {
+          success: false,
+          conflictFiles
+        };
+      }
+      throw new Error(`Merge failed: ${stderr || stdout || "unknown error"}`);
+    } catch (error48) {
+      if (error48 instanceof Error) {
+        throw error48;
+      }
+      throw new Error(`Failed to merge branch ${branchName}: ${String(error48)}`);
+    }
   }
-  if (ctx.storyGitRef) {
-    for (const completedStory of ctx.storiesToExecute) {
-      try {
-        const rawFiles = await captureOutputFiles(ctx.workdir, ctx.storyGitRef, completedStory.workdir);
-        const filtered = filterOutputFiles(rawFiles);
-        if (filtered.length > 0) {
-          completedStory.outputFiles = filtered;
+  async mergeAll(projectRoot, storyIds, dependencies) {
+    const orderedStories = this.topologicalSort(storyIds, dependencies);
+    const results = [];
+    const failedStories = new Set;
+    for (const storyId of orderedStories) {
+      const deps = dependencies[storyId] || [];
+      const hasFailedDeps = deps.some((dep) => failedStories.has(dep));
+      if (hasFailedDeps) {
+        results.push({
+          success: false,
+          storyId,
+          conflictFiles: []
+        });
+        failedStories.add(storyId);
+        continue;
+      }
+      let result = await this.merge(projectRoot, storyId);
+      if (!result.success && result.conflictFiles) {
+        try {
+          await this.rebaseWorktree(projectRoot, storyId);
+          result = await this.merge(projectRoot, storyId);
+          if (!result.success) {
+            results.push({
+              success: false,
+              storyId,
+              conflictFiles: result.conflictFiles,
+              retryCount: 1
+            });
+            failedStories.add(storyId);
+            continue;
+          }
+          results.push({
+            success: true,
+            storyId,
+            retryCount: 1
+          });
+        } catch (error48) {
+          results.push({
+            success: false,
+            storyId,
+            conflictFiles: result.conflictFiles,
+            retryCount: 1
+          });
+          failedStories.add(storyId);
         }
-        const diffSummary = await captureDiffSummary(ctx.workdir, ctx.storyGitRef, completedStory.workdir);
-        if (diffSummary) {
-          completedStory.diffSummary = diffSummary;
+      } else if (result.success) {
+        results.push({
+          success: true,
+          storyId,
+          retryCount: 0
+        });
+      } else {
+        results.push({
+          success: false,
+          storyId,
+          retryCount: 0
+        });
+        failedStories.add(storyId);
+      }
+    }
+    return results;
+  }
+  topologicalSort(storyIds, dependencies) {
+    const visited = new Set;
+    const sorted = [];
+    const visiting = new Set;
+    const visit = (storyId) => {
+      if (visited.has(storyId)) {
+        return;
+      }
+      if (visiting.has(storyId)) {
+        throw new Error(`Circular dependency detected involving ${storyId}`);
+      }
+      visiting.add(storyId);
+      const deps = dependencies[storyId] || [];
+      for (const dep of deps) {
+        if (storyIds.includes(dep)) {
+          visit(dep);
         }
-      } catch {}
+      }
+      visiting.delete(storyId);
+      visited.add(storyId);
+      sorted.push(storyId);
+    };
+    for (const storyId of storyIds) {
+      visit(storyId);
     }
+    return sorted;
   }
-  const updatedCounts = countStories(prd);
-  logger?.info("progress", "Progress update", {
-    totalStories: updatedCounts.total,
-    passedStories: updatedCounts.passed,
-    failedStories: updatedCounts.failed,
-    pendingStories: updatedCounts.pending,
-    totalCost: ctx.totalCost + costDelta,
-    costLimit: ctx.config.execution.costLimit,
-    elapsedMs: Date.now() - ctx.startTime,
-    storyDurationMs: ctx.storyStartTime ? Date.now() - ctx.storyStartTime : undefined
-  });
-  return { storiesCompletedDelta, costDelta, prd, prdDirty: true };
-}
-async function handlePipelineFailure(ctx, pipelineResult) {
-  const logger = getSafeLogger();
-  let prd = ctx.prd;
-  let prdDirty = false;
-  const costDelta = pipelineResult.context.agentResult?.estimatedCost || 0;
-  switch (pipelineResult.finalAction) {
-    case "pause":
-      markStoryPaused(prd, ctx.story.id);
-      await savePRD(prd, ctx.prdPath);
-      prdDirty = true;
-      logger?.warn("pipeline", "Story paused", { storyId: ctx.story.id, reason: pipelineResult.reason });
-      pipelineEventBus.emit({
-        type: "story:paused",
-        storyId: ctx.story.id,
-        reason: pipelineResult.reason || "Pipeline paused",
-        cost: ctx.totalCost
+  async rebaseWorktree(projectRoot, storyId) {
+    const worktreePath = `${projectRoot}/.nax-wt/${storyId}`;
+    try {
+      const currentBranchProc = _mergeDeps.spawn(["git", "rev-parse", "--abbrev-ref", "HEAD"], {
+        cwd: projectRoot,
+        stdout: "pipe",
+        stderr: "pipe"
       });
-      break;
-    case "skip":
-      logger?.warn("pipeline", "Story skipped", { storyId: ctx.story.id, reason: pipelineResult.reason });
-      prdDirty = true;
-      break;
-    case "fail":
-      markStoryFailed(prd, ctx.story.id, pipelineResult.context.tddFailureCategory, pipelineResult.stoppedAtStage);
-      await savePRD(prd, ctx.prdPath);
-      prdDirty = true;
-      logger?.error("pipeline", "Story failed", { storyId: ctx.story.id, reason: pipelineResult.reason });
-      if (ctx.featureDir) {
-        await appendProgress(ctx.featureDir, ctx.story.id, "failed", `${ctx.story.title} \u2014 ${pipelineResult.reason}`);
+      const exitCode = await currentBranchProc.exited;
+      if (exitCode !== 0) {
+        throw new Error("Failed to get current branch");
       }
-      pipelineEventBus.emit({
-        type: "story:failed",
-        storyId: ctx.story.id,
-        story: ctx.story,
-        reason: pipelineResult.reason || "Pipeline failed",
-        countsTowardEscalation: true,
-        feature: ctx.feature,
-        attempts: ctx.story.attempts
+      const currentBranch = (await new Response(currentBranchProc.stdout).text()).trim();
+      const rebaseProc = _mergeDeps.spawn(["git", "rebase", currentBranch], {
+        cwd: worktreePath,
+        stdout: "pipe",
+        stderr: "pipe"
       });
-      if (ctx.story.attempts !== undefined && ctx.story.attempts >= ctx.config.execution.rectification.maxRetries) {
-        await pipelineEventBus.emitAsync({
-          type: "human-review:requested",
-          storyId: ctx.story.id,
-          reason: pipelineResult.reason || "Max retries exceeded",
-          feature: ctx.feature,
-          attempts: ctx.story.attempts
+      const rebaseExitCode = await rebaseProc.exited;
+      if (rebaseExitCode !== 0) {
+        const stderr = await new Response(rebaseProc.stderr).text();
+        const abortProc = _mergeDeps.spawn(["git", "rebase", "--abort"], {
+          cwd: worktreePath,
+          stdout: "pipe",
+          stderr: "pipe"
         });
+        await abortProc.exited;
+        throw new Error(`Rebase failed: ${stderr || "unknown error"}`);
       }
-      break;
-    case "escalate": {
-      const escalationResult = await handleTierEscalation({
-        story: ctx.story,
-        storiesToExecute: ctx.storiesToExecute,
-        isBatchExecution: ctx.isBatchExecution,
-        routing: ctx.routing,
-        pipelineResult,
-        config: ctx.config,
-        prd,
-        prdPath: ctx.prdPath,
-        featureDir: ctx.featureDir,
-        hooks: ctx.hooks,
-        feature: ctx.feature,
-        totalCost: ctx.totalCost,
-        workdir: ctx.workdir,
-        attemptCost: pipelineResult.context.agentResult?.estimatedCost || 0
+    } catch (error48) {
+      if (error48 instanceof Error) {
+        throw error48;
+      }
+      throw new Error(`Failed to rebase worktree ${storyId}: ${String(error48)}`);
+    }
+  }
+  async getConflictFiles(projectRoot) {
+    try {
+      const proc = _mergeDeps.spawn(["git", "diff", "--name-only", "--diff-filter=U"], {
+        cwd: projectRoot,
+        stdout: "pipe",
+        stderr: "pipe"
+      });
+      const exitCode = await proc.exited;
+      if (exitCode !== 0) {
+        return [];
+      }
+      const stdout = await new Response(proc.stdout).text();
+      return stdout.trim().split(`
+`).filter((line) => line.length > 0);
+    } catch {
+      return [];
+    }
+  }
+  async abortMerge(projectRoot) {
+    try {
+      const proc = _mergeDeps.spawn(["git", "merge", "--abort"], {
+        cwd: projectRoot,
+        stdout: "pipe",
+        stderr: "pipe"
+      });
+      await proc.exited;
+    } catch (error48) {
+      const logger = getSafeLogger();
+      logger?.warn("worktree", "Failed to abort merge", {
+        error: errorMessage(error48)
       });
-      prd = escalationResult.prd;
-      prdDirty = escalationResult.prdDirty;
-      break;
     }
   }
-  return { prd, prdDirty, costDelta };
 }
-var init_pipeline_result_handler = __esm(() => {
+var _mergeDeps;
+var init_merge = __esm(() => {
   init_logger2();
-  init_event_bus();
-  init_prd();
-  init_git();
-  init_escalation();
-  init_progress();
+  init_bun_deps();
+  _mergeDeps = {
+    spawn
+  };
 });
 
-// src/execution/iteration-runner.ts
-import { join as join51 } from "path";
-async function runIteration(ctx, prd, selection, iterations, totalCost, allStoryMetrics) {
+// src/execution/merge-conflict-rectify.ts
+var exports_merge_conflict_rectify = {};
+__export(exports_merge_conflict_rectify, {
+  rectifyConflictedStory: () => rectifyConflictedStory
+});
+import path15 from "path";
+async function rectifyConflictedStory(options) {
+  const { storyId, workdir, config: config2, hooks, pluginRegistry, prd, eventEmitter, agentGetFn } = options;
   const logger = getSafeLogger();
-  const { story, storiesToExecute, routing, isBatchExecution } = selection;
-  if (ctx.dryRun) {
-    const dryRunResult = await handleDryRun({
+  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,
+      effectiveConfig: config2,
       prd,
-      prdPath: ctx.prdPath,
-      storiesToExecute,
+      story,
+      stories: [story],
+      workdir: worktreePath,
+      featureDir: undefined,
+      hooks,
+      plugins: pluginRegistry,
+      storyStartTime: new Date().toISOString(),
       routing,
-      statusWriter: ctx.statusWriter,
-      pluginRegistry: ctx.pluginRegistry,
-      runId: ctx.runId,
-      totalCost,
-      iterations
-    });
-    return {
-      prd,
-      storiesCompletedDelta: dryRunResult.storiesCompletedDelta,
-      costDelta: 0,
-      prdDirty: dryRunResult.prdDirty
-    };
-  }
-  const storyStartTime = Date.now();
-  const storyGitRef = await captureGitRef(ctx.workdir);
-  const accumulatedAttemptCost = (story.priorFailures || []).reduce((sum, f) => sum + (f.cost || 0), 0);
-  const effectiveConfig = story.workdir ? await _iterationRunnerDeps.loadConfigForWorkdir(join51(ctx.workdir, ".nax", "config.json"), story.workdir) : ctx.config;
-  const pipelineContext = {
-    config: ctx.config,
-    effectiveConfig,
-    prd,
-    story,
-    stories: storiesToExecute,
-    routing,
-    workdir: ctx.workdir,
-    prdPath: ctx.prdPath,
-    featureDir: ctx.featureDir,
-    hooks: ctx.hooks,
-    plugins: ctx.pluginRegistry,
-    storyStartTime: new Date().toISOString(),
-    storyGitRef: storyGitRef ?? undefined,
-    interaction: ctx.interactionChain ?? undefined,
-    agentGetFn: ctx.agentGetFn,
-    pidRegistry: ctx.pidRegistry,
-    accumulatedAttemptCost: accumulatedAttemptCost > 0 ? accumulatedAttemptCost : 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,
-    storyStartTime
-  };
-  if (pipelineResult.success) {
-    const r2 = await handlePipelineSuccess(handlerCtx, pipelineResult);
-    return {
-      prd: r2.prd,
-      storiesCompletedDelta: r2.storiesCompletedDelta,
-      costDelta: r2.costDelta,
-      prdDirty: r2.prdDirty,
-      finalAction: pipelineResult.finalAction
+      agentGetFn
     };
+    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: errorMessage(error48)
+    });
+    return { success: false, storyId, cost: 0, finalConflict: false, pipelineFailure: true };
   }
-  const r = await handlePipelineFailure(handlerCtx, pipelineResult);
-  return {
-    prd: r.prd,
-    storiesCompletedDelta: 0,
-    costDelta: r.costDelta,
-    prdDirty: r.prdDirty,
-    finalAction: pipelineResult.finalAction,
-    reason: pipelineResult.reason,
-    subStoryCount: pipelineResult.subStoryCount
-  };
 }
-var _iterationRunnerDeps;
-var init_iteration_runner = __esm(() => {
-  init_loader();
+var init_merge_conflict_rectify = __esm(() => {
   init_logger2();
-  init_runner();
-  init_stages();
-  init_git();
-  init_dry_run();
-  init_pipeline_result_handler();
-  _iterationRunnerDeps = {
-    loadConfigForWorkdir
-  };
 });
 
-// src/execution/executor-types.ts
-function buildPreviewRouting(story, config2) {
-  const cached2 = story.routing;
-  const defaultComplexity = "medium";
-  const defaultTier = "balanced";
-  const defaultStrategy = "test-after";
-  return {
-    complexity: cached2?.complexity ?? defaultComplexity,
-    modelTier: cached2?.modelTier ?? config2.autoMode.complexityRouting?.[defaultComplexity] ?? defaultTier,
-    testStrategy: cached2?.testStrategy ?? defaultStrategy,
-    reasoning: cached2 ? "cached from story.routing" : "preview (pending pipeline routing stage)"
-  };
-}
-
-// src/execution/story-selector.ts
-function selectNextStories(prd, config2, batchPlan, currentBatchIndex, lastStoryId, useBatch) {
-  if (useBatch && currentBatchIndex < batchPlan.length) {
-    const batch = batchPlan[currentBatchIndex];
-    const storiesToExecute = batch.stories.filter((s) => !s.passes && s.status !== "passed" && s.status !== "skipped" && s.status !== "blocked" && s.status !== "failed" && s.status !== "paused" && s.status !== "decomposed");
-    if (storiesToExecute.length === 0) {
-      return { selection: null, nextBatchIndex: currentBatchIndex + 1 };
+// src/execution/parallel-batch.ts
+var exports_parallel_batch = {};
+__export(exports_parallel_batch, {
+  runParallelBatch: () => runParallelBatch,
+  _parallelBatchDeps: () => _parallelBatchDeps
+});
+import path16 from "path";
+async function runParallelBatch(options) {
+  const { stories, ctx, prd } = options;
+  const { workdir, config: config2, maxConcurrency, pipelineContext, eventEmitter, agentGetFn, hooks, pluginRegistry } = ctx;
+  const worktreeManager = await _parallelBatchDeps.createWorktreeManager();
+  const worktreePaths = new Map;
+  const storyStartTimes = new Map;
+  for (const story of stories) {
+    storyStartTimes.set(story.id, Date.now());
+    await worktreeManager.create(workdir, story.id);
+    worktreePaths.set(story.id, path16.join(workdir, ".nax-wt", story.id));
+  }
+  const workerResult = await _parallelBatchDeps.executeParallelBatch(stories, workdir, config2, pipelineContext, worktreePaths, maxConcurrency, eventEmitter);
+  const batchEndMs = Date.now();
+  const completed = workerResult.merged;
+  const failed = workerResult.failed.map((f) => ({
+    story: f.story,
+    pipelineResult: f.pipelineResult ?? {
+      success: false,
+      finalAction: "fail",
+      reason: f.error,
+      context: { ...pipelineContext, story: f.story, stories: [f.story], workdir }
     }
-    const story2 = storiesToExecute[0];
-    return {
-      selection: {
-        story: story2,
-        storiesToExecute,
-        routing: buildPreviewRouting(story2, config2),
-        isBatchExecution: batch.isBatch && storiesToExecute.length > 1
-      },
-      nextBatchIndex: currentBatchIndex + 1
-    };
+  }));
+  const storyEndTimes = new Map;
+  for (const story of [...workerResult.pipelinePassed, ...workerResult.merged]) {
+    storyEndTimes.set(story.id, batchEndMs);
   }
-  const story = getNextStory(prd, lastStoryId, config2.execution.rectification?.maxRetries ?? 2);
-  if (!story)
-    return null;
-  return {
-    selection: {
-      story,
-      storiesToExecute: [story],
-      routing: buildPreviewRouting(story, config2),
-      isBatchExecution: false
+  for (const { story } of workerResult.failed) {
+    storyEndTimes.set(story.id, batchEndMs);
+  }
+  const mergeConflicts = [];
+  for (const conflict of workerResult.mergeConflicts) {
+    const story = stories.find((s) => s.id === conflict.storyId);
+    if (!story)
+      continue;
+    try {
+      const rectResult = await _parallelBatchDeps.rectifyConflictedStory({
+        ...conflict,
+        workdir,
+        config: config2,
+        hooks,
+        pluginRegistry,
+        prd,
+        eventEmitter,
+        agentGetFn
+      });
+      mergeConflicts.push({ story, rectified: rectResult.success, cost: rectResult.cost });
+    } catch (err) {
+      const logger = getSafeLogger();
+      logger?.warn("[parallel-batch]", "rectification failed for story", {
+        storyId: story.id,
+        error: err.message
+      });
+      mergeConflicts.push({ story, rectified: false, cost: 0 });
+    }
+    storyEndTimes.set(conflict.storyId, Date.now());
+  }
+  const storyCosts = workerResult.storyCosts;
+  const totalCost = [...storyCosts.values()].reduce((sum, c) => sum + c, 0);
+  const storyDurations = new Map;
+  for (const story of stories) {
+    const startMs = storyStartTimes.get(story.id);
+    const endMs = storyEndTimes.get(story.id);
+    if (startMs !== undefined && endMs !== undefined) {
+      storyDurations.set(story.id, endMs - startMs);
+    }
+  }
+  return { completed, failed, mergeConflicts, storyCosts, storyDurations, totalCost };
+}
+var _parallelBatchDeps;
+var init_parallel_batch = __esm(() => {
+  init_logger2();
+  _parallelBatchDeps = {
+    executeParallelBatch: async (_stories, _projectRoot, _config, _context, _worktreePaths, _maxConcurrency, _eventEmitter) => {
+      const { executeParallelBatch: executeParallelBatch2 } = await Promise.resolve().then(() => (init_parallel_worker(), exports_parallel_worker));
+      return executeParallelBatch2(_stories, _projectRoot, _config, _context, _worktreePaths, _maxConcurrency, _eventEmitter);
     },
-    nextBatchIndex: currentBatchIndex
+    createWorktreeManager: async () => {
+      const { WorktreeManager: WorktreeManager2 } = await Promise.resolve().then(() => (init_manager(), exports_manager));
+      return new WorktreeManager2;
+    },
+    createMergeEngine: async (worktreeManager) => {
+      const { MergeEngine: MergeEngine2 } = await Promise.resolve().then(() => (init_merge(), exports_merge));
+      return new MergeEngine2(worktreeManager);
+    },
+    rectifyConflictedStory: async (opts) => {
+      const { rectifyConflictedStory: rectifyConflictedStory2 } = await Promise.resolve().then(() => (init_merge_conflict_rectify(), exports_merge_conflict_rectify));
+      return rectifyConflictedStory2(opts);
+    }
   };
-}
-var init_story_selector = __esm(() => {
-  init_prd();
 });
 
-// src/execution/sequential-executor.ts
-var exports_sequential_executor = {};
-__export(exports_sequential_executor, {
-  executeSequential: () => executeSequential
+// src/execution/unified-executor.ts
+var exports_unified_executor = {};
+__export(exports_unified_executor, {
+  executeUnified: () => executeUnified,
+  _unifiedExecutorDeps: () => _unifiedExecutorDeps
 });
-async function executeSequential(ctx, initialPrd) {
+async function executeUnified(ctx, initialPrd) {
   const logger = getSafeLogger();
-  let [prd, prdDirty, iterations, storiesCompleted, totalCost, lastStoryId, currentBatchIndex] = [
-    initialPrd,
-    false,
-    0,
-    0,
-    0,
-    null,
-    0
-  ];
+  let prd = initialPrd;
+  let prdDirty = false;
+  let iterations = 0;
+  let storiesCompleted = 0;
+  let totalCost = 0;
+  let lastStoryId = null;
+  let currentBatchIndex = 0;
   const allStoryMetrics = [];
   let warningSent = false;
   let deferredReview;
@@ -36078,20 +35742,22 @@ async function executeSequential(ctx, initialPrd) {
       deferredReview = await runDeferredReview(ctx.workdir, ctx.config.review, ctx.pluginRegistry, runStartRef);
       return buildResult2("completed");
     }
-    logger?.info("execution", "Running pre-run pipeline (acceptance test setup)");
-    const preRunCtx = {
-      config: ctx.config,
-      effectiveConfig: ctx.config,
-      prd,
-      workdir: ctx.workdir,
-      featureDir: ctx.featureDir,
-      story: prd.userStories[0],
-      stories: prd.userStories,
-      routing: { complexity: "simple", modelTier: "fast", testStrategy: "test-after", reasoning: "" },
-      hooks: ctx.hooks,
-      agentGetFn: ctx.agentGetFn
-    };
-    await runPipeline(preRunPipeline, preRunCtx, ctx.eventEmitter);
+    if (ctx.config.acceptance?.enabled) {
+      logger?.info("execution", "Running pre-run pipeline (acceptance test setup)");
+      const preRunCtx = {
+        config: ctx.config,
+        effectiveConfig: ctx.config,
+        prd,
+        workdir: ctx.workdir,
+        featureDir: ctx.featureDir,
+        story: prd.userStories[0],
+        stories: prd.userStories,
+        routing: { complexity: "simple", modelTier: "fast", testStrategy: "test-after", reasoning: "" },
+        hooks: ctx.hooks,
+        agentGetFn: ctx.agentGetFn
+      };
+      await runPipeline(preRunPipeline, preRunCtx, ctx.eventEmitter);
+    }
     while (iterations < ctx.config.execution.maxIterations) {
       iterations++;
       if (Math.round(process.memoryUsage().heapUsed / 1024 / 1024) > 1024)
@@ -36103,13 +35769,203 @@ async function executeSequential(ctx, initialPrd) {
       if (isComplete(prd)) {
         if (ctx.interactionChain && isTriggerEnabled("pre-merge", ctx.config)) {
           const shouldProceed = await checkPreMerge({ featureName: ctx.feature, totalStories: prd.userStories.length, cost: totalCost }, ctx.config, ctx.interactionChain);
-          if (!shouldProceed) {
+          if (!shouldProceed)
             return buildResult2("pre-merge-aborted");
-          }
         }
         deferredReview = await runDeferredReview(ctx.workdir, ctx.config.review, ctx.pluginRegistry, runStartRef);
         return buildResult2("completed");
       }
+      const costLimit = ctx.config.execution.costLimit;
+      if ((ctx.parallelCount ?? 0) > 0) {
+        const readyStories = getAllReadyStories(prd);
+        const batch = _unifiedExecutorDeps.selectIndependentBatch(readyStories, ctx.parallelCount);
+        if (batch.length > 1) {
+          for (const story of batch) {
+            pipelineEventBus.emit({
+              type: "story:started",
+              storyId: story.id,
+              story,
+              workdir: ctx.workdir,
+              modelTier: story.routing?.modelTier ?? ctx.config.autoMode.complexityRouting?.[story.routing?.complexity ?? "medium"] ?? "balanced",
+              agent: ctx.config.autoMode.defaultAgent,
+              iteration: iterations
+            });
+          }
+          const batchStartedAt = new Date().toISOString();
+          const storyStartMs = new Map;
+          for (const s of batch)
+            storyStartMs.set(s.id, Date.now());
+          const batchResult = await _unifiedExecutorDeps.runParallelBatch({
+            stories: batch,
+            ctx: {
+              workdir: ctx.workdir,
+              config: ctx.config,
+              hooks: ctx.hooks,
+              pluginRegistry: ctx.pluginRegistry,
+              maxConcurrency: ctx.parallelCount,
+              pipelineContext: {
+                config: ctx.config,
+                effectiveConfig: ctx.config,
+                prd,
+                hooks: ctx.hooks,
+                featureDir: ctx.featureDir,
+                agentGetFn: ctx.agentGetFn,
+                pidRegistry: ctx.pidRegistry
+              },
+              eventEmitter: ctx.eventEmitter,
+              agentGetFn: ctx.agentGetFn
+            },
+            prd
+          });
+          for (const { story, pipelineResult } of batchResult.failed) {
+            const storyRouting = prd.userStories.find((s) => s.id === story.id)?.routing;
+            await handlePipelineFailure({
+              config: ctx.config,
+              prd,
+              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: [story],
+              routing: {
+                complexity: storyRouting?.complexity ?? "medium",
+                modelTier: storyRouting?.modelTier ?? "balanced",
+                testStrategy: storyRouting?.testStrategy ?? "test-after",
+                reasoning: storyRouting?.reasoning ?? ""
+              },
+              isBatchExecution: false,
+              allStoryMetrics,
+              storyGitRef: null,
+              interactionChain: ctx.interactionChain
+            }, pipelineResult);
+          }
+          totalCost += batchResult.totalCost;
+          storiesCompleted += batchResult.completed.length;
+          prdDirty = true;
+          const batchCompletedAt = new Date().toISOString();
+          for (const story of batchResult.completed) {
+            const storyCost = batchResult.storyCosts.get(story.id) ?? 0;
+            const storyStartTime = storyStartMs.get(story.id) ?? Date.now();
+            const storyDuration = batchResult.storyDurations?.get(story.id) ?? Date.now() - storyStartTime;
+            allStoryMetrics.push({
+              storyId: story.id,
+              complexity: story.routing?.complexity ?? "medium",
+              modelTier: story.routing?.modelTier ?? "balanced",
+              modelUsed: ctx.config.autoMode.defaultAgent,
+              attempts: 1,
+              finalTier: story.routing?.modelTier ?? "balanced",
+              success: true,
+              cost: storyCost,
+              durationMs: storyDuration,
+              firstPassSuccess: true,
+              startedAt: batchStartedAt,
+              completedAt: batchCompletedAt,
+              source: "parallel"
+            });
+          }
+          for (const conflict of batchResult.mergeConflicts) {
+            if (conflict.rectified) {
+              const storyStartTime = storyStartMs.get(conflict.story.id) ?? Date.now();
+              const storyDuration = batchResult.storyDurations?.get(conflict.story.id) ?? Date.now() - storyStartTime;
+              allStoryMetrics.push({
+                storyId: conflict.story.id,
+                complexity: conflict.story.routing?.complexity ?? "medium",
+                modelTier: conflict.story.routing?.modelTier ?? "balanced",
+                modelUsed: ctx.config.autoMode.defaultAgent,
+                attempts: 1,
+                finalTier: conflict.story.routing?.modelTier ?? "balanced",
+                success: true,
+                cost: batchResult.storyCosts.get(conflict.story.id) ?? 0,
+                durationMs: storyDuration,
+                firstPassSuccess: false,
+                startedAt: batchStartedAt,
+                completedAt: batchCompletedAt,
+                source: "rectification",
+                rectificationCost: conflict.cost
+              });
+            }
+          }
+          if (totalCost >= costLimit) {
+            return buildResult2("cost-limit");
+          }
+          continue;
+        }
+        if (batch.length === 1) {
+          const singleStory = batch[0];
+          const singleSelection = {
+            story: singleStory,
+            storiesToExecute: [singleStory],
+            routing: buildPreviewRouting(singleStory, ctx.config),
+            isBatchExecution: false
+          };
+          if (!ctx.useBatch)
+            lastStoryId = singleStory.id;
+          if (totalCost >= costLimit) {
+            const shouldProceed = ctx.interactionChain && isTriggerEnabled("cost-exceeded", ctx.config) ? await checkCostExceeded({ featureName: ctx.feature, cost: totalCost, limit: costLimit }, ctx.config, ctx.interactionChain) : false;
+            if (!shouldProceed) {
+              pipelineEventBus.emit({
+                type: "run:paused",
+                reason: `Cost limit reached: $${totalCost.toFixed(2)}`,
+                storyId: singleStory.id,
+                cost: totalCost
+              });
+              return buildResult2("cost-limit");
+            }
+            pipelineEventBus.emit({ type: "run:resumed", feature: ctx.feature });
+          }
+          pipelineEventBus.emit({
+            type: "story:started",
+            storyId: singleStory.id,
+            story: singleStory,
+            workdir: ctx.workdir,
+            modelTier: singleSelection.routing.modelTier,
+            agent: ctx.config.autoMode.defaultAgent,
+            iteration: iterations
+          });
+          const singleIter = await _unifiedExecutorDeps.runIteration(ctx, prd, singleSelection, iterations, totalCost, allStoryMetrics);
+          [prd, storiesCompleted, totalCost, prdDirty] = [
+            singleIter.prd,
+            storiesCompleted + singleIter.storiesCompletedDelta,
+            totalCost + singleIter.costDelta,
+            singleIter.prdDirty
+          ];
+          if (singleIter.finalAction === "decomposed") {
+            iterations--;
+            pipelineEventBus.emit({
+              type: "story:decomposed",
+              storyId: singleStory.id,
+              story: singleStory,
+              subStoryCount: singleIter.subStoryCount ?? 0
+            });
+            if (singleIter.prdDirty) {
+              prd = await loadPRD(ctx.prdPath);
+              prdDirty = false;
+            }
+            ctx.statusWriter.setPrd(prd);
+            continue;
+          }
+          if (singleIter.prdDirty) {
+            prd = await loadPRD(ctx.prdPath);
+            prdDirty = false;
+          }
+          ctx.statusWriter.setPrd(prd);
+          ctx.statusWriter.setCurrentStory(null);
+          await ctx.statusWriter.update(totalCost, iterations);
+          if (isStalled(prd)) {
+            pipelineEventBus.emit({ type: "run:paused", reason: "All remaining stories blocked", cost: totalCost });
+            return buildResult2("stalled");
+          }
+          if (ctx.config.execution.iterationDelayMs > 0)
+            await Bun.sleep(ctx.config.execution.iterationDelayMs);
+          continue;
+        }
+      }
       const selected = selectNextStories(prd, ctx.config, ctx.batchPlan, currentBatchIndex, lastStoryId, ctx.useBatch);
       if (!selected)
         return buildResult2("no-stories");
@@ -36121,8 +35977,8 @@ async function executeSequential(ctx, initialPrd) {
       const { selection } = selected;
       if (!ctx.useBatch)
         lastStoryId = selection.story.id;
-      if (totalCost >= ctx.config.execution.costLimit) {
-        const shouldProceed = ctx.interactionChain && isTriggerEnabled("cost-exceeded", ctx.config) ? await checkCostExceeded({ featureName: ctx.feature, cost: totalCost, limit: ctx.config.execution.costLimit }, ctx.config, ctx.interactionChain) : false;
+      if (totalCost >= costLimit) {
+        const shouldProceed = ctx.interactionChain && isTriggerEnabled("cost-exceeded", ctx.config) ? await checkCostExceeded({ featureName: ctx.feature, cost: totalCost, limit: costLimit }, ctx.config, ctx.interactionChain) : false;
         if (!shouldProceed) {
           pipelineEventBus.emit({
             type: "run:paused",
@@ -36143,7 +35999,7 @@ async function executeSequential(ctx, initialPrd) {
         agent: ctx.config.autoMode.defaultAgent,
         iteration: iterations
       });
-      const iter = await runIteration(ctx, prd, selection, iterations, totalCost, allStoryMetrics);
+      const iter = await _unifiedExecutorDeps.runIteration(ctx, prd, selection, iterations, totalCost, allStoryMetrics);
       [prd, storiesCompleted, totalCost, prdDirty] = [
         iter.prd,
         storiesCompleted + iter.storiesCompletedDelta,
@@ -36166,7 +36022,6 @@ async function executeSequential(ctx, initialPrd) {
         continue;
       }
       if (ctx.interactionChain && isTriggerEnabled("cost-warning", ctx.config) && !warningSent) {
-        const costLimit = ctx.config.execution.costLimit;
         const triggerCfg = ctx.config.interaction?.triggers?.["cost-warning"];
         const threshold = typeof triggerCfg === "object" ? triggerCfg.threshold ?? 0.8 : 0.8;
         if (totalCost >= costLimit * threshold) {
@@ -36188,12 +36043,17 @@ async function executeSequential(ctx, initialPrd) {
       if (ctx.config.execution.iterationDelayMs > 0)
         await Bun.sleep(ctx.config.execution.iterationDelayMs);
     }
-    logger?.info("execution", "Running post-run pipeline (acceptance tests)");
-    await runPipeline(postRunPipeline, { config: ctx.config, prd, workdir: ctx.workdir, story: prd.userStories[0] }, ctx.eventEmitter);
+    if (ctx.config.acceptance?.enabled) {
+      logger?.info("execution", "Running post-run pipeline (acceptance tests)");
+      await runPipeline(postRunPipeline, { config: ctx.config, prd, workdir: ctx.workdir, story: prd.userStories[0] }, ctx.eventEmitter);
+    }
     return buildResult2("max-iterations");
-  } finally {}
+  } finally {
+    stopHeartbeat();
+  }
 }
-var init_sequential_executor = __esm(() => {
+var _unifiedExecutorDeps;
+var init_unified_executor = __esm(() => {
   init_triggers();
   init_logger2();
   init_event_bus();
@@ -36207,21 +36067,31 @@ var init_sequential_executor = __esm(() => {
   init_prd();
   init_crash_recovery();
   init_deferred_review();
+  init_helpers();
   init_iteration_runner();
+  init_pipeline_result_handler();
   init_story_selector();
+  _unifiedExecutorDeps = {
+    runParallelBatch: async (opts) => {
+      const { runParallelBatch: runParallelBatch2 } = await Promise.resolve().then(() => (init_parallel_batch(), exports_parallel_batch));
+      return runParallelBatch2(opts);
+    },
+    runIteration,
+    selectIndependentBatch
+  };
 });
 
 // src/project/detector.ts
-import { join as join52 } from "path";
+import { join as join51 } from "path";
 async function detectLanguage(workdir, pkg) {
   const deps = _detectorDeps;
-  if (await deps.fileExists(join52(workdir, "go.mod")))
+  if (await deps.fileExists(join51(workdir, "go.mod")))
     return "go";
-  if (await deps.fileExists(join52(workdir, "Cargo.toml")))
+  if (await deps.fileExists(join51(workdir, "Cargo.toml")))
     return "rust";
-  if (await deps.fileExists(join52(workdir, "pyproject.toml")))
+  if (await deps.fileExists(join51(workdir, "pyproject.toml")))
     return "python";
-  if (await deps.fileExists(join52(workdir, "requirements.txt")))
+  if (await deps.fileExists(join51(workdir, "requirements.txt")))
     return "python";
   if (pkg != null) {
     const allDeps = {
@@ -36281,18 +36151,18 @@ async function detectLintTool(workdir, language) {
   if (language === "python")
     return "ruff";
   const deps = _detectorDeps;
-  if (await deps.fileExists(join52(workdir, "biome.json")))
+  if (await deps.fileExists(join51(workdir, "biome.json")))
     return "biome";
-  if (await deps.fileExists(join52(workdir, ".eslintrc")))
+  if (await deps.fileExists(join51(workdir, ".eslintrc")))
     return "eslint";
-  if (await deps.fileExists(join52(workdir, ".eslintrc.js")))
+  if (await deps.fileExists(join51(workdir, ".eslintrc.js")))
     return "eslint";
-  if (await deps.fileExists(join52(workdir, ".eslintrc.json")))
+  if (await deps.fileExists(join51(workdir, ".eslintrc.json")))
     return "eslint";
   return;
 }
 async function detectProjectProfile(workdir, existing) {
-  const pkg = await _detectorDeps.readJson(join52(workdir, "package.json"));
+  const pkg = await _detectorDeps.readJson(join51(workdir, "package.json"));
   const language = existing.language !== undefined ? existing.language : await detectLanguage(workdir, pkg);
   const type = existing.type !== undefined ? existing.type : detectType(pkg);
   const testFramework = existing.testFramework !== undefined ? existing.testFramework : await detectTestFramework(workdir, language, pkg);
@@ -36385,7 +36255,7 @@ async function writeStatusFile(filePath, status) {
 var init_status_file = () => {};
 
 // src/execution/status-writer.ts
-import { join as join53 } from "path";
+import { join as join52 } from "path";
 
 class StatusWriter {
   statusFile;
@@ -36453,7 +36323,7 @@ class StatusWriter {
     if (!this._prd)
       return;
     const safeLogger = getSafeLogger();
-    const featureStatusPath = join53(featureDir, "status.json");
+    const featureStatusPath = join52(featureDir, "status.json");
     try {
       const base = this.getSnapshot(totalCost, iterations);
       if (!base) {
@@ -36661,7 +36531,7 @@ __export(exports_run_initialization, {
   initializeRun: () => initializeRun,
   _reconcileDeps: () => _reconcileDeps
 });
-import { join as join54 } from "path";
+import { join as join53 } from "path";
 async function reconcileState(prd, prdPath, workdir, config2) {
   const logger = getSafeLogger();
   let reconciledCount = 0;
@@ -36679,7 +36549,7 @@ async function reconcileState(prd, prdPath, workdir, config2) {
       });
       continue;
     }
-    const effectiveWorkdir = story.workdir ? join54(workdir, story.workdir) : workdir;
+    const effectiveWorkdir = story.workdir ? join53(workdir, story.workdir) : workdir;
     try {
       const reviewResult = await _reconcileDeps.runReview(config2.review, effectiveWorkdir, config2.execution);
       if (!reviewResult.success) {
@@ -36781,7 +36651,7 @@ __export(exports_run_setup, {
   setupRun: () => setupRun,
   _runSetupDeps: () => _runSetupDeps
 });
-import * as os5 from "os";
+import * as os3 from "os";
 import path18 from "path";
 async function setupRun(options) {
   const logger = getSafeLogger();
@@ -36878,7 +36748,7 @@ async function setupRun(options) {
       explicit: Object.fromEntries(explicitFields.map((f) => [f, existingProjectConfig[f]])),
       detected: Object.fromEntries(autodetectedFields.map((f) => [f, detectedProfile[f]]))
     });
-    const globalPluginsDir = path18.join(os5.homedir(), ".nax", "plugins");
+    const globalPluginsDir = path18.join(os3.homedir(), ".nax", "plugins");
     const projectPluginsDir = path18.join(workdir, ".nax", "plugins");
     const configPlugins = config2.plugins || [];
     const pluginRegistry = await loadPlugins(globalPluginsDir, projectPluginsDir, configPlugins, workdir, config2.disabledPlugins);
@@ -67887,9 +67757,9 @@ var require_jsx_dev_runtime = __commonJS((exports, module) => {
 
 // bin/nax.ts
 init_source();
-import { existsSync as existsSync35, mkdirSync as mkdirSync6 } from "fs";
+import { existsSync as existsSync34, mkdirSync as mkdirSync6 } from "fs";
 import { homedir as homedir8 } from "os";
-import { join as join56 } from "path";
+import { join as join55 } from "path";
 
 // node_modules/commander/esm.mjs
 var import__ = __toESM(require_commander(), 1);
@@ -70828,7 +70698,7 @@ import { existsSync as existsSync22 } from "fs";
 import { join as join35 } from "path";
 var VALID_AGENTS = ["claude", "codex", "opencode", "cursor", "windsurf", "aider", "gemini"];
 async function generateCommand(options) {
-  const workdir = process.cwd();
+  const workdir = options.dir ?? process.cwd();
   const dryRun = options.dryRun ?? false;
   let config2;
   try {
@@ -72202,50 +72072,8 @@ async function runExecutionPhase(options, prd, pluginRegistry) {
   if (options.useBatch) {
     await tryLlmBatchRoute(options.config, readyStories, "routing");
   }
-  if (options.parallel !== undefined) {
-    const runParallelExecution2 = options.runParallelExecution ?? (await Promise.resolve().then(() => (init_parallel_executor(), exports_parallel_executor))).runParallelExecution;
-    const parallelResult = await runParallelExecution2({
-      prdPath: options.prdPath,
-      workdir: options.workdir,
-      config: options.config,
-      hooks: options.hooks,
-      feature: options.feature,
-      featureDir: options.featureDir,
-      parallelCount: options.parallel,
-      eventEmitter: options.eventEmitter,
-      statusWriter: options.statusWriter,
-      runId: options.runId,
-      startedAt: options.startedAt,
-      startTime: options.startTime,
-      totalCost,
-      iterations,
-      storiesCompleted,
-      allStoryMetrics,
-      pluginRegistry,
-      formatterMode: options.formatterMode,
-      headless: options.headless,
-      agentGetFn: options.agentGetFn,
-      pidRegistry: options.pidRegistry,
-      interactionChain: options.interactionChain
-    }, prd);
-    prd = parallelResult.prd;
-    totalCost = parallelResult.totalCost;
-    storiesCompleted = parallelResult.storiesCompleted;
-    allStoryMetrics.push(...parallelResult.storyMetrics);
-    if (parallelResult.completed && parallelResult.durationMs !== undefined) {
-      return {
-        prd,
-        iterations,
-        storiesCompleted,
-        totalCost,
-        allStoryMetrics,
-        completedEarly: true,
-        durationMs: parallelResult.durationMs
-      };
-    }
-  }
-  const { executeSequential: executeSequential2 } = await Promise.resolve().then(() => (init_sequential_executor(), exports_sequential_executor));
-  const sequentialResult = await executeSequential2({
+  const { executeUnified: executeUnified2 } = await Promise.resolve().then(() => (init_unified_executor(), exports_unified_executor));
+  const unifiedResult = await executeUnified2({
     prdPath: options.prdPath,
     workdir: options.workdir,
     config: options.config,
@@ -72260,23 +72088,18 @@ async function runExecutionPhase(options, prd, pluginRegistry) {
     logFilePath: options.logFilePath,
     runId: options.runId,
     startTime: options.startTime,
-    batchPlan,
+    parallelCount: options.parallel,
     agentGetFn: options.agentGetFn,
     pidRegistry: options.pidRegistry,
-    interactionChain: options.interactionChain
+    interactionChain: options.interactionChain,
+    batchPlan
   }, prd);
-  prd = sequentialResult.prd;
-  iterations = sequentialResult.iterations;
-  totalCost += sequentialResult.totalCost;
-  storiesCompleted += sequentialResult.storiesCompleted;
-  allStoryMetrics.push(...sequentialResult.allStoryMetrics);
-  return {
-    prd,
-    iterations,
-    storiesCompleted,
-    totalCost,
-    allStoryMetrics
-  };
+  prd = unifiedResult.prd;
+  iterations = unifiedResult.iterations;
+  storiesCompleted = unifiedResult.storiesCompleted;
+  totalCost = unifiedResult.totalCost;
+  allStoryMetrics.push(...unifiedResult.allStoryMetrics);
+  return { prd, iterations, storiesCompleted, totalCost, allStoryMetrics };
 }
 
 // src/execution/runner-setup.ts
@@ -72310,10 +72133,6 @@ async function runSetupPhase(options) {
 // src/execution/runner.ts
 init_escalation();
 init_escalation();
-var _runnerDeps = {
-  fireHook,
-  runParallelExecution: null
-};
 async function run(options) {
   const {
     prdPath,
@@ -72387,7 +72206,6 @@ async function run(options) {
       formatterMode,
       headless,
       parallel,
-      runParallelExecution: _runnerDeps.runParallelExecution ?? undefined,
       agentGetFn,
       pidRegistry,
       interactionChain
@@ -72643,7 +72461,7 @@ __export(exports_base, {
   ConEmu: () => ConEmu
 });
 import process4 from "process";
-import os6 from "os";
+import os4 from "os";
 
 // node_modules/environment/index.js
 var isBrowser = globalThis.window?.document !== undefined;
@@ -72742,7 +72560,7 @@ var isOldWindows = () => {
   if (isBrowser || !isWindows2) {
     return false;
   }
-  const parts = os6.release().split(".");
+  const parts = os4.release().split(".");
   const major = Number(parts[0]);
   const build = Number(parts[2] ?? 0);
   if (major < 10) {
@@ -79821,15 +79639,15 @@ Next: nax generate --package ${options.package}`));
     }
     return;
   }
-  const naxDir = join56(workdir, ".nax");
-  if (existsSync35(naxDir) && !options.force) {
+  const naxDir = join55(workdir, ".nax");
+  if (existsSync34(naxDir) && !options.force) {
     console.log(source_default.yellow("nax already initialized. Use --force to overwrite."));
     return;
   }
-  mkdirSync6(join56(naxDir, "features"), { recursive: true });
-  mkdirSync6(join56(naxDir, "hooks"), { recursive: true });
-  await Bun.write(join56(naxDir, "config.json"), JSON.stringify(DEFAULT_CONFIG, null, 2));
-  await Bun.write(join56(naxDir, "hooks.json"), JSON.stringify({
+  mkdirSync6(join55(naxDir, "features"), { recursive: true });
+  mkdirSync6(join55(naxDir, "hooks"), { recursive: true });
+  await Bun.write(join55(naxDir, "config.json"), JSON.stringify(DEFAULT_CONFIG, null, 2));
+  await Bun.write(join55(naxDir, "hooks.json"), JSON.stringify({
     hooks: {
       "on-start": { command: 'echo "nax started: $NAX_FEATURE"', enabled: false },
       "on-complete": { command: 'echo "nax complete: $NAX_FEATURE"', enabled: false },
@@ -79837,12 +79655,12 @@ Next: nax generate --package ${options.package}`));
       "on-error": { command: 'echo "nax error: $NAX_REASON"', enabled: false }
     }
   }, null, 2));
-  await Bun.write(join56(naxDir, ".gitignore"), `# nax temp files
+  await Bun.write(join55(naxDir, ".gitignore"), `# nax temp files
 *.tmp
 .paused.json
 .nax-verifier-verdict.json
 `);
-  await Bun.write(join56(naxDir, "context.md"), `# Project Context
+  await Bun.write(join55(naxDir, "context.md"), `# Project Context
 
 This document defines coding standards, architectural decisions, and forbidden patterns for this project.
 Run \`nax generate\` to regenerate agent config files (CLAUDE.md, AGENTS.md, .cursorrules, etc.) from this file.
@@ -79939,7 +79757,7 @@ program2.command("run").description("Run the orchestration loop for a feature").
     console.error(source_default.red("Error: --plan requires --from <spec-path>"));
     process.exit(1);
   }
-  if (options.from && !existsSync35(options.from)) {
+  if (options.from && !existsSync34(options.from)) {
     console.error(source_default.red(`Error: File not found: ${options.from} (required with --plan)`));
     process.exit(1);
   }
@@ -79968,10 +79786,10 @@ program2.command("run").description("Run the orchestration loop for a feature").
     console.error(source_default.red("nax not initialized. Run: nax init"));
     process.exit(1);
   }
-  const featureDir = join56(naxDir, "features", options.feature);
-  const prdPath = join56(featureDir, "prd.json");
+  const featureDir = join55(naxDir, "features", options.feature);
+  const prdPath = join55(featureDir, "prd.json");
   if (options.plan && options.from) {
-    if (existsSync35(prdPath) && !options.force) {
+    if (existsSync34(prdPath) && !options.force) {
       console.error(source_default.red(`Error: prd.json already exists for feature "${options.feature}".`));
       console.error(source_default.dim("   Use --force to overwrite, or run without --plan to use the existing PRD."));
       process.exit(1);
@@ -79991,10 +79809,10 @@ program2.command("run").description("Run the orchestration loop for a feature").
       }
     }
     try {
-      const planLogDir = join56(featureDir, "plan");
+      const planLogDir = join55(featureDir, "plan");
       mkdirSync6(planLogDir, { recursive: true });
       const planLogId = new Date().toISOString().replace(/:/g, "-").replace(/\..+/, "");
-      const planLogPath = join56(planLogDir, `${planLogId}.jsonl`);
+      const planLogPath = join55(planLogDir, `${planLogId}.jsonl`);
       initLogger({ level: "info", filePath: planLogPath, useChalk: false, headless: true });
       console.log(source_default.dim(`   [Plan log: ${planLogPath}]`));
       console.log(source_default.dim("   [Planning phase: generating PRD from spec]"));
@@ -80027,15 +79845,15 @@ program2.command("run").description("Run the orchestration loop for a feature").
       process.exit(1);
     }
   }
-  if (!existsSync35(prdPath)) {
+  if (!existsSync34(prdPath)) {
     console.error(source_default.red(`Feature "${options.feature}" not found or missing prd.json`));
     process.exit(1);
   }
   resetLogger();
-  const runsDir = join56(featureDir, "runs");
+  const runsDir = join55(featureDir, "runs");
   mkdirSync6(runsDir, { recursive: true });
   const runId = new Date().toISOString().replace(/:/g, "-").replace(/\..+/, "");
-  const logFilePath = join56(runsDir, `${runId}.jsonl`);
+  const logFilePath = join55(runsDir, `${runId}.jsonl`);
   const isTTY = process.stdout.isTTY ?? false;
   const headlessFlag = options.headless ?? false;
   const headlessEnv = process.env.NAX_HEADLESS === "1";
@@ -80051,7 +79869,7 @@ program2.command("run").description("Run the orchestration loop for a feature").
     config2.autoMode.defaultAgent = options.agent;
   }
   config2.execution.maxIterations = Number.parseInt(options.maxIterations, 10);
-  const globalNaxDir = join56(homedir8(), ".nax");
+  const globalNaxDir = join55(homedir8(), ".nax");
   const hooks = await loadHooksConfig(naxDir, globalNaxDir);
   const eventEmitter = new PipelineEventEmitter;
   let tuiInstance;
@@ -80074,7 +79892,7 @@ program2.command("run").description("Run the orchestration loop for a feature").
   } else {
     console.log(source_default.dim("   [Headless mode \u2014 pipe output]"));
   }
-  const statusFilePath = join56(workdir, ".nax", "status.json");
+  const statusFilePath = join55(workdir, ".nax", "status.json");
   let parallel;
   if (options.parallel !== undefined) {
     parallel = Number.parseInt(options.parallel, 10);
@@ -80100,9 +79918,9 @@ program2.command("run").description("Run the orchestration loop for a feature").
     headless: useHeadless,
     skipPrecheck: options.skipPrecheck ?? false
   });
-  const latestSymlink = join56(runsDir, "latest.jsonl");
+  const latestSymlink = join55(runsDir, "latest.jsonl");
   try {
-    if (existsSync35(latestSymlink)) {
+    if (existsSync34(latestSymlink)) {
       Bun.spawnSync(["rm", latestSymlink]);
     }
     Bun.spawnSync(["ln", "-s", `${runId}.jsonl`, latestSymlink], {
@@ -80138,9 +79956,9 @@ features.command("create <name>").description("Create a new feature").option("-d
     console.error(source_default.red("nax not initialized. Run: nax init"));
     process.exit(1);
   }
-  const featureDir = join56(naxDir, "features", name);
+  const featureDir = join55(naxDir, "features", name);
   mkdirSync6(featureDir, { recursive: true });
-  await Bun.write(join56(featureDir, "spec.md"), `# Feature: ${name}
+  await Bun.write(join55(featureDir, "spec.md"), `# Feature: ${name}
 
 ## Overview
 
@@ -80173,7 +79991,7 @@ features.command("create <name>").description("Create a new feature").option("-d
 
 <!-- What this feature explicitly does NOT cover. -->
 `);
-  await Bun.write(join56(featureDir, "progress.txt"), `# Progress: ${name}
+  await Bun.write(join55(featureDir, "progress.txt"), `# Progress: ${name}
 
 Created: ${new Date().toISOString()}
 
@@ -80199,8 +80017,8 @@ features.command("list").description("List all features").option("-d, --dir <pat
     console.error(source_default.red("nax not initialized."));
     process.exit(1);
   }
-  const featuresDir = join56(naxDir, "features");
-  if (!existsSync35(featuresDir)) {
+  const featuresDir = join55(naxDir, "features");
+  if (!existsSync34(featuresDir)) {
     console.log(source_default.dim("No features yet."));
     return;
   }
@@ -80214,8 +80032,8 @@ features.command("list").description("List all features").option("-d, --dir <pat
 Features:
 `));
   for (const name of entries) {
-    const prdPath = join56(featuresDir, name, "prd.json");
-    if (existsSync35(prdPath)) {
+    const prdPath = join55(featuresDir, name, "prd.json");
+    if (existsSync34(prdPath)) {
       const prd = await loadPRD(prdPath);
       const c = countStories(prd);
       console.log(`  ${name} \u2014 ${c.passed}/${c.total} stories done`);
@@ -80245,10 +80063,10 @@ Use: nax plan -f <feature> --from <spec>`));
     process.exit(1);
   }
   const config2 = await loadConfig(workdir);
-  const featureLogDir = join56(naxDir, "features", options.feature, "plan");
+  const featureLogDir = join55(naxDir, "features", options.feature, "plan");
   mkdirSync6(featureLogDir, { recursive: true });
   const planLogId = new Date().toISOString().replace(/:/g, "-").replace(/\..+/, "");
-  const planLogPath = join56(featureLogDir, `${planLogId}.jsonl`);
+  const planLogPath = join55(featureLogDir, `${planLogId}.jsonl`);
   initLogger({ level: "info", filePath: planLogPath, useChalk: false, headless: true });
   console.log(source_default.dim(`   [Plan log: ${planLogPath}]`));
   try {
@@ -80285,8 +80103,8 @@ program2.command("analyze").description("(deprecated) Parse spec.md into prd.jso
     console.error(source_default.red("nax not initialized. Run: nax init"));
     process.exit(1);
   }
-  const featureDir = join56(naxDir, "features", options.feature);
-  if (!existsSync35(featureDir)) {
+  const featureDir = join55(naxDir, "features", options.feature);
+  if (!existsSync34(featureDir)) {
     console.error(source_default.red(`Feature "${options.feature}" not found.`));
     process.exit(1);
   }
@@ -80301,7 +80119,7 @@ program2.command("analyze").description("(deprecated) Parse spec.md into prd.jso
       specPath: options.from,
       reclassify: options.reclassify
     });
-    const prdPath = join56(featureDir, "prd.json");
+    const prdPath = join55(featureDir, "prd.json");
     await Bun.write(prdPath, JSON.stringify(prd, null, 2));
     const c = countStories(prd);
     console.log(source_default.green(`
@@ -80334,9 +80152,17 @@ program2.command("agents").description("List available coding agents with status
     process.exit(1);
   }
 });
-program2.command("config").description("Display effective merged configuration").option("--explain", "Show detailed field descriptions", false).option("--diff", "Show only fields where project overrides global", false).action(async (options) => {
+program2.command("config").description("Display effective merged configuration").option("-d, --dir <path>", "Project directory", process.cwd()).option("--explain", "Show detailed field descriptions", false).option("--diff", "Show only fields where project overrides global", false).action(async (options) => {
+  let workdir;
+  try {
+    workdir = validateDirectory(options.dir);
+  } catch (err) {
+    console.error(source_default.red(`Invalid directory: ${err.message}`));
+    process.exit(1);
+    return;
+  }
   try {
-    const config2 = await loadConfig();
+    const config2 = await loadConfig(workdir);
     await configCommand(config2, { explain: options.explain, diff: options.diff });
   } catch (err) {
     console.error(source_default.red(`Error: ${err.message}`));
@@ -80530,9 +80356,18 @@ program2.command("prompts").description("Assemble or initialize prompts").option
     process.exit(1);
   }
 });
-program2.command("generate").description("Generate agent config files (CLAUDE.md, AGENTS.md, etc.) from nax/context.md").option("-c, --context <path>", "Context file path (default: nax/context.md)").option("-o, --output <dir>", "Output directory (default: project root)").option("-a, --agent <name>", "Specific agent (claude|opencode|cursor|windsurf|aider)").option("--dry-run", "Preview without writing files", false).option("--no-auto-inject", "Disable auto-injection of project metadata").option("--package <dir>", "Generate CLAUDE.md for a specific package (e.g. packages/api)").option("--all-packages", "Generate CLAUDE.md for all discovered packages", false).action(async (options) => {
+program2.command("generate").description("Generate agent config files (CLAUDE.md, AGENTS.md, etc.) from nax/context.md").option("-d, --dir <path>", "Project directory", process.cwd()).option("-c, --context <path>", "Context file path (default: nax/context.md)").option("-o, --output <dir>", "Output directory (default: project root)").option("-a, --agent <name>", "Specific agent (claude|opencode|cursor|windsurf|aider)").option("--dry-run", "Preview without writing files", false).option("--no-auto-inject", "Disable auto-injection of project metadata").option("--package <dir>", "Generate CLAUDE.md for a specific package (e.g. packages/api)").option("--all-packages", "Generate CLAUDE.md for all discovered packages", false).action(async (options) => {
+  let workdir;
+  try {
+    workdir = validateDirectory(options.dir);
+  } catch (err) {
+    console.error(source_default.red(`Invalid directory: ${err.message}`));
+    process.exit(1);
+    return;
+  }
   try {
     await generateCommand({
+      dir: workdir,
       context: options.context,
       output: options.output,
       agent: options.agent,