@nathapp/nax 0.58.5 → 0.59.1

package/dist/nax.js

@@ -3527,6 +3527,8 @@ async function writePromptAudit(entry) {
     let baseDir;
     if (entry.auditDir) {
       baseDir = isAbsolute(entry.auditDir) ? entry.auditDir : join(entry.workdir, entry.auditDir);
+    } else if (entry.projectDir) {
+      baseDir = join(entry.projectDir, ".nax", "prompt-audit");
     } else {
       const wtMarker = `${sep}.nax-wt${sep}`;
       const wtIdx = entry.workdir.indexOf(wtMarker);
@@ -18267,7 +18269,16 @@ var init_schemas3 = __esm(() => {
     modelTier: ModelTierSchema.default("balanced"),
     rules: exports_external.array(exports_external.string()).default([]),
     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__/"])
+    excludePatterns: exports_external.array(exports_external.string()).default([
+      ":!test/",
+      ":!tests/",
+      ":!*_test.go",
+      ":!*.test.ts",
+      ":!*.spec.ts",
+      ":!**/__tests__/",
+      ":!.nax/",
+      ":!.nax-pids"
+    ])
   });
   ReviewDialogueConfigSchema = exports_external.object({
     enabled: exports_external.boolean().default(false),
@@ -18612,7 +18623,16 @@ var init_schemas3 = __esm(() => {
         modelTier: "balanced",
         rules: [],
         timeoutMs: 600000,
-        excludePatterns: [":!test/", ":!tests/", ":!*_test.go", ":!*.test.ts", ":!*.spec.ts", ":!**/__tests__/"]
+        excludePatterns: [
+          ":!test/",
+          ":!tests/",
+          ":!*_test.go",
+          ":!*.test.ts",
+          ":!*.spec.ts",
+          ":!**/__tests__/",
+          ":!.nax/",
+          ":!.nax-pids"
+        ]
       },
       dialogue: {
         enabled: false,
@@ -19186,6 +19206,7 @@ class AcpAgentAdapter {
             prompt: currentPrompt,
             sessionName,
             workdir: options.workdir,
+            projectDir: options.projectDir,
             auditDir: _runAuditConfig.agent.promptAudit.dir,
             storyId: options.storyId,
             featureName: options.featureName,
@@ -19239,11 +19260,15 @@ class AcpAgentAdapter {
       }
       runState.succeeded = !timedOut && lastResponse?.stopReason === "end_turn";
     } finally {
+      const isSessionBroken = !runState.succeeded && lastResponse?.stopReason === "error";
       if (runState.succeeded && !options.keepSessionOpen) {
         await closeAcpSession(session);
         if (options.featureName && options.storyId) {
           await clearAcpSession(options.workdir, options.featureName, options.storyId, options.sessionRole);
         }
+      } else if (isSessionBroken) {
+        getSafeLogger()?.debug("acp-adapter", "Closing broken session for retry", { sessionName });
+        await closeAcpSession(session);
       } else if (!runState.succeeded) {
         getSafeLogger()?.info("acp-adapter", "Keeping session open for retry", { sessionName });
       } else {
@@ -19492,7 +19517,7 @@ class AcpAgentAdapter {
       this.markUnavailable(this.name);
       throw new Error("[acp-adapter] plan() returned empty spec content");
     }
-    return { specContent };
+    return { specContent, costUsd: result.estimatedCost };
   }
   async decompose(options) {
     const model = options.modelDef?.model;
@@ -19521,6 +19546,9 @@ class AcpAgentAdapter {
     }
     return { stories };
   }
+  clearUnavailableAgents() {
+    this._unavailableAgents.clear();
+  }
   markUnavailable(agentName) {
     this._unavailableAgents.add(agentName);
   }
@@ -20089,6 +20117,75 @@ var init_interactive = __esm(() => {
   init_execution();
 });
 
+// src/config/path-security.ts
+import { existsSync as existsSync2, lstatSync, realpathSync } from "fs";
+import { basename, isAbsolute as isAbsolute3, normalize, resolve as resolve2 } from "path";
+function validateDirectory(dirPath, baseDir) {
+  const resolved = resolve2(dirPath);
+  if (!existsSync2(resolved)) {
+    throw new Error(`Directory does not exist: ${dirPath}`);
+  }
+  let realPath;
+  try {
+    realPath = realpathSync(resolved);
+  } catch (error48) {
+    throw new Error(`Failed to resolve path: ${dirPath} (${error48.message})`);
+  }
+  try {
+    const stats = lstatSync(realPath);
+    if (!stats.isDirectory()) {
+      throw new Error(`Not a directory: ${dirPath}`);
+    }
+  } catch (error48) {
+    throw new Error(`Failed to stat path: ${dirPath} (${error48.message})`);
+  }
+  if (baseDir) {
+    const resolvedBase = resolve2(baseDir);
+    const realBase = existsSync2(resolvedBase) ? realpathSync(resolvedBase) : resolvedBase;
+    if (!isWithinDirectory(realPath, realBase)) {
+      throw new Error(`Path is outside allowed directory: ${dirPath} (resolved to ${realPath}, base: ${realBase})`);
+    }
+  }
+  return realPath;
+}
+function isWithinDirectory(targetPath, basePath) {
+  const normalizedTarget = normalize(targetPath);
+  const normalizedBase = normalize(basePath);
+  if (!isAbsolute3(normalizedTarget) || !isAbsolute3(normalizedBase)) {
+    return false;
+  }
+  const baseWithSlash = normalizedBase.endsWith("/") ? normalizedBase : `${normalizedBase}/`;
+  const targetWithSlash = normalizedTarget.endsWith("/") ? normalizedTarget : `${normalizedTarget}/`;
+  return targetWithSlash.startsWith(baseWithSlash) || normalizedTarget === normalizedBase;
+}
+function validateFilePath(filePath, baseDir) {
+  const resolved = resolve2(filePath);
+  let realPath;
+  try {
+    if (!existsSync2(resolved)) {
+      const parent = resolve2(resolved, "..");
+      if (existsSync2(parent)) {
+        const realParent = realpathSync(parent);
+        realPath = resolve2(realParent, basename(resolved));
+      } else {
+        realPath = resolved;
+      }
+    } else {
+      realPath = realpathSync(resolved);
+    }
+  } catch (error48) {
+    throw new Error(`Failed to resolve path: ${filePath} (${error48.message})`);
+  }
+  const resolvedBase = resolve2(baseDir);
+  const realBase = existsSync2(resolvedBase) ? realpathSync(resolvedBase) : resolvedBase;
+  if (!isWithinDirectory(realPath, realBase)) {
+    throw new Error(`Path is outside allowed directory: ${filePath} (resolved to ${realPath}, base: ${realBase})`);
+  }
+  return realPath;
+}
+var MAX_DIRECTORY_DEPTH = 10;
+var init_path_security = () => {};
+
 // src/agents/shared/model-resolution.ts
 var exports_model_resolution = {};
 __export(exports_model_resolution, {
@@ -20114,7 +20211,7 @@ var init_model_resolution = __esm(() => {
 // src/agents/claude/plan.ts
 import { mkdtempSync, rmSync } from "fs";
 import { tmpdir } from "os";
-import { join as join3 } from "path";
+import { join as join3, resolve as resolve3 } from "path";
 function buildPlanCommand(binary, options) {
   const cmd = [binary, "--permission-mode", "plan"];
   let modelDef = options.modelDef;
@@ -20134,17 +20231,12 @@ function buildPlanCommand(binary, options) {
 
 ${options.prompt}`;
   }
-  if (options.inputFile) {
-    try {
-      const inputContent = __require("fs").readFileSync(__require("path").resolve(options.workdir, options.inputFile), "utf-8");
-      fullPrompt = `${fullPrompt}
+  if (options.resolvedInputContent) {
+    fullPrompt = `${fullPrompt}
 
 ## Input Requirements
 
-${inputContent}`;
-    } catch (error48) {
-      throw new Error(`Failed to read input file ${options.inputFile}: ${error48.message}`);
-    }
+${options.resolvedInputContent}`;
   }
   if (!options.interactive) {
     cmd.push("-p", fullPrompt);
@@ -20155,7 +20247,13 @@ ${inputContent}`;
 }
 async function runPlan(binary, options, pidRegistry) {
   const { resolveBalancedModelDef: resolveBalancedModelDef2 } = await Promise.resolve().then(() => (init_model_resolution(), exports_model_resolution));
-  const cmd = buildPlanCommand(binary, options);
+  let resolvedOptions = options;
+  if (options.inputFile) {
+    const inputPath = validateFilePath(resolve3(options.workdir, options.inputFile), options.workdir);
+    const resolvedInputContent = await Bun.file(inputPath).text();
+    resolvedOptions = { ...options, resolvedInputContent };
+  }
+  const cmd = buildPlanCommand(binary, resolvedOptions);
   let modelDef = options.modelDef;
   if (!modelDef) {
     if (!options.config) {
@@ -20224,6 +20322,7 @@ async function runPlan(binary, options, pidRegistry) {
   }
 }
 var init_plan = __esm(() => {
+  init_path_security();
   init_timeout_handler();
   init_logger2();
   init_env();
@@ -20376,8 +20475,8 @@ class ClaudeCodeAdapter {
     let stdoutTimeoutId;
     const stdout = await Promise.race([
       new Response(proc.stdout).text(),
-      new Promise((resolve2) => {
-        stdoutTimeoutId = setTimeout(() => resolve2(""), 5000);
+      new Promise((resolve4) => {
+        stdoutTimeoutId = setTimeout(() => resolve4(""), 5000);
       })
     ]);
     clearTimeout(stdoutTimeoutId);
@@ -20725,7 +20824,12 @@ function createAgentRegistry(config2) {
       installed: await agent.isInstalled()
     })));
   }
-  return { getAgent: getAgent2, getInstalledAgents: getInstalledAgents2, checkAgentHealth: checkAgentHealth2, protocol };
+  function resetStoryState() {
+    for (const adapter of acpCache.values()) {
+      adapter.clearUnavailableAgents();
+    }
+  }
+  return { getAgent: getAgent2, getInstalledAgents: getInstalledAgents2, checkAgentHealth: checkAgentHealth2, protocol, resetStoryState };
 }
 var ALL_AGENTS;
 var init_registry = __esm(() => {
@@ -20745,75 +20849,6 @@ var init_registry = __esm(() => {
   ];
 });
 
-// src/config/path-security.ts
-import { existsSync as existsSync3, lstatSync, realpathSync } from "fs";
-import { basename, isAbsolute as isAbsolute3, normalize, resolve as resolve2 } from "path";
-function validateDirectory(dirPath, baseDir) {
-  const resolved = resolve2(dirPath);
-  if (!existsSync3(resolved)) {
-    throw new Error(`Directory does not exist: ${dirPath}`);
-  }
-  let realPath;
-  try {
-    realPath = realpathSync(resolved);
-  } catch (error48) {
-    throw new Error(`Failed to resolve path: ${dirPath} (${error48.message})`);
-  }
-  try {
-    const stats = lstatSync(realPath);
-    if (!stats.isDirectory()) {
-      throw new Error(`Not a directory: ${dirPath}`);
-    }
-  } catch (error48) {
-    throw new Error(`Failed to stat path: ${dirPath} (${error48.message})`);
-  }
-  if (baseDir) {
-    const resolvedBase = resolve2(baseDir);
-    const realBase = existsSync3(resolvedBase) ? realpathSync(resolvedBase) : resolvedBase;
-    if (!isWithinDirectory(realPath, realBase)) {
-      throw new Error(`Path is outside allowed directory: ${dirPath} (resolved to ${realPath}, base: ${realBase})`);
-    }
-  }
-  return realPath;
-}
-function isWithinDirectory(targetPath, basePath) {
-  const normalizedTarget = normalize(targetPath);
-  const normalizedBase = normalize(basePath);
-  if (!isAbsolute3(normalizedTarget) || !isAbsolute3(normalizedBase)) {
-    return false;
-  }
-  const baseWithSlash = normalizedBase.endsWith("/") ? normalizedBase : `${normalizedBase}/`;
-  const targetWithSlash = normalizedTarget.endsWith("/") ? normalizedTarget : `${normalizedTarget}/`;
-  return targetWithSlash.startsWith(baseWithSlash) || normalizedTarget === normalizedBase;
-}
-function validateFilePath(filePath, baseDir) {
-  const resolved = resolve2(filePath);
-  let realPath;
-  try {
-    if (!existsSync3(resolved)) {
-      const parent = resolve2(resolved, "..");
-      if (existsSync3(parent)) {
-        const realParent = realpathSync(parent);
-        realPath = resolve2(realParent, basename(resolved));
-      } else {
-        realPath = resolved;
-      }
-    } else {
-      realPath = realpathSync(resolved);
-    }
-  } catch (error48) {
-    throw new Error(`Failed to resolve path: ${filePath} (${error48.message})`);
-  }
-  const resolvedBase = resolve2(baseDir);
-  const realBase = existsSync3(resolvedBase) ? realpathSync(resolvedBase) : resolvedBase;
-  if (!isWithinDirectory(realPath, realBase)) {
-    throw new Error(`Path is outside allowed directory: ${filePath} (resolved to ${realPath}, base: ${realBase})`);
-  }
-  return realPath;
-}
-var MAX_DIRECTORY_DEPTH = 10;
-var init_path_security = () => {};
-
 // src/utils/json-file.ts
 import { existsSync as existsSync6 } from "fs";
 async function loadJsonFile(path, context = "json-file") {
@@ -21008,7 +21043,7 @@ function isPlainObject2(value) {
 
 // src/config/paths.ts
 import { homedir as homedir2 } from "os";
-import { join as join7, resolve as resolve3 } from "path";
+import { join as join7, resolve as resolve4 } from "path";
 function globalConfigDir() {
   const override = process.env[GLOBAL_CONFIG_DIR_ENV];
   if (override)
@@ -21016,7 +21051,7 @@ function globalConfigDir() {
   return join7(homedir2(), ".nax");
 }
 function projectConfigDir(projectRoot) {
-  return join7(resolve3(projectRoot), PROJECT_NAX_DIR);
+  return join7(resolve4(projectRoot), PROJECT_NAX_DIR);
 }
 var GLOBAL_CONFIG_DIR_ENV = "NAX_GLOBAL_CONFIG_DIR", PROJECT_NAX_DIR = ".nax";
 var init_paths = () => {};
@@ -21170,12 +21205,12 @@ var init_profile = __esm(() => {
 
 // src/config/loader.ts
 import { existsSync as existsSync7 } from "fs";
-import { basename as basename2, dirname as dirname3, join as join9, resolve as resolve4 } from "path";
+import { basename as basename2, dirname as dirname2, join as join9, resolve as resolve5 } from "path";
 function globalConfigPath() {
   return join9(globalConfigDir(), "config.json");
 }
 function findProjectDir(startDir = process.cwd()) {
-  let dir = resolve4(startDir);
+  let dir = resolve5(startDir);
   let depth = 0;
   while (depth < MAX_DIRECTORY_DEPTH) {
     const candidate = join9(dir, PROJECT_NAX_DIR);
@@ -21226,7 +21261,7 @@ function applyBatchModeCompat(conf) {
 async function loadConfig(startDir, cliOverrides) {
   let rawConfig = structuredClone(DEFAULT_CONFIG);
   const projDir = startDir ? basename2(startDir) === PROJECT_NAX_DIR ? startDir : findProjectDir(startDir) : findProjectDir();
-  const projectRoot = startDir ? basename2(startDir) === PROJECT_NAX_DIR ? dirname3(startDir) : startDir : process.cwd();
+  const projectRoot = startDir ? basename2(startDir) === PROJECT_NAX_DIR ? dirname2(startDir) : startDir : process.cwd();
   const profileName = await resolveProfileName(cliOverrides ?? {}, process.env, projectRoot);
   const globalConfRaw = await loadJsonFile(globalConfigPath(), "config");
   if (globalConfRaw) {
@@ -21269,8 +21304,8 @@ ${errors3.join(`
 }
 async function loadConfigForWorkdir(rootConfigPath, packageDir) {
   const logger = getLogger();
-  const resolvedRootConfigPath = resolve4(rootConfigPath);
-  const rootNaxDir = dirname3(resolvedRootConfigPath);
+  const resolvedRootConfigPath = resolve5(rootConfigPath);
+  const rootNaxDir = dirname2(resolvedRootConfigPath);
   let rootConfigPromise = _rootConfigCache.get(resolvedRootConfigPath);
   if (!rootConfigPromise) {
     rootConfigPromise = loadConfig(rootNaxDir);
@@ -21281,7 +21316,7 @@ async function loadConfigForWorkdir(rootConfigPath, packageDir) {
     logger.debug("config", "No packageDir \u2014 using root config");
     return rootConfig;
   }
-  const repoRoot = dirname3(rootNaxDir);
+  const repoRoot = dirname2(rootNaxDir);
   const packageConfigPath = join9(repoRoot, PROJECT_NAX_DIR, "mono", packageDir, "config.json");
   const packageOverride = await loadJsonFile(packageConfigPath, "config");
   if (!packageOverride) {
@@ -21508,25 +21543,89 @@ function pipelineStageForDebate(stage) {
   }
 }
 function resolveModelDefForDebater(debater, tier, config2) {
-  if (debater.model && !isTierLabel(debater.model)) {
-    return resolveModel(debater.model);
+  const modelOverride = debater.model;
+  let effectiveTier = tier;
+  if (modelOverride) {
+    const aliasedTier = MODEL_SHORTHAND_TIERS[modelOverride.toLowerCase()];
+    if (aliasedTier) {
+      effectiveTier = aliasedTier;
+    } else if (!isTierLabel(modelOverride)) {
+      return resolveModel(modelOverride);
+    }
   }
   const configModels = config2?.models ?? DEFAULT_CONFIG.models;
   const configDefaultAgent = config2?.autoMode?.defaultAgent ?? DEFAULT_CONFIG.autoMode.defaultAgent;
   try {
-    return resolveModelForAgent(configModels, debater.agent, tier, configDefaultAgent);
+    return resolveModelForAgent(configModels, debater.agent, effectiveTier, configDefaultAgent);
   } catch {}
   try {
-    return resolveModelForAgent(DEFAULT_CONFIG.models, DEFAULT_CONFIG.autoMode.defaultAgent, tier, DEFAULT_CONFIG.autoMode.defaultAgent);
+    return resolveModelForAgent(DEFAULT_CONFIG.models, DEFAULT_CONFIG.autoMode.defaultAgent, effectiveTier, DEFAULT_CONFIG.autoMode.defaultAgent);
   } catch {
     return resolveModelForAgent(configModels, debater.agent, "fast", configDefaultAgent);
   }
 }
-async function resolveOutcome(proposalOutputs, critiqueOutputs, stageConfig, config2, storyId, timeoutMs, workdir, featureName) {
+async function resolveOutcome(proposalOutputs, critiqueOutputs, stageConfig, config2, storyId, timeoutMs, workdir, featureName, reviewerSession, resolverContext) {
   const resolverConfig = stageConfig.resolver;
   const logger = _debateSessionDeps.getSafeLogger();
+  if (reviewerSession && resolverContext) {
+    try {
+      const debateCtx = {
+        resolverType: resolverConfig.type
+      };
+      if (resolverConfig.type === "majority-fail-closed" || resolverConfig.type === "majority-fail-open") {
+        const failOpen = resolverConfig.type === "majority-fail-open";
+        const rawOutcome = majorityResolver(proposalOutputs, failOpen);
+        let passCount = 0;
+        let failCount = 0;
+        for (const proposal of proposalOutputs) {
+          try {
+            const stripped = proposal.trim().replace(/^```(?:json)?\s*\n?/, "").replace(/\n?```\s*$/, "");
+            const parsed = JSON.parse(stripped);
+            if (typeof parsed.passed === "boolean" && parsed.passed)
+              passCount++;
+            else if (failOpen)
+              passCount++;
+            else
+              failCount++;
+          } catch {
+            if (failOpen)
+              passCount++;
+            else
+              failCount++;
+          }
+        }
+        debateCtx.majorityVote = { passed: rawOutcome === "passed", passCount, failCount };
+      }
+      const story = {
+        id: resolverContext.story.id,
+        title: resolverContext.story.title,
+        description: "",
+        acceptanceCriteria: resolverContext.story.acceptanceCriteria
+      };
+      let dialogueResult;
+      if (resolverContext.isReReview) {
+        dialogueResult = await reviewerSession.reReviewDebate(resolverContext.labeledProposals, critiqueOutputs, resolverContext.diff, debateCtx);
+      } else {
+        dialogueResult = await reviewerSession.resolveDebate(resolverContext.labeledProposals, critiqueOutputs, resolverContext.diff, story, resolverContext.semanticConfig, debateCtx);
+      }
+      const outcome = dialogueResult.checkResult.success ? "passed" : "failed";
+      return {
+        outcome,
+        resolverCostUsd: dialogueResult.cost ?? 0,
+        dialogueResult
+      };
+    } catch (err) {
+      logger?.warn("debate", "ReviewerSession.resolveDebate() failed \u2014 falling back to stateless resolver", {
+        storyId,
+        error: err instanceof Error ? err.message : String(err)
+      });
+    }
+  }
+  if (reviewerSession && !resolverContext) {
+    logger?.warn("debate", "ReviewerSession provided but resolverContext is undefined \u2014 falling back to stateless resolver", { storyId });
+  }
   if (resolverConfig.type === "majority-fail-closed" || resolverConfig.type === "majority-fail-open") {
-    if (workdir !== undefined) {
+    if (workdir !== undefined && !reviewerSession) {
       logger?.warn("debate", "majority resolver does not support implementer session resumption \u2014 switch to synthesis or custom resolver for context-aware semantic review");
     }
     return {
@@ -21552,7 +21651,8 @@ async function resolveOutcome(proposalOutputs, critiqueOutputs, stageConfig, con
       });
       return {
         outcome: "passed",
-        resolverCostUsd: resolverResult.costUsd
+        resolverCostUsd: resolverResult.costUsd,
+        output: resolverResult.output
       };
     }
     return { outcome: "passed", resolverCostUsd: 0 };
@@ -21573,12 +21673,13 @@ async function resolveOutcome(proposalOutputs, critiqueOutputs, stageConfig, con
     });
     return {
       outcome: "passed",
-      resolverCostUsd: resolverResult.costUsd
+      resolverCostUsd: resolverResult.costUsd,
+      output: resolverResult.output
     };
   }
   return { outcome: "passed", resolverCostUsd: 0 };
 }
-var RESOLVER_FALLBACK_AGENT = "synthesis", _debateSessionDeps;
+var RESOLVER_FALLBACK_AGENT = "synthesis", _debateSessionDeps, MODEL_SHORTHAND_TIERS;
 var init_session_helpers = __esm(() => {
   init_adapter();
   init_registry();
@@ -21590,6 +21691,11 @@ var init_session_helpers = __esm(() => {
     getSafeLogger,
     readFile: (path) => Bun.file(path).text()
   };
+  MODEL_SHORTHAND_TIERS = {
+    haiku: "fast",
+    sonnet: "balanced",
+    opus: "powerful"
+  };
 });
 
 // src/debate/concurrency.ts
@@ -21775,7 +21881,11 @@ async function runStateful(ctx, prompt) {
     critiqueOutputs = critiqueSettled.filter((r) => r.status === "fulfilled").map((r) => r.value.output);
   }
   const proposalOutputs = successfulProposals.map((s) => s.output);
-  const outcome = await resolveOutcome(proposalOutputs, critiqueOutputs, ctx.stageConfig, ctx.config, ctx.storyId, ctx.timeoutSeconds * 1000, ctx.workdir, ctx.featureName);
+  const fullResolverContext = ctx.resolverContextInput ? {
+    ...ctx.resolverContextInput,
+    labeledProposals: successfulProposals.map((s) => ({ debater: s.debater.agent, output: s.output }))
+  } : undefined;
+  const outcome = await resolveOutcome(proposalOutputs, critiqueOutputs, ctx.stageConfig, ctx.config, ctx.storyId, ctx.timeoutSeconds * 1000, ctx.workdir, ctx.featureName, ctx.reviewerSession, fullResolverContext);
   totalCostUsd += outcome.resolverCostUsd;
   const proposals = successfulProposals.map((s) => ({
     debater: s.debater,
@@ -21802,6 +21912,50 @@ var init_session_stateful = __esm(() => {
 });
 
 // src/debate/session-hybrid.ts
+async function runRebuttalLoop(ctx, proposals, originalPrompt, sessionRolePrefix) {
+  const logger = _debateSessionDeps.getSafeLogger();
+  const config2 = ctx.stageConfig;
+  const rebuttals = [];
+  let costUsd = 0;
+  const proposalList = proposals.map((s) => ({ debater: s.debater, output: s.output }));
+  try {
+    for (let round = 1;round <= config2.rounds; round++) {
+      const priorRebuttals = rebuttals.filter((r) => r.round < round).map((r) => r.output);
+      for (let debaterIdx = 0;debaterIdx < proposals.length; debaterIdx++) {
+        const proposal = proposals[debaterIdx];
+        const sessionRole = `${sessionRolePrefix}-${debaterIdx}`;
+        logger?.info("debate:rebuttal-start", "debate:rebuttal-start", {
+          storyId: ctx.storyId,
+          round,
+          debaterIndex: debaterIdx
+        });
+        const rebuttalPrompt = buildRebuttalContext(originalPrompt, proposalList, priorRebuttals, debaterIdx);
+        try {
+          const turnResult = await runStatefulTurn(ctx, proposal.adapter, proposal.debater, rebuttalPrompt, sessionRole, true);
+          costUsd += turnResult.cost;
+          rebuttals.push({ debater: proposal.debater, round, output: turnResult.output });
+        } catch (err) {
+          logger?.warn("debate", "debate:rebuttal-failed", {
+            storyId: ctx.storyId,
+            round,
+            debaterIndex: debaterIdx,
+            error: err instanceof Error ? err.message : String(err)
+          });
+        }
+      }
+    }
+  } finally {
+    for (let debaterIdx = 0;debaterIdx < proposals.length; debaterIdx++) {
+      const proposal = proposals[debaterIdx];
+      const sessionRole = `${sessionRolePrefix}-${debaterIdx}`;
+      try {
+        const closeCost = await closeStatefulSession(ctx, proposal.adapter, proposal.debater, sessionRole);
+        costUsd += closeCost;
+      } catch {}
+    }
+  }
+  return { rebuttals, costUsd };
+}
 async function runHybrid(ctx, prompt) {
   const logger = _debateSessionDeps.getSafeLogger();
   const config2 = ctx.stageConfig;
@@ -21870,45 +22024,14 @@ async function runHybrid(ctx, prompt) {
   }
   const proposalOutputs = successfulProposals.map((s) => s.output);
   const proposalList = successfulProposals.map((s) => ({ debater: s.debater, output: s.output }));
-  const rebuttals = [];
-  try {
-    for (let round = 1;round <= config2.rounds; round++) {
-      const priorRebuttals = rebuttals.filter((r) => r.round < round).map((r) => r.output);
-      for (let debaterIdx = 0;debaterIdx < successfulProposals.length; debaterIdx++) {
-        const proposal = successfulProposals[debaterIdx];
-        const sessionRole = `debate-hybrid-${debaterIdx}`;
-        logger?.info("debate:rebuttal-start", "debate:rebuttal-start", {
-          storyId: ctx.storyId,
-          round,
-          debaterIndex: debaterIdx
-        });
-        const rebuttalPrompt = buildRebuttalContext(prompt, proposalList, priorRebuttals, debaterIdx);
-        try {
-          const turnResult = await runStatefulTurn(ctx, proposal.adapter, proposal.debater, rebuttalPrompt, sessionRole, true);
-          totalCostUsd += turnResult.cost;
-          rebuttals.push({ debater: proposal.debater, round, output: turnResult.output });
-        } catch (err) {
-          logger?.warn("debate", "debate:rebuttal-failed", {
-            storyId: ctx.storyId,
-            round,
-            debaterIndex: debaterIdx,
-            error: err instanceof Error ? err.message : String(err)
-          });
-        }
-      }
-    }
-  } finally {
-    for (let debaterIdx = 0;debaterIdx < successfulProposals.length; debaterIdx++) {
-      const proposal = successfulProposals[debaterIdx];
-      const sessionRole = `debate-hybrid-${debaterIdx}`;
-      try {
-        const closeCost = await closeStatefulSession(ctx, proposal.adapter, proposal.debater, sessionRole);
-        totalCostUsd += closeCost;
-      } catch {}
-    }
-  }
+  const { rebuttals, costUsd: rebuttalCost } = await runRebuttalLoop(ctx, successfulProposals, prompt, "debate-hybrid");
+  totalCostUsd += rebuttalCost;
   const critiqueOutputs = rebuttals.map((r) => r.output);
-  const resolveResult = await resolveOutcome(proposalOutputs, critiqueOutputs, ctx.stageConfig, ctx.config, ctx.storyId, ctx.timeoutSeconds * 1000);
+  const fullResolverContext = ctx.resolverContextInput ? {
+    ...ctx.resolverContextInput,
+    labeledProposals: successfulProposals.map((s) => ({ debater: s.debater.agent, output: s.output }))
+  } : undefined;
+  const resolveResult = await resolveOutcome(proposalOutputs, critiqueOutputs, ctx.stageConfig, ctx.config, ctx.storyId, ctx.timeoutSeconds * 1000, ctx.workdir, ctx.featureName, ctx.reviewerSession, fullResolverContext);
   totalCostUsd += resolveResult.resolverCostUsd;
   return {
     storyId: ctx.storyId,
@@ -22051,7 +22174,11 @@ async function runOneShot(ctx, prompt) {
     critiqueOutputs = critiqueSettled.filter((r) => r.status === "fulfilled").map((r) => r.value.output);
   }
   const proposalOutputs = successful.map((p) => p.output);
-  const outcome = await resolveOutcome(proposalOutputs, critiqueOutputs, ctx.stageConfig, ctx.config, ctx.storyId, ctx.timeoutMs);
+  const fullResolverContext = ctx.resolverContextInput ? {
+    ...ctx.resolverContextInput,
+    labeledProposals: successful.map((p) => ({ debater: p.debater.agent, output: p.output }))
+  } : undefined;
+  const outcome = await resolveOutcome(proposalOutputs, critiqueOutputs, ctx.stageConfig, ctx.config, ctx.storyId, ctx.timeoutMs, ctx.workdir, ctx.featureName, ctx.reviewerSession, fullResolverContext);
   totalCostUsd += outcome.resolverCostUsd;
   const proposals = successful.map((p) => ({
     debater: p.debater,
@@ -22083,7 +22210,7 @@ async function runPlan2(ctx, basePrompt, opts) {
   const logger = _debateSessionDeps.getSafeLogger();
   const config2 = ctx.stageConfig;
   const debaters = config2.debaters ?? [];
-  const totalCostUsd = 0;
+  let totalCostUsd = 0;
   const resolved = [];
   for (const debater of debaters) {
     const adapter = _debateSessionDeps.getAgent(debater.agent, ctx.config);
@@ -22106,13 +22233,16 @@ async function runPlan2(ctx, basePrompt, opts) {
 
 Write the PRD JSON directly to this file path: ${tempOutputPath}
 Do NOT output the JSON to the conversation. Write the file, then reply with a brief confirmation.`;
-    await adapter.plan({
+    const modelTier = modelTierFromDebater(debater);
+    const modelDef = resolveModelDefForDebater(debater, modelTier, ctx.config);
+    const planResult = await adapter.plan({
       prompt: debaterPrompt,
       workdir: opts.workdir,
       interactive: false,
       timeoutSeconds: opts.timeoutSeconds,
       config: ctx.config,
-      modelTier: debater.model ?? "balanced",
+      modelTier,
+      modelDef,
       dangerouslySkipPermissions: opts.dangerouslySkipPermissions,
       maxInteractionTurns: opts.maxInteractionTurns,
       featureName: opts.feature,
@@ -22120,13 +22250,14 @@ Do NOT output the JSON to the conversation. Write the file, then reply with a br
       sessionRole: `plan-${i}`
     });
     const output = await _debateSessionDeps.readFile(tempOutputPath);
-    return { debater, adapter, output, cost: 0 };
+    return { debater, adapter, output, cost: planResult.costUsd ?? 0 };
   }), concurrencyLimit);
   const successful = [];
   for (let i = 0;i < settled.length; i++) {
     const res = settled[i];
     if (res.status === "fulfilled") {
       successful.push(res.value);
+      totalCostUsd += res.value.cost;
     } else {
       const { debater } = resolved[i];
       logger?.warn("debate", "debate:debater-failed", {
@@ -22178,9 +22309,30 @@ Do NOT output the JSON to the conversation. Write the file, then reply with a br
     };
   }
   const proposalOutputs = successful.map((p) => p.output);
+  const mode = ctx.stageConfig.mode ?? "panel";
+  const sessionMode = ctx.stageConfig.sessionMode ?? "one-shot";
+  let critiqueOutputs = [];
+  let rebuttalList;
+  if (mode === "hybrid" && sessionMode === "stateful") {
+    const hybridCtx = {
+      storyId: ctx.storyId,
+      stage: ctx.stage,
+      stageConfig: ctx.stageConfig,
+      config: ctx.config,
+      workdir: opts.workdir,
+      featureName: opts.feature,
+      timeoutSeconds: opts.timeoutSeconds ?? 600
+    };
+    const { rebuttals, costUsd } = await runRebuttalLoop(hybridCtx, successful, basePrompt, "plan-hybrid");
+    critiqueOutputs = rebuttals.map((r) => r.output);
+    rebuttalList = rebuttals;
+    totalCostUsd += costUsd;
+  } else if (mode === "hybrid") {
+    logger?.warn("debate", "hybrid mode requires sessionMode: stateful for plan \u2014 running as panel");
+  }
   const resolverTimeoutMs = (ctx.stageConfig.timeoutSeconds ?? 600) * 1000;
-  const outcome = await resolveOutcome(proposalOutputs, [], ctx.stageConfig, ctx.config, ctx.storyId, resolverTimeoutMs);
-  const winningOutput = successful[0].output;
+  const outcome = await resolveOutcome(proposalOutputs, critiqueOutputs, ctx.stageConfig, ctx.config, ctx.storyId, resolverTimeoutMs, opts.workdir, opts.feature);
+  const winningOutput = outcome.output ?? successful[0].output;
   const proposals = successful.map((p) => ({ debater: p.debater, output: p.output }));
   logger?.info("debate", "debate:result", {
     storyId: ctx.storyId,
@@ -22191,16 +22343,18 @@ Do NOT output the JSON to the conversation. Write the file, then reply with a br
     storyId: ctx.storyId,
     stage: ctx.stage,
     outcome: outcome.outcome,
-    rounds: 1,
+    rounds: rebuttalList ? config2.rounds : 1,
     debaters: successful.map((p) => p.debater.agent),
     resolverType: config2.resolver.type,
     proposals,
+    rebuttals: rebuttalList,
     output: winningOutput,
     totalCostUsd
   };
 }
 var init_session_plan = __esm(() => {
   init_session_helpers();
+  init_session_hybrid();
 });
 
 // src/debate/session.ts
@@ -22212,6 +22366,8 @@ class DebateSession {
   workdir;
   featureName;
   timeoutSeconds;
+  reviewerSession;
+  resolverContextInput;
   get timeoutMs() {
     return this.timeoutSeconds * 1000;
   }
@@ -22223,6 +22379,8 @@ class DebateSession {
     this.workdir = opts.workdir ?? process.cwd();
     this.featureName = opts.featureName ?? opts.stage;
     this.timeoutSeconds = opts.timeoutSeconds ?? opts.stageConfig.timeoutSeconds ?? DEFAULT_TIMEOUT_SECONDS;
+    this.reviewerSession = opts.reviewerSession;
+    this.resolverContextInput = opts.resolverContextInput;
   }
   async run(prompt) {
     const sessionMode = this.stageConfig.sessionMode ?? "one-shot";
@@ -22236,7 +22394,9 @@ class DebateSession {
           config: this.config,
           workdir: this.workdir,
           featureName: this.featureName,
-          timeoutSeconds: this.timeoutSeconds
+          timeoutSeconds: this.timeoutSeconds,
+          reviewerSession: this.reviewerSession,
+          resolverContextInput: this.resolverContextInput
         }, prompt);
       }
       const logger = _debateSessionDeps.getSafeLogger();
@@ -22246,7 +22406,11 @@ class DebateSession {
         stage: this.stage,
         stageConfig: this.stageConfig,
         config: this.config,
-        timeoutMs: this.timeoutMs
+        timeoutMs: this.timeoutMs,
+        workdir: this.workdir,
+        featureName: this.featureName,
+        reviewerSession: this.reviewerSession,
+        resolverContextInput: this.resolverContextInput
       }, prompt);
     }
     if (sessionMode === "stateful") {
@@ -22257,7 +22421,9 @@ class DebateSession {
         config: this.config,
         workdir: this.workdir,
         featureName: this.featureName,
-        timeoutSeconds: this.timeoutSeconds
+        timeoutSeconds: this.timeoutSeconds,
+        reviewerSession: this.reviewerSession,
+        resolverContextInput: this.resolverContextInput
       }, prompt);
     }
     return runOneShot({
@@ -22265,7 +22431,11 @@ class DebateSession {
       stage: this.stage,
       stageConfig: this.stageConfig,
       config: this.config,
-      timeoutMs: this.timeoutMs
+      timeoutMs: this.timeoutMs,
+      workdir: this.workdir,
+      featureName: this.featureName,
+      reviewerSession: this.reviewerSession,
+      resolverContextInput: this.resolverContextInput
     }, prompt);
   }
   async runPlan(basePrompt, opts) {
@@ -22600,30 +22770,41 @@ class CLIInteractionPlugin {
   }
   async send(request) {
     this.pendingRequests.set(request.id, request);
-    console.log(`
-${"=".repeat(80)}`);
-    console.log(`[INTERACTION] ${request.stage.toUpperCase()} \u2014 ${request.type.toUpperCase()}`);
-    console.log("=".repeat(80));
-    console.log(`
+    process.stdout.write(`
+${"=".repeat(80)}
+`);
+    process.stdout.write(`[INTERACTION] ${request.stage.toUpperCase()} \u2014 ${request.type.toUpperCase()}
+`);
+    process.stdout.write(`${"=".repeat(80)}
+`);
+    process.stdout.write(`
 ${request.summary}
+
 `);
     if (request.detail) {
-      console.log(request.detail);
-      console.log("");
+      process.stdout.write(`${request.detail}
+`);
+      process.stdout.write(`
+`);
     }
     if (request.options && request.options.length > 0) {
-      console.log("Options:");
+      process.stdout.write(`Options:
+`);
       for (const opt of request.options) {
         const desc = opt.description ? ` \u2014 ${opt.description}` : "";
-        console.log(`  [${opt.key}] ${opt.label}${desc}`);
+        process.stdout.write(`  [${opt.key}] ${opt.label}${desc}
+`);
       }
-      console.log("");
+      process.stdout.write(`
+`);
     }
     if (request.timeout) {
       const timeoutSec = Math.floor(request.timeout / 1000);
-      console.log(`[Timeout: ${timeoutSec}s | Fallback: ${request.fallback}]`);
+      process.stdout.write(`[Timeout: ${timeoutSec}s | Fallback: ${request.fallback}]
+`);
     }
-    console.log(`${"=".repeat(80)}
+    process.stdout.write(`${"=".repeat(80)}
+
 `);
   }
   async receive(requestId, timeout = 60000) {
@@ -22645,9 +22826,9 @@ ${request.summary}
     if (!this.rl) {
       throw new Error("CLI plugin not initialized");
     }
-    const timeoutPromise = new Promise((resolve5) => {
+    const timeoutPromise = new Promise((resolve6) => {
       setTimeout(() => {
-        resolve5({
+        resolve6({
           requestId: request.id,
           action: "skip",
           respondedBy: "timeout",
@@ -22799,9 +22980,9 @@ ${request.summary}
     if (!this.rl) {
       throw new Error("CLI plugin not initialized");
     }
-    return new Promise((resolve5) => {
+    return new Promise((resolve6) => {
       this.rl?.question(prompt, (answer) => {
-        resolve5(answer);
+        resolve6(answer);
       });
     });
   }
@@ -23233,7 +23414,7 @@ class WebhookInteractionPlugin {
       this.pendingResponses.delete(requestId);
       return early;
     }
-    return new Promise((resolve5) => {
+    return new Promise((resolve6) => {
       const existingCallback = this.receiveCallbacks.get(requestId);
       if (existingCallback) {
         this.clearReceiveTimer(requestId);
@@ -23247,7 +23428,7 @@ class WebhookInteractionPlugin {
       const timer = setTimeout(() => {
         this.clearReceiveTimer(requestId);
         this.receiveCallbacks.delete(requestId);
-        resolve5({
+        resolve6({
           requestId,
           action: "skip",
           respondedBy: "timeout",
@@ -23258,7 +23439,7 @@ class WebhookInteractionPlugin {
       this.receiveCallbacks.set(requestId, (response) => {
         this.clearReceiveTimer(requestId);
         this.receiveCallbacks.delete(requestId);
-        resolve5(response);
+        resolve6(response);
       });
     });
   }
@@ -25203,6 +25384,7 @@ async function runPipeline(stages, context, eventEmitter) {
   const logger = getLogger();
   const retryCountMap = new Map;
   let i = 0;
+  let stageCostAccum = 0;
   while (i < stages.length) {
     const stage = stages[i];
     if (!stage.enabled(context)) {
@@ -25221,27 +25403,58 @@ async function runPipeline(stages, context, eventEmitter) {
         reason: `Stage "${stage.name}" threw error: ${errorMessage(error48)}`
       };
       eventEmitter?.emit("stage:exit", stage.name, failResult);
-      return { success: false, finalAction: "fail", reason: failResult.reason, stoppedAtStage: stage.name, context };
+      return {
+        success: false,
+        finalAction: "fail",
+        reason: failResult.reason,
+        stoppedAtStage: stage.name,
+        context,
+        stageCost: stageCostAccum > 0 ? stageCostAccum : undefined
+      };
     }
+    if (result.cost)
+      stageCostAccum += result.cost;
     eventEmitter?.emit("stage:exit", stage.name, result);
     switch (result.action) {
       case "continue":
         i++;
         continue;
       case "skip":
-        return { success: false, finalAction: "skip", reason: result.reason, stoppedAtStage: stage.name, context };
+        return {
+          success: false,
+          finalAction: "skip",
+          reason: result.reason,
+          stoppedAtStage: stage.name,
+          context,
+          stageCost: stageCostAccum > 0 ? stageCostAccum : undefined
+        };
       case "fail":
-        return { success: false, finalAction: "fail", reason: result.reason, stoppedAtStage: stage.name, context };
+        return {
+          success: false,
+          finalAction: "fail",
+          reason: result.reason,
+          stoppedAtStage: stage.name,
+          context,
+          stageCost: stageCostAccum > 0 ? stageCostAccum : undefined
+        };
       case "escalate":
         return {
           success: false,
           finalAction: "escalate",
           reason: result.reason ?? "Stage requested escalation to higher tier",
           stoppedAtStage: stage.name,
-          context
+          context,
+          stageCost: stageCostAccum > 0 ? stageCostAccum : undefined
         };
       case "pause":
-        return { success: false, finalAction: "pause", reason: result.reason, stoppedAtStage: stage.name, context };
+        return {
+          success: false,
+          finalAction: "pause",
+          reason: result.reason,
+          stoppedAtStage: stage.name,
+          context,
+          stageCost: stageCostAccum > 0 ? stageCostAccum : undefined
+        };
       case "retry": {
         const retries = (retryCountMap.get(result.fromStage) ?? 0) + 1;
         if (retries > MAX_STAGE_RETRIES) {
@@ -25251,7 +25464,8 @@ async function runPipeline(stages, context, eventEmitter) {
             finalAction: "fail",
             reason: `Stage "${stage.name}" exceeded max retries (${MAX_STAGE_RETRIES}) for "${result.fromStage}"`,
             stoppedAtStage: stage.name,
-            context
+            context,
+            stageCost: stageCostAccum > 0 ? stageCostAccum : undefined
           };
         }
         retryCountMap.set(result.fromStage, retries);
@@ -25263,7 +25477,8 @@ async function runPipeline(stages, context, eventEmitter) {
             finalAction: "escalate",
             reason: `Retry target stage "${result.fromStage}" not found`,
             stoppedAtStage: stage.name,
-            context
+            context,
+            stageCost: stageCostAccum > 0 ? stageCostAccum : undefined
           };
         }
         logger.debug("pipeline", `Retrying from stage "${result.fromStage}" (attempt ${retries}/${MAX_STAGE_RETRIES})`);
@@ -25276,7 +25491,12 @@ async function runPipeline(stages, context, eventEmitter) {
       }
     }
   }
-  return { success: true, finalAction: "complete", context };
+  return {
+    success: true,
+    finalAction: "complete",
+    context,
+    stageCost: stageCostAccum > 0 ? stageCostAccum : undefined
+  };
 }
 var MAX_STAGE_RETRIES = 5;
 var init_runner = __esm(() => {
@@ -25814,8 +26034,7 @@ var init_acceptance = __esm(() => {
   acceptanceStage = {
     name: "acceptance",
     enabled(ctx) {
-      const effectiveConfig = ctx.effectiveConfig ?? ctx.config;
-      if (!effectiveConfig.acceptance.enabled) {
+      if (!ctx.config.acceptance.enabled) {
         return false;
       }
       if (!areAllStoriesComplete(ctx)) {
@@ -25825,7 +26044,6 @@ var init_acceptance = __esm(() => {
     },
     async execute(ctx) {
       const logger = getLogger();
-      const effectiveConfig = ctx.effectiveConfig ?? ctx.config;
       logger.info("acceptance", "Running acceptance tests", { storyId: ctx.story.id });
       if (!ctx.featureDir) {
         logger.warn("acceptance", "No feature directory \u2014 skipping acceptance tests", { storyId: ctx.story.id });
@@ -25833,7 +26051,7 @@ var init_acceptance = __esm(() => {
       }
       const testGroups = ctx.acceptanceTestPaths ?? [
         {
-          testPath: resolveAcceptanceFeatureTestPath(ctx.featureDir, effectiveConfig.acceptance.testPath, effectiveConfig.project?.language),
+          testPath: resolveAcceptanceFeatureTestPath(ctx.featureDir, ctx.config.acceptance.testPath, ctx.config.project?.language),
           packageDir: ctx.workdir
         }
       ];
@@ -25848,7 +26066,7 @@ var init_acceptance = __esm(() => {
           logger.warn("acceptance", "Acceptance test file not found \u2014 skipping", { storyId: ctx.story.id, testPath });
           continue;
         }
-        const testCmdParts = buildAcceptanceRunCommand(testPath, effectiveConfig.project?.testFramework, effectiveConfig.acceptance.command);
+        const testCmdParts = buildAcceptanceRunCommand(testPath, ctx.config.project?.testFramework, ctx.config.acceptance.command);
         logger.info("acceptance", "Running acceptance command", {
           storyId: ctx.story.id,
           cmd: testCmdParts.join(" "),
@@ -25943,12 +26161,12 @@ function buildRefinementPrompt(criteria, codebaseContext, options) {
 `);
   const strategySection = buildStrategySection(options);
   const refinedExample = buildRefinedExample(options?.testStrategy);
+  const codebaseSection = codebaseContext ? `CODEBASE CONTEXT:
+${codebaseContext}
+` : "";
   const core2 = `You are an acceptance criteria refinement assistant. Your task is to convert raw acceptance criteria into concrete, machine-verifiable assertions.
 
-CODEBASE CONTEXT:
-${codebaseContext}
-${strategySection}
-ACCEPTANCE CRITERIA TO REFINE:
+${codebaseSection}${strategySection}ACCEPTANCE CRITERIA TO REFINE:
 ${criteriaList}
 
 For each criterion, produce a refined version that is concrete and automatically testable where possible.
@@ -26201,12 +26419,11 @@ ${stderr}` };
       if (!ctx.featureDir) {
         return { action: "fail", reason: "[acceptance-setup] featureDir is not set" };
       }
-      const effectiveConfig = ctx.effectiveConfig ?? ctx.config;
-      const language = effectiveConfig.project?.language;
-      const testPathConfig = (ctx.effectiveConfig ?? ctx.config).acceptance.testPath;
+      const language = ctx.config.project?.language;
+      const testPathConfig = ctx.config.acceptance.testPath;
       const metaPath = path5.join(ctx.featureDir, "acceptance-meta.json");
-      const allCriteria = ctx.prd.userStories.filter((s) => !s.id.startsWith("US-FIX-")).flatMap((s) => s.acceptanceCriteria);
-      const nonFixStories = ctx.prd.userStories.filter((s) => !s.id.startsWith("US-FIX-"));
+      const allCriteria = ctx.prd.userStories.filter((s) => !s.id.startsWith("US-FIX-") && s.status !== "decomposed").flatMap((s) => s.acceptanceCriteria);
+      const nonFixStories = ctx.prd.userStories.filter((s) => !s.id.startsWith("US-FIX-") && s.status !== "decomposed");
       const workdirGroups = new Map;
       for (const story of nonFixStories) {
         const wd = story.workdir ?? "";
@@ -26262,7 +26479,7 @@ ${stderr}` };
       }
       if (shouldGenerate) {
         totalCriteria = allCriteria.length;
-        const agent = (ctx.agentGetFn ?? _acceptanceSetupDeps.getAgent)(ctx.config.autoMode.defaultAgent);
+        const agent = (ctx.agentGetFn ?? _acceptanceSetupDeps.getAgent)(ctx.rootConfig.autoMode.defaultAgent);
         let allRefinedCriteria;
         if (ctx.config.acceptance.refinement) {
           const maxConcurrency = ctx.config.acceptance.refinementConcurrency ?? 3;
@@ -26306,7 +26523,7 @@ ${stderr}` };
           const groupRefined = allRefinedCriteria.filter((r) => groupStoryIds.has(r.storyId));
           let modelDef;
           try {
-            modelDef = resolveModelForAgent(ctx.config.models, ctx.routing.agent ?? ctx.config.autoMode.defaultAgent, ctx.config.acceptance.model ?? "fast", ctx.config.autoMode.defaultAgent);
+            modelDef = resolveModelForAgent(ctx.rootConfig.models, ctx.routing.agent ?? ctx.rootConfig.autoMode.defaultAgent, ctx.config.acceptance.model ?? "fast", ctx.rootConfig.autoMode.defaultAgent);
           } catch {
             const tier = ctx.config.acceptance.model ?? "fast";
             modelDef = { provider: "anthropic", model: tier };
@@ -26342,7 +26559,7 @@ ${stderr}` };
       }
       let redFailCount = 0;
       for (const { testPath, packageDir } of testPaths) {
-        const runCmd = buildAcceptanceRunCommand(testPath, effectiveConfig.project?.testFramework, effectiveConfig.acceptance.command);
+        const runCmd = buildAcceptanceRunCommand(testPath, ctx.config.project?.testFramework, ctx.config.acceptance.command);
         getSafeLogger()?.info("acceptance-setup", "Running acceptance RED gate command", {
           cmd: runCmd.join(" "),
           packageDir
@@ -26365,59 +26582,6 @@ ${stderr}` };
   };
 });
 
-// src/agents/claude/index.ts
-var init_claude = __esm(() => {
-  init_adapter3();
-  init_execution();
-});
-
-// src/agents/shared/validation.ts
-function validateAgentForTier(agent, tier) {
-  return agent.capabilities.supportedTiers.includes(tier);
-}
-function validateAgentFeature(agent, feature) {
-  return agent.capabilities.features.has(feature);
-}
-function describeAgentCapabilities(agent) {
-  const tiers = agent.capabilities.supportedTiers.join(",");
-  const features = Array.from(agent.capabilities.features).join(",");
-  const maxTokens = agent.capabilities.maxContextTokens;
-  return `${agent.name}: tiers=[${tiers}], maxTokens=${maxTokens}, features=[${features}]`;
-}
-
-// src/agents/index.ts
-var exports_agents = {};
-__export(exports_agents, {
-  validateAgentForTier: () => validateAgentForTier,
-  validateAgentFeature: () => validateAgentFeature,
-  parseTokenUsage: () => parseTokenUsage,
-  getInstalledAgents: () => getInstalledAgents,
-  getAllAgentNames: () => getAllAgentNames,
-  getAgentVersions: () => getAgentVersions,
-  getAgentVersion: () => getAgentVersion,
-  getAgent: () => getAgent,
-  formatCostWithConfidence: () => formatCostWithConfidence,
-  estimateCostFromTokenUsage: () => estimateCostFromTokenUsage,
-  estimateCostFromOutput: () => estimateCostFromOutput,
-  estimateCostByDuration: () => estimateCostByDuration,
-  estimateCost: () => estimateCost,
-  describeAgentCapabilities: () => describeAgentCapabilities,
-  checkAgentHealth: () => checkAgentHealth,
-  MODEL_PRICING: () => MODEL_PRICING,
-  CompleteError: () => CompleteError,
-  ClaudeCodeAdapter: () => ClaudeCodeAdapter,
-  COST_RATES: () => COST_RATES,
-  AllAgentsUnavailableError: () => AllAgentsUnavailableError
-});
-var init_agents = __esm(() => {
-  init_types2();
-  init_claude();
-  init_registry();
-  init_cost();
-  init_version_detection();
-  init_errors();
-});
-
 // src/quality/runner.ts
 var {spawn: spawn2 } = globalThis.Bun;
 async function runQualityCommand(opts) {
@@ -26720,7 +26884,60 @@ Do NOT add new features \u2014 only fix the identified issues.
 Commit your fixes when done.${scopeConstraint}`;
 }
 
-// src/review/dialogue.ts
+// src/agents/claude/index.ts
+var init_claude = __esm(() => {
+  init_adapter3();
+  init_execution();
+});
+
+// src/agents/shared/validation.ts
+function validateAgentForTier(agent, tier) {
+  return agent.capabilities.supportedTiers.includes(tier);
+}
+function validateAgentFeature(agent, feature) {
+  return agent.capabilities.features.has(feature);
+}
+function describeAgentCapabilities(agent) {
+  const tiers = agent.capabilities.supportedTiers.join(",");
+  const features = Array.from(agent.capabilities.features).join(",");
+  const maxTokens = agent.capabilities.maxContextTokens;
+  return `${agent.name}: tiers=[${tiers}], maxTokens=${maxTokens}, features=[${features}]`;
+}
+
+// src/agents/index.ts
+var exports_agents = {};
+__export(exports_agents, {
+  validateAgentForTier: () => validateAgentForTier,
+  validateAgentFeature: () => validateAgentFeature,
+  parseTokenUsage: () => parseTokenUsage,
+  getInstalledAgents: () => getInstalledAgents,
+  getAllAgentNames: () => getAllAgentNames,
+  getAgentVersions: () => getAgentVersions,
+  getAgentVersion: () => getAgentVersion,
+  getAgent: () => getAgent,
+  formatCostWithConfidence: () => formatCostWithConfidence,
+  estimateCostFromTokenUsage: () => estimateCostFromTokenUsage,
+  estimateCostFromOutput: () => estimateCostFromOutput,
+  estimateCostByDuration: () => estimateCostByDuration,
+  estimateCost: () => estimateCost,
+  describeAgentCapabilities: () => describeAgentCapabilities,
+  checkAgentHealth: () => checkAgentHealth,
+  MODEL_PRICING: () => MODEL_PRICING,
+  CompleteError: () => CompleteError,
+  ClaudeCodeAdapter: () => ClaudeCodeAdapter,
+  COST_RATES: () => COST_RATES,
+  AllAgentsUnavailableError: () => AllAgentsUnavailableError
+});
+var init_agents = __esm(() => {
+  init_types2();
+  init_claude();
+  init_registry();
+  init_cost();
+  init_version_detection();
+  init_errors();
+});
+
+// src/review/dialogue-prompts.ts
 function buildReviewPrompt(diff, story, _semanticConfig) {
   const criteria = story.acceptanceCriteria.map((c) => `- ${c}`).join(`
 `);
@@ -26754,6 +26971,98 @@ function buildReReviewPrompt(updatedDiff, previousFindings) {
   ].join(`
 `);
 }
+function buildProposalsSection(proposals) {
+  return proposals.map((p) => `### ${p.debater}
+${p.output}`).join(`
+
+`);
+}
+function buildCritiquesSection(critiques) {
+  if (critiques.length === 0)
+    return "";
+  return `
+
+## Critiques
+${critiques.map((c, i) => `### Critique ${i + 1}
+${c}`).join(`
+
+`)}`;
+}
+function buildVoteTallyLine(ctx) {
+  if (!ctx.majorityVote)
+    return "";
+  const { passCount, failCount } = ctx.majorityVote;
+  const failOpenNote = ctx.resolverType === "majority-fail-open" ? " (unparseable proposals count as pass)" : " (unparseable proposals count as fail)";
+  return `
+
+The preliminary majority vote is: **${passCount} passed, ${failCount} failed**${failOpenNote}. Verify the failing findings with tools before giving your authoritative verdict.`;
+}
+function buildResolverFraming(ctx) {
+  switch (ctx.resolverType) {
+    case "majority-fail-closed":
+    case "majority-fail-open":
+      return "You are the authoritative reviewer resolving a debate. A preliminary vote was taken \u2014 see tally below. Verify disputed findings using tools (READ files, GREP for usage) and give your final verdict.";
+    case "synthesis":
+      return "You are a synthesis reviewer. Synthesize the debater proposals into a single, coherent, tool-verified verdict. Use READ and GREP to verify claims before ruling.";
+    case "custom":
+      return "You are the judge. Evaluate the debater proposals independently. Verify claims with tools (READ, GREP) and give your final authoritative verdict.";
+    default:
+      return "You are the reviewer. Evaluate the debater proposals and give your final authoritative verdict.";
+  }
+}
+function buildDebateResolverPrompt(proposals, critiques, diff, story, _semanticConfig, resolverContext) {
+  const criteria = story.acceptanceCriteria.map((c) => `- ${c}`).join(`
+`);
+  const framing = buildResolverFraming(resolverContext);
+  const voteTally = buildVoteTallyLine(resolverContext);
+  const proposalsSection = buildProposalsSection(proposals);
+  const critiquesSection = buildCritiquesSection(critiques);
+  return [
+    framing,
+    "",
+    `## Story ${story.id}: ${story.title}`,
+    "",
+    "## Acceptance Criteria",
+    criteria,
+    "",
+    "## Debater Proposals",
+    proposalsSection,
+    critiquesSection,
+    "",
+    "## Diff",
+    diff,
+    voteTally,
+    "",
+    "Respond with JSON: { passed: boolean, findings: [...], findingReasoning: { [id]: string } }"
+  ].filter((line) => line !== undefined).join(`
+`);
+}
+function buildDebateReReviewPrompt(proposals, critiques, updatedDiff, previousFindings, resolverContext) {
+  const framing = buildResolverFraming(resolverContext);
+  const findingsList = previousFindings.length > 0 ? previousFindings.map((f) => `- ${f.ruleId}: ${f.message}`).join(`
+`) : "(none)";
+  const proposalsSection = buildProposalsSection(proposals);
+  const critiquesSection = buildCritiquesSection(critiques);
+  return [
+    `${framing} This is a re-review after implementer changes.`,
+    "",
+    "## Previous Findings",
+    findingsList,
+    "",
+    "## Updated Debater Proposals",
+    proposalsSection,
+    critiquesSection,
+    "",
+    "## Updated Diff",
+    updatedDiff,
+    "",
+    "Respond with JSON: { passed: boolean, findings: [...], findingReasoning: { [id]: string }, deltaSummary: string }",
+    "deltaSummary should describe which previous findings are resolved vs still present."
+  ].filter((line) => line !== undefined).join(`
+`);
+}
+
+// src/review/dialogue.ts
 function extractDeltaSummary(rawOutput, previousFindings, newFindings) {
   try {
     const parsed = JSON.parse(rawOutput);
@@ -26825,6 +27134,7 @@ function createReviewerSession(agent, storyId, workdir, featureName, _config) {
   let lastCheckResult = null;
   let lastStory = null;
   let lastSemanticConfig = null;
+  let lastWasDebateResolve = false;
   const sessionState = {
     generation: 1,
     pendingCompactionContext: null
@@ -26883,10 +27193,12 @@ ${prompt}`,
       history.push({ role: "implementer", content: prompt });
       history.push({ role: "reviewer", content: result.output });
       const parsed = parseReviewResponse(result.output);
-      lastCheckResult = parsed;
+      const reviewResult = { ...parsed, cost: result.estimatedCost ?? 0 };
+      lastCheckResult = reviewResult;
       lastStory = story;
       lastSemanticConfig = semanticConfig;
-      return parsed;
+      lastWasDebateResolve = false;
+      return reviewResult;
     },
     async reReview(updatedDiff) {
       if (!active) {
@@ -26920,7 +27232,7 @@ ${prompt}`,
       history.push({ role: "reviewer", content: result.output });
       const parsed = parseReviewResponse(result.output);
       const deltaSummary = extractDeltaSummary(result.output, previousFindings, parsed.checkResult.findings);
-      const dialogueResult = { ...parsed, deltaSummary };
+      const dialogueResult = { ...parsed, deltaSummary, cost: result.estimatedCost ?? 0 };
       lastCheckResult = dialogueResult;
       const maxMessages = _config.review?.dialogue?.maxDialogueMessages ?? 20;
       if (history.length > maxMessages) {
@@ -26955,6 +27267,76 @@ ${prompt}`,
       history.push({ role: "reviewer", content: result.output });
       return result.output;
     },
+    async resolveDebate(proposals, critiques, diff, story, semanticConfig, resolverContext) {
+      if (!active) {
+        throw new NaxError(`[dialogue] ReviewerSession for story ${storyId} has been destroyed`, "REVIEWER_SESSION_DESTROYED", { stage: "review", storyId, featureName });
+      }
+      const prompt = buildDebateResolverPrompt(proposals, critiques, diff, story, semanticConfig, resolverContext);
+      const { modelTier, modelDef, timeoutSeconds } = resolveRunParams(semanticConfig);
+      const { effectivePrompt, acpSessionName } = buildEffectiveRunArgs(prompt);
+      const result = await agent.run({
+        prompt: effectivePrompt,
+        workdir,
+        modelTier,
+        modelDef,
+        timeoutSeconds,
+        sessionRole: "reviewer",
+        keepSessionOpen: true,
+        pipelineStage: "review",
+        config: _config,
+        storyId,
+        featureName,
+        acpSessionName
+      });
+      history.push({ role: "implementer", content: prompt });
+      history.push({ role: "reviewer", content: result.output });
+      const parsed = parseReviewResponse(result.output);
+      const reviewResult = { ...parsed, cost: result.estimatedCost ?? 0 };
+      lastCheckResult = reviewResult;
+      lastStory = story;
+      lastSemanticConfig = semanticConfig;
+      lastWasDebateResolve = true;
+      return reviewResult;
+    },
+    async reReviewDebate(proposals, critiques, updatedDiff, resolverContext) {
+      if (!active) {
+        throw new NaxError(`[dialogue] ReviewerSession for story ${storyId} has been destroyed`, "REVIEWER_SESSION_DESTROYED", { stage: "review", storyId, featureName });
+      }
+      if (!lastCheckResult || !lastSemanticConfig || !lastWasDebateResolve) {
+        throw new NaxError(`[dialogue] reReviewDebate() called before any resolveDebate() on story ${storyId}`, "NO_REVIEW_RESULT", { stage: "review", storyId });
+      }
+      const previousFindings = lastCheckResult.checkResult.findings;
+      const prompt = buildDebateReReviewPrompt(proposals, critiques, updatedDiff, previousFindings, resolverContext);
+      const { modelTier, modelDef, timeoutSeconds } = resolveRunParams(lastSemanticConfig);
+      const { effectivePrompt, acpSessionName } = buildEffectiveRunArgs(prompt);
+      const result = await agent.run({
+        prompt: effectivePrompt,
+        workdir,
+        modelTier,
+        modelDef,
+        timeoutSeconds,
+        sessionRole: "reviewer",
+        keepSessionOpen: true,
+        pipelineStage: "review",
+        config: _config,
+        storyId,
+        featureName,
+        acpSessionName
+      });
+      history.push({ role: "implementer", content: prompt });
+      history.push({ role: "reviewer", content: result.output });
+      const parsed = parseReviewResponse(result.output);
+      const deltaSummary = extractDeltaSummary(result.output, previousFindings, parsed.checkResult.findings);
+      const dialogueResult = { ...parsed, deltaSummary, cost: result.estimatedCost ?? 0 };
+      lastCheckResult = dialogueResult;
+      const maxMessages = _config.review?.dialogue?.maxDialogueMessages ?? 20;
+      if (history.length > maxMessages) {
+        const compactedSummary = compactHistory(history);
+        sessionState.generation++;
+        sessionState.pendingCompactionContext = compactedSummary;
+      }
+      return dialogueResult;
+    },
     getVerdict() {
       if (!lastCheckResult || !lastStory) {
         throw new NaxError(`[dialogue] getVerdict() called before any review() on story ${storyId}`, "NO_REVIEW_RESULT", { stage: "review", storyId });
@@ -27190,10 +27572,8 @@ var init_language_commands = __esm(() => {
 // src/review/semantic.ts
 var {spawn: spawn3 } = globalThis.Bun;
 async function collectDiff(workdir, storyGitRef, excludePatterns) {
-  const cmd = ["git", "diff", "--unified=3", `${storyGitRef}..HEAD`];
-  if (excludePatterns.length > 0) {
-    cmd.push("--", ".", ...excludePatterns);
-  }
+  const merged = [...new Set([...excludePatterns, ...ALWAYS_EXCLUDED])];
+  const cmd = ["git", "diff", "--unified=3", `${storyGitRef}..HEAD`, "--", ".", ...merged];
   const proc = _semanticDeps.spawn({
     cmd,
     cwd: workdir,
@@ -27353,7 +27733,7 @@ function toReviewFindings(findings) {
     source: "semantic-review"
   }));
 }
-async function runSemanticReview(workdir, storyGitRef, story, semanticConfig, modelResolver, naxConfig, featureName) {
+async function runSemanticReview(workdir, storyGitRef, story, semanticConfig, modelResolver, naxConfig, featureName, resolverSession) {
   const startTime = Date.now();
   const logger = getSafeLogger();
   if (featureName === undefined) {
@@ -27423,6 +27803,7 @@ async function runSemanticReview(workdir, storyGitRef, story, semanticConfig, mo
   const reviewDebateEnabled = naxConfig?.debate?.enabled && naxConfig?.debate?.stages?.review?.enabled;
   if (reviewDebateEnabled) {
     const reviewStageConfig = naxConfig?.debate?.stages.review;
+    const isReReview = resolverSession !== undefined && resolverSession.history.length > 0;
     const debateSession = _semanticDeps.createDebateSession({
       storyId: story.id,
       stage: "review",
@@ -27430,25 +27811,69 @@ async function runSemanticReview(workdir, storyGitRef, story, semanticConfig, mo
       config: naxConfig ?? DEFAULT_CONFIG,
       workdir,
       featureName,
-      timeoutSeconds: naxConfig?.execution?.sessionTimeoutSeconds
+      timeoutSeconds: naxConfig?.execution?.sessionTimeoutSeconds,
+      reviewerSession: resolverSession,
+      resolverContextInput: resolverSession ? {
+        diff,
+        story: { id: story.id, title: story.title, acceptanceCriteria: story.acceptanceCriteria },
+        semanticConfig,
+        resolverType: reviewStageConfig.resolver.type,
+        isReReview
+      } : undefined
     });
+    const historyLenBefore = resolverSession?.history.length ?? 0;
     const debateResult = await debateSession.run(prompt);
-    let passCount = 0;
-    let failCount = 0;
+    const debateCost = debateResult.totalCostUsd ?? 0;
+    const sessionUsed = resolverSession && resolverSession.history.length > historyLenBefore;
+    if (sessionUsed) {
+      const durationMs3 = Date.now() - startTime;
+      try {
+        const verdict = resolverSession.getVerdict();
+        const findings = verdict.findings ?? [];
+        if (!verdict.passed && findings.length > 0) {
+          logger?.warn("review", `Semantic review failed (debate+dialogue): ${findings.length} findings`, {
+            storyId: story.id,
+            durationMs: durationMs3
+          });
+          return {
+            check: "semantic",
+            success: false,
+            command: "",
+            exitCode: 1,
+            output: `Semantic review failed:
+
+${findings.map((f) => `${f.ruleId}: ${f.message}`).join(`
+`)}`,
+            durationMs: durationMs3,
+            findings,
+            cost: debateCost
+          };
+        }
+        const label = verdict.passed ? "Semantic review passed (debate+dialogue)" : "Semantic review passed (debate+dialogue, all findings non-blocking)";
+        logger?.info("review", label, { storyId: story.id, durationMs: durationMs3 });
+        return {
+          check: "semantic",
+          success: true,
+          command: "",
+          exitCode: 0,
+          output: label,
+          durationMs: durationMs3,
+          cost: debateCost
+        };
+      } catch {
+        logger?.warn("review", "getVerdict() failed after debate+dialogue \u2014 falling back to stateless verdict", {
+          storyId: story.id
+        });
+      }
+    }
+    const resolverPassed = debateResult.outcome === "passed";
     const allFindings = [];
     for (const p of debateResult.proposals) {
       const parsed2 = parseLLMResponse(p.output);
       if (parsed2) {
-        if (parsed2.passed)
-          passCount++;
-        else
-          failCount++;
         allFindings.push(...parsed2.findings);
-      } else {
-        failCount++;
       }
     }
-    const majorityPassed = passCount > failCount;
     const seen = new Set;
     const deduped = [];
     for (const f of allFindings) {
@@ -27460,7 +27885,7 @@ async function runSemanticReview(workdir, storyGitRef, story, semanticConfig, mo
     }
     const debateBlocking = deduped.filter((f) => isBlockingSeverity(f.severity));
     const durationMs2 = Date.now() - startTime;
-    if (!majorityPassed) {
+    if (!resolverPassed) {
       if (debateBlocking.length > 0) {
         logger?.warn("review", `Semantic review failed (debate): ${debateBlocking.length} findings`, {
           storyId: story.id,
@@ -27475,7 +27900,8 @@ async function runSemanticReview(workdir, storyGitRef, story, semanticConfig, mo
 
 ${formatFindings(debateBlocking)}`,
           durationMs: durationMs2,
-          findings: toReviewFindings(debateBlocking)
+          findings: toReviewFindings(debateBlocking),
+          cost: debateCost
         };
       }
       logger?.info("review", "Semantic review passed (debate, all findings non-blocking)", {
@@ -27488,7 +27914,8 @@ ${formatFindings(debateBlocking)}`,
         command: "",
         exitCode: 0,
         output: "Semantic review passed (debate, all findings were unverifiable or informational)",
-        durationMs: durationMs2
+        durationMs: durationMs2,
+        cost: debateCost
       };
     }
     logger?.info("review", "Semantic review passed (debate)", { storyId: story.id, durationMs: durationMs2 });
@@ -27498,7 +27925,8 @@ ${formatFindings(debateBlocking)}`,
       command: "",
       exitCode: 0,
       output: "Semantic review passed",
-      durationMs: durationMs2
+      durationMs: durationMs2,
+      cost: debateCost
     };
   }
   const implementerSidecarKey = `${story.id}:implementer`;
@@ -27517,6 +27945,7 @@ ${formatFindings(debateBlocking)}`,
     }
   } catch {}
   let rawResponse;
+  let llmCost = 0;
   try {
     let runErr;
     let runSucceeded = false;
@@ -27533,6 +27962,7 @@ ${formatFindings(debateBlocking)}`,
         config: naxConfig ?? DEFAULT_CONFIG
       });
       runOutput = runResult.output;
+      llmCost = runResult.estimatedCost ?? 0;
       runSucceeded = true;
     } catch (err) {
       runErr = err;
@@ -27548,6 +27978,7 @@ ${formatFindings(debateBlocking)}`,
         config: naxConfig ?? DEFAULT_CONFIG
       });
       rawResponse = typeof completeResult === "string" ? completeResult : completeResult.output;
+      llmCost = typeof completeResult === "string" ? 0 : completeResult.costUsd ?? 0;
     }
   } catch (err) {
     logger?.warn("semantic", "LLM call failed \u2014 fail-open", { cause: String(err) });
@@ -27573,7 +28004,8 @@ ${formatFindings(debateBlocking)}`,
         command: "",
         exitCode: 1,
         output: "semantic review: LLM response truncated but indicated failure (passed:false found in partial response)",
-        durationMs: Date.now() - startTime
+        durationMs: Date.now() - startTime,
+        cost: llmCost
       };
     }
     logger?.warn("semantic", "LLM returned invalid JSON \u2014 fail-open", { rawResponse: rawResponse.slice(0, 200) });
@@ -27583,7 +28015,8 @@ ${formatFindings(debateBlocking)}`,
       command: "",
       exitCode: 0,
       output: "semantic review: could not parse LLM response (fail-open)",
-      durationMs: Date.now() - startTime
+      durationMs: Date.now() - startTime,
+      cost: llmCost
     };
   }
   const blockingFindings = parsed.findings.filter((f) => isBlockingSeverity(f.severity));
@@ -27620,7 +28053,8 @@ ${formatFindings(blockingFindings)}`;
       exitCode: 1,
       output,
       durationMs: durationMs2,
-      findings: toReviewFindings(blockingFindings)
+      findings: toReviewFindings(blockingFindings),
+      cost: llmCost
     };
   }
   if (!parsed.passed && blockingFindings.length === 0) {
@@ -27632,7 +28066,8 @@ ${formatFindings(blockingFindings)}`;
       command: "",
       exitCode: 0,
       output: "Semantic review passed (all findings were unverifiable or informational)",
-      durationMs: durationMs2
+      durationMs: durationMs2,
+      cost: llmCost
     };
   }
   const durationMs = Date.now() - startTime;
@@ -27645,10 +28080,11 @@ ${formatFindings(blockingFindings)}`;
     command: "",
     exitCode: parsed.passed ? 0 : 1,
     output: parsed.passed ? "Semantic review passed" : "Semantic review failed (no findings)",
-    durationMs
+    durationMs,
+    cost: llmCost
   };
 }
-var _semanticDeps, DIFF_CAP_BYTES = 51200;
+var _semanticDeps, DIFF_CAP_BYTES = 51200, ALWAYS_EXCLUDED;
 var init_semantic = __esm(() => {
   init_adapter();
   init_config();
@@ -27662,6 +28098,7 @@ var init_semantic = __esm(() => {
     createDebateSession: (opts) => new DebateSession(opts),
     readAcpSession
   };
+  ALWAYS_EXCLUDED = [":!.nax/", ":!.nax-pids"];
 });
 
 // src/review/runner.ts
@@ -27746,7 +28183,7 @@ async function getUncommittedFilesImpl(workdir) {
     return [];
   }
 }
-async function runReview(config2, workdir, executionConfig, qualityCommands, storyId, storyGitRef, story, modelResolver, naxConfig, retrySkipChecks, featureName) {
+async function runReview(config2, workdir, executionConfig, qualityCommands, storyId, storyGitRef, story, modelResolver, naxConfig, retrySkipChecks, featureName, resolverSession) {
   const startTime = Date.now();
   const logger = getSafeLogger();
   const checks3 = [];
@@ -27803,10 +28240,19 @@ Stage and commit these files before running review.`
         modelTier: "balanced",
         rules: [],
         timeoutMs: 600000,
-        excludePatterns: [":!test/", ":!tests/", ":!*_test.go", ":!*.test.ts", ":!*.spec.ts", ":!**/__tests__/"]
+        excludePatterns: [
+          ":!test/",
+          ":!tests/",
+          ":!*_test.go",
+          ":!*.test.ts",
+          ":!*.spec.ts",
+          ":!**/__tests__/",
+          ":!.nax/",
+          ":!.nax-pids"
+        ]
       };
       const runSemantic = _reviewSemanticDeps.runSemanticReview;
-      const result2 = featureName !== undefined ? await runSemantic(workdir, storyGitRef, semanticStory, semanticCfg, modelResolver ?? (() => null), naxConfig, featureName) : await runSemantic(workdir, storyGitRef, semanticStory, semanticCfg, modelResolver ?? (() => null), naxConfig);
+      const result2 = await runSemantic(workdir, storyGitRef, semanticStory, semanticCfg, modelResolver ?? (() => null), naxConfig, featureName, resolverSession);
       checks3.push(result2);
       if (!result2.success && !firstFailure) {
         firstFailure = `${checkName} failed`;
@@ -27888,9 +28334,9 @@ async function getChangedFiles(workdir, baseRef) {
 }
 
 class ReviewOrchestrator {
-  async review(reviewConfig, workdir, executionConfig, plugins, storyGitRef, scopePrefix, qualityCommands, storyId, story, modelResolver, naxConfig, retrySkipChecks, featureName) {
+  async review(reviewConfig, workdir, executionConfig, plugins, storyGitRef, scopePrefix, qualityCommands, storyId, story, modelResolver, naxConfig, retrySkipChecks, featureName, resolverSession) {
     const logger = getSafeLogger();
-    const builtIn = await runReview(reviewConfig, workdir, executionConfig, qualityCommands, storyId, storyGitRef, story, modelResolver, naxConfig, retrySkipChecks, featureName);
+    const builtIn = await runReview(reviewConfig, workdir, executionConfig, qualityCommands, storyId, storyGitRef, story, modelResolver, naxConfig, retrySkipChecks, featureName, resolverSession);
     if (!builtIn.success) {
       return { builtIn, success: false, failureReason: builtIn.failureReason, pluginFailed: false };
     }
@@ -27951,6 +28397,21 @@ class ReviewOrchestrator {
     }
     return { builtIn, success: true, pluginFailed: false };
   }
+  reviewFromContext(ctx) {
+    const retrySkipChecks = ctx.retrySkipChecks;
+    ctx.retrySkipChecks = undefined;
+    const agentResolver = ctx.agentGetFn ?? undefined;
+    const agentName = ctx.rootConfig.autoMode?.defaultAgent;
+    const modelResolver = agentName ? (_tier) => agentResolver ? agentResolver(agentName) ?? null : null : undefined;
+    const reviewDebateEnabled = ctx.rootConfig?.debate?.enabled && ctx.rootConfig?.debate?.stages?.review?.enabled;
+    const resolverSession = reviewDebateEnabled ? ctx.reviewerSession : undefined;
+    return this.review(ctx.config.review, ctx.workdir, ctx.config.execution, ctx.plugins, ctx.storyGitRef, ctx.story.workdir, ctx.config.quality?.commands, ctx.story.id, {
+      id: ctx.story.id,
+      title: ctx.story.title,
+      description: ctx.story.description,
+      acceptanceCriteria: ctx.story.acceptanceCriteria
+    }, modelResolver, ctx.config, retrySkipChecks, ctx.prd.feature, resolverSession);
+  }
 }
 var _orchestratorDeps, reviewOrchestrator;
 var init_orchestrator = __esm(() => {
@@ -27966,7 +28427,6 @@ __export(exports_review, {
   reviewStage: () => reviewStage,
   _reviewDeps: () => _reviewDeps
 });
-import { join as join17 } from "path";
 var reviewStage, _reviewDeps;
 var init_review = __esm(() => {
   init_agents();
@@ -27976,19 +28436,15 @@ var init_review = __esm(() => {
   init_orchestrator();
   reviewStage = {
     name: "review",
-    enabled: (ctx) => (ctx.effectiveConfig ?? ctx.config).review.enabled,
+    enabled: (ctx) => ctx.config.review.enabled,
     async execute(ctx) {
       const logger = getLogger();
-      const effectiveConfig = ctx.effectiveConfig ?? ctx.config;
-      const dialogueEnabled = effectiveConfig.review?.dialogue?.enabled ?? false;
+      const reviewDebateEnabled = ctx.rootConfig?.debate?.enabled && ctx.rootConfig?.debate?.stages?.review?.enabled;
+      const dialogueEnabled = ctx.config.review?.dialogue?.enabled ?? false;
       logger.info("review", "Running review phase", { storyId: ctx.story.id });
-      const effectiveWorkdir = ctx.story.workdir ? join17(ctx.workdir, ctx.story.workdir) : ctx.workdir;
       const agentResolver = ctx.agentGetFn ?? getAgent;
-      const agentName = effectiveConfig.autoMode?.defaultAgent;
-      const modelResolver = (_tier) => agentName ? agentResolver(agentName) ?? null : null;
-      const retrySkipChecks = ctx.retrySkipChecks;
-      ctx.retrySkipChecks = undefined;
-      if (dialogueEnabled && ctx.reviewerSession) {
+      const agentName = ctx.rootConfig.autoMode?.defaultAgent;
+      if (dialogueEnabled && !reviewDebateEnabled && ctx.reviewerSession) {
         try {
           const diff = ctx.storyGitRef ?? "";
           const reReviewResult = await ctx.reviewerSession.reReview(diff);
@@ -28025,57 +28481,56 @@ var init_review = __esm(() => {
       }
       if (dialogueEnabled && !ctx.reviewerSession) {
         const agent = agentName ? agentResolver(agentName) ?? null : null;
-        ctx.reviewerSession = _reviewDeps.createReviewerSession(agent ?? null, ctx.story.id, effectiveWorkdir, ctx.prd.feature ?? "", ctx.config);
-        const semanticConfig = effectiveConfig.review?.semantic;
-        if (semanticConfig && agent) {
-          try {
-            const diff = ctx.storyGitRef ?? "";
-            const story = {
-              id: ctx.story.id,
-              title: ctx.story.title,
-              description: ctx.story.description,
-              acceptanceCriteria: ctx.story.acceptanceCriteria
-            };
-            const sessionResult = await ctx.reviewerSession.review(diff, story, semanticConfig);
-            const passed = sessionResult.checkResult.success;
-            ctx.reviewResult = {
-              success: passed,
-              checks: passed ? [] : [
-                {
-                  check: "semantic",
-                  success: false,
-                  command: "reviewer-session-review",
-                  exitCode: 1,
-                  output: sessionResult.checkResult.findings.map((f) => f.message).join(`
+        ctx.reviewerSession = _reviewDeps.createReviewerSession(agent ?? null, ctx.story.id, ctx.workdir, ctx.prd.feature ?? "", ctx.config);
+        if (!reviewDebateEnabled) {
+          const semanticConfig = ctx.config.review?.semantic;
+          if (semanticConfig && agent) {
+            try {
+              const diff = ctx.storyGitRef ?? "";
+              const story = {
+                id: ctx.story.id,
+                title: ctx.story.title,
+                description: ctx.story.description,
+                acceptanceCriteria: ctx.story.acceptanceCriteria
+              };
+              const sessionResult = await ctx.reviewerSession.review(diff, story, semanticConfig);
+              const passed = sessionResult.checkResult.success;
+              ctx.reviewResult = {
+                success: passed,
+                checks: passed ? [] : [
+                  {
+                    check: "semantic",
+                    success: false,
+                    command: "reviewer-session-review",
+                    exitCode: 1,
+                    output: sessionResult.checkResult.findings.map((f) => f.message).join(`
 `),
-                  durationMs: 0,
-                  findings: sessionResult.checkResult.findings
-                }
-              ],
-              totalDurationMs: 0
-            };
-            if (passed) {
-              logger.info("review", "Review passed (dialogue session)", { storyId: ctx.story.id });
-            } else {
-              logger.warn("review", "Review failed (dialogue session) \u2014 handing off to autofix", {
+                    durationMs: 0,
+                    findings: sessionResult.checkResult.findings
+                  }
+                ],
+                totalDurationMs: 0
+              };
+              const dialogueCost = sessionResult.cost ?? 0;
+              if (passed) {
+                logger.info("review", "Review passed (dialogue session)", { storyId: ctx.story.id });
+              } else {
+                logger.warn("review", "Review failed (dialogue session) \u2014 handing off to autofix", {
+                  storyId: ctx.story.id
+                });
+              }
+              return { action: "continue", cost: dialogueCost || undefined };
+            } catch (err) {
+              logger.warn("review", "ReviewerSession.review() failed \u2014 falling back to one-shot review", {
                 storyId: ctx.story.id
               });
             }
-            return { action: "continue" };
-          } catch (err) {
-            logger.warn("review", "ReviewerSession.review() failed \u2014 falling back to one-shot review", {
-              storyId: ctx.story.id
-            });
           }
         }
       }
-      const result = await reviewOrchestrator.review(effectiveConfig.review, effectiveWorkdir, effectiveConfig.execution, ctx.plugins, ctx.storyGitRef, ctx.story.workdir, effectiveConfig.quality?.commands, ctx.story.id, {
-        id: ctx.story.id,
-        title: ctx.story.title,
-        description: ctx.story.description,
-        acceptanceCriteria: ctx.story.acceptanceCriteria
-      }, modelResolver, ctx.config, retrySkipChecks, ctx.prd.feature);
+      const result = await reviewOrchestrator.reviewFromContext(ctx);
       ctx.reviewResult = result.builtIn;
+      const reviewCost = (result.builtIn.checks ?? []).reduce((sum, c) => sum + (c.cost ?? 0), 0) || undefined;
       if (!result.success) {
         const pluginFindings = result.builtIn.pluginReviewers?.flatMap((pr) => pr.findings ?? []) ?? [];
         const semanticFindings = (result.builtIn.checks ?? []).filter((c) => c.check === "semantic" && !c.success && c.findings?.length).flatMap((c) => c.findings ?? []);
@@ -28084,29 +28539,29 @@ var init_review = __esm(() => {
           ctx.reviewFindings = allFindings;
         }
         if (result.pluginFailed) {
-          if (ctx.interaction && isTriggerEnabled("security-review", effectiveConfig)) {
-            const shouldContinue = await _reviewDeps.checkSecurityReview({ featureName: ctx.prd.feature, storyId: ctx.story.id }, effectiveConfig, ctx.interaction);
+          if (ctx.interaction && isTriggerEnabled("security-review", ctx.config)) {
+            const shouldContinue = await _reviewDeps.checkSecurityReview({ featureName: ctx.prd.feature, storyId: ctx.story.id }, ctx.config, ctx.interaction);
             if (!shouldContinue) {
               logger.error("review", `Plugin reviewer failed: ${result.failureReason}`, { storyId: ctx.story.id });
-              return { action: "fail", reason: `Review failed: ${result.failureReason}` };
+              return { action: "fail", reason: `Review failed: ${result.failureReason}`, cost: reviewCost };
             }
             logger.warn("review", "Security-review trigger escalated \u2014 retrying story", { storyId: ctx.story.id });
-            return { action: "escalate", reason: `Review failed: ${result.failureReason}` };
+            return { action: "escalate", reason: `Review failed: ${result.failureReason}`, cost: reviewCost };
           }
           logger.error("review", `Plugin reviewer failed: ${result.failureReason}`, { storyId: ctx.story.id });
-          return { action: "fail", reason: `Review failed: ${result.failureReason}` };
+          return { action: "fail", reason: `Review failed: ${result.failureReason}`, cost: reviewCost };
         }
         logger.warn("review", "Review failed (built-in checks) \u2014 handing off to autofix", {
           reason: result.failureReason,
           storyId: ctx.story.id
         });
-        return { action: "continue" };
+        return { action: "continue", cost: reviewCost };
       }
       logger.info("review", "Review passed", {
         durationMs: result.builtIn.totalDurationMs,
         storyId: ctx.story.id
       });
-      return { action: "continue" };
+      return { action: "continue", cost: reviewCost };
     }
   };
   _reviewDeps = {
@@ -28116,7 +28571,6 @@ var init_review = __esm(() => {
 });
 
 // src/pipeline/stages/autofix.ts
-import { join as join18 } from "path";
 async function recheckReview(ctx) {
   const { reviewStage: reviewStage2 } = await Promise.resolve().then(() => (init_review(), exports_review));
   if (!reviewStage2.enabled(ctx))
@@ -28154,16 +28608,15 @@ Your previous fix attempt (attempt ${attempt}) did not resolve the quality error
 }
 async function runAgentRectification(ctx, lintFixCmd, formatFixCmd, effectiveWorkdir) {
   const logger = getLogger();
-  const effectiveConfig = ctx.effectiveConfig ?? ctx.config;
-  const maxPerCycle = effectiveConfig.quality.autofix?.maxAttempts ?? 2;
-  const maxTotal = effectiveConfig.quality.autofix?.maxTotalAttempts ?? 10;
-  const rethinkAtAttempt = effectiveConfig.quality.autofix?.rethinkAtAttempt ?? 2;
-  const urgencyAtAttempt = effectiveConfig.quality.autofix?.urgencyAtAttempt ?? 3;
+  const maxPerCycle = ctx.config.quality.autofix?.maxAttempts ?? 2;
+  const maxTotal = ctx.config.quality.autofix?.maxTotalAttempts ?? 10;
+  const rethinkAtAttempt = ctx.config.quality.autofix?.rethinkAtAttempt ?? 2;
+  const urgencyAtAttempt = ctx.config.quality.autofix?.urgencyAtAttempt ?? 3;
   const consumed = ctx.autofixAttempt ?? 0;
   const failedChecks = collectFailedChecks(ctx);
   if (failedChecks.length === 0) {
     logger.debug("autofix", "No failed checks found \u2014 skipping agent rectification", { storyId: ctx.story.id });
-    return false;
+    return { succeeded: false, cost: 0 };
   }
   if (consumed >= maxTotal) {
     logger.warn("autofix", "Global autofix budget exhausted \u2014 escalating", {
@@ -28171,16 +28624,17 @@ async function runAgentRectification(ctx, lintFixCmd, formatFixCmd, effectiveWor
       totalAttempts: consumed,
       maxTotalAttempts: maxTotal
     });
-    return false;
+    return { succeeded: false, cost: 0 };
   }
   const remainingBudget = maxTotal - consumed;
   const maxAttempts = Math.min(maxPerCycle, remainingBudget);
-  const agentGetFn = ctx.agentGetFn ?? _autofixDeps.getAgent;
+  const agentGetFn = ctx.agentGetFn ?? ((name) => _autofixDeps.getAgent(name, ctx.rootConfig));
   const loopState = {
     attempt: 0,
     failedChecks
   };
-  return runSharedRectificationLoop({
+  let autofixCostAccum = 0;
+  const succeeded = await runSharedRectificationLoop({
     stage: "autofix",
     storyId: ctx.story.id,
     maxAttempts,
@@ -28207,29 +28661,30 @@ async function runAgentRectification(ctx, lintFixCmd, formatFixCmd, effectiveWor
     },
     runAttempt: async (attempt, prompt) => {
       ctx.autofixAttempt = consumed + attempt;
-      const agent = agentGetFn(ctx.config.autoMode.defaultAgent);
+      const agent = agentGetFn(ctx.rootConfig.autoMode.defaultAgent);
       if (!agent) {
         logger.error("autofix", "Agent not found \u2014 cannot run agent rectification", { storyId: ctx.story.id });
         throw new Error("AUTOFIX_AGENT_NOT_FOUND");
       }
-      const modelTier = ctx.story.routing?.modelTier ?? ctx.config.autoMode.escalation.tierOrder[0]?.tier ?? "balanced";
-      const modelDef = resolveModelForAgent(ctx.config.models, ctx.routing.agent ?? ctx.config.autoMode.defaultAgent, modelTier, ctx.config.autoMode.defaultAgent);
-      const rectificationWorkdir = ctx.story.workdir ? join18(ctx.workdir, ctx.story.workdir) : ctx.workdir;
+      const modelTier = ctx.story.routing?.modelTier ?? ctx.rootConfig.autoMode.escalation.tierOrder[0]?.tier ?? "balanced";
+      const modelDef = resolveModelForAgent(ctx.rootConfig.models, ctx.routing.agent ?? ctx.rootConfig.autoMode.defaultAgent, modelTier, ctx.rootConfig.autoMode.defaultAgent);
       const result = await agent.run({
         prompt,
-        workdir: rectificationWorkdir,
+        workdir: ctx.workdir,
         modelTier,
         modelDef,
         timeoutSeconds: ctx.config.execution.sessionTimeoutSeconds,
         dangerouslySkipPermissions: resolvePermissions(ctx.config, "rectification").skipPermissions,
         pipelineStage: "rectification",
         config: ctx.config,
+        projectDir: ctx.projectDir,
         maxInteractionTurns: ctx.config.agent?.maxInteractionTurns,
         storyId: ctx.story.id,
         sessionRole: "implementer"
       });
+      autofixCostAccum += result.estimatedCost ?? 0;
       if (ctx.reviewerSession && result.output) {
-        const maxClarifications = effectiveConfig.review?.dialogue?.maxClarificationsPerAttempt ?? 3;
+        const maxClarifications = ctx.config.review?.dialogue?.maxClarificationsPerAttempt ?? 3;
         let clarifyCount = 0;
         const clarifyRegex = new RegExp(CLARIFY_REGEX.source, `${CLARIFY_REGEX.flags}g`);
         let match;
@@ -28312,10 +28767,11 @@ async function runAgentRectification(ctx, lintFixCmd, formatFixCmd, effectiveWor
     }
     throw error48;
   });
+  return { succeeded, cost: autofixCostAccum };
 }
 var CLARIFY_REGEX, autofixStage, _autofixDeps;
 var init_autofix = __esm(() => {
-  init_agents();
+  init_registry();
   init_config();
   init_loader();
   init_logger2();
@@ -28329,7 +28785,7 @@ var init_autofix = __esm(() => {
         return false;
       if (ctx.reviewResult.success)
         return false;
-      const autofixEnabled = (ctx.effectiveConfig ?? ctx.config).quality.autofix?.enabled ?? true;
+      const autofixEnabled = ctx.config.quality.autofix?.enabled ?? true;
       return autofixEnabled;
     },
     skipReason(ctx) {
@@ -28343,16 +28799,14 @@ var init_autofix = __esm(() => {
       if (!reviewResult || reviewResult.success) {
         return { action: "continue" };
       }
-      const effectiveConfig = ctx.effectiveConfig ?? ctx.config;
-      const lintFixCmd = effectiveConfig.quality.commands.lintFix ?? effectiveConfig.review.commands.lintFix;
-      const formatFixCmd = effectiveConfig.quality.commands.formatFix ?? effectiveConfig.review.commands.formatFix;
-      const effectiveWorkdir = ctx.story.workdir ? join18(ctx.workdir, ctx.story.workdir) : ctx.workdir;
+      const lintFixCmd = ctx.config.quality.commands.lintFix ?? ctx.config.review.commands.lintFix;
+      const formatFixCmd = ctx.config.quality.commands.formatFix ?? ctx.config.review.commands.formatFix;
       const failedCheckNames = new Set((reviewResult.checks ?? []).filter((c) => !c.success).map((c) => c.check));
       const hasLintFailure = failedCheckNames.has("lint");
       logger.info("autofix", "Starting autofix", {
         storyId: ctx.story.id,
         failedChecks: [...failedCheckNames],
-        workdir: effectiveWorkdir
+        workdir: ctx.workdir
       });
       if (hasLintFailure && (lintFixCmd || formatFixCmd)) {
         if (lintFixCmd) {
@@ -28360,7 +28814,7 @@ var init_autofix = __esm(() => {
           const lintResult = await _autofixDeps.runQualityCommand({
             commandName: "lintFix",
             command: lintFixCmd,
-            workdir: effectiveWorkdir,
+            workdir: ctx.workdir,
             storyId: ctx.story.id
           });
           logger.debug("autofix", `lintFix exit=${lintResult.exitCode}`, { storyId: ctx.story.id, command: lintFixCmd });
@@ -28376,7 +28830,7 @@ var init_autofix = __esm(() => {
           const fmtResult = await _autofixDeps.runQualityCommand({
             commandName: "formatFix",
             command: formatFixCmd,
-            workdir: effectiveWorkdir,
+            workdir: ctx.workdir,
             storyId: ctx.story.id
           });
           logger.debug("autofix", `formatFix exit=${fmtResult.exitCode}`, {
@@ -28393,6 +28847,14 @@ var init_autofix = __esm(() => {
         const recheckPassed = await _autofixDeps.recheckReview(ctx);
         pipelineEventBus.emit({ type: "autofix:completed", storyId: ctx.story.id, fixed: recheckPassed });
         if (recheckPassed) {
+          const passedChecks = (ctx.reviewResult?.checks ?? []).filter((c) => c.success).map((c) => c.check);
+          if (passedChecks.length > 0) {
+            ctx.retrySkipChecks = new Set(passedChecks);
+            logger.debug("autofix", "Skipping already-passed checks on retry", {
+              storyId: ctx.story.id,
+              skippedChecks: passedChecks
+            });
+          }
           logger.info("autofix", "Mechanical autofix succeeded \u2014 retrying review", { storyId: ctx.story.id });
           return { action: "retry", fromStage: "review" };
         }
@@ -28400,7 +28862,7 @@ var init_autofix = __esm(() => {
           storyId: ctx.story.id
         });
       }
-      const agentFixed = await _autofixDeps.runAgentRectification(ctx, lintFixCmd, formatFixCmd, effectiveWorkdir);
+      const { succeeded: agentFixed, cost: agentCost } = await _autofixDeps.runAgentRectification(ctx, lintFixCmd, formatFixCmd, ctx.workdir);
       if (agentFixed) {
         if (ctx.reviewResult)
           ctx.reviewResult = { ...ctx.reviewResult, success: true };
@@ -28413,14 +28875,18 @@ var init_autofix = __esm(() => {
           });
         }
         logger.info("autofix", "Agent rectification succeeded \u2014 retrying review", { storyId: ctx.story.id });
-        return { action: "retry", fromStage: "review" };
+        return { action: "retry", fromStage: "review", cost: agentCost };
       }
       logger.warn("autofix", "Autofix exhausted \u2014 escalating", { storyId: ctx.story.id });
-      return { action: "escalate", reason: "Autofix exhausted: review still failing after fix attempts" };
+      return {
+        action: "escalate",
+        reason: "Autofix exhausted: review still failing after fix attempts",
+        cost: agentCost
+      };
     }
   };
   _autofixDeps = {
-    getAgent,
+    getAgent: (name, config2) => createAgentRegistry(config2).getAgent(name),
     runQualityCommand,
     recheckReview,
     runAgentRectification: (ctx, lintFixCmd, formatFixCmd, effectiveWorkdir) => runAgentRectification(ctx, lintFixCmd, formatFixCmd, effectiveWorkdir),
@@ -28486,10 +28952,10 @@ var init_semantic_verdict = __esm(() => {
 
 // src/execution/progress.ts
 import { appendFile as appendFile2, mkdir } from "fs/promises";
-import { join as join19 } from "path";
+import { join as join17 } from "path";
 async function appendProgress(featureDir, storyId, status, message) {
   await mkdir(featureDir, { recursive: true });
-  const progressPath = join19(featureDir, "progress.txt");
+  const progressPath = join17(featureDir, "progress.txt");
   const timestamp = new Date().toISOString();
   const entry = `[${timestamp}] ${storyId} \u2014 ${status.toUpperCase()} \u2014 ${message}
 `;
@@ -28514,7 +28980,7 @@ var init_completion = __esm(() => {
       const logger = getLogger();
       const isBatch = ctx.stories.length > 1;
       const sessionCost = ctx.agentResult?.estimatedCost || 0;
-      const prdPath = ctx.featureDir ? `${ctx.featureDir}/prd.json` : `${ctx.workdir}/nax/features/unknown/prd.json`;
+      const prdPath = ctx.prdPath ?? (ctx.featureDir ? `${ctx.featureDir}/prd.json` : `${ctx.workdir}/nax/features/unknown/prd.json`);
       const storyStartTime = ctx.storyStartTime || new Date().toISOString();
       if (isBatch) {
         ctx.storyMetrics = collectBatchMetrics(ctx, storyStartTime);
@@ -28565,7 +29031,7 @@ var init_completion = __esm(() => {
         };
         await _completionDeps.persistSemanticVerdict(ctx.featureDir, ctx.story.id, verdict);
       }
-      await savePRD(ctx.prd, prdPath);
+      await _completionDeps.savePRD(ctx.prd, prdPath);
       const updatedCounts = countStories(ctx.prd);
       logger.info("completion", "Progress update", {
         storyId: ctx.story.id,
@@ -28584,7 +29050,8 @@ var init_completion = __esm(() => {
   };
   _completionDeps = {
     checkReviewGate,
-    persistSemanticVerdict
+    persistSemanticVerdict,
+    savePRD
   };
 });
 
@@ -28595,7 +29062,7 @@ function estimateTokens(text) {
 
 // src/constitution/loader.ts
 import { existsSync as existsSync17 } from "fs";
-import { join as join20 } from "path";
+import { join as join18 } from "path";
 function truncateToTokens(text, maxTokens) {
   const maxChars = maxTokens * 3;
   if (text.length <= maxChars) {
@@ -28617,7 +29084,7 @@ async function loadConstitution(projectDir, config2) {
   }
   let combinedContent = "";
   if (!config2.skipGlobal) {
-    const globalPath = join20(globalConfigDir(), config2.path);
+    const globalPath = join18(globalConfigDir(), config2.path);
     if (existsSync17(globalPath)) {
       const validatedPath = validateFilePath(globalPath, globalConfigDir());
       const globalFile = Bun.file(validatedPath);
@@ -28627,7 +29094,7 @@ async function loadConstitution(projectDir, config2) {
       }
     }
   }
-  const projectPath = join20(projectDir, config2.path);
+  const projectPath = join18(projectDir, config2.path);
   if (existsSync17(projectPath)) {
     const validatedPath = validateFilePath(projectPath, projectDir);
     const projectFile = Bun.file(validatedPath);
@@ -28675,7 +29142,7 @@ var init_constitution = __esm(() => {
 });
 
 // src/pipeline/stages/constitution.ts
-import { dirname as dirname4 } from "path";
+import { dirname as dirname3 } from "path";
 var constitutionStage;
 var init_constitution2 = __esm(() => {
   init_constitution();
@@ -28685,7 +29152,7 @@ var init_constitution2 = __esm(() => {
     enabled: (ctx) => ctx.config.constitution.enabled,
     async execute(ctx) {
       const logger = getLogger();
-      const ngentDir = ctx.featureDir ? dirname4(dirname4(ctx.featureDir)) : `${ctx.workdir}/nax`;
+      const ngentDir = ctx.featureDir ? dirname3(dirname3(ctx.featureDir)) : `${ctx.workdir}/nax`;
       const result = await loadConstitution(ngentDir, ctx.config.constitution);
       if (result) {
         ctx.constitution = result;
@@ -28850,6 +29317,27 @@ function createStoryContext(story, priority) {
   return { type: "story", storyId: story.id, content, priority, tokens: estimateTokens(content) };
 }
 function createDependencyContext(story, priority) {
+  const content = isCompletedDependency(story) ? formatCompletedDependency(story) : formatFullDependency(story);
+  return { type: "dependency", storyId: story.id, content, priority, tokens: estimateTokens(content) };
+}
+function isCompletedDependency(story) {
+  return story.status === "passed" || story.status === "decomposed" || story.status === "skipped";
+}
+function formatCompletedDependency(story) {
+  const header = `## ${story.id} (${story.status}): ${story.title}`;
+  if (story.diffSummary) {
+    return `${header}
+
+**Changes made:**
+\`\`\`
+${story.diffSummary}
+\`\`\``;
+  }
+  return `${header}
+
+Status: ${story.status} (no diff summary available)`;
+}
+function formatFullDependency(story) {
   let content = formatStoryAsText(story);
   if (story.diffSummary) {
     content += `
@@ -28859,7 +29347,7 @@ function createDependencyContext(story, priority) {
 ${story.diffSummary}
 \`\`\``;
   }
-  return { type: "dependency", storyId: story.id, content, priority, tokens: estimateTokens(content) };
+  return content;
 }
 function createErrorContext(errorMessage2, priority) {
   return { type: "error", content: errorMessage2, priority, tokens: estimateTokens(errorMessage2) };
@@ -29535,7 +30023,8 @@ ${pkgContent.trim()}`;
     if (built.elements.length === 0 && !packageSection) {
       return;
     }
-    const baseMarkdown = built.elements.length > 0 ? formatContextAsMarkdown(built) : "";
+    const elementsForMarkdown = built.elements.filter((e) => e.type !== "story");
+    const baseMarkdown = elementsForMarkdown.length > 0 ? formatContextAsMarkdown({ ...built, elements: elementsForMarkdown }) : "";
     const markdown = packageSection ? `${baseMarkdown}${packageSection}` : baseMarkdown;
     return { markdown, builtContext: built };
   } catch (error48) {
@@ -29546,6 +30035,10 @@ ${pkgContent.trim()}`;
     return;
   }
 }
+function buildStoryContextFullFromCtx(ctx) {
+  const packageWorkdir = ctx.story.workdir ? ctx.workdir : undefined;
+  return buildStoryContextFull(ctx.prd, ctx.story, ctx.config, packageWorkdir);
+}
 function getAllReadyStories(prd) {
   const storyIds = new Set(prd.userStories.map((s) => s.id));
   const completedIds = new Set(prd.userStories.filter((s) => s.passes || s.status === "skipped").map((s) => s.id));
@@ -29656,7 +30149,6 @@ var init_helpers = __esm(() => {
 });
 
 // src/pipeline/stages/context.ts
-import { join as join21 } from "path";
 var contextStage;
 var init_context2 = __esm(() => {
   init_helpers();
@@ -29666,8 +30158,7 @@ var init_context2 = __esm(() => {
     enabled: () => true,
     async execute(ctx) {
       const logger = getLogger();
-      const packageWorkdir = ctx.story.workdir ? join21(ctx.workdir, ctx.story.workdir) : undefined;
-      const result = await buildStoryContextFull(ctx.prd, ctx.story, ctx.config, packageWorkdir);
+      const result = await buildStoryContextFullFromCtx(ctx);
       if (result) {
         ctx.contextMarkdown = result.markdown;
         ctx.builtContext = result.builtContext;
@@ -29800,14 +30291,14 @@ var init_isolation = __esm(() => {
 
 // src/context/greenfield.ts
 import { readdir } from "fs/promises";
-import { join as join22 } from "path";
+import { join as join19 } from "path";
 async function scanForTestFiles(dir, testPattern, isRootCall = true) {
   const results = [];
   const ignoreDirs = new Set(["node_modules", "dist", "build", ".next", ".git"]);
   try {
     const entries = await readdir(dir, { withFileTypes: true });
     for (const entry of entries) {
-      const fullPath = join22(dir, entry.name);
+      const fullPath = join19(dir, entry.name);
       if (entry.isDirectory()) {
         if (ignoreDirs.has(entry.name))
           continue;
@@ -29873,10 +30364,10 @@ async function executeWithTimeout(command, timeoutSeconds, env2, options) {
   const timeoutMs = timeoutSeconds * 1000;
   let timedOut = false;
   const timer = { id: undefined };
-  const timeoutPromise = new Promise((resolve7) => {
+  const timeoutPromise = new Promise((resolve8) => {
     timer.id = setTimeout(() => {
       timedOut = true;
-      resolve7();
+      resolve8();
     }, timeoutMs);
   });
   const processPromise = proc.exited;
@@ -29885,7 +30376,12 @@ async function executeWithTimeout(command, timeoutSeconds, env2, options) {
   if (timedOut) {
     const pid = proc.pid;
     killProcessGroup(pid, "SIGTERM");
-    await Bun.sleep(gracePeriodMs);
+    await Promise.race([
+      proc.exited,
+      new Promise((resolve8) => {
+        setTimeout(resolve8, gracePeriodMs);
+      })
+    ]);
     killProcessGroup(pid, "SIGKILL");
     const [out, err] = await Promise.all([
       raceWithDeadline(stdoutPromise, drainTimeoutMs),
@@ -30147,13 +30643,13 @@ function parseTestOutput(output, exitCode) {
 
 // src/verification/runners.ts
 import { existsSync as existsSync18 } from "fs";
-import { join as join23 } from "path";
+import { join as join20 } from "path";
 async function verifyAssets(workingDirectory, expectedFiles) {
   if (!expectedFiles || expectedFiles.length === 0)
     return { success: true, missingFiles: [] };
   const missingFiles = [];
   for (const file3 of expectedFiles) {
-    if (!existsSync18(join23(workingDirectory, file3)))
+    if (!existsSync18(join20(workingDirectory, file3)))
       missingFiles.push(file3);
   }
   if (missingFiles.length > 0) {
@@ -30478,10 +30974,10 @@ var init_prompts = __esm(() => {
 });
 
 // src/tdd/rectification-gate.ts
-async function runFullSuiteGate(story, config2, workdir, agent, implementerTier, contextMarkdown, lite, logger, featureName) {
+async function runFullSuiteGate(story, config2, workdir, agent, implementerTier, contextMarkdown, lite, logger, featureName, projectDir) {
   const rectificationEnabled = config2.execution.rectification?.enabled ?? false;
   if (!rectificationEnabled)
-    return false;
+    return { passed: false, cost: 0 };
   const rectificationConfig = config2.execution.rectification;
   const testCmd = config2.quality?.commands?.test ?? "bun test";
   const fullSuiteTimeout = rectificationConfig.fullSuiteTimeoutSeconds;
@@ -30496,7 +30992,7 @@ async function runFullSuiteGate(story, config2, workdir, agent, implementerTier,
   if (!fullSuitePassed && fullSuiteResult.output) {
     const testSummary = _rectificationGateDeps.parseBunTestOutput(fullSuiteResult.output);
     if (testSummary.failed > 0) {
-      return await runRectificationLoop(story, config2, workdir, agent, implementerTier, contextMarkdown, lite, logger, testSummary, rectificationConfig, testCmd, fullSuiteTimeout, featureName);
+      return await runRectificationLoop(story, config2, workdir, agent, implementerTier, contextMarkdown, lite, logger, testSummary, rectificationConfig, testCmd, fullSuiteTimeout, featureName, projectDir);
     }
     if (testSummary.passed > 0) {
       logger.info("tdd", "Full suite gate passed (non-zero exit, 0 failures, tests detected)", {
@@ -30504,7 +31000,7 @@ async function runFullSuiteGate(story, config2, workdir, agent, implementerTier,
         exitCode: fullSuiteResult.exitCode,
         passedTests: testSummary.passed
       });
-      return true;
+      return { passed: true, cost: 0 };
     }
     logger.warn("tdd", "Full suite gate inconclusive \u2014 no test results parsed from output (possible crash/OOM)", {
       storyId: story.id,
@@ -30512,19 +31008,19 @@ async function runFullSuiteGate(story, config2, workdir, agent, implementerTier,
       outputLength: fullSuiteResult.output.length,
       outputTail: fullSuiteResult.output.slice(-200)
     });
-    return false;
+    return { passed: false, cost: 0 };
   }
   if (fullSuitePassed) {
     logger.info("tdd", "Full suite gate passed", { storyId: story.id });
-    return true;
+    return { passed: true, cost: 0 };
   }
   logger.warn("tdd", "Full suite gate execution failed (no output)", {
     storyId: story.id,
     exitCode: fullSuiteResult.exitCode
   });
-  return false;
+  return { passed: false, cost: 0 };
 }
-async function runRectificationLoop(story, config2, workdir, agent, implementerTier, contextMarkdown, lite, logger, testSummary, rectificationConfig, testCmd, fullSuiteTimeout, featureName) {
+async function runRectificationLoop(story, config2, workdir, agent, implementerTier, contextMarkdown, lite, logger, testSummary, rectificationConfig, testCmd, fullSuiteTimeout, featureName, projectDir) {
   const rectificationState = {
     attempt: 0,
     initialFailures: testSummary.failed,
@@ -30544,6 +31040,7 @@ async function runRectificationLoop(story, config2, workdir, agent, implementerT
     ...rectificationState,
     isolationPassed: true
   };
+  let gateCostAccum = 0;
   const fixed = await runSharedRectificationLoop({
     stage: "tdd",
     storyId: story.id,
@@ -30575,6 +31072,7 @@ async function runRectificationLoop(story, config2, workdir, agent, implementerT
         dangerouslySkipPermissions: resolvePermissions(config2, "rectification").skipPermissions,
         pipelineStage: "rectification",
         config: config2,
+        projectDir,
         maxInteractionTurns: config2.agent?.maxInteractionTurns,
         featureName,
         storyId: story.id,
@@ -30585,6 +31083,7 @@ async function runRectificationLoop(story, config2, workdir, agent, implementerT
       if (!rectifyResult.success && rectifyResult.pid) {
         await cleanupProcessTree(rectifyResult.pid);
       }
+      gateCostAccum += rectifyResult.estimatedCost ?? 0;
       if (rectifyResult.success) {
         logger.info("tdd", "Rectification agent session complete", {
           storyId: story.id,
@@ -30645,7 +31144,7 @@ async function runRectificationLoop(story, config2, workdir, agent, implementerT
     }
   });
   if (fixed) {
-    return true;
+    return { passed: true, cost: gateCostAccum };
   }
   const finalFullSuite = await _rectificationGateDeps.executeWithTimeout(testCmd, fullSuiteTimeout, undefined, {
     cwd: workdir
@@ -30657,10 +31156,10 @@ async function runRectificationLoop(story, config2, workdir, agent, implementerT
       attempts: rectificationState.attempt,
       remainingFailures: rectificationState.currentFailures
     });
-    return false;
+    return { passed: false, cost: gateCostAccum };
   }
   logger.info("tdd", "Full suite gate passed", { storyId: story.id });
-  return true;
+  return { passed: true, cost: gateCostAccum };
 }
 var _rectificationGateDeps;
 var init_rectification_gate = __esm(() => {
@@ -31064,36 +31563,10 @@ Set \`approved: false\` when ANY of these conditions are true:
 - Critical acceptance criteria are not met
 - Code quality is poor (security issues, severe bugs, etc.)
 
-**Full JSON schema example** (fill in all fields with real values):
+**JSON schema** (fill in all fields with real values):
 
 \`\`\`json
-{
-  "version": 1,
-  "approved": true,
-  "tests": {
-    "allPassing": true,
-    "passCount": 42,
-    "failCount": 0
-  },
-  "testModifications": {
-    "detected": false,
-    "files": [],
-    "legitimate": true,
-    "reasoning": "No test files were modified by the implementer"
-  },
-  "acceptanceCriteria": {
-    "allMet": true,
-    "criteria": [
-      { "criterion": "Example criterion", "met": true }
-    ]
-  },
-  "quality": {
-    "rating": "good",
-    "issues": []
-  },
-  "fixes": [],
-  "reasoning": "All tests pass, implementation is clean, all acceptance criteria are met."
-}
+{"version":1,"approved":true,"tests":{"allPassing":true,"passCount":42,"failCount":0},"testModifications":{"detected":false,"files":[],"legitimate":true,"reasoning":"..."},"acceptanceCriteria":{"allMet":true,"criteria":[{"criterion":"...","met":true}]},"quality":{"rating":"good","issues":[]},"fixes":[],"reasoning":"..."}
 \`\`\`
 
 **Field notes:**
@@ -31110,13 +31583,13 @@ var exports_loader = {};
 __export(exports_loader, {
   loadOverride: () => loadOverride
 });
-import { join as join24 } from "path";
+import { join as join21 } from "path";
 async function loadOverride(role, workdir, config2) {
   const overridePath = config2.prompts?.overrides?.[role];
   if (!overridePath) {
     return null;
   }
-  const absolutePath = join24(workdir, overridePath);
+  const absolutePath = join21(workdir, overridePath);
   const file3 = Bun.file(absolutePath);
   if (!await file3.exists()) {
     return null;
@@ -31326,7 +31799,7 @@ async function rollbackToRef(workdir, ref) {
   }
   logger.info("tdd", "Successfully rolled back git changes", { ref });
 }
-async function runTddSession(role, agent, story, config2, workdir, modelTier, beforeRef, contextMarkdown, lite = false, skipIsolation = false, constitution, featureName, interactionBridge) {
+async function runTddSession(role, agent, story, config2, workdir, modelTier, beforeRef, contextMarkdown, lite = false, skipIsolation = false, constitution, featureName, interactionBridge, projectDir) {
   const startTime = Date.now();
   let prompt;
   if (_sessionRunnerDeps.buildPrompt) {
@@ -31356,6 +31829,7 @@ async function runTddSession(role, agent, story, config2, workdir, modelTier, be
     dangerouslySkipPermissions: resolvePermissions(config2, "run").skipPermissions,
     pipelineStage: "run",
     config: config2,
+    projectDir,
     maxInteractionTurns: config2.agent?.maxInteractionTurns,
     featureName,
     storyId: story.id,
@@ -31727,7 +32201,8 @@ async function runThreeSessionTdd(options) {
     dryRun = false,
     lite = false,
     _recursionDepth = 0,
-    interactionChain
+    interactionChain,
+    projectDir
   } = options;
   const logger = getLogger();
   const MAX_RECURSION_DEPTH = 2;
@@ -31786,7 +32261,7 @@ async function runThreeSessionTdd(options) {
   let session1;
   if (!isRetry) {
     const testWriterTier = config2.tdd.sessionTiers?.testWriter ?? "balanced";
-    session1 = await runTddSession("test-writer", agent, story, config2, workdir, testWriterTier, session1Ref, contextMarkdown, lite, lite, constitution, featureName, buildInteractionBridge(interactionChain, { featureName, storyId: story.id, stage: "execution" }));
+    session1 = await runTddSession("test-writer", agent, story, config2, workdir, testWriterTier, session1Ref, contextMarkdown, lite, lite, constitution, featureName, buildInteractionBridge(interactionChain, { featureName, storyId: story.id, stage: "execution" }), projectDir);
     sessions.push(session1);
   }
   if (session1 && !session1.success) {
@@ -31848,7 +32323,7 @@ async function runThreeSessionTdd(options) {
   });
   const session2Ref = await captureGitRef(workdir) ?? "HEAD";
   const implementerTier = config2.tdd.sessionTiers?.implementer ?? modelTier;
-  const session2 = await runTddSession("implementer", agent, story, config2, workdir, implementerTier, session2Ref, contextMarkdown, lite, lite, constitution, featureName, buildInteractionBridge(interactionChain, { featureName, storyId: story.id, stage: "execution" }));
+  const session2 = await runTddSession("implementer", agent, story, config2, workdir, implementerTier, session2Ref, contextMarkdown, lite, lite, constitution, featureName, buildInteractionBridge(interactionChain, { featureName, storyId: story.id, stage: "execution" }), projectDir);
   sessions.push(session2);
   if (!session2.success) {
     needsHumanReview = true;
@@ -31864,10 +32339,10 @@ async function runThreeSessionTdd(options) {
       lite
     };
   }
-  const fullSuiteGatePassed = await runFullSuiteGate(story, config2, workdir, agent, implementerTier, contextMarkdown, lite, logger, featureName);
+  const { passed: fullSuiteGatePassed, cost: fullSuiteGateCost } = await runFullSuiteGate(story, config2, workdir, agent, implementerTier, contextMarkdown, lite, logger, featureName, projectDir);
   const session3Ref = await captureGitRef(workdir) ?? "HEAD";
   const verifierTier = config2.tdd.sessionTiers?.verifier ?? "fast";
-  const session3 = await runTddSession("verifier", agent, story, config2, workdir, verifierTier, session3Ref, undefined, false, false, constitution, featureName);
+  const session3 = await runTddSession("verifier", agent, story, config2, workdir, verifierTier, session3Ref, undefined, false, false, constitution, featureName, undefined, projectDir);
   sessions.push(session3);
   const verdict = await readVerdict(workdir);
   await cleanupVerdict(workdir);
@@ -31927,7 +32402,7 @@ async function runThreeSessionTdd(options) {
       needsHumanReview = false;
     }
   }
-  const totalCost = sessions.reduce((sum, s) => sum + s.estimatedCost, 0);
+  const totalCost = sessions.reduce((sum, s) => sum + s.estimatedCost, 0) + fullSuiteGateCost;
   logger.info("tdd", allSuccessful ? "[OK] Three-session TDD complete" : "[WARN] Three-session TDD needs review", {
     storyId: story.id,
     success: allSuccessful,
@@ -31963,6 +32438,22 @@ async function runThreeSessionTdd(options) {
     fullSuiteGatePassed
   };
 }
+function runThreeSessionTddFromCtx(ctx, opts) {
+  return runThreeSessionTdd({
+    agent: opts.agent,
+    story: ctx.story,
+    config: ctx.config,
+    workdir: ctx.workdir,
+    modelTier: ctx.routing.modelTier,
+    featureName: ctx.prd.feature,
+    contextMarkdown: ctx.contextMarkdown,
+    constitution: ctx.constitution?.content,
+    dryRun: opts.dryRun ?? false,
+    lite: opts.lite ?? false,
+    interactionChain: ctx.interaction,
+    projectDir: ctx.projectDir
+  });
+}
 var init_orchestrator2 = __esm(() => {
   init_config();
   init_greenfield();
@@ -31985,17 +32476,6 @@ var init_tdd = __esm(() => {
 });
 
 // src/pipeline/stages/execution.ts
-import { existsSync as existsSync19 } from "fs";
-import { join as join25 } from "path";
-function resolveStoryWorkdir(repoRoot, storyWorkdir) {
-  if (!storyWorkdir)
-    return repoRoot;
-  const resolved = join25(repoRoot, storyWorkdir);
-  if (!existsSync19(resolved)) {
-    throw new Error(`[execution] story.workdir "${storyWorkdir}" does not exist at "${resolved}"`);
-  }
-  return resolved;
-}
 function isAmbiguousOutput(output) {
   if (!output)
     return false;
@@ -32042,11 +32522,11 @@ var init_execution2 = __esm(() => {
     enabled: () => true,
     async execute(ctx) {
       const logger = getLogger();
-      const agent = (ctx.agentGetFn ?? _executionDeps.getAgent)(ctx.config.autoMode.defaultAgent);
+      const agent = (ctx.agentGetFn ?? _executionDeps.getAgent)(ctx.rootConfig.autoMode.defaultAgent);
       if (!agent) {
         return {
           action: "fail",
-          reason: `Agent "${ctx.config.autoMode.defaultAgent}" not found`
+          reason: `Agent "${ctx.rootConfig.autoMode.defaultAgent}" not found`
         };
       }
       const isTddStrategy = ctx.routing.testStrategy === "three-session-tdd" || ctx.routing.testStrategy === "three-session-tdd-lite";
@@ -32056,20 +32536,7 @@ var init_execution2 = __esm(() => {
           storyId: ctx.story.id,
           lite: isLiteMode
         });
-        const effectiveWorkdir = _executionDeps.resolveStoryWorkdir(ctx.workdir, ctx.story.workdir);
-        const tddResult = await runThreeSessionTdd({
-          agent,
-          story: ctx.story,
-          config: ctx.config,
-          workdir: effectiveWorkdir,
-          modelTier: ctx.routing.modelTier,
-          featureName: ctx.prd.feature,
-          contextMarkdown: ctx.contextMarkdown,
-          constitution: ctx.constitution?.content,
-          dryRun: false,
-          lite: isLiteMode,
-          interactionChain: ctx.interaction
-        });
+        const tddResult = await runThreeSessionTddFromCtx(ctx, { agent, dryRun: false, lite: isLiteMode });
         ctx.agentResult = {
           success: tddResult.success,
           estimatedCost: tddResult.totalCost,
@@ -32132,17 +32599,17 @@ Category: ${tddResult.failureCategory ?? "unknown"}`,
           supportedTiers: agent.capabilities.supportedTiers
         });
       }
-      const storyWorkdir = _executionDeps.resolveStoryWorkdir(ctx.workdir, ctx.story.workdir);
       const keepSessionOpen = !!(ctx.config.review?.enabled === true || ctx.config.execution.rectification?.enabled === true);
       const result = await agent.run({
         prompt: ctx.prompt,
-        workdir: storyWorkdir,
+        workdir: ctx.workdir,
         modelTier: ctx.routing.modelTier,
-        modelDef: resolveModelForAgent(ctx.config.models, ctx.routing.agent ?? ctx.config.autoMode.defaultAgent, ctx.routing.modelTier, ctx.config.autoMode.defaultAgent),
+        modelDef: resolveModelForAgent(ctx.rootConfig.models, ctx.routing.agent ?? ctx.rootConfig.autoMode.defaultAgent, ctx.routing.modelTier, ctx.rootConfig.autoMode.defaultAgent),
         timeoutSeconds: ctx.config.execution.sessionTimeoutSeconds,
         dangerouslySkipPermissions: resolvePermissions(ctx.config, "run").skipPermissions,
         pipelineStage: "run",
         config: ctx.config,
+        projectDir: ctx.projectDir,
         maxInteractionTurns: ctx.config.agent?.maxInteractionTurns,
         pidRegistry: ctx.pidRegistry,
         featureName: ctx.prd.feature,
@@ -32156,7 +32623,7 @@ Category: ${tddResult.failureCategory ?? "unknown"}`,
         })
       });
       ctx.agentResult = result;
-      await autoCommitIfDirty(storyWorkdir, "execution", "single-session", ctx.story.id);
+      await autoCommitIfDirty(ctx.workdir, "execution", "single-session", ctx.story.id);
       const combinedOutput = (result.output ?? "") + (result.stderr ?? "");
       if (_executionDeps.detectMergeConflict(combinedOutput) && ctx.interaction && isTriggerEnabled("merge-conflict", ctx.config)) {
         const shouldProceed = await _executionDeps.checkMergeConflict({ featureName: ctx.prd.feature, storyId: ctx.story.id }, ctx.config, ctx.interaction);
@@ -32197,8 +32664,7 @@ Category: ${tddResult.failureCategory ?? "unknown"}`,
     detectMergeConflict,
     checkMergeConflict,
     isAmbiguousOutput,
-    checkStoryAmbiguity,
-    resolveStoryWorkdir
+    checkStoryAmbiguity
   };
 });
 
@@ -32475,17 +32941,16 @@ var init_prompt = __esm(() => {
     async execute(ctx) {
       const logger = getLogger();
       const isBatch = ctx.stories.length > 1;
-      const effectiveConfig = ctx.effectiveConfig ?? ctx.config;
       const acceptanceEntries = await _loadAcceptanceEntries(ctx, logger);
       let prompt;
       if (isBatch) {
-        const builder = PromptBuilder.for("batch").withLoader(ctx.workdir, ctx.config).stories(ctx.stories).context(ctx.contextMarkdown).constitution(ctx.constitution?.content).testCommand(effectiveConfig.quality?.commands?.test).hermeticConfig(effectiveConfig.quality?.testing);
+        const builder = PromptBuilder.for("batch").withLoader(ctx.workdir, ctx.config).stories(ctx.stories).context(ctx.contextMarkdown).constitution(ctx.constitution?.content).testCommand(ctx.config.quality?.commands?.test).hermeticConfig(ctx.config.quality?.testing);
         if (acceptanceEntries.length > 0)
           builder.acceptanceContext(acceptanceEntries);
         prompt = await builder.build();
       } else {
         const role = ctx.routing.testStrategy === "no-test" ? "no-test" : "tdd-simple";
-        const builder = PromptBuilder.for(role).withLoader(ctx.workdir, ctx.config).story(ctx.story).context(ctx.contextMarkdown).constitution(ctx.constitution?.content).testCommand(effectiveConfig.quality?.commands?.test).hermeticConfig(effectiveConfig.quality?.testing).noTestJustification(ctx.story.routing?.noTestJustification);
+        const builder = PromptBuilder.for(role).withLoader(ctx.workdir, ctx.config).story(ctx.story).context(ctx.contextMarkdown).constitution(ctx.constitution?.content).testCommand(ctx.config.quality?.commands?.test).hermeticConfig(ctx.config.quality?.testing).noTestJustification(ctx.story.routing?.noTestJustification);
         if (acceptanceEntries.length > 0)
           builder.acceptanceContext(acceptanceEntries);
         prompt = await builder.build();
@@ -32718,7 +33183,18 @@ async function _defaultRunDebate(storyId, stageConfig, prompt, config2) {
   return { output, totalCostUsd };
 }
 async function runRectificationLoop2(opts) {
-  const { config: config2, workdir, story, testCommand, timeoutSeconds, testOutput, promptPrefix, featureName, agentGetFn } = opts;
+  const {
+    config: config2,
+    workdir,
+    story,
+    testCommand,
+    timeoutSeconds,
+    testOutput,
+    promptPrefix,
+    featureName,
+    agentGetFn,
+    projectDir
+  } = opts;
   const logger = getSafeLogger();
   const rectificationConfig = config2.execution.rectification;
   const testSummary = parseBunTestOutput(testOutput);
@@ -32729,7 +33205,8 @@ async function runRectificationLoop2(opts) {
     currentFailures: testSummary.failed,
     lastExitCode: 1
   };
-  return runSharedRectificationLoop({
+  let costAccum = 0;
+  const succeeded = await runSharedRectificationLoop({
     stage: "rectification",
     storyId: story.id,
     maxAttempts: rectificationConfig.maxRetries,
@@ -32810,11 +33287,13 @@ ${rectificationPrompt}`;
         dangerouslySkipPermissions: resolvePermissions(config2, "rectification").skipPermissions,
         pipelineStage: "rectification",
         config: config2,
+        projectDir,
         maxInteractionTurns: config2.agent?.maxInteractionTurns,
         featureName,
         storyId: story.id,
         sessionRole: "implementer"
       });
+      costAccum += agentResult.estimatedCost ?? 0;
       if (agentResult.success) {
         logger?.info("rectification", `Agent ${label} session complete`, {
           storyId: story.id,
@@ -32934,11 +33413,13 @@ ${escalationPrompt}`;
         dangerouslySkipPermissions: resolvePermissions(config2, "rectification").skipPermissions,
         pipelineStage: "rectification",
         config: config2,
+        projectDir,
         maxInteractionTurns: config2.agent?.maxInteractionTurns,
         featureName,
         storyId: story.id,
         sessionRole: "implementer"
       });
+      costAccum += escalationRunResult.estimatedCost ?? 0;
       logger?.info("rectification", "escalated rectification attempt cost", {
         storyId: story.id,
         escalatedTier,
@@ -32975,6 +33456,21 @@ ${escalationPrompt}`;
     }
     throw error48;
   });
+  return { succeeded, cost: costAccum };
+}
+function runRectificationLoopFromCtx(ctx, opts) {
+  return runRectificationLoop2({
+    config: ctx.config,
+    workdir: ctx.workdir,
+    story: ctx.story,
+    testCommand: opts.testCommand,
+    timeoutSeconds: ctx.config.execution.verificationTimeoutSeconds,
+    testOutput: opts.testOutput,
+    promptPrefix: opts.promptPrefix,
+    featureName: ctx.prd.feature,
+    agentGetFn: ctx.agentGetFn,
+    projectDir: ctx.projectDir
+  });
 }
 var _rectificationDeps;
 var init_rectification_loop = __esm(() => {
@@ -33036,36 +33532,28 @@ var init_rectify = __esm(() => {
         attempt: rectifyAttempt,
         testOutput
       });
-      const effectiveConfig = ctx.effectiveConfig ?? ctx.config;
-      const testCommand = effectiveConfig.review?.commands?.test ?? effectiveConfig.quality.commands.test ?? "bun test";
-      const fixed = await _rectifyDeps.runRectificationLoop({
-        config: ctx.config,
-        workdir: ctx.workdir,
-        story: ctx.story,
-        testCommand,
-        timeoutSeconds: effectiveConfig.execution.verificationTimeoutSeconds,
-        testOutput,
-        agentGetFn: ctx.agentGetFn
-      });
+      const testCommand = ctx.config.review?.commands?.test ?? ctx.config.quality.commands.test ?? "bun test";
+      const { succeeded, cost } = await _rectifyDeps.runRectificationLoop(ctx, { testCommand, testOutput });
       pipelineEventBus.emit({
         type: "rectify:completed",
         storyId: ctx.story.id,
         attempt: rectifyAttempt,
-        fixed
+        fixed: succeeded
       });
-      if (fixed) {
+      if (succeeded) {
         logger.info("rectify", "Rectification succeeded \u2014 retrying verify", { storyId: ctx.story.id });
         ctx.verifyResult = undefined;
-        return { action: "retry", fromStage: "verify" };
+        return { action: "retry", fromStage: "verify", cost };
       }
       logger.warn("rectify", "Rectification exhausted \u2014 escalating", { storyId: ctx.story.id });
       return {
         action: "escalate",
-        reason: `Rectification exhausted after ${maxRetries} attempts (${verifyResult.failCount} test failures)`
+        reason: `Rectification exhausted after ${maxRetries} attempts (${verifyResult.failCount} test failures)`,
+        cost
       };
     }
   };
-  _rectifyDeps = { runRectificationLoop: runRectificationLoop2 };
+  _rectifyDeps = { runRectificationLoop: runRectificationLoopFromCtx };
 });
 
 // src/verification/orchestrator-types.ts
@@ -33172,16 +33660,16 @@ class AcceptanceStrategy {
     }, timeoutMs);
     const exitCode = await Promise.race([
       proc.exited,
-      new Promise((resolve7) => setTimeout(() => resolve7(124), timeoutMs + 6000))
+      new Promise((resolve8) => setTimeout(() => resolve8(124), timeoutMs + 6000))
     ]);
     clearTimeout(timeoutId);
     const stdout = await Promise.race([
       new Response(proc.stdout).text(),
-      new Promise((resolve7) => setTimeout(() => resolve7(""), 3000))
+      new Promise((resolve8) => setTimeout(() => resolve8(""), 3000))
     ]);
     const stderr = await Promise.race([
       new Response(proc.stderr).text(),
-      new Promise((resolve7) => setTimeout(() => resolve7(""), 3000))
+      new Promise((resolve8) => setTimeout(() => resolve8(""), 3000))
     ]);
     const durationMs = Date.now() - start;
     if (timedOut || exitCode === 124) {
@@ -33591,34 +34079,31 @@ var init_regression2 = __esm(() => {
   regressionStage = {
     name: "regression",
     enabled(ctx) {
-      const effectiveConfig = ctx.effectiveConfig ?? ctx.config;
-      const mode = effectiveConfig.execution.regressionGate?.mode ?? "deferred";
+      const mode = ctx.config.execution.regressionGate?.mode ?? "deferred";
       if (mode !== "per-story")
         return false;
       if (ctx.verifyResult && !ctx.verifyResult.success)
         return false;
-      const gateEnabled = effectiveConfig.execution.regressionGate?.enabled ?? true;
+      const gateEnabled = ctx.config.execution.regressionGate?.enabled ?? true;
       return gateEnabled;
     },
     skipReason(ctx) {
-      const effectiveConfig = ctx.effectiveConfig ?? ctx.config;
-      const mode = effectiveConfig.execution.regressionGate?.mode ?? "deferred";
+      const mode = ctx.config.execution.regressionGate?.mode ?? "deferred";
       if (mode !== "per-story")
         return `not needed (regression mode is '${mode}', not 'per-story')`;
       return "disabled (regression gate not enabled in config)";
     },
     async execute(ctx) {
       const logger = getLogger();
-      const effectiveConfig = ctx.effectiveConfig ?? ctx.config;
-      const testCommand = effectiveConfig.review?.commands?.test ?? effectiveConfig.quality.commands.test ?? "bun test";
-      const timeoutSeconds = effectiveConfig.execution.regressionGate?.timeoutSeconds ?? 120;
+      const testCommand = ctx.config.review?.commands?.test ?? ctx.config.quality.commands.test ?? "bun test";
+      const timeoutSeconds = ctx.config.execution.regressionGate?.timeoutSeconds ?? 120;
       logger.info("regression", "Running full-suite regression gate", { storyId: ctx.story.id });
       const verifyCtx = {
         workdir: ctx.workdir,
         testCommand,
         timeoutSeconds,
         storyId: ctx.story.id,
-        acceptOnTimeout: effectiveConfig.execution.regressionGate?.acceptOnTimeout ?? true,
+        acceptOnTimeout: ctx.config.execution.regressionGate?.acceptOnTimeout ?? true,
         config: ctx.config
       };
       const result = await _regressionStageDeps.verifyRegression(verifyCtx);
@@ -34225,7 +34710,6 @@ var init_routing = __esm(() => {
 });
 
 // src/pipeline/stages/routing.ts
-import { join as join26 } from "path";
 var routingStage, _routingDeps;
 var init_routing2 = __esm(() => {
   init_greenfield();
@@ -34238,13 +34722,12 @@ var init_routing2 = __esm(() => {
     enabled: () => true,
     async execute(ctx) {
       const logger = getLogger();
-      const effectiveConfig = ctx.effectiveConfig ?? ctx.config;
-      const agentName = effectiveConfig.execution?.agent ?? "claude";
+      const agentName = ctx.config.execution?.agent ?? "claude";
       const adapter = ctx.agentGetFn ? ctx.agentGetFn(agentName) : undefined;
       if (ctx.story.id === ctx.stories[0]?.id) {
         _routingDeps.clearCache();
       }
-      const decision = await _routingDeps.resolveRouting(ctx.story, effectiveConfig, ctx.plugins, adapter);
+      const decision = await _routingDeps.resolveRouting(ctx.story, ctx.config, ctx.plugins, adapter);
       const TIER_RANK = { fast: 0, balanced: 1, powerful: 2 };
       const derivedTier = decision.modelTier;
       const previousTier = ctx.story.routing?.modelTier;
@@ -34262,9 +34745,9 @@ var init_routing2 = __esm(() => {
       if (ctx.prdPath) {
         await _routingDeps.savePRD(ctx.prd, ctx.prdPath);
       }
-      const greenfieldDetectionEnabled = effectiveConfig.tdd.greenfieldDetection ?? true;
+      const greenfieldDetectionEnabled = ctx.config.tdd.greenfieldDetection ?? true;
       if (greenfieldDetectionEnabled && routing.testStrategy.startsWith("three-session-tdd")) {
-        const greenfieldScanDir = ctx.story.workdir ? join26(ctx.workdir, ctx.story.workdir) : ctx.workdir;
+        const greenfieldScanDir = ctx.workdir;
         const isGreenfield = await _routingDeps.isGreenfieldStory(ctx.story, greenfieldScanDir);
         if (isGreenfield) {
           logger.info("routing", "Greenfield detected \u2014 forcing test-after strategy", {
@@ -34315,7 +34798,7 @@ var init_crash_detector = __esm(() => {
 });
 
 // src/pipeline/stages/verify.ts
-import { join as join27 } from "path";
+import { join as join22 } from "path";
 function coerceSmartTestRunner(val) {
   if (val === undefined || val === true)
     return DEFAULT_SMART_RUNNER_CONFIG2;
@@ -34331,7 +34814,7 @@ function buildScopedCommand2(testFiles, baseCommand, testScopedTemplate) {
 }
 async function readPackageName(dir) {
   try {
-    const content = await Bun.file(join27(dir, "package.json")).json();
+    const content = await Bun.file(join22(dir, "package.json")).json();
     return typeof content.name === "string" ? content.name : null;
   } catch {
     return null;
@@ -34364,26 +34847,24 @@ var init_verify = __esm(() => {
     skipReason: () => "not needed (full-suite gate already passed)",
     async execute(ctx) {
       const logger = getLogger();
-      const effectiveConfig = ctx.effectiveConfig ?? ctx.config;
-      if (!effectiveConfig.quality.requireTests) {
+      if (!ctx.config.quality.requireTests) {
         logger.debug("verify", "Skipping verification (quality.requireTests = false)", { storyId: ctx.story.id });
         return { action: "continue" };
       }
-      const testCommand = effectiveConfig.review?.commands?.test ?? effectiveConfig.quality.commands.test;
-      const testScopedTemplate = effectiveConfig.quality.commands.testScoped;
+      const testCommand = ctx.config.review?.commands?.test ?? ctx.config.quality.commands.test;
+      const testScopedTemplate = ctx.config.quality.commands.testScoped;
       if (!testCommand) {
         logger.debug("verify", "Skipping verification (no test command configured)", { storyId: ctx.story.id });
         return { action: "continue" };
       }
       logger.info("verify", "Running verification", { storyId: ctx.story.id });
-      const effectiveWorkdir = ctx.story.workdir ? join27(ctx.workdir, ctx.story.workdir) : ctx.workdir;
       let effectiveCommand = testCommand;
       let isFullSuite = true;
-      const smartRunnerConfig = coerceSmartTestRunner(effectiveConfig.execution.smartTestRunner);
-      const regressionMode = effectiveConfig.execution.regressionGate?.mode ?? "deferred";
+      const smartRunnerConfig = coerceSmartTestRunner(ctx.config.execution.smartTestRunner);
+      const regressionMode = ctx.config.execution.regressionGate?.mode ?? "deferred";
       let resolvedTestScopedTemplate = testScopedTemplate;
       if (testScopedTemplate && ctx.story.workdir) {
-        const resolved = await resolvePackageTemplate(testScopedTemplate, effectiveWorkdir);
+        const resolved = await resolvePackageTemplate(testScopedTemplate, ctx.workdir);
         resolvedTestScopedTemplate = resolved ?? undefined;
       }
       const isMonorepoOrchestrator = isMonorepoOrchestratorCommand(testCommand);
@@ -34402,8 +34883,8 @@ var init_verify = __esm(() => {
           });
         }
       } else if (smartRunnerConfig.enabled) {
-        const sourceFiles = await _smartRunnerDeps.getChangedSourceFiles(effectiveWorkdir, ctx.storyGitRef, ctx.story.workdir);
-        const pass1Files = await _smartRunnerDeps.mapSourceToTests(sourceFiles, effectiveWorkdir);
+        const sourceFiles = await _smartRunnerDeps.getChangedSourceFiles(ctx.workdir, ctx.storyGitRef, ctx.story.workdir);
+        const pass1Files = await _smartRunnerDeps.mapSourceToTests(sourceFiles, ctx.workdir);
         if (pass1Files.length > 0) {
           logger.info("verify", `[smart-runner] Pass 1: path convention matched ${pass1Files.length} test files`, {
             storyId: ctx.story.id
@@ -34411,7 +34892,7 @@ var init_verify = __esm(() => {
           effectiveCommand = buildScopedCommand2(pass1Files, testCommand, resolvedTestScopedTemplate);
           isFullSuite = false;
         } else if (smartRunnerConfig.fallback === "import-grep") {
-          const pass2Files = await _smartRunnerDeps.importGrepFallback(sourceFiles, effectiveWorkdir, smartRunnerConfig.testFilePatterns);
+          const pass2Files = await _smartRunnerDeps.importGrepFallback(sourceFiles, ctx.workdir, smartRunnerConfig.testFilePatterns);
           if (pass2Files.length > 0) {
             logger.info("verify", `[smart-runner] Pass 2: import-grep matched ${pass2Files.length} test files`, {
               storyId: ctx.story.id
@@ -34437,10 +34918,10 @@ var init_verify = __esm(() => {
         command: effectiveCommand
       });
       const result = await _verifyDeps.regression({
-        workdir: effectiveWorkdir,
+        workdir: ctx.workdir,
         command: effectiveCommand,
-        timeoutSeconds: effectiveConfig.execution.verificationTimeoutSeconds,
-        acceptOnTimeout: effectiveConfig.execution.regressionGate?.acceptOnTimeout ?? true
+        timeoutSeconds: ctx.config.execution.verificationTimeoutSeconds,
+        acceptOnTimeout: ctx.config.execution.regressionGate?.acceptOnTimeout ?? true
       });
       ctx.verifyResult = {
         success: result.success,
@@ -34457,7 +34938,7 @@ var init_verify = __esm(() => {
       };
       if (!result.success) {
         if (result.status === "TIMEOUT") {
-          const timeout = effectiveConfig.execution.verificationTimeoutSeconds;
+          const timeout = ctx.config.execution.verificationTimeoutSeconds;
           logger.error("verify", `Test suite exceeded timeout (${timeout}s). This is NOT a test failure \u2014 consider increasing execution.verificationTimeoutSeconds or scoping tests.`, {
             exitCode: result.status,
             storyId: ctx.story.id,
@@ -34475,7 +34956,7 @@ var init_verify = __esm(() => {
         if (result.status === "TIMEOUT" || detectRuntimeCrash(result.output)) {
           return {
             action: "escalate",
-            reason: result.status === "TIMEOUT" ? `Test suite TIMEOUT after ${effectiveConfig.execution.verificationTimeoutSeconds}s (not a code failure)` : `Tests failed with runtime crash (exit code ${result.status ?? "non-zero"})`
+            reason: result.status === "TIMEOUT" ? `Test suite TIMEOUT after ${ctx.config.execution.verificationTimeoutSeconds}s (not a code failure)` : `Tests failed with runtime crash (exit code ${result.status ?? "non-zero"})`
           };
         }
         return { action: "continue" };
@@ -34593,9 +35074,9 @@ __export(exports_init_context, {
   generateContextTemplate: () => generateContextTemplate,
   _initContextDeps: () => _initContextDeps
 });
-import { existsSync as existsSync22 } from "fs";
+import { existsSync as existsSync21 } from "fs";
 import { mkdir as mkdir2 } from "fs/promises";
-import { basename as basename4, join as join31 } from "path";
+import { basename as basename3, join as join26 } from "path";
 async function findFiles(dir, maxFiles = 200) {
   try {
     const proc = Bun.spawnSync([
@@ -34623,8 +35104,8 @@ async function findFiles(dir, maxFiles = 200) {
   return [];
 }
 async function readPackageManifest(projectRoot) {
-  const packageJsonPath = join31(projectRoot, "package.json");
-  if (!existsSync22(packageJsonPath)) {
+  const packageJsonPath = join26(projectRoot, "package.json");
+  if (!existsSync21(packageJsonPath)) {
     return null;
   }
   try {
@@ -34641,8 +35122,8 @@ async function readPackageManifest(projectRoot) {
   }
 }
 async function readReadmeSnippet(projectRoot) {
-  const readmePath = join31(projectRoot, "README.md");
-  if (!existsSync22(readmePath)) {
+  const readmePath = join26(projectRoot, "README.md");
+  if (!existsSync21(readmePath)) {
     return null;
   }
   try {
@@ -34659,8 +35140,8 @@ async function detectEntryPoints(projectRoot) {
   const candidates = ["src/index.ts", "src/main.ts", "main.go", "src/lib.rs"];
   const found = [];
   for (const candidate of candidates) {
-    const path13 = join31(projectRoot, candidate);
-    if (existsSync22(path13)) {
+    const path13 = join26(projectRoot, candidate);
+    if (existsSync21(path13)) {
       found.push(candidate);
     }
   }
@@ -34670,8 +35151,8 @@ async function detectConfigFiles(projectRoot) {
   const candidates = ["tsconfig.json", "biome.json", "turbo.json", ".env.example"];
   const found = [];
   for (const candidate of candidates) {
-    const path13 = join31(projectRoot, candidate);
-    if (existsSync22(path13)) {
+    const path13 = join26(projectRoot, candidate);
+    if (existsSync21(path13)) {
       found.push(candidate);
     }
   }
@@ -34683,7 +35164,7 @@ async function scanProject(projectRoot) {
   const readmeSnippet = await readReadmeSnippet(projectRoot);
   const entryPoints = await detectEntryPoints(projectRoot);
   const configFiles = await detectConfigFiles(projectRoot);
-  const projectName = packageManifest?.name || basename4(projectRoot);
+  const projectName = packageManifest?.name || basename3(projectRoot);
   return {
     projectName,
     fileTree,
@@ -34831,13 +35312,13 @@ function generatePackageContextTemplate(packagePath) {
 }
 async function initPackage(repoRoot, packagePath, force = false) {
   const logger = getLogger();
-  const naxDir = join31(repoRoot, ".nax", "mono", packagePath);
-  const contextPath = join31(naxDir, "context.md");
-  if (existsSync22(contextPath) && !force) {
+  const naxDir = join26(repoRoot, ".nax", "mono", packagePath);
+  const contextPath = join26(naxDir, "context.md");
+  if (existsSync21(contextPath) && !force) {
     logger.info("init", "Package context.md already exists (use --force to overwrite)", { path: contextPath });
     return;
   }
-  if (!existsSync22(naxDir)) {
+  if (!existsSync21(naxDir)) {
     await mkdir2(naxDir, { recursive: true });
   }
   const content = generatePackageContextTemplate(packagePath);
@@ -34846,13 +35327,13 @@ async function initPackage(repoRoot, packagePath, force = false) {
 }
 async function initContext(projectRoot, options = {}) {
   const logger = getLogger();
-  const naxDir = join31(projectRoot, ".nax");
-  const contextPath = join31(naxDir, "context.md");
-  if (existsSync22(contextPath) && !options.force) {
+  const naxDir = join26(projectRoot, ".nax");
+  const contextPath = join26(naxDir, "context.md");
+  if (existsSync21(contextPath) && !options.force) {
     logger.info("init", "context.md already exists, skipping (use --force to overwrite)", { path: contextPath });
     return;
   }
-  if (!existsSync22(naxDir)) {
+  if (!existsSync21(naxDir)) {
     await mkdir2(naxDir, { recursive: true });
   }
   const scan = await scanProject(projectRoot);
@@ -34877,23 +35358,23 @@ var init_init_context = __esm(() => {
 
 // src/utils/path-security.ts
 import { realpathSync as realpathSync3 } from "fs";
-import { dirname as dirname5, isAbsolute as isAbsolute5, join as join32, normalize as normalize2, resolve as resolve7 } from "path";
+import { dirname as dirname4, isAbsolute as isAbsolute5, join as join27, normalize as normalize2, resolve as resolve8 } from "path";
 function safeRealpathForComparison(p) {
   try {
     return realpathSync3(p);
   } catch {
-    const parent = dirname5(p);
+    const parent = dirname4(p);
     if (parent === p)
       return normalize2(p);
     const resolvedParent = safeRealpathForComparison(parent);
-    return join32(resolvedParent, p.split("/").pop() ?? "");
+    return join27(resolvedParent, p.split("/").pop() ?? "");
   }
 }
 function validateModulePath(modulePath, allowedRoots) {
   if (!modulePath) {
     return { valid: false, error: "Module path is empty" };
   }
-  const resolvedRoots = allowedRoots.map((r) => safeRealpathForComparison(resolve7(r)));
+  const resolvedRoots = allowedRoots.map((r) => safeRealpathForComparison(resolve8(r)));
   if (isAbsolute5(modulePath)) {
     const normalized = normalize2(modulePath);
     const resolved = safeRealpathForComparison(normalized);
@@ -34903,8 +35384,8 @@ function validateModulePath(modulePath, allowedRoots) {
     }
   } else {
     for (let i = 0;i < allowedRoots.length; i++) {
-      const originalRoot = resolve7(allowedRoots[i]);
-      const absoluteInput = resolve7(join32(originalRoot, modulePath));
+      const originalRoot = resolve8(allowedRoots[i]);
+      const absoluteInput = resolve8(join27(originalRoot, modulePath));
       const resolved = safeRealpathForComparison(absoluteInput);
       const resolvedRoot = resolvedRoots[i];
       if (resolved.startsWith(`${resolvedRoot}/`) || resolved === resolvedRoot) {
@@ -35265,11 +35746,11 @@ function getSafeLogger6() {
   return getSafeLogger();
 }
 function extractPluginName(pluginPath) {
-  const basename6 = path13.basename(pluginPath);
-  if (basename6 === "index.ts" || basename6 === "index.js" || basename6 === "index.mjs") {
+  const basename5 = path13.basename(pluginPath);
+  if (basename5 === "index.ts" || basename5 === "index.js" || basename5 === "index.mjs") {
     return path13.basename(path13.dirname(pluginPath));
   }
-  return basename6.replace(/\.(ts|js|mjs)$/, "");
+  return basename5.replace(/\.(ts|js|mjs)$/, "");
 }
 async function loadPlugins(globalDir, projectDir, configPlugins, projectRoot, disabledPlugins) {
   const loadedPlugins = [];
@@ -35430,7 +35911,7 @@ async function loadAndValidatePlugin(initialModulePath, config2, allowedRoots =
     return null;
   }
 }
-var _pluginErrorSink = (...args) => console.error(...args);
+var _pluginErrorSink = () => {};
 var init_loader4 = __esm(() => {
   init_logger2();
   init_path_security2();
@@ -35440,19 +35921,19 @@ var init_loader4 = __esm(() => {
 });
 
 // src/hooks/runner.ts
-import { join as join47 } from "path";
+import { join as join42 } from "path";
 async function loadHooksConfig(projectDir, globalDir) {
   let globalHooks = { hooks: {} };
   let projectHooks = { hooks: {} };
   let skipGlobal = false;
-  const projectPath = join47(projectDir, "hooks.json");
+  const projectPath = join42(projectDir, "hooks.json");
   const projectData = await loadJsonFile(projectPath, "hooks");
   if (projectData) {
     projectHooks = projectData;
     skipGlobal = projectData.skipGlobal ?? false;
   }
   if (!skipGlobal && globalDir) {
-    const globalPath = join47(globalDir, "hooks.json");
+    const globalPath = join42(globalDir, "hooks.json");
     const globalData = await loadJsonFile(globalPath, "hooks");
     if (globalData) {
       globalHooks = globalData;
@@ -35652,7 +36133,7 @@ var package_default;
 var init_package = __esm(() => {
   package_default = {
     name: "@nathapp/nax",
-    version: "0.58.5",
+    version: "0.59.1",
     description: "AI Coding Agent Orchestrator \u2014 loops until done",
     type: "module",
     bin: {
@@ -35732,8 +36213,8 @@ var init_version = __esm(() => {
   NAX_VERSION = package_default.version;
   NAX_COMMIT = (() => {
     try {
-      if (/^[0-9a-f]{6,10}$/.test("374b714e"))
-        return "374b714e";
+      if (/^[0-9a-f]{6,10}$/.test("b8492d03"))
+        return "b8492d03";
     } catch {}
     try {
       const result = Bun.spawnSync(["git", "rev-parse", "--short", "HEAD"], {
@@ -36029,18 +36510,18 @@ var init_crash_signals = __esm(() => {
 
 // src/execution/crash-recovery.ts
 function installCrashHandlers(ctx) {
-  if (handlersInstalled) {
-    return () => {};
+  if (activeCleanup) {
+    activeCleanup();
   }
   const cleanup = installSignalHandlers(ctx);
-  handlersInstalled = true;
-  return () => {
+  activeCleanup = () => {
     cleanup();
     stopHeartbeat();
-    handlersInstalled = false;
+    activeCleanup = null;
   };
+  return activeCleanup;
 }
-var handlersInstalled = false;
+var activeCleanup = null;
 var init_crash_recovery = __esm(() => {
   init_crash_heartbeat();
   init_crash_signals();
@@ -36361,12 +36842,13 @@ async function diagnoseAcceptanceFailure(agent, options) {
     semanticVerdicts: options.semanticVerdicts
   });
   try {
+    const timeoutSeconds = (config2.acceptance?.timeoutMs ?? 120000) / 1000;
     const result = await agent.run({
       prompt,
       workdir,
       modelTier: undefined,
       modelDef,
-      timeoutSeconds: 300,
+      timeoutSeconds,
       sessionRole: "diagnose",
       acpSessionName: sessionName,
       featureName,
@@ -36375,12 +36857,13 @@ async function diagnoseAcceptanceFailure(agent, options) {
     });
     const diagnosis = parseDiagnosisResult(result.output);
     if (diagnosis) {
-      return diagnosis;
+      return { ...diagnosis, cost: result.estimatedCost ?? 0 };
     }
     return {
       verdict: "source_bug",
       reasoning: "diagnosis failed \u2014 falling back to source fix",
-      confidence: 0
+      confidence: 0,
+      cost: result.estimatedCost ?? 0
     };
   } catch {
     return {
@@ -36492,7 +36975,7 @@ __export(exports_acceptance_loop, {
   _regenerateDeps: () => _regenerateDeps,
   _acceptanceLoopDeps: () => _acceptanceLoopDeps
 });
-import path15, { join as join48 } from "path";
+import path15, { join as join43 } from "path";
 function isStubTestFile(content) {
   return /expect\s*\(\s*true\s*\)\s*\.\s*toBe\s*\(\s*(?:false|true)\s*\)/.test(content);
 }
@@ -36581,15 +37064,16 @@ async function executeFixStory(ctx, story, prd, iterations) {
     agent: ctx.config.autoMode.defaultAgent,
     iteration: iterations
   }), ctx.workdir);
-  const fixEffectiveConfig = story.workdir ? await loadConfigForWorkdir(join48(ctx.workdir, ".nax", "config.json"), story.workdir) : ctx.config;
+  const fixEffectiveConfig = story.workdir ? await loadConfigForWorkdir(join43(ctx.workdir, ".nax", "config.json"), story.workdir) : ctx.config;
   const fixContext = {
-    config: ctx.config,
-    effectiveConfig: fixEffectiveConfig,
+    config: fixEffectiveConfig,
+    rootConfig: ctx.config,
     prd,
     story,
     stories: [story],
     routing,
-    workdir: ctx.workdir,
+    projectDir: ctx.workdir,
+    workdir: story.workdir ? join43(ctx.workdir, story.workdir) : ctx.workdir,
     featureDir: ctx.featureDir,
     hooks: ctx.hooks,
     plugins: ctx.pluginRegistry,
@@ -36768,6 +37252,7 @@ async function runFixRouting(options) {
     storyId,
     semanticVerdicts: options.semanticVerdicts
   });
+  const diagnosisCost = diagnosis.cost ?? 0;
   logger?.info("acceptance.diagnosis", "Diagnosis complete", {
     verdict: diagnosis.verdict,
     confidence: diagnosis.confidence,
@@ -36777,7 +37262,7 @@ async function runFixRouting(options) {
     logger?.info("acceptance", "Diagnosis: source_bug \u2014 executing source fix");
     if (!agent) {
       logger?.error("acceptance", "Agent not found for source fix execution");
-      return { fixed: false, cost: 0, prdDirty: false };
+      return { fixed: false, cost: diagnosisCost, prdDirty: false };
     }
     let fixAttempts = 0;
     while (fixAttempts < fixMaxRetries) {
@@ -36799,7 +37284,7 @@ async function runFixRouting(options) {
         attempt: fixAttempts
       });
       if (fixResult.success) {
-        return { fixed: true, cost: fixResult.cost, prdDirty: false };
+        return { fixed: true, cost: fixResult.cost + diagnosisCost, prdDirty: false };
       }
       logger?.warn("acceptance.source-fix", "Source fix attempt failed", {
         attempt: fixAttempts,
@@ -36812,13 +37297,13 @@ async function runFixRouting(options) {
         break;
       }
     }
-    return { fixed: false, cost: 0, prdDirty: false };
+    return { fixed: false, cost: diagnosisCost, prdDirty: false };
   }
   if (diagnosis.verdict === "test_bug") {
     logger?.info("acceptance", "Diagnosis: test_bug \u2014 regenerating acceptance test");
     if (!ctx.featureDir) {
       logger?.error("acceptance", "Cannot regenerate test without featureDir");
-      return { fixed: false, cost: 0, prdDirty: false };
+      return { fixed: false, cost: diagnosisCost, prdDirty: false };
     }
     const testPath = await findExistingAcceptanceTestPath({
       acceptanceTestPaths: ctx.acceptanceTestPaths,
@@ -36835,29 +37320,29 @@ async function runFixRouting(options) {
           language: ctx.config.project?.language
         })
       });
-      return { fixed: false, cost: 0, prdDirty: false };
+      return { fixed: false, cost: diagnosisCost, prdDirty: false };
     }
     const regenerated = await regenerateAcceptanceTest(testPath, acceptanceContext);
     logger?.info("acceptance.test-regen", "Test regeneration completed", {
       outcome: regenerated ? "success" : "failure"
     });
     if (!regenerated) {
-      return { fixed: false, cost: 0, prdDirty: false };
+      return { fixed: false, cost: diagnosisCost, prdDirty: false };
     }
     const { acceptanceStage: acceptanceStage2 } = await Promise.resolve().then(() => (init_acceptance(), exports_acceptance));
     const acceptanceResult = await acceptanceStage2.execute(acceptanceContext);
     if (acceptanceResult.action === "continue") {
       logger?.info("acceptance", "Acceptance passed after test regeneration");
-      return { fixed: true, cost: 0, prdDirty: true };
+      return { fixed: true, cost: diagnosisCost, prdDirty: true };
     }
     logger?.warn("acceptance", "Acceptance still failing after test regeneration");
-    return { fixed: false, cost: 0, prdDirty: true };
+    return { fixed: false, cost: diagnosisCost, prdDirty: true };
   }
   if (diagnosis.verdict === "both") {
     logger?.info("acceptance", "Diagnosis: both \u2014 executing source fix then regenerating test if needed");
     if (!agent) {
       logger?.error("acceptance", "Agent not found for source fix execution");
-      return { fixed: false, cost: 0, prdDirty: false };
+      return { fixed: false, cost: diagnosisCost, prdDirty: false };
     }
     let sourceFixSuccess = false;
     let sourceFixCost = 0;
@@ -36897,19 +37382,19 @@ async function runFixRouting(options) {
       }
     }
     if (!sourceFixSuccess) {
-      return { fixed: false, cost: sourceFixCost, prdDirty: false };
+      return { fixed: false, cost: sourceFixCost + diagnosisCost, prdDirty: false };
     }
     logger?.info("acceptance", "Source fix succeeded \u2014 re-running acceptance to verify");
     const { acceptanceStage: acceptanceStage2 } = await Promise.resolve().then(() => (init_acceptance(), exports_acceptance));
     const acceptanceResult = await acceptanceStage2.execute(acceptanceContext);
     if (acceptanceResult.action === "continue") {
       logger?.info("acceptance", "Acceptance passed after source fix");
-      return { fixed: true, cost: sourceFixCost, prdDirty: false };
+      return { fixed: true, cost: sourceFixCost + diagnosisCost, prdDirty: false };
     }
     logger?.info("acceptance", "Acceptance still failing after source fix \u2014 regenerating test");
     if (!ctx.featureDir) {
       logger?.error("acceptance", "Cannot regenerate test without featureDir");
-      return { fixed: false, cost: sourceFixCost, prdDirty: false };
+      return { fixed: false, cost: sourceFixCost + diagnosisCost, prdDirty: false };
     }
     const testPath = await findExistingAcceptanceTestPath({
       acceptanceTestPaths: ctx.acceptanceTestPaths,
@@ -36926,15 +37411,15 @@ async function runFixRouting(options) {
           language: ctx.config.project?.language
         })
       });
-      return { fixed: false, cost: sourceFixCost, prdDirty: false };
+      return { fixed: false, cost: sourceFixCost + diagnosisCost, prdDirty: false };
     }
     const regenerated = await regenerateAcceptanceTest(testPath, acceptanceContext);
     logger?.info("acceptance.test-regen", "Test regeneration completed", {
       outcome: regenerated ? "success" : "failure"
     });
-    return { fixed: regenerated, cost: sourceFixCost, prdDirty: regenerated };
+    return { fixed: regenerated, cost: sourceFixCost + diagnosisCost, prdDirty: regenerated };
   }
-  return { fixed: false, cost: 0, prdDirty: false };
+  return { fixed: false, cost: diagnosisCost, prdDirty: false };
 }
 async function runAcceptanceLoop(ctx) {
   const logger = getSafeLogger();
@@ -36950,7 +37435,7 @@ async function runAcceptanceLoop(ctx) {
     const firstStory = prd.userStories[0];
     const acceptanceContext = {
       config: ctx.config,
-      effectiveConfig: ctx.config,
+      rootConfig: ctx.config,
       prd,
       story: firstStory,
       stories: [firstStory],
@@ -36960,6 +37445,7 @@ async function runAcceptanceLoop(ctx) {
         testStrategy: "test-after",
         reasoning: "Acceptance validation"
       },
+      projectDir: ctx.workdir,
       workdir: ctx.workdir,
       featureDir: ctx.featureDir,
       hooks: ctx.hooks,
@@ -37185,6 +37671,20 @@ async function runDeferredRegression(options) {
   const testCommand = config2.quality.commands.test ?? "bun test";
   const timeoutSeconds = config2.execution.regressionGate?.timeoutSeconds ?? 120;
   const maxRectificationAttempts = config2.execution.regressionGate?.maxRectificationAttempts ?? 2;
+  const acceptOnTimeout = config2.execution.regressionGate?.acceptOnTimeout ?? true;
+  const verifyOpts = {
+    workdir,
+    command: testCommand,
+    timeoutSeconds,
+    forceExit: config2.quality.forceExit,
+    detectOpenHandles: config2.quality.detectOpenHandles,
+    detectOpenHandlesRetries: config2.quality.detectOpenHandlesRetries,
+    timeoutRetryCount: 0,
+    gracePeriodMs: config2.quality.gracePeriodMs,
+    drainTimeoutMs: config2.quality.drainTimeoutMs,
+    shell: config2.quality.shell,
+    stripEnvVars: config2.quality.stripEnvVars
+  };
   const counts = countStories(prd);
   const passedStories = prd.userStories.filter((s) => s.status === "passed");
   if (passedStories.length === 0) {
@@ -37202,19 +37702,7 @@ async function runDeferredRegression(options) {
     totalStories: counts.total,
     passedStories: passedStories.length
   });
-  const fullSuiteResult = await _regressionDeps.runVerification({
-    workdir,
-    command: testCommand,
-    timeoutSeconds,
-    forceExit: config2.quality.forceExit,
-    detectOpenHandles: config2.quality.detectOpenHandles,
-    detectOpenHandlesRetries: config2.quality.detectOpenHandlesRetries,
-    timeoutRetryCount: 0,
-    gracePeriodMs: config2.quality.gracePeriodMs,
-    drainTimeoutMs: config2.quality.drainTimeoutMs,
-    shell: config2.quality.shell,
-    stripEnvVars: config2.quality.stripEnvVars
-  });
+  const fullSuiteResult = await _regressionDeps.runVerification(verifyOpts);
   if (fullSuiteResult.success) {
     logger?.info("regression", "Full suite passed");
     return {
@@ -37226,7 +37714,6 @@ async function runDeferredRegression(options) {
       affectedStories: []
     };
   }
-  const acceptOnTimeout = config2.execution.regressionGate?.acceptOnTimeout ?? true;
   if (fullSuiteResult.status === "TIMEOUT" && acceptOnTimeout) {
     logger?.warn("regression", "Full-suite regression gate timed out (accepted as pass)");
     return {
@@ -37308,6 +37795,8 @@ async function runDeferredRegression(options) {
     };
   }
   let rectificationAttempts = 0;
+  let storiesRectified = 0;
+  let currentTestOutput = fullSuiteResult.output;
   const affectedStoriesList = Array.from(affectedStoriesObjs.values());
   for (const story of affectedStoriesList) {
     for (let attempt = 0;attempt < maxRectificationAttempts; attempt++) {
@@ -37319,32 +37808,51 @@ async function runDeferredRegression(options) {
         story,
         testCommand,
         timeoutSeconds,
-        testOutput: fullSuiteResult.output,
+        testOutput: currentTestOutput,
         promptPrefix: `# DEFERRED REGRESSION: Full-Suite Failures
 
 Your story ${story.id} broke tests in the full suite. Fix these regressions.`,
         agentGetFn
       });
       if (fixed) {
+        storiesRectified++;
         logger?.info("regression", `Story ${story.id} rectified successfully`);
+        logger?.info("regression", "Re-running full suite after story rectification", {
+          storyId: story.id,
+          storiesRectified,
+          storiesRemaining: affectedStoriesList.length - storiesRectified
+        });
+        const midResult = await _regressionDeps.runVerification(verifyOpts);
+        const midSuccess = midResult.success || midResult.status === "TIMEOUT" && acceptOnTimeout;
+        if (midSuccess) {
+          logger?.info("regression", "Full suite passed after story rectification \u2014 early exit", {
+            storyId: story.id,
+            storiesRectified,
+            storiesSkipped: affectedStoriesList.length - storiesRectified,
+            passCount: midResult.passCount ?? 0
+          });
+          return {
+            success: true,
+            failedTests: testFilesInFailures.size,
+            failedTestFiles: Array.from(testFilesInFailures),
+            passedTests: midResult.passCount ?? 0,
+            rectificationAttempts,
+            affectedStories: Array.from(affectedStories)
+          };
+        }
+        logger?.warn("regression", "Full suite still failing after story rectification \u2014 continuing", {
+          storyId: story.id,
+          failCount: midResult.failCount ?? 0,
+          passCount: midResult.passCount ?? 0
+        });
+        if (midResult.output)
+          currentTestOutput = midResult.output;
         break;
       }
     }
   }
   logger?.info("regression", "Re-running full suite after rectification");
-  const retryResult = await _regressionDeps.runVerification({
-    workdir,
-    command: testCommand,
-    timeoutSeconds,
-    forceExit: config2.quality.forceExit,
-    detectOpenHandles: config2.quality.detectOpenHandles,
-    detectOpenHandlesRetries: config2.quality.detectOpenHandlesRetries,
-    timeoutRetryCount: 0,
-    gracePeriodMs: config2.quality.gracePeriodMs,
-    drainTimeoutMs: config2.quality.drainTimeoutMs,
-    shell: config2.quality.shell,
-    stripEnvVars: config2.quality.stripEnvVars
-  });
+  const retryResult = await _regressionDeps.runVerification(verifyOpts);
   const success2 = retryResult.success || retryResult.status === "TIMEOUT" && acceptOnTimeout;
   if (success2) {
     logger?.info("regression", "Deferred regression gate passed after rectification");
@@ -37601,12 +38109,12 @@ var init_headless_formatter = __esm(() => {
 // src/pipeline/subscribers/events-writer.ts
 import { appendFile as appendFile3, mkdir as mkdir3 } from "fs/promises";
 import { homedir as homedir5 } from "os";
-import { basename as basename7, join as join49 } from "path";
+import { basename as basename6, join as join44 } from "path";
 function wireEventsWriter(bus, feature, runId, workdir) {
   const logger = getSafeLogger();
-  const project = basename7(workdir);
-  const eventsDir = join49(homedir5(), ".nax", "events", project);
-  const eventsFile = join49(eventsDir, "events.jsonl");
+  const project = basename6(workdir);
+  const eventsDir = join44(homedir5(), ".nax", "events", project);
+  const eventsFile = join44(eventsDir, "events.jsonl");
   let dirReady = false;
   const write = (line) => {
     return (async () => {
@@ -37787,12 +38295,12 @@ var init_interaction2 = __esm(() => {
 // src/pipeline/subscribers/registry.ts
 import { mkdir as mkdir4, writeFile } from "fs/promises";
 import { homedir as homedir6 } from "os";
-import { basename as basename8, join as join50 } from "path";
+import { basename as basename7, join as join45 } from "path";
 function wireRegistry(bus, feature, runId, workdir) {
   const logger = getSafeLogger();
-  const project = basename8(workdir);
-  const runDir = join50(homedir6(), ".nax", "runs", `${project}-${feature}-${runId}`);
-  const metaFile = join50(runDir, "meta.json");
+  const project = basename7(workdir);
+  const runDir = join45(homedir6(), ".nax", "runs", `${project}-${feature}-${runId}`);
+  const metaFile = join45(runDir, "meta.json");
   const unsub = bus.on("run:started", (_ev) => {
     return (async () => {
       try {
@@ -37802,8 +38310,8 @@ function wireRegistry(bus, feature, runId, workdir) {
           project,
           feature,
           workdir,
-          statusPath: join50(workdir, ".nax", "features", feature, "status.json"),
-          eventsDir: join50(workdir, ".nax", "features", feature, "runs"),
+          statusPath: join45(workdir, ".nax", "features", feature, "status.json"),
+          eventsDir: join45(workdir, ".nax", "features", feature, "runs"),
           registeredAt: new Date().toISOString()
         };
         await writeFile(metaFile, JSON.stringify(meta3, null, 2));
@@ -38328,7 +38836,7 @@ function filterOutputFiles(files) {
 }
 async function handlePipelineSuccess(ctx, pipelineResult) {
   const logger = getSafeLogger();
-  const costDelta = pipelineResult.context.agentResult?.estimatedCost || 0;
+  const costDelta = (pipelineResult.context.agentResult?.estimatedCost ?? 0) + (pipelineResult.stageCost ?? 0);
   const prd = ctx.prd;
   if (pipelineResult.context.storyMetrics) {
     ctx.allStoryMetrics.push(...pipelineResult.context.storyMetrics);
@@ -38376,7 +38884,7 @@ async function handlePipelineFailure(ctx, pipelineResult) {
   const logger = getSafeLogger();
   let prd = ctx.prd;
   let prdDirty = false;
-  const costDelta = pipelineResult.context.agentResult?.estimatedCost || 0;
+  const costDelta = (pipelineResult.context.agentResult?.estimatedCost ?? 0) + (pipelineResult.stageCost ?? 0);
   switch (pipelineResult.finalAction) {
     case "pause":
       markStoryPaused(prd, ctx.story.id);
@@ -38455,7 +38963,7 @@ var init_pipeline_result_handler = __esm(() => {
 });
 
 // src/execution/iteration-runner.ts
-import { join as join51 } from "path";
+import { join as join46 } from "path";
 async function runIteration(ctx, prd, selection, iterations, totalCost, allStoryMetrics) {
   const logger = getSafeLogger();
   const { story, storiesToExecute, routing, isBatchExecution } = selection;
@@ -38490,15 +38998,16 @@ async function runIteration(ctx, prd, selection, iterations, totalCost, allStory
     }
   }
   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 effectiveConfig = story.workdir ? await _iterationRunnerDeps.loadConfigForWorkdir(join46(ctx.workdir, ".nax", "config.json"), story.workdir) : ctx.config;
   const pipelineContext = {
-    config: ctx.config,
-    effectiveConfig,
+    config: effectiveConfig,
+    rootConfig: ctx.config,
     prd,
     story,
     stories: storiesToExecute,
     routing,
-    workdir: ctx.workdir,
+    projectDir: ctx.workdir,
+    workdir: story.workdir ? join46(ctx.workdir, story.workdir) : ctx.workdir,
     prdPath: ctx.prdPath,
     featureDir: ctx.featureDir,
     hooks: ctx.hooks,
@@ -38523,13 +39032,6 @@ async function runIteration(ctx, prd, selection, iterations, totalCost, allStory
   await ctx.statusWriter.update(totalCost, iterations);
   const pipelineResult = await runPipeline(defaultPipeline, pipelineContext, ctx.eventEmitter);
   const currentPrd = pipelineResult.context.prd;
-  pipelineContext.agentResult = undefined;
-  pipelineContext.prompt = undefined;
-  pipelineContext.contextMarkdown = undefined;
-  pipelineContext.builtContext = undefined;
-  pipelineContext.verifyResult = undefined;
-  pipelineContext.reviewResult = undefined;
-  pipelineContext.constitution = undefined;
   const handlerCtx = {
     config: ctx.config,
     prd: currentPrd,
@@ -38552,26 +39054,36 @@ async function runIteration(ctx, prd, selection, iterations, totalCost, allStory
     storyStartTime,
     statusWriter: ctx.statusWriter
   };
+  let iterResult;
   if (pipelineResult.success) {
-    const r2 = await handlePipelineSuccess(handlerCtx, pipelineResult);
-    return {
-      prd: r2.prd,
-      storiesCompletedDelta: r2.storiesCompletedDelta,
-      costDelta: r2.costDelta,
-      prdDirty: r2.prdDirty,
+    const r = await handlePipelineSuccess(handlerCtx, pipelineResult);
+    iterResult = {
+      prd: r.prd,
+      storiesCompletedDelta: r.storiesCompletedDelta,
+      costDelta: r.costDelta,
+      prdDirty: r.prdDirty,
       finalAction: pipelineResult.finalAction
     };
+  } else {
+    const r = await handlePipelineFailure(handlerCtx, pipelineResult);
+    iterResult = {
+      prd: r.prd,
+      storiesCompletedDelta: 0,
+      costDelta: r.costDelta,
+      prdDirty: r.prdDirty,
+      finalAction: pipelineResult.finalAction,
+      reason: pipelineResult.reason,
+      subStoryCount: pipelineResult.subStoryCount
+    };
   }
-  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
-  };
+  pipelineContext.agentResult = undefined;
+  pipelineContext.prompt = undefined;
+  pipelineContext.contextMarkdown = undefined;
+  pipelineContext.builtContext = undefined;
+  pipelineContext.verifyResult = undefined;
+  pipelineContext.reviewResult = undefined;
+  pipelineContext.constitution = undefined;
+  return iterResult;
 }
 var _iterationRunnerDeps;
 var init_iteration_runner = __esm(() => {
@@ -38651,6 +39163,7 @@ __export(exports_parallel_worker, {
   executeStoryInWorktree: () => executeStoryInWorktree,
   executeParallelBatch: () => executeParallelBatch
 });
+import { join as join47 } from "path";
 async function executeStoryInWorktree(story, worktreePath, context, routing, eventEmitter) {
   const logger = getSafeLogger();
   try {
@@ -38665,10 +39178,12 @@ async function executeStoryInWorktree(story, worktreePath, context, routing, eve
     }
     const pipelineContext = {
       ...context,
-      effectiveConfig: context.effectiveConfig ?? context.config,
+      config: context.config,
+      rootConfig: context.rootConfig,
       story,
       stories: [story],
-      workdir: worktreePath,
+      projectDir: context.projectDir,
+      workdir: story.workdir ? join47(worktreePath, story.workdir) : worktreePath,
       routing,
       storyGitRef: storyGitRef ?? undefined
     };
@@ -38713,7 +39228,7 @@ async function executeParallelBatch(stories, projectRoot, config2, context, work
     }
     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 storyContext = storyConfig ? { ...context, config: storyConfig } : context;
     const executePromise = executeStoryInWorktree(story, worktreePath, storyContext, routing, eventEmitter).then((result) => {
       results.totalCost += result.cost;
       results.storyCosts.set(story.id, result.cost);
@@ -38755,19 +39270,19 @@ __export(exports_manager, {
   _managerDeps: () => _managerDeps,
   WorktreeManager: () => WorktreeManager
 });
-import { existsSync as existsSync30, symlinkSync } from "fs";
+import { existsSync as existsSync29, symlinkSync } from "fs";
 import { mkdir as mkdir5 } from "fs/promises";
-import { join as join52 } from "path";
+import { join as join48 } from "path";
 
 class WorktreeManager {
   async ensureGitExcludes(projectRoot) {
     const logger = getSafeLogger();
-    const infoDir = join52(projectRoot, ".git", "info");
-    const excludePath = join52(infoDir, "exclude");
+    const infoDir = join48(projectRoot, ".git", "info");
+    const excludePath = join48(infoDir, "exclude");
     try {
       await mkdir5(infoDir, { recursive: true });
       let existing = "";
-      if (existsSync30(excludePath)) {
+      if (existsSync29(excludePath)) {
         existing = await Bun.file(excludePath).text();
       }
       const missing = NAX_GITIGNORE_ENTRIES.filter((entry) => !existing.includes(entry));
@@ -38790,7 +39305,7 @@ ${missing.join(`
   }
   async create(projectRoot, storyId) {
     validateStoryId(storyId);
-    const worktreePath = join52(projectRoot, ".nax-wt", storyId);
+    const worktreePath = join48(projectRoot, ".nax-wt", storyId);
     const branchName = `nax/${storyId}`;
     try {
       const pruneProc = _managerDeps.spawn(["git", "worktree", "prune"], {
@@ -38831,9 +39346,9 @@ ${missing.join(`
       }
       throw new Error(`Failed to create worktree: ${String(error48)}`);
     }
-    const nodeModulesSource = join52(projectRoot, "node_modules");
-    if (existsSync30(nodeModulesSource)) {
-      const nodeModulesTarget = join52(worktreePath, "node_modules");
+    const nodeModulesSource = join48(projectRoot, "node_modules");
+    if (existsSync29(nodeModulesSource)) {
+      const nodeModulesTarget = join48(worktreePath, "node_modules");
       try {
         symlinkSync(nodeModulesSource, nodeModulesTarget, "dir");
       } catch (error48) {
@@ -38841,9 +39356,9 @@ ${missing.join(`
         throw new Error(`Failed to symlink node_modules: ${errorMessage(error48)}`);
       }
     }
-    const envSource = join52(projectRoot, ".env");
-    if (existsSync30(envSource)) {
-      const envTarget = join52(worktreePath, ".env");
+    const envSource = join48(projectRoot, ".env");
+    if (existsSync29(envSource)) {
+      const envTarget = join48(worktreePath, ".env");
       try {
         symlinkSync(envSource, envTarget, "file");
       } catch (error48) {
@@ -38854,7 +39369,7 @@ ${missing.join(`
   }
   async remove(projectRoot, storyId) {
     validateStoryId(storyId);
-    const worktreePath = join52(projectRoot, ".nax-wt", storyId);
+    const worktreePath = join48(projectRoot, ".nax-wt", storyId);
     const branchName = `nax/${storyId}`;
     try {
       const proc = _managerDeps.spawn(["git", "worktree", "remove", worktreePath, "--force"], {
@@ -39214,10 +39729,11 @@ async function rectifyConflictedStory(options) {
     const routing = routeTask2(story.title, story.description, story.acceptanceCriteria, story.tags, config2);
     const pipelineContext = {
       config: config2,
-      effectiveConfig: config2,
+      rootConfig: config2,
       prd,
       story,
       stories: [story],
+      projectDir: workdir,
       workdir: worktreePath,
       featureDir: undefined,
       hooks,
@@ -39454,8 +39970,9 @@ async function executeUnified(ctx, initialPrd) {
       logger?.info("execution", "Running pre-run pipeline (acceptance test setup)");
       preRunCtx = {
         config: ctx.config,
-        effectiveConfig: ctx.config,
+        rootConfig: ctx.config,
         prd,
+        projectDir: ctx.workdir,
         workdir: ctx.workdir,
         featureDir: ctx.featureDir,
         story: prd.userStories[0],
@@ -39500,6 +40017,7 @@ async function executeUnified(ctx, initialPrd) {
         const readyStories = getAllReadyStories(prd);
         const batch = _unifiedExecutorDeps.selectIndependentBatch(readyStories, ctx.parallelCount);
         if (batch.length > 1) {
+          ctx.onBeforeStory?.();
           for (const story of batch) {
             pipelineEventBus.emit({
               type: "story:started",
@@ -39525,8 +40043,9 @@ async function executeUnified(ctx, initialPrd) {
               maxConcurrency: ctx.parallelCount,
               pipelineContext: {
                 config: ctx.config,
-                effectiveConfig: ctx.config,
+                rootConfig: ctx.config,
                 prd,
+                projectDir: ctx.workdir,
                 hooks: ctx.hooks,
                 featureDir: ctx.featureDir,
                 agentGetFn: ctx.agentGetFn,
@@ -39640,6 +40159,7 @@ async function executeUnified(ctx, initialPrd) {
             }
             pipelineEventBus.emit({ type: "run:resumed", feature: ctx.feature });
           }
+          ctx.onBeforeStory?.();
           pipelineEventBus.emit({
             type: "story:started",
             storyId: singleStory.id,
@@ -39702,6 +40222,7 @@ async function executeUnified(ctx, initialPrd) {
         }
         pipelineEventBus.emit({ type: "run:resumed", feature: ctx.feature });
       }
+      ctx.onBeforeStory?.();
       pipelineEventBus.emit({
         type: "story:started",
         storyId: selection.story.id,
@@ -39790,16 +40311,16 @@ var init_unified_executor = __esm(() => {
 });
 
 // src/project/detector.ts
-import { join as join53 } from "path";
+import { join as join49 } from "path";
 async function detectLanguage(workdir, pkg) {
   const deps = _detectorDeps;
-  if (await deps.fileExists(join53(workdir, "go.mod")))
+  if (await deps.fileExists(join49(workdir, "go.mod")))
     return "go";
-  if (await deps.fileExists(join53(workdir, "Cargo.toml")))
+  if (await deps.fileExists(join49(workdir, "Cargo.toml")))
     return "rust";
-  if (await deps.fileExists(join53(workdir, "pyproject.toml")))
+  if (await deps.fileExists(join49(workdir, "pyproject.toml")))
     return "python";
-  if (await deps.fileExists(join53(workdir, "requirements.txt")))
+  if (await deps.fileExists(join49(workdir, "requirements.txt")))
     return "python";
   if (pkg != null) {
     const allDeps = {
@@ -39859,18 +40380,18 @@ async function detectLintTool(workdir, language) {
   if (language === "python")
     return "ruff";
   const deps = _detectorDeps;
-  if (await deps.fileExists(join53(workdir, "biome.json")))
+  if (await deps.fileExists(join49(workdir, "biome.json")))
     return "biome";
-  if (await deps.fileExists(join53(workdir, ".eslintrc")))
+  if (await deps.fileExists(join49(workdir, ".eslintrc")))
     return "eslint";
-  if (await deps.fileExists(join53(workdir, ".eslintrc.js")))
+  if (await deps.fileExists(join49(workdir, ".eslintrc.js")))
     return "eslint";
-  if (await deps.fileExists(join53(workdir, ".eslintrc.json")))
+  if (await deps.fileExists(join49(workdir, ".eslintrc.json")))
     return "eslint";
   return;
 }
 async function detectProjectProfile(workdir, existing) {
-  const pkg = await _detectorDeps.readJson(join53(workdir, "package.json"));
+  const pkg = await _detectorDeps.readJson(join49(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);
@@ -39907,7 +40428,7 @@ var init_project = __esm(() => {
 
 // src/execution/status-file.ts
 import { rename, unlink as unlink3 } from "fs/promises";
-import { resolve as resolve9 } from "path";
+import { resolve as resolve10 } from "path";
 function countProgress(prd) {
   const stories = prd.userStories;
   const passed = stories.filter((s) => s.status === "passed").length;
@@ -39952,7 +40473,7 @@ function buildStatusSnapshot(state) {
   return snapshot;
 }
 async function writeStatusFile(filePath, status) {
-  const resolvedPath = resolve9(filePath);
+  const resolvedPath = resolve10(filePath);
   if (filePath.includes("../") || filePath.includes("..\\")) {
     throw new Error("Invalid status file path: path traversal detected");
   }
@@ -39966,7 +40487,7 @@ async function writeStatusFile(filePath, status) {
 var init_status_file = () => {};
 
 // src/execution/status-writer.ts
-import { join as join54 } from "path";
+import { join as join50 } from "path";
 
 class StatusWriter {
   statusFile;
@@ -40080,7 +40601,7 @@ class StatusWriter {
     if (!this._prd)
       return;
     const safeLogger = getSafeLogger();
-    const featureStatusPath = join54(featureDir, "status.json");
+    const featureStatusPath = join50(featureDir, "status.json");
     const write = async () => {
       try {
         const base = this.getSnapshot(totalCost, iterations);
@@ -40291,7 +40812,7 @@ __export(exports_run_initialization, {
   initializeRun: () => initializeRun,
   _reconcileDeps: () => _reconcileDeps
 });
-import { join as join55 } from "path";
+import { join as join51 } from "path";
 async function reconcileState(prd, prdPath, workdir, config2) {
   const logger = getSafeLogger();
   let reconciledCount = 0;
@@ -40309,7 +40830,7 @@ async function reconcileState(prd, prdPath, workdir, config2) {
       });
       continue;
     }
-    const effectiveWorkdir = story.workdir ? join55(workdir, story.workdir) : workdir;
+    const effectiveWorkdir = story.workdir ? join51(workdir, story.workdir) : workdir;
     try {
       const reviewResult = await _reconcileDeps.runReview(config2.review, effectiveWorkdir, config2.execution);
       if (!reviewResult.success) {
@@ -40373,7 +40894,7 @@ function validateStoryCount(counts, config2) {
 }
 function logActiveProtocol(config2) {
   const logger = getSafeLogger();
-  const protocol = config2.agent?.protocol ?? "cli";
+  const protocol = config2.agent?.protocol;
   logger?.info("run-initialization", `Agent protocol: ${protocol}`, { protocol });
 }
 async function initializeRun(ctx) {
@@ -41035,14 +41556,14 @@ See https://react.dev/link/invalid-hook-call for tips about how to debug and fix
       prevActScopeDepth !== actScopeDepth - 1 && console.error("You seem to have overlapping act() calls, this is not supported. Be sure to await previous act() calls before making a new one. ");
       actScopeDepth = prevActScopeDepth;
     }
-    function recursivelyFlushAsyncActWork(returnValue, resolve10, reject) {
+    function recursivelyFlushAsyncActWork(returnValue, resolve11, reject) {
       var queue = ReactSharedInternals.actQueue;
       if (queue !== null)
         if (queue.length !== 0)
           try {
             flushActQueue(queue);
             enqueueTask(function() {
-              return recursivelyFlushAsyncActWork(returnValue, resolve10, reject);
+              return recursivelyFlushAsyncActWork(returnValue, resolve11, reject);
             });
             return;
           } catch (error48) {
@@ -41050,7 +41571,7 @@ See https://react.dev/link/invalid-hook-call for tips about how to debug and fix
           }
         else
           ReactSharedInternals.actQueue = null;
-      0 < ReactSharedInternals.thrownErrors.length ? (queue = aggregateErrors(ReactSharedInternals.thrownErrors), ReactSharedInternals.thrownErrors.length = 0, reject(queue)) : resolve10(returnValue);
+      0 < ReactSharedInternals.thrownErrors.length ? (queue = aggregateErrors(ReactSharedInternals.thrownErrors), ReactSharedInternals.thrownErrors.length = 0, reject(queue)) : resolve11(returnValue);
     }
     function flushActQueue(queue) {
       if (!isFlushing) {
@@ -41226,14 +41747,14 @@ See https://react.dev/link/invalid-hook-call for tips about how to debug and fix
           didAwaitActCall || didWarnNoAwaitAct || (didWarnNoAwaitAct = true, console.error("You called act(async () => ...) without await. This could lead to unexpected testing behaviour, interleaving multiple act calls and mixing their scopes. You should - await act(async () => ...);"));
         });
         return {
-          then: function(resolve10, reject) {
+          then: function(resolve11, reject) {
             didAwaitActCall = true;
             thenable.then(function(returnValue) {
               popActScope(prevActQueue, prevActScopeDepth);
               if (prevActScopeDepth === 0) {
                 try {
                   flushActQueue(queue), enqueueTask(function() {
-                    return recursivelyFlushAsyncActWork(returnValue, resolve10, reject);
+                    return recursivelyFlushAsyncActWork(returnValue, resolve11, reject);
                   });
                 } catch (error$0) {
                   ReactSharedInternals.thrownErrors.push(error$0);
@@ -41244,7 +41765,7 @@ See https://react.dev/link/invalid-hook-call for tips about how to debug and fix
                   reject(_thrownError);
                 }
               } else
-                resolve10(returnValue);
+                resolve11(returnValue);
             }, function(error48) {
               popActScope(prevActQueue, prevActScopeDepth);
               0 < ReactSharedInternals.thrownErrors.length ? (error48 = aggregateErrors(ReactSharedInternals.thrownErrors), ReactSharedInternals.thrownErrors.length = 0, reject(error48)) : reject(error48);
@@ -41260,11 +41781,11 @@ See https://react.dev/link/invalid-hook-call for tips about how to debug and fix
       if (0 < ReactSharedInternals.thrownErrors.length)
         throw callback = aggregateErrors(ReactSharedInternals.thrownErrors), ReactSharedInternals.thrownErrors.length = 0, callback;
       return {
-        then: function(resolve10, reject) {
+        then: function(resolve11, reject) {
           didAwaitActCall = true;
           prevActScopeDepth === 0 ? (ReactSharedInternals.actQueue = queue, enqueueTask(function() {
-            return recursivelyFlushAsyncActWork(returnValue$jscomp$0, resolve10, reject);
-          })) : resolve10(returnValue$jscomp$0);
+            return recursivelyFlushAsyncActWork(returnValue$jscomp$0, resolve11, reject);
+          })) : resolve11(returnValue$jscomp$0);
         }
       };
     };
@@ -44106,8 +44627,8 @@ It can also happen if the client has a browser extension installed which messes
         currentEntangledActionThenable = {
           status: "pending",
           value: undefined,
-          then: function(resolve10) {
-            entangledListeners.push(resolve10);
+          then: function(resolve11) {
+            entangledListeners.push(resolve11);
           }
         };
       }
@@ -44131,8 +44652,8 @@ It can also happen if the client has a browser extension installed which messes
         status: "pending",
         value: null,
         reason: null,
-        then: function(resolve10) {
-          listeners.push(resolve10);
+        then: function(resolve11) {
+          listeners.push(resolve11);
         }
       };
       thenable.then(function() {
@@ -71522,9 +72043,9 @@ var require_jsx_dev_runtime = __commonJS((exports, module) => {
 
 // bin/nax.ts
 init_source();
-import { existsSync as existsSync32, mkdirSync as mkdirSync7 } from "fs";
+import { existsSync as existsSync31, mkdirSync as mkdirSync7 } from "fs";
 import { homedir as homedir8 } from "os";
-import { join as join57 } from "path";
+import { join as join53 } from "path";
 
 // node_modules/commander/esm.mjs
 var import__ = __toESM(require_commander(), 1);
@@ -71550,15 +72071,15 @@ import { join as join11 } from "path";
 import { createInterface as createInterface2 } from "readline";
 
 // src/analyze/scanner.ts
-import { existsSync as existsSync2, readdirSync } from "fs";
+import { existsSync as existsSync3, readdirSync } from "fs";
 import { join as join4 } from "path";
 async function scanCodebase(workdir) {
   const srcPath = join4(workdir, "src");
   const packageJsonPath = join4(workdir, "package.json");
-  const fileTree = existsSync2(srcPath) ? await generateFileTree(srcPath, 3) : "No src/ directory";
+  const fileTree = existsSync3(srcPath) ? await generateFileTree(srcPath, 3) : "No src/ directory";
   let dependencies = {};
   let devDependencies = {};
-  if (existsSync2(packageJsonPath)) {
+  if (existsSync3(packageJsonPath)) {
     try {
       const pkg = await Bun.file(packageJsonPath).json();
       dependencies = pkg.dependencies || {};
@@ -71619,16 +72140,16 @@ function detectTestPatterns(workdir, dependencies, devDependencies) {
   } else {
     patterns.push("Test framework: likely bun:test (no framework dependency)");
   }
-  if (existsSync2(join4(workdir, "test"))) {
+  if (existsSync3(join4(workdir, "test"))) {
     patterns.push("Test directory: test/");
   }
-  if (existsSync2(join4(workdir, "__tests__"))) {
+  if (existsSync3(join4(workdir, "__tests__"))) {
     patterns.push("Test directory: __tests__/");
   }
-  if (existsSync2(join4(workdir, "tests"))) {
+  if (existsSync3(join4(workdir, "tests"))) {
     patterns.push("Test directory: tests/");
   }
-  const hasTestFiles = existsSync2(join4(workdir, "test")) || existsSync2(join4(workdir, "src"));
+  const hasTestFiles = existsSync3(join4(workdir, "test")) || existsSync3(join4(workdir, "src"));
   if (hasTestFiles) {
     patterns.push("Test files: *.test.ts, *.spec.ts");
   }
@@ -71640,7 +72161,7 @@ init_test_strategy();
 
 // src/context/generator.ts
 init_path_security();
-import { existsSync as existsSync5, readFileSync } from "fs";
+import { existsSync as existsSync5 } from "fs";
 import { join as join6, relative } from "path";
 
 // src/context/injector.ts
@@ -71983,7 +72504,6 @@ var windsurfGenerator = {
 // src/context/generator.ts
 var _generatorDeps = {
   existsSync: (p) => existsSync5(p),
-  readFileSync: (p, enc) => readFileSync(p, enc),
   readTextFile: (p) => Bun.file(p).text(),
   writeFile: (p, content) => Bun.write(p, content),
   buildProjectMetadata
@@ -72085,47 +72605,41 @@ async function discoverWorkspacePackages(repoRoot) {
     }
   }
   const turboPath = join6(repoRoot, "turbo.json");
-  if (_generatorDeps.existsSync(turboPath)) {
-    try {
-      const turbo = JSON.parse(_generatorDeps.readFileSync(turboPath, "utf-8"));
-      if (Array.isArray(turbo.packages)) {
-        await resolveGlobs(turbo.packages);
-      }
-    } catch {}
-  }
+  try {
+    const turbo = JSON.parse(await _generatorDeps.readTextFile(turboPath));
+    if (Array.isArray(turbo.packages)) {
+      await resolveGlobs(turbo.packages);
+    }
+  } catch {}
   const pkgPath = join6(repoRoot, "package.json");
-  if (_generatorDeps.existsSync(pkgPath)) {
-    try {
-      const pkg = JSON.parse(_generatorDeps.readFileSync(pkgPath, "utf-8"));
-      const ws = pkg.workspaces;
-      const patterns = Array.isArray(ws) ? ws : Array.isArray(ws?.packages) ? ws.packages : [];
-      if (patterns.length > 0)
-        await resolveGlobs(patterns);
-    } catch {}
-  }
+  try {
+    const pkg = JSON.parse(await _generatorDeps.readTextFile(pkgPath));
+    const ws = pkg.workspaces;
+    const patterns = Array.isArray(ws) ? ws : Array.isArray(ws?.packages) ? ws.packages : [];
+    if (patterns.length > 0)
+      await resolveGlobs(patterns);
+  } catch {}
   const pnpmPath = join6(repoRoot, "pnpm-workspace.yaml");
-  if (_generatorDeps.existsSync(pnpmPath)) {
-    try {
-      const raw = _generatorDeps.readFileSync(pnpmPath, "utf-8");
-      const lines = raw.split(`
+  try {
+    const raw = await _generatorDeps.readTextFile(pnpmPath);
+    const lines = raw.split(`
 `);
-      let inPackages = false;
-      const patterns = [];
-      for (const line of lines) {
-        if (/^packages\s*:/.test(line)) {
-          inPackages = true;
-          continue;
-        }
-        if (inPackages && /^\s+-\s+/.test(line)) {
-          patterns.push(line.replace(/^\s+-\s+['"]?/, "").replace(/['"]?\s*$/, ""));
-        } else if (inPackages && !/^\s/.test(line)) {
-          break;
-        }
+    let inPackages = false;
+    const patterns = [];
+    for (const line of lines) {
+      if (/^packages\s*:/.test(line)) {
+        inPackages = true;
+        continue;
       }
-      if (patterns.length > 0)
-        await resolveGlobs(patterns);
-    } catch {}
-  }
+      if (inPackages && /^\s+-\s+/.test(line)) {
+        patterns.push(line.replace(/^\s+-\s+['"]?/, "").replace(/['"]?\s*$/, ""));
+      } else if (inPackages && !/^\s/.test(line)) {
+        break;
+      }
+    }
+    if (patterns.length > 0)
+      await resolveGlobs(patterns);
+  } catch {}
   return results.sort();
 }
 async function generateForPackage(packageDir, config2, dryRun = false, repoRoot) {
@@ -72657,13 +73171,13 @@ function createCliInteractionBridge() {
       process.stdout.write(`
 \uD83E\uDD16 Agent: ${text}
 You: `);
-      return new Promise((resolve5) => {
+      return new Promise((resolve6) => {
         const rl = createInterface2({ input: process.stdin, terminal: false });
         rl.once("line", (line) => {
           rl.close();
-          resolve5(line.trim());
+          resolve6(line.trim());
         });
-        rl.once("close", () => resolve5(""));
+        rl.once("close", () => resolve6(""));
       });
     }
   };
@@ -73168,20 +73682,20 @@ async function displayModelEfficiency(workdir) {
 // src/cli/status-features.ts
 init_source();
 import { existsSync as existsSync15, readdirSync as readdirSync4 } from "fs";
-import { join as join14, resolve as resolve6 } from "path";
+import { join as join14, resolve as resolve7 } from "path";
 
 // src/commands/common.ts
 init_path_security();
 init_errors();
 import { existsSync as existsSync14, readdirSync as readdirSync3, realpathSync as realpathSync2 } from "fs";
-import { join as join12, resolve as resolve5 } from "path";
+import { join as join12, resolve as resolve6 } from "path";
 function resolveProject(options = {}) {
   const { dir, feature } = options;
   let projectRoot;
   let naxDir;
   let configPath;
   if (dir) {
-    projectRoot = realpathSync2(resolve5(dir));
+    projectRoot = realpathSync2(resolve6(dir));
     naxDir = join12(projectRoot, ".nax");
     if (!existsSync14(naxDir)) {
       throw new NaxError(`Directory does not contain a nax project: ${projectRoot}
@@ -73234,7 +73748,7 @@ No features found in this project.`;
   };
 }
 function findProjectRoot(startDir) {
-  let current = resolve5(startDir);
+  let current = resolve6(startDir);
   let depth = 0;
   while (depth < MAX_DIRECTORY_DEPTH) {
     const naxDir = join12(current, ".nax");
@@ -73551,7 +74065,7 @@ async function displayFeatureStatus(options = {}) {
   if (options.feature) {
     let featureDir;
     if (options.dir) {
-      featureDir = join14(resolve6(options.dir), ".nax", "features", options.feature);
+      featureDir = join14(resolve7(options.dir), ".nax", "features", options.feature);
     } else {
       const resolved = resolveProject({ feature: options.feature });
       if (!resolved.featureDir) {
@@ -73661,8 +74175,8 @@ async function runsShowCommand(options) {
 }
 // src/cli/prompts-main.ts
 init_logger2();
-import { existsSync as existsSync20, mkdirSync as mkdirSync3 } from "fs";
-import { join as join29 } from "path";
+import { existsSync as existsSync19, mkdirSync as mkdirSync3 } from "fs";
+import { join as join24 } from "path";
 
 // src/pipeline/index.ts
 init_runner();
@@ -73737,7 +74251,7 @@ function buildFrontmatter(story, ctx, role) {
 
 // src/cli/prompts-tdd.ts
 init_prompts2();
-import { join as join28 } from "path";
+import { join as join23 } from "path";
 async function handleThreeSessionTddPrompts(story, ctx, outputDir, logger) {
   const [testWriterPrompt, implementerPrompt, verifierPrompt] = await Promise.all([
     PromptBuilder.for("test-writer", { isolation: "strict" }).withLoader(ctx.workdir, ctx.config).story(story).context(ctx.contextMarkdown).constitution(ctx.constitution?.content).testCommand(ctx.config.quality?.commands?.test).build(),
@@ -73756,7 +74270,7 @@ ${frontmatter}---
 
 ${session.prompt}`;
     if (outputDir) {
-      const promptFile = join28(outputDir, `${story.id}.${session.role}.md`);
+      const promptFile = join23(outputDir, `${story.id}.${session.role}.md`);
       await Bun.write(promptFile, fullOutput);
       logger.info("cli", "Written TDD prompt file", {
         storyId: story.id,
@@ -73772,7 +74286,7 @@ ${"=".repeat(80)}`);
     }
   }
   if (outputDir && ctx.contextMarkdown) {
-    const contextFile = join28(outputDir, `${story.id}.context.md`);
+    const contextFile = join23(outputDir, `${story.id}.context.md`);
     const frontmatter = buildFrontmatter(story, ctx);
     const contextOutput = `---
 ${frontmatter}---
@@ -73786,13 +74300,13 @@ ${ctx.contextMarkdown}`;
 async function promptsCommand(options) {
   const logger = getLogger();
   const { feature, workdir, config: config2, storyId, outputDir } = options;
-  const naxDir = join29(workdir, ".nax");
-  if (!existsSync20(naxDir)) {
+  const naxDir = join24(workdir, ".nax");
+  if (!existsSync19(naxDir)) {
     throw new Error(`.nax directory not found. Run 'nax init' first in ${workdir}`);
   }
-  const featureDir = join29(naxDir, "features", feature);
-  const prdPath = join29(featureDir, "prd.json");
-  if (!existsSync20(prdPath)) {
+  const featureDir = join24(naxDir, "features", feature);
+  const prdPath = join24(featureDir, "prd.json");
+  if (!existsSync19(prdPath)) {
     throw new Error(`Feature "${feature}" not found or missing prd.json`);
   }
   const prd = await loadPRD(prdPath);
@@ -73813,7 +74327,7 @@ async function promptsCommand(options) {
   for (const story of stories) {
     const ctx = {
       config: config2,
-      effectiveConfig: config2,
+      rootConfig: config2,
       prd,
       story,
       stories: [story],
@@ -73823,6 +74337,7 @@ async function promptsCommand(options) {
         testStrategy: "test-after",
         reasoning: "Placeholder routing"
       },
+      projectDir: workdir,
       workdir,
       featureDir,
       hooks: { hooks: {} }
@@ -73852,10 +74367,10 @@ ${frontmatter}---
 
 ${ctx.prompt}`;
     if (outputDir) {
-      const promptFile = join29(outputDir, `${story.id}.prompt.md`);
+      const promptFile = join24(outputDir, `${story.id}.prompt.md`);
       await Bun.write(promptFile, fullOutput);
       if (ctx.contextMarkdown) {
-        const contextFile = join29(outputDir, `${story.id}.context.md`);
+        const contextFile = join24(outputDir, `${story.id}.context.md`);
         const contextOutput = `---
 ${frontmatter}---
 
@@ -73881,8 +74396,8 @@ ${"=".repeat(80)}`);
   return processedStories;
 }
 // src/cli/prompts-init.ts
-import { existsSync as existsSync21, mkdirSync as mkdirSync4 } from "fs";
-import { join as join30 } from "path";
+import { existsSync as existsSync20, mkdirSync as mkdirSync4 } from "fs";
+import { join as join25 } from "path";
 var TEMPLATE_ROLES = [
   { file: "test-writer.md", role: "test-writer" },
   { file: "implementer.md", role: "implementer", variant: "standard" },
@@ -73906,9 +74421,9 @@ var TEMPLATE_HEADER = `<!--
 `;
 async function promptsInitCommand(options) {
   const { workdir, force = false, autoWireConfig = true } = options;
-  const templatesDir = join30(workdir, ".nax", "templates");
+  const templatesDir = join25(workdir, ".nax", "templates");
   mkdirSync4(templatesDir, { recursive: true });
-  const existingFiles = TEMPLATE_ROLES.map((t) => t.file).filter((f) => existsSync21(join30(templatesDir, f)));
+  const existingFiles = TEMPLATE_ROLES.map((t) => t.file).filter((f) => existsSync20(join25(templatesDir, f)));
   if (existingFiles.length > 0 && !force) {
     console.warn(`[WARN] nax/templates/ already contains files: ${existingFiles.join(", ")}. No files overwritten.
        Pass --force to overwrite existing templates.`);
@@ -73916,7 +74431,7 @@ async function promptsInitCommand(options) {
   }
   const written = [];
   for (const template of TEMPLATE_ROLES) {
-    const filePath = join30(templatesDir, template.file);
+    const filePath = join25(templatesDir, template.file);
     const roleBody = template.role === "implementer" ? buildRoleTaskSection(template.role, template.variant) : buildRoleTaskSection(template.role);
     const content = TEMPLATE_HEADER + roleBody;
     await Bun.write(filePath, content);
@@ -73932,8 +74447,8 @@ async function promptsInitCommand(options) {
   return written;
 }
 async function autoWirePromptsConfig(workdir) {
-  const configPath = join30(workdir, "nax.config.json");
-  if (!existsSync21(configPath)) {
+  const configPath = join25(workdir, "nax.config.json");
+  if (!existsSync20(configPath)) {
     const exampleConfig = JSON.stringify({
       prompts: {
         overrides: {
@@ -74097,8 +74612,8 @@ function pad(str, width) {
 init_config();
 init_logger2();
 init_prd();
-import { existsSync as existsSync23, readdirSync as readdirSync6 } from "fs";
-import { join as join35 } from "path";
+import { existsSync as existsSync22, readdirSync as readdirSync6 } from "fs";
+import { join as join30 } from "path";
 
 // src/cli/diagnose-analysis.ts
 function detectFailurePattern(story, prd, status) {
@@ -74297,8 +74812,8 @@ function isProcessAlive2(pid) {
   }
 }
 async function loadStatusFile2(workdir) {
-  const statusPath = join35(workdir, ".nax", "status.json");
-  if (!existsSync23(statusPath))
+  const statusPath = join30(workdir, ".nax", "status.json");
+  if (!existsSync22(statusPath))
     return null;
   try {
     return await Bun.file(statusPath).json();
@@ -74325,7 +74840,7 @@ async function countCommitsSince(workdir, since) {
   }
 }
 async function checkLock(workdir) {
-  const lockFile = Bun.file(join35(workdir, "nax.lock"));
+  const lockFile = Bun.file(join30(workdir, "nax.lock"));
   if (!await lockFile.exists())
     return { lockPresent: false };
   try {
@@ -74343,8 +74858,8 @@ async function diagnoseCommand(options = {}) {
   const logger = getLogger();
   const workdir = options.workdir ?? process.cwd();
   const naxSubdir = findProjectDir(workdir);
-  let projectDir = naxSubdir ? join35(naxSubdir, "..") : null;
-  if (!projectDir && existsSync23(join35(workdir, ".nax"))) {
+  let projectDir = naxSubdir ? join30(naxSubdir, "..") : null;
+  if (!projectDir && existsSync22(join30(workdir, ".nax"))) {
     projectDir = workdir;
   }
   if (!projectDir)
@@ -74355,8 +74870,8 @@ async function diagnoseCommand(options = {}) {
     if (status2) {
       feature = status2.run.feature;
     } else {
-      const featuresDir = join35(projectDir, ".nax", "features");
-      if (!existsSync23(featuresDir))
+      const featuresDir = join30(projectDir, ".nax", "features");
+      if (!existsSync22(featuresDir))
         throw new Error("No features found in project");
       const features = readdirSync6(featuresDir, { withFileTypes: true }).filter((e) => e.isDirectory()).map((e) => e.name);
       if (features.length === 0)
@@ -74365,9 +74880,9 @@ async function diagnoseCommand(options = {}) {
       logger.info("diagnose", "No feature specified, using first found", { feature });
     }
   }
-  const featureDir = join35(projectDir, ".nax", "features", feature);
-  const prdPath = join35(featureDir, "prd.json");
-  if (!existsSync23(prdPath))
+  const featureDir = join30(projectDir, ".nax", "features", feature);
+  const prdPath = join30(featureDir, "prd.json");
+  if (!existsSync22(prdPath))
     throw new Error(`Feature not found: ${feature}`);
   const prd = await loadPRD(prdPath);
   const status = await loadStatusFile2(projectDir);
@@ -74408,8 +74923,8 @@ init_interaction();
 // src/cli/generate.ts
 init_source();
 init_loader();
-import { existsSync as existsSync24 } from "fs";
-import { join as join36 } from "path";
+import { existsSync as existsSync23 } from "fs";
+import { join as join31 } from "path";
 var VALID_AGENTS = ["claude", "codex", "opencode", "cursor", "windsurf", "aider", "gemini"];
 async function generateCommand(options) {
   const workdir = options.dir ?? process.cwd();
@@ -74452,7 +74967,7 @@ async function generateCommand(options) {
     return;
   }
   if (options.package) {
-    const packageDir = join36(workdir, options.package);
+    const packageDir = join31(workdir, options.package);
     if (dryRun) {
       console.log(source_default.yellow("\u26A0 Dry run \u2014 no files will be written"));
     }
@@ -74472,10 +74987,10 @@ async function generateCommand(options) {
       process.exit(1);
     return;
   }
-  const contextPath = options.context ? join36(workdir, options.context) : join36(workdir, ".nax/context.md");
-  const outputDir = options.output ? join36(workdir, options.output) : workdir;
+  const contextPath = options.context ? join31(workdir, options.context) : join31(workdir, ".nax/context.md");
+  const outputDir = options.output ? join31(workdir, options.output) : workdir;
   const autoInject = !options.noAutoInject;
-  if (!existsSync24(contextPath)) {
+  if (!existsSync23(contextPath)) {
     console.error(source_default.red(`\u2717 Context file not found: ${contextPath}`));
     console.error(source_default.yellow("  Create .nax/context.md first, or run `nax init` to scaffold it."));
     process.exit(1);
@@ -74577,8 +75092,8 @@ async function generateCommand(options) {
 }
 // src/cli/config-display.ts
 init_loader();
-import { existsSync as existsSync26 } from "fs";
-import { join as join38 } from "path";
+import { existsSync as existsSync25 } from "fs";
+import { join as join33 } from "path";
 
 // src/cli/config-descriptions.ts
 var FIELD_DESCRIPTIONS = {
@@ -74817,10 +75332,10 @@ function deepEqual(a, b) {
 // src/cli/config-get.ts
 init_defaults();
 init_loader();
-import { existsSync as existsSync25 } from "fs";
-import { join as join37 } from "path";
+import { existsSync as existsSync24 } from "fs";
+import { join as join32 } from "path";
 async function loadConfigFile(path15) {
-  if (!existsSync25(path15))
+  if (!existsSync24(path15))
     return null;
   try {
     return await Bun.file(path15).json();
@@ -74840,7 +75355,7 @@ async function loadProjectConfig() {
   const projectDir = findProjectDir();
   if (!projectDir)
     return null;
-  const projectPath = join37(projectDir, "config.json");
+  const projectPath = join32(projectDir, "config.json");
   return await loadConfigFile(projectPath);
 }
 
@@ -74900,14 +75415,14 @@ async function configCommand(config2, options = {}) {
 function determineConfigSources() {
   const globalPath = globalConfigPath();
   const projectDir = findProjectDir();
-  const projectPath = projectDir ? join38(projectDir, "config.json") : null;
+  const projectPath = projectDir ? join33(projectDir, "config.json") : null;
   return {
     global: fileExists(globalPath) ? globalPath : null,
     project: projectPath && fileExists(projectPath) ? projectPath : null
   };
 }
 function fileExists(path15) {
-  return existsSync26(path15);
+  return existsSync25(path15);
 }
 function displayConfigWithDescriptions(obj, path15, sources, indent = 0) {
   const indentStr = "  ".repeat(indent);
@@ -75049,15 +75564,15 @@ init_paths();
 init_profile();
 import { mkdirSync as mkdirSync5 } from "fs";
 import { readdirSync as readdirSync7 } from "fs";
-import { join as join39 } from "path";
+import { join as join34 } from "path";
 var _profileCLIDeps = {
   env: process.env
 };
 var SENSITIVE_KEY_PATTERN = /key|token|secret|password|credential/i;
 var VAR_PATTERN = /\$[A-Za-z_][A-Za-z0-9_]*/;
 async function profileListCommand(startDir) {
-  const globalProfilesDir = join39(globalConfigDir(), "profiles");
-  const projectProfilesDir = join39(projectConfigDir(startDir), "profiles");
+  const globalProfilesDir = join34(globalConfigDir(), "profiles");
+  const projectProfilesDir = join34(projectConfigDir(startDir), "profiles");
   const globalProfiles = scanProfileDir(globalProfilesDir);
   const projectProfiles = scanProfileDir(projectProfilesDir);
   const activeProfile = await resolveProfileName({}, _profileCLIDeps.env, startDir);
@@ -75116,7 +75631,7 @@ function maskProfileValues(obj) {
   return result;
 }
 async function profileUseCommand(profileName, startDir) {
-  const configPath = join39(projectConfigDir(startDir), "config.json");
+  const configPath = join34(projectConfigDir(startDir), "config.json");
   const configFile = Bun.file(configPath);
   let existing = {};
   if (await configFile.exists()) {
@@ -75135,8 +75650,8 @@ async function profileCurrentCommand(startDir) {
   return resolveProfileName({}, _profileCLIDeps.env, startDir);
 }
 async function profileCreateCommand(profileName, startDir) {
-  const profilesDir = join39(projectConfigDir(startDir), "profiles");
-  const profilePath = join39(profilesDir, `${profileName}.json`);
+  const profilesDir = join34(projectConfigDir(startDir), "profiles");
+  const profilePath = join34(profilesDir, `${profileName}.json`);
   const profileFile = Bun.file(profilePath);
   if (await profileFile.exists()) {
     throw new Error(`Profile "${profileName}" already exists at ${profilePath}`);
@@ -75201,25 +75716,25 @@ async function diagnose(options) {
 }
 
 // src/commands/logs.ts
-import { existsSync as existsSync28 } from "fs";
-import { join as join43 } from "path";
+import { existsSync as existsSync27 } from "fs";
+import { join as join38 } from "path";
 
 // src/commands/logs-formatter.ts
 init_source();
 init_formatter();
 import { readdirSync as readdirSync9 } from "fs";
-import { join as join42 } from "path";
+import { join as join37 } from "path";
 
 // src/commands/logs-reader.ts
-import { existsSync as existsSync27, readdirSync as readdirSync8 } from "fs";
+import { existsSync as existsSync26, readdirSync as readdirSync8 } from "fs";
 import { readdir as readdir3 } from "fs/promises";
-import { join as join41 } from "path";
+import { join as join36 } from "path";
 
 // src/utils/paths.ts
 import { homedir as homedir4 } from "os";
-import { join as join40 } from "path";
+import { join as join35 } from "path";
 function getRunsDir() {
-  return process.env.NAX_RUNS_DIR ?? join40(homedir4(), ".nax", "runs");
+  return process.env.NAX_RUNS_DIR ?? join35(homedir4(), ".nax", "runs");
 }
 
 // src/commands/logs-reader.ts
@@ -75236,7 +75751,7 @@ async function resolveRunFileFromRegistry(runId) {
   }
   let matched = null;
   for (const entry of entries) {
-    const metaPath = join41(runsDir, entry, "meta.json");
+    const metaPath = join36(runsDir, entry, "meta.json");
     try {
       const meta3 = await Bun.file(metaPath).json();
       if (meta3.runId === runId || meta3.runId.startsWith(runId)) {
@@ -75248,7 +75763,7 @@ async function resolveRunFileFromRegistry(runId) {
   if (!matched) {
     throw new Error(`Run not found in registry: ${runId}`);
   }
-  if (!existsSync27(matched.eventsDir)) {
+  if (!existsSync26(matched.eventsDir)) {
     console.log(`Log directory unavailable for run: ${runId}`);
     return null;
   }
@@ -75258,14 +75773,14 @@ async function resolveRunFileFromRegistry(runId) {
     return null;
   }
   const specificFile = files.find((f) => f === `${matched.runId}.jsonl`);
-  return join41(matched.eventsDir, specificFile ?? files[0]);
+  return join36(matched.eventsDir, specificFile ?? files[0]);
 }
 async function selectRunFile(runsDir) {
   const files = readdirSync8(runsDir).filter((f) => f.endsWith(".jsonl") && f !== "latest.jsonl").sort().reverse();
   if (files.length === 0) {
     return null;
   }
-  return join41(runsDir, files[0]);
+  return join36(runsDir, files[0]);
 }
 async function extractRunSummary(filePath) {
   const file3 = Bun.file(filePath);
@@ -75350,7 +75865,7 @@ Runs:
   console.log(source_default.gray("  Timestamp            Stories  Duration  Cost      Status"));
   console.log(source_default.gray("  \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500"));
   for (const file3 of files) {
-    const filePath = join42(runsDir, file3);
+    const filePath = join37(runsDir, file3);
     const summary = await extractRunSummary(filePath);
     const timestamp = file3.replace(".jsonl", "");
     const stories = summary ? `${summary.passed}/${summary.total}` : "?/?";
@@ -75464,7 +75979,7 @@ async function logsCommand(options) {
     return;
   }
   const resolved = resolveProject({ dir: options.dir });
-  const naxDir = join43(resolved.projectDir, ".nax");
+  const naxDir = join38(resolved.projectDir, ".nax");
   const configPath = resolved.configPath;
   const configFile = Bun.file(configPath);
   const config2 = await configFile.json();
@@ -75472,9 +75987,9 @@ async function logsCommand(options) {
   if (!featureName) {
     throw new Error("No feature specified in config.json");
   }
-  const featureDir = join43(naxDir, "features", featureName);
-  const runsDir = join43(featureDir, "runs");
-  if (!existsSync28(runsDir)) {
+  const featureDir = join38(naxDir, "features", featureName);
+  const runsDir = join38(featureDir, "runs");
+  if (!existsSync27(runsDir)) {
     throw new Error(`No runs directory found for feature: ${featureName}`);
   }
   if (options.list) {
@@ -75497,8 +76012,8 @@ init_source();
 init_config();
 init_prd();
 init_precheck();
-import { existsSync as existsSync29 } from "fs";
-import { join as join44 } from "path";
+import { existsSync as existsSync28 } from "fs";
+import { join as join39 } from "path";
 async function precheckCommand(options) {
   const resolved = resolveProject({
     dir: options.dir,
@@ -75520,14 +76035,14 @@ async function precheckCommand(options) {
       process.exit(1);
     }
   }
-  const naxDir = join44(resolved.projectDir, ".nax");
-  const featureDir = join44(naxDir, "features", featureName);
-  const prdPath = join44(featureDir, "prd.json");
-  if (!existsSync29(featureDir)) {
+  const naxDir = join39(resolved.projectDir, ".nax");
+  const featureDir = join39(naxDir, "features", featureName);
+  const prdPath = join39(featureDir, "prd.json");
+  if (!existsSync28(featureDir)) {
     console.error(source_default.red(`Feature not found: ${featureName}`));
     process.exit(1);
   }
-  if (!existsSync29(prdPath)) {
+  if (!existsSync28(prdPath)) {
     console.error(source_default.red(`Missing prd.json for feature: ${featureName}`));
     console.error(source_default.dim(`Run: nax plan -f ${featureName} --from spec.md --auto`));
     process.exit(EXIT_CODES.INVALID_PRD);
@@ -75544,7 +76059,7 @@ async function precheckCommand(options) {
 // src/commands/runs.ts
 init_source();
 import { readdir as readdir4 } from "fs/promises";
-import { join as join45 } from "path";
+import { join as join40 } from "path";
 var DEFAULT_LIMIT = 20;
 var _runsCmdDeps = {
   getRunsDir
@@ -75599,7 +76114,7 @@ async function runsCommand(options = {}) {
   }
   const rows = [];
   for (const entry of entries) {
-    const metaPath = join45(runsDir, entry, "meta.json");
+    const metaPath = join40(runsDir, entry, "meta.json");
     let meta3;
     try {
       meta3 = await Bun.file(metaPath).json();
@@ -75676,7 +76191,7 @@ async function runsCommand(options = {}) {
 
 // src/commands/unlock.ts
 init_source();
-import { join as join46 } from "path";
+import { join as join41 } from "path";
 function isProcessAlive3(pid) {
   try {
     process.kill(pid, 0);
@@ -75691,7 +76206,7 @@ function formatLockAge(ageMs) {
 }
 async function unlockCommand(options) {
   const workdir = options.dir ?? process.cwd();
-  const lockPath = join46(workdir, "nax.lock");
+  const lockPath = join41(workdir, "nax.lock");
   const lockFile = Bun.file(lockPath);
   const exists = await lockFile.exists();
   if (!exists) {
@@ -75767,11 +76282,9 @@ async function runCompletionPhase(options) {
   const regressionAlreadyPassed = postRunStatus?.regression?.status === "passed";
   if (acceptanceAlreadyPassed && regressionAlreadyPassed) {
     logger?.info("execution", "Post-run phases already passed \u2014 skipping acceptance and regression");
-    console.info("Post-run phases already passed \u2014 skipping acceptance and regression");
   } else {
     if (acceptanceAlreadyPassed) {
       logger?.info("execution", "Acceptance already passed \u2014 skipping acceptance phase");
-      console.info("Acceptance already passed \u2014 skipping acceptance phase");
     } else if (options.config.acceptance.enabled && isComplete(options.prd)) {
       options.statusWriter.setPostRunPhase("acceptance", { status: "running" });
       const acceptanceResult = await _runnerCompletionDeps.runAcceptanceLoop({
@@ -75970,6 +76483,7 @@ async function runExecutionPhase(options, prd, pluginRegistry) {
     startTime: options.startTime,
     parallelCount: options.parallel,
     agentGetFn: options.agentGetFn,
+    onBeforeStory: options.onBeforeStory,
     pidRegistry: options.pidRegistry,
     interactionChain: options.interactionChain,
     batchPlan
@@ -76094,6 +76608,7 @@ async function run(options) {
       headless,
       parallel,
       agentGetFn,
+      onBeforeStory: () => registry2.resetStoryState(),
       pidRegistry,
       interactionChain
     }, prd, pluginRegistry);
@@ -81677,8 +82192,8 @@ class Ink {
     }
   }
   async waitUntilExit() {
-    this.exitPromise ||= new Promise((resolve10, reject2) => {
-      this.resolveExitPromise = resolve10;
+    this.exitPromise ||= new Promise((resolve11, reject2) => {
+      this.resolveExitPromise = resolve11;
       this.rejectExitPromise = reject2;
     });
     if (!this.beforeExitHandler) {
@@ -83491,7 +84006,7 @@ async function promptForConfirmation(question) {
   if (!process.stdin.isTTY) {
     return true;
   }
-  return new Promise((resolve10) => {
+  return new Promise((resolve11) => {
     process.stdout.write(source_default.bold(`${question} [Y/n] `));
     process.stdin.setRawMode(true);
     process.stdin.resume();
@@ -83504,9 +84019,9 @@ async function promptForConfirmation(question) {
       process.stdout.write(`
 `);
       if (answer === "n") {
-        resolve10(false);
+        resolve11(false);
       } else {
-        resolve10(true);
+        resolve11(true);
       }
     };
     process.stdin.on("data", handler);
@@ -83535,15 +84050,15 @@ Next: nax generate --package ${options.package}`));
     }
     return;
   }
-  const naxDir = join57(workdir, ".nax");
-  if (existsSync32(naxDir) && !options.force) {
+  const naxDir = join53(workdir, ".nax");
+  if (existsSync31(naxDir) && !options.force) {
     console.log(source_default.yellow("nax already initialized. Use --force to overwrite."));
     return;
   }
-  mkdirSync7(join57(naxDir, "features"), { recursive: true });
-  mkdirSync7(join57(naxDir, "hooks"), { recursive: true });
-  await Bun.write(join57(naxDir, "config.json"), JSON.stringify(DEFAULT_CONFIG, null, 2));
-  await Bun.write(join57(naxDir, "hooks.json"), JSON.stringify({
+  mkdirSync7(join53(naxDir, "features"), { recursive: true });
+  mkdirSync7(join53(naxDir, "hooks"), { recursive: true });
+  await Bun.write(join53(naxDir, "config.json"), JSON.stringify(DEFAULT_CONFIG, null, 2));
+  await Bun.write(join53(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 },
@@ -83551,12 +84066,12 @@ Next: nax generate --package ${options.package}`));
       "on-error": { command: 'echo "nax error: $NAX_REASON"', enabled: false }
     }
   }, null, 2));
-  await Bun.write(join57(naxDir, ".gitignore"), `# nax temp files
+  await Bun.write(join53(naxDir, ".gitignore"), `# nax temp files
 *.tmp
 .paused.json
 .nax-verifier-verdict.json
 `);
-  await Bun.write(join57(naxDir, "context.md"), `# Project Context
+  await Bun.write(join53(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.
@@ -83653,7 +84168,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 && !existsSync32(options.from)) {
+  if (options.from && !existsSync31(options.from)) {
     console.error(source_default.red(`Error: File not found: ${options.from} (required with --plan)`));
     process.exit(1);
   }
@@ -83686,10 +84201,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 = join57(naxDir, "features", options.feature);
-  const prdPath = join57(featureDir, "prd.json");
+  const featureDir = join53(naxDir, "features", options.feature);
+  const prdPath = join53(featureDir, "prd.json");
   if (options.plan && options.from) {
-    if (existsSync32(prdPath) && !options.force) {
+    if (existsSync31(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);
@@ -83709,10 +84224,10 @@ program2.command("run").description("Run the orchestration loop for a feature").
       }
     }
     try {
-      const planLogDir = join57(featureDir, "plan");
+      const planLogDir = join53(featureDir, "plan");
       mkdirSync7(planLogDir, { recursive: true });
       const planLogId = new Date().toISOString().replace(/:/g, "-").replace(/\..+/, "");
-      const planLogPath = join57(planLogDir, `${planLogId}.jsonl`);
+      const planLogPath = join53(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]"));
@@ -83751,15 +84266,15 @@ program2.command("run").description("Run the orchestration loop for a feature").
       process.exit(1);
     }
   }
-  if (!existsSync32(prdPath)) {
+  if (!existsSync31(prdPath)) {
     console.error(source_default.red(`Feature "${options.feature}" not found or missing prd.json`));
     process.exit(1);
   }
   resetLogger();
-  const runsDir = join57(featureDir, "runs");
+  const runsDir = join53(featureDir, "runs");
   mkdirSync7(runsDir, { recursive: true });
   const runId = new Date().toISOString().replace(/:/g, "-").replace(/\..+/, "");
-  const logFilePath = join57(runsDir, `${runId}.jsonl`);
+  const logFilePath = join53(runsDir, `${runId}.jsonl`);
   const isTTY = process.stdout.isTTY ?? false;
   const headlessFlag = options.headless ?? false;
   const headlessEnv = process.env.NAX_HEADLESS === "1";
@@ -83775,7 +84290,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 = join57(homedir8(), ".nax");
+  const globalNaxDir = join53(homedir8(), ".nax");
   const hooks = await loadHooksConfig(naxDir, globalNaxDir);
   const eventEmitter = new PipelineEventEmitter;
   let tuiInstance;
@@ -83798,7 +84313,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 = join57(workdir, ".nax", "status.json");
+  const statusFilePath = join53(workdir, ".nax", "status.json");
   let parallel;
   if (options.parallel !== undefined) {
     parallel = Number.parseInt(options.parallel, 10);
@@ -83824,9 +84339,9 @@ program2.command("run").description("Run the orchestration loop for a feature").
     headless: useHeadless,
     skipPrecheck: options.skipPrecheck ?? false
   });
-  const latestSymlink = join57(runsDir, "latest.jsonl");
+  const latestSymlink = join53(runsDir, "latest.jsonl");
   try {
-    if (existsSync32(latestSymlink)) {
+    if (existsSync31(latestSymlink)) {
       Bun.spawnSync(["rm", latestSymlink]);
     }
     Bun.spawnSync(["ln", "-s", `${runId}.jsonl`, latestSymlink], {
@@ -83862,9 +84377,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 = join57(naxDir, "features", name);
+  const featureDir = join53(naxDir, "features", name);
   mkdirSync7(featureDir, { recursive: true });
-  await Bun.write(join57(featureDir, "spec.md"), `# Feature: ${name}
+  await Bun.write(join53(featureDir, "spec.md"), `# Feature: ${name}
 
 ## Overview
 
@@ -83897,7 +84412,7 @@ features.command("create <name>").description("Create a new feature").option("-d
 
 <!-- What this feature explicitly does NOT cover. -->
 `);
-  await Bun.write(join57(featureDir, "progress.txt"), `# Progress: ${name}
+  await Bun.write(join53(featureDir, "progress.txt"), `# Progress: ${name}
 
 Created: ${new Date().toISOString()}
 
@@ -83923,8 +84438,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 = join57(naxDir, "features");
-  if (!existsSync32(featuresDir)) {
+  const featuresDir = join53(naxDir, "features");
+  if (!existsSync31(featuresDir)) {
     console.log(source_default.dim("No features yet."));
     return;
   }
@@ -83938,8 +84453,8 @@ features.command("list").description("List all features").option("-d, --dir <pat
 Features:
 `));
   for (const name of entries) {
-    const prdPath = join57(featuresDir, name, "prd.json");
-    if (existsSync32(prdPath)) {
+    const prdPath = join53(featuresDir, name, "prd.json");
+    if (existsSync31(prdPath)) {
       const prd = await loadPRD(prdPath);
       const c = countStories(prd);
       console.log(`  ${name} \u2014 ${c.passed}/${c.total} stories done`);
@@ -83973,10 +84488,10 @@ Use: nax plan -f <feature> --from <spec>`));
     cliOverrides.profile = options.profile;
   }
   const config2 = await loadConfig(workdir, cliOverrides);
-  const featureLogDir = join57(naxDir, "features", options.feature, "plan");
+  const featureLogDir = join53(naxDir, "features", options.feature, "plan");
   mkdirSync7(featureLogDir, { recursive: true });
   const planLogId = new Date().toISOString().replace(/:/g, "-").replace(/\..+/, "");
-  const planLogPath = join57(featureLogDir, `${planLogId}.jsonl`);
+  const planLogPath = join53(featureLogDir, `${planLogId}.jsonl`);
   initLogger({ level: "info", filePath: planLogPath, useChalk: false, headless: true });
   console.log(source_default.dim(`   [Plan log: ${planLogPath}]`));
   try {