@nathapp/nax 0.77.3 → 0.78.0

package/dist/nax.js

@@ -19356,18 +19356,36 @@ function findProjectDir(startDir = process.cwd()) {
   }
   return null;
 }
+function defaultConfigWarn(msg) {
+  try {
+    getLogger().warn("config", msg);
+  } catch {}
+}
 function applyRemovedStrategyCompat(conf) {
   const routing = conf.routing;
   const strategy = routing?.strategy;
   const REMOVED_STRATEGIES = ["manual", "adaptive", "custom"];
   if (typeof strategy === "string" && REMOVED_STRATEGIES.includes(strategy)) {
-    try {
-      getLogger().warn("config", `routing.strategy="${strategy}" was removed in ROUTE-001 and is no longer supported. Falling back to "keyword". Update your config to use "keyword" or "llm".`);
-    } catch {}
+    defaultConfigWarn(`routing.strategy="${strategy}" was removed in ROUTE-001 and is no longer supported. Falling back to "keyword". Update your config to use "keyword" or "llm".`);
     return { ...conf, routing: { ...routing, strategy: "keyword" } };
   }
   return conf;
 }
+function _applyRemovedRoutingKeysShim(conf, warn = defaultConfigWarn) {
+  const routing = conf.routing;
+  if (!routing || typeof routing !== "object")
+    return conf;
+  const REMOVED_ROUTING_KEYS = ["customStrategyPath", "adaptive"];
+  let newRouting = routing;
+  for (const key of REMOVED_ROUTING_KEYS) {
+    if (key in newRouting) {
+      warn(`routing.${key} was removed in ROUTE-001 along with the "custom"/"adaptive" strategies and has no effect. Remove it from your config.`);
+      const { [key]: _removed, ...rest } = newRouting;
+      newRouting = rest;
+    }
+  }
+  return newRouting === routing ? conf : { ...conf, routing: newRouting };
+}
 function applyBatchModeCompat(conf) {
   const routing = conf.routing;
   const llm = routing?.llm;
@@ -19375,9 +19393,7 @@ function applyBatchModeCompat(conf) {
     const batchMode = llm.batchMode;
     if (typeof batchMode === "boolean") {
       const mappedMode = batchMode ? "one-shot" : "per-story";
-      try {
-        getLogger().warn("config", `routing.llm.batchMode is deprecated and will be removed in v1.0. Mapped to mode="${mappedMode}". Update your config to use routing.llm.mode instead.`);
-      } catch {}
+      defaultConfigWarn(`routing.llm.batchMode is deprecated and will be removed in v1.0. Mapped to mode="${mappedMode}". Update your config to use routing.llm.mode instead.`);
       return {
         ...conf,
         routing: {
@@ -19389,11 +19405,7 @@ function applyBatchModeCompat(conf) {
   }
   return conf;
 }
-function _applyLegacyReviewExecutionShim(conf, warn = (msg) => {
-  try {
-    getLogger().warn("config", msg);
-  } catch {}
-}) {
+function _applyLegacyReviewExecutionShim(conf, warn = defaultConfigWarn) {
   let result = conf;
   const execution = conf.execution;
   if (execution && typeof execution === "object" && "inlineReview" in execution) {
@@ -19420,11 +19432,7 @@ function _applyLegacyReviewExecutionShim(conf, warn = (msg) => {
   }
   return result;
 }
-function applyRoutingRetryDeprecationWarning(conf, warn = (msg) => {
-  try {
-    getLogger().warn("config", msg);
-  } catch {}
-}) {
+function applyRoutingRetryDeprecationWarning(conf, warn = defaultConfigWarn) {
   const routing = conf.routing;
   const llm = routing?.llm;
   if (!llm)
@@ -19450,14 +19458,14 @@ async function loadConfig(startDir, cliOverrides) {
   } catch {}
   if (globalConfRaw) {
     const { profile: _gProfile, ...globalConfStripped } = globalConfRaw;
-    const globalConf = _applyLegacyReviewExecutionShim(applyRoutingRetryDeprecationWarning(applyBatchModeCompat(applyRemovedStrategyCompat(migrateLegacyReviewModelKey(migrateLegacyTestPattern(globalConfStripped, logger), logger)))));
+    const globalConf = _applyLegacyReviewExecutionShim(_applyRemovedRoutingKeysShim(applyRoutingRetryDeprecationWarning(applyBatchModeCompat(applyRemovedStrategyCompat(migrateLegacyReviewModelKey(migrateLegacyTestPattern(globalConfStripped, logger), logger))))));
     rawConfig = deepMergeConfig(rawConfig, globalConf);
   }
   if (projDir) {
     const projConf = await loadJsonFile(join3(projDir, "config.json"), "config");
     if (projConf) {
       const { profile: _pProfile, ...projConfStripped } = projConf;
-      const resolvedProjConf = _applyLegacyReviewExecutionShim(applyRoutingRetryDeprecationWarning(applyBatchModeCompat(applyRemovedStrategyCompat(migrateLegacyReviewModelKey(migrateLegacyTestPattern(projConfStripped, logger), logger)))));
+      const resolvedProjConf = _applyLegacyReviewExecutionShim(_applyRemovedRoutingKeysShim(applyRoutingRetryDeprecationWarning(applyBatchModeCompat(applyRemovedStrategyCompat(migrateLegacyReviewModelKey(migrateLegacyTestPattern(projConfStripped, logger), logger))))));
       rawConfig = deepMergeConfig(rawConfig, resolvedProjConf);
     }
   }
@@ -20033,6 +20041,7 @@ __export(exports_config, {
   TEST_STRATEGY_GUIDE: () => TEST_STRATEGY_GUIDE,
   SPEC_ANCHOR_RULES: () => SPEC_ANCHOR_RULES,
   SINGLE_SESSION_TEST_OWNING_STRATEGIES: () => SINGLE_SESSION_TEST_OWNING_STRATEGIES,
+  RoutingConfigSchema: () => RoutingConfigSchema,
   ReviewConfigSchema: () => ReviewConfigSchema,
   PlanConfigSchema: () => PlanConfigSchema,
   NaxConfigSchema: () => NaxConfigSchema,
@@ -24339,17 +24348,25 @@ function buildManifest(inputs) {
     ...staleChunkIds.length > 0 && { staleChunks: staleChunkIds }
   };
 }
-function rebuildUsedTokens(prior, packed, newPriorStageDigest) {
-  const priorChunksTokens = prior.chunks.reduce((sum, c) => sum + c.tokens, 0);
-  const extraTokens = packed.filter((c) => !prior.chunks.some((pc) => pc.id === c.id)).reduce((sum, c) => sum + c.tokens, 0);
-  const packedTokens = priorChunksTokens + extraTokens;
-  const newDigestContent = newPriorStageDigest?.trim();
-  const newDigestContribution = newDigestContent ? Math.ceil(newDigestContent.length / 4) : 0;
-  return Math.max(0, packedTokens + newDigestContribution);
-}
 var CHUNK_SUMMARY_CHARS = 300;
 
 // src/context/engine/orchestrator-rebuild-helpers.ts
+function toContextChunk(packed) {
+  const providerId = packed.providerId ?? packed.id.split(":")[0] ?? "unknown";
+  return {
+    id: packed.id,
+    providerId,
+    kind: packed.kind,
+    scope: packed.scope,
+    role: packed.role,
+    content: packed.content,
+    tokens: packed.tokens,
+    rawScore: packed.rawScore,
+    score: packed.score,
+    reason: packed.reason,
+    ...packed.staleCandidate && { staleCandidate: true }
+  };
+}
 function buildFailureNoteChunk(priorAgentId, newAgentId, failure) {
   const lines = [
     "## Agent swap (availability fallback)",
@@ -24385,17 +24402,62 @@ var DEFAULT_REBUILD_AGENT_ID = "claude";
 function scoreDensity(chunk) {
   return chunk.tokens > 0 ? chunk.score / chunk.tokens : Number.POSITIVE_INFINITY;
 }
+function greedyNonFloor(nonFloor, remainingBudget) {
+  const sorted = [...nonFloor].sort((a, b) => scoreDensity(b) - scoreDensity(a));
+  const selected = [];
+  const excludedIds = [];
+  let used = 0;
+  for (const chunk of sorted) {
+    if (used + chunk.tokens <= remainingBudget) {
+      selected.push(chunk);
+      used += chunk.tokens;
+    } else {
+      excludedIds.push(chunk.id);
+    }
+  }
+  return { selected, excludedIds };
+}
+function largestSingleItem(nonFloor, remainingBudget) {
+  let best = null;
+  for (const chunk of nonFloor) {
+    if (chunk.tokens > remainingBudget)
+      continue;
+    if (best === null || chunk.score > best.score)
+      best = chunk;
+  }
+  return best ? [best] : [];
+}
+function repairNonFloor(nonFloor, remainingBudget) {
+  const greedy = greedyNonFloor(nonFloor, remainingBudget);
+  const greedyScore = greedy.selected.reduce((s, c) => s + c.score, 0);
+  const largest = largestSingleItem(nonFloor, remainingBudget);
+  const largestScore = largest.reduce((s, c) => s + c.score, 0);
+  const candidates = [
+    { selected: greedy.selected, totalScore: greedyScore },
+    { selected: largest, totalScore: largestScore }
+  ];
+  let best = candidates[0];
+  for (const candidate of candidates) {
+    if (candidate.totalScore > best.totalScore) {
+      best = candidate;
+    }
+  }
+  const winnerIds = new Set(best.selected.map((c) => c.id));
+  const excludedIds = nonFloor.filter((c) => !winnerIds.has(c.id)).map((c) => c.id);
+  return { selected: best.selected, excludedIds };
+}
 function packChunks(chunks, budgetTokens, availableBudgetTokens) {
   const effectiveBudget = availableBudgetTokens !== undefined ? Math.min(budgetTokens, availableBudgetTokens) : budgetTokens;
   const floorChunks = chunks.filter((c) => FLOOR_KINDS.includes(c.kind));
-  const nonFloorChunks = chunks.filter((c) => !FLOOR_KINDS.includes(c.kind)).sort((a, b) => scoreDensity(b) - scoreDensity(a));
+  const nonFloorChunks = chunks.filter((c) => !FLOOR_KINDS.includes(c.kind));
   const packed = [];
-  const budgetExcludedIds = [];
   const floorPackedIds = [];
   const floorOverageIds = [];
   let usedTokens = 0;
+  const totalFloorTokens = floorChunks.reduce((sum, c) => sum + c.tokens, 0);
+  const floorCollectivelyOverflows = totalFloorTokens > effectiveBudget;
   for (const chunk of floorChunks) {
-    const overflows = usedTokens + chunk.tokens > effectiveBudget;
+    const overflows = floorCollectivelyOverflows || usedTokens + chunk.tokens > effectiveBudget;
     const packedChunk = { ...chunk };
     if (overflows) {
       packedChunk.reason = "budget-exceeded-by-floor";
@@ -24405,15 +24467,20 @@ function packChunks(chunks, budgetTokens, availableBudgetTokens) {
     packed.push(packedChunk);
     usedTokens += chunk.tokens;
   }
-  for (const chunk of nonFloorChunks) {
-    if (usedTokens + chunk.tokens <= effectiveBudget) {
-      packed.push({ ...chunk });
-      usedTokens += chunk.tokens;
-    } else {
-      budgetExcludedIds.push(chunk.id);
-    }
+  const remainingBudget = Math.max(0, effectiveBudget - usedTokens);
+  const { selected, excludedIds } = repairNonFloor(nonFloorChunks, remainingBudget);
+  for (const chunk of selected) {
+    packed.push({ ...chunk });
+    usedTokens += chunk.tokens;
   }
-  return { packed, budgetExcludedIds, usedTokens, effectiveBudget, floorPackedIds, floorOverageIds };
+  return {
+    packed,
+    budgetExcludedIds: excludedIds,
+    usedTokens,
+    effectiveBudget,
+    floorPackedIds,
+    floorOverageIds
+  };
 }
 var FLOOR_KINDS;
 var init_packing = __esm(() => {
@@ -28491,6 +28558,147 @@ var init_render = __esm(() => {
   FIXED_RENDER_OVERHEAD_TOKENS = Math.ceil(FIXED_RENDER_OVERHEAD_CHARS / 4);
 });
 
+// src/context/engine/scratch-neutralizer.ts
+function neutralizeForAgent(content, sourceAgent, targetAgent) {
+  if (!content || !sourceAgent || !targetAgent || sourceAgent === targetAgent)
+    return content;
+  if (sourceAgent.toLowerCase() !== "claude")
+    return content;
+  let result = content;
+  for (const [pattern, replacement] of CLAUDE_TOOL_SUBSTITUTIONS) {
+    result = result.replace(pattern, replacement);
+  }
+  return result;
+}
+var CLAUDE_TOOL_SUBSTITUTIONS;
+var init_scratch_neutralizer = __esm(() => {
+  CLAUDE_TOOL_SUBSTITUTIONS = [
+    [/\bthe\s+Read\s+tool\b/gi, "a file read"],
+    [/\bthe\s+Edit\s+tool\b/gi, "a file edit"],
+    [/\bthe\s+Write\s+tool\b/gi, "a file write"],
+    [/\bthe\s+Bash\s+tool\b/gi, "a shell command"],
+    [/\bthe\s+Grep\s+tool\b/gi, "a code search"],
+    [/\bthe\s+Glob\s+tool\b/gi, "a file search"],
+    [/\bthe\s+Agent\s+tool\b/gi, "a sub-agent"],
+    [/\bthe\s+Task\s+tool\b/gi, "a sub-agent"]
+  ];
+});
+
+// src/context/engine/rebuild.ts
+import { randomUUID as randomUUID2 } from "crypto";
+function toPackedChunks(prior, newAgentId, targetAgentId) {
+  const priorAgentForNeutralize = prior.agentId ?? "";
+  return prior.chunks.map((c) => {
+    const content = newAgentId && newAgentId !== priorAgentForNeutralize && c.kind === "session" ? neutralizeForAgent(c.content, priorAgentForNeutralize, targetAgentId) : c.content;
+    return { ...c, content, rawScore: c.score, roleFiltered: false, belowMinScore: false };
+  });
+}
+function rebuild(prior, options = {}, deps = DEFAULT_REBUILD_DEPS) {
+  const { newAgentId, failure, priorStageDigest, storyId } = options;
+  const targetAgentId = newAgentId ?? prior.agentId ?? DEFAULT_REBUILD_AGENT_ID;
+  const logger = deps.getLogger();
+  if (newAgentId && !AGENT_PROFILES[newAgentId]) {
+    logger.warn("context-v2", "rebuildForAgent: unknown agent id \u2014 using conservative defaults", {
+      ...storyId && { storyId },
+      stage: prior.manifest.stage,
+      agentId: newAgentId
+    });
+  }
+  const priorChunkIds = prior.chunks.map((c) => c.id);
+  const packedChunks = toPackedChunks(prior, newAgentId, targetAgentId);
+  const targetProfile = getAgentProfile(targetAgentId).profile;
+  const rebuiltPullTools = targetProfile.caps.supportsToolCalls ? prior.pullTools : [];
+  const effectiveBudget = Math.min(prior.manifest.effectiveBudget ?? Number.POSITIVE_INFINITY, targetProfile.caps.preferredPromptTokens);
+  let failureNoteChunk;
+  if (failure && newAgentId && !prior.manifest.rebuildInfo) {
+    failureNoteChunk = buildFailureNoteChunk(prior.agentId || "unknown", newAgentId, failure);
+    packedChunks.push(failureNoteChunk);
+  }
+  let packResult = packChunks(packedChunks, effectiveBudget);
+  if (failureNoteChunk && !packResult.packed.some((c) => c.id === failureNoteChunk.id)) {
+    packResult = {
+      ...packResult,
+      packed: [...packResult.packed, failureNoteChunk],
+      usedTokens: packResult.usedTokens + failureNoteChunk.tokens
+    };
+  }
+  const chunkById = new Map(packResult.packed.map((c) => [c.id, c]));
+  const orderedChunks = [];
+  for (const priorId of priorChunkIds) {
+    const chunk = chunkById.get(priorId);
+    if (chunk)
+      orderedChunks.push(chunk);
+  }
+  if (failureNoteChunk && chunkById.has(failureNoteChunk.id)) {
+    orderedChunks.push(failureNoteChunk);
+  }
+  const pushMarkdown = newAgentId ? renderForAgent(orderedChunks, targetAgentId, { priorStageDigest }) : renderChunks(orderedChunks, { priorStageDigest });
+  const digest = buildDigest(orderedChunks);
+  const dTokens = digestTokens(digest);
+  const newDigestContent = priorStageDigest?.trim();
+  const digestContribution = newDigestContent ? Math.ceil(newDigestContent.length / 4) : 0;
+  const usedTokens = packResult.usedTokens + digestContribution;
+  const rebuildInfo = failure && newAgentId ? {
+    priorAgentId: prior.agentId ?? "unknown",
+    newAgentId: targetAgentId,
+    failureCategory: failure.category,
+    failureOutcome: failure.outcome,
+    priorChunkIds,
+    newChunkIds: orderedChunks.map((c) => c.id),
+    chunkIdMap: [
+      ...priorChunkIds.map((priorId) => {
+        const entry = chunkById.get(priorId);
+        return entry ? { priorChunkId: priorId, newChunkId: priorId } : null;
+      }).filter((entry) => entry !== null),
+      ...failureNoteChunk ? [{ priorChunkId: failureNoteChunk.id, newChunkId: failureNoteChunk.id }] : []
+    ]
+  } : undefined;
+  const includedChunkIds = new Set(orderedChunks.map((c) => c.id));
+  const chunkSummaries = Object.fromEntries(orderedChunks.map((c) => [c.id, c.content.slice(0, CHUNK_SUMMARY_CHARS)]));
+  const chunkEffectiveness = prior.manifest.chunkEffectiveness ? Object.fromEntries(Object.entries(prior.manifest.chunkEffectiveness).filter(([id]) => includedChunkIds.has(id))) : undefined;
+  const excludedChunks = packResult.budgetExcludedIds.filter((id) => !includedChunkIds.has(id)).map((id) => ({ id, reason: "budget" }));
+  const manifest = {
+    ...prior.manifest,
+    requestId: deps.uuid(),
+    includedChunks: orderedChunks.map((c) => c.id),
+    excludedChunks,
+    chunkTokens: Object.fromEntries(orderedChunks.map((c) => [c.id, c.tokens])),
+    usedTokens,
+    digestTokens: dTokens,
+    buildMs: 0,
+    rebuildInfo,
+    effectiveBudget,
+    floorItems: packResult.floorPackedIds,
+    floorOverageItems: packResult.floorOverageIds.length > 0 ? packResult.floorOverageIds : undefined,
+    chunkSummaries: Object.keys(chunkSummaries).length > 0 ? chunkSummaries : undefined,
+    staleChunks: orderedChunks.some((c) => c.staleCandidate) ? orderedChunks.filter((c) => c.staleCandidate).map((c) => c.id) : undefined,
+    chunkEffectiveness: chunkEffectiveness && Object.keys(chunkEffectiveness).length > 0 ? chunkEffectiveness : undefined
+  };
+  const rebuiltChunks = orderedChunks.map(toContextChunk);
+  return {
+    pushMarkdown,
+    pullTools: rebuiltPullTools,
+    digest,
+    manifest,
+    chunks: rebuiltChunks,
+    agentId: targetAgentId
+  };
+}
+var DEFAULT_REBUILD_DEPS;
+var init_rebuild = __esm(() => {
+  init_logger2();
+  init_agent_profiles();
+  init_agent_renderer();
+  init_digest();
+  init_packing();
+  init_render();
+  init_scratch_neutralizer();
+  DEFAULT_REBUILD_DEPS = {
+    uuid: () => randomUUID2(),
+    getLogger: () => getLogger()
+  };
+});
+
 // src/context/engine/scoring.ts
 function roleMultiplier(chunkRoles, callerRole) {
   if (chunkRoles.includes(callerRole))
@@ -28527,34 +28735,8 @@ var init_scoring = __esm(() => {
   };
 });
 
-// src/context/engine/scratch-neutralizer.ts
-function neutralizeForAgent(content, sourceAgent, targetAgent) {
-  if (!content || !sourceAgent || !targetAgent || sourceAgent === targetAgent)
-    return content;
-  if (sourceAgent.toLowerCase() !== "claude")
-    return content;
-  let result = content;
-  for (const [pattern, replacement] of CLAUDE_TOOL_SUBSTITUTIONS) {
-    result = result.replace(pattern, replacement);
-  }
-  return result;
-}
-var CLAUDE_TOOL_SUBSTITUTIONS;
-var init_scratch_neutralizer = __esm(() => {
-  CLAUDE_TOOL_SUBSTITUTIONS = [
-    [/\bthe\s+Read\s+tool\b/gi, "a file read"],
-    [/\bthe\s+Edit\s+tool\b/gi, "a file edit"],
-    [/\bthe\s+Write\s+tool\b/gi, "a file write"],
-    [/\bthe\s+Bash\s+tool\b/gi, "a shell command"],
-    [/\bthe\s+Grep\s+tool\b/gi, "a code search"],
-    [/\bthe\s+Glob\s+tool\b/gi, "a file search"],
-    [/\bthe\s+Agent\s+tool\b/gi, "a sub-agent"],
-    [/\bthe\s+Task\s+tool\b/gi, "a sub-agent"]
-  ];
-});
-
 // src/context/engine/orchestrator.ts
-import { createHash as createHash5, randomUUID as randomUUID2 } from "crypto";
+import { createHash as createHash5, randomUUID as randomUUID3 } from "crypto";
 function buildPullToolDescriptors(stageToolNames, pullConfig) {
   if (!pullConfig?.enabled || stageToolNames.length === 0)
     return [];
@@ -28584,22 +28766,6 @@ async function fetchWithTimeout(provider, request, timeoutMs = PROVIDER_FETCH_TI
     clearTimeout(handle);
   }
 }
-function toContextChunk(packed) {
-  const providerId = packed.providerId ?? packed.id.split(":")[0] ?? "unknown";
-  return {
-    id: packed.id,
-    providerId,
-    kind: packed.kind,
-    scope: packed.scope,
-    role: packed.role,
-    content: packed.content,
-    tokens: packed.tokens,
-    rawScore: packed.rawScore,
-    score: packed.score,
-    reason: packed.reason,
-    ...packed.staleCandidate && { staleCandidate: true }
-  };
-}
 function enrichRaw(chunk, providerId) {
   return { ...chunk, providerId };
 }
@@ -28760,9 +28926,8 @@ class ContextOrchestrator {
         excludedNonFloorChunkCount: budgetExcludedIds.length
       });
     }
-    const pushMarkdown = renderChunks(packed, {
-      priorStageDigest: request.priorStageDigest
-    });
+    const renderOptions = { priorStageDigest: request.priorStageDigest };
+    const pushMarkdown = request.agentId !== undefined ? renderForAgent(packed, request.agentId, renderOptions) : renderChunks(packed, renderOptions);
     const digest = buildDigest(packed);
     const dTokens = digestTokens(digest);
     const buildMs = _orchestratorDeps.now() - startMs;
@@ -28799,62 +28964,10 @@ class ContextOrchestrator {
     };
   }
   rebuildForAgent(prior, options = {}) {
-    const { newAgentId, failure, priorStageDigest, storyId } = options;
-    const targetAgentId = newAgentId ?? prior.agentId ?? DEFAULT_REBUILD_AGENT_ID;
-    const logger = _orchestratorDeps.getLogger();
-    if (newAgentId && !AGENT_PROFILES[newAgentId]) {
-      logger.warn("context-v2", "rebuildForAgent: unknown agent id \u2014 using conservative defaults", {
-        ...storyId && { storyId },
-        stage: prior.manifest.stage,
-        agentId: newAgentId
-      });
-    }
-    const priorChunkIds = prior.chunks.map((c) => c.id);
-    const priorAgentForNeutralize = prior.agentId ?? "";
-    const packedChunks = prior.chunks.map((c) => {
-      const content = newAgentId && newAgentId !== priorAgentForNeutralize && c.kind === "session" ? neutralizeForAgent(c.content, priorAgentForNeutralize, targetAgentId) : c.content;
-      return { ...c, content, rawScore: c.score, roleFiltered: false, belowMinScore: false };
+    return _orchestratorDeps.rebuild(prior, options, {
+      uuid: _orchestratorDeps.uuid,
+      getLogger: _orchestratorDeps.getLogger
     });
-    if (failure && newAgentId) {
-      packedChunks.push(buildFailureNoteChunk(priorAgentForNeutralize || "unknown", newAgentId, failure));
-    }
-    const pushMarkdown = newAgentId ? renderForAgent(packedChunks, targetAgentId, { priorStageDigest }) : renderChunks(packedChunks, { priorStageDigest });
-    const digest = buildDigest(packedChunks);
-    const dTokens = digestTokens(digest);
-    const rebuildInfo = failure && newAgentId ? {
-      priorAgentId: prior.agentId ?? "unknown",
-      newAgentId: targetAgentId,
-      failureCategory: failure.category,
-      failureOutcome: failure.outcome,
-      priorChunkIds,
-      newChunkIds: packedChunks.map((c) => c.id),
-      chunkIdMap: priorChunkIds.map((priorChunkId, index) => {
-        const newChunkId = packedChunks[index]?.id;
-        return newChunkId ? { priorChunkId, newChunkId } : null;
-      }).filter((entry) => entry !== null)
-    } : undefined;
-    const usedTokens = rebuildUsedTokens(prior, packedChunks, priorStageDigest);
-    const targetProfile = getAgentProfile(targetAgentId).profile;
-    const rebuiltPullTools = targetProfile.caps.supportsToolCalls ? prior.pullTools : [];
-    const manifest = {
-      ...prior.manifest,
-      requestId: _orchestratorDeps.uuid(),
-      includedChunks: packedChunks.map((c) => c.id),
-      chunkTokens: Object.fromEntries(packedChunks.map((c) => [c.id, c.tokens])),
-      usedTokens,
-      digestTokens: dTokens,
-      buildMs: 0,
-      rebuildInfo,
-      effectiveBudget: Math.min(prior.manifest.effectiveBudget ?? Number.POSITIVE_INFINITY, targetProfile.caps.preferredPromptTokens)
-    };
-    return {
-      pushMarkdown,
-      pullTools: rebuiltPullTools,
-      digest,
-      manifest,
-      chunks: packedChunks.map(toContextChunk),
-      agentId: targetAgentId
-    };
   }
 }
 var _orchestratorDeps, PROVIDER_FETCH_TIMEOUT_MS = 5000;
@@ -28867,14 +28980,15 @@ var init_orchestrator = __esm(() => {
   init_digest();
   init_packing();
   init_pull_tools();
+  init_rebuild();
   init_render();
   init_scoring();
-  init_scratch_neutralizer();
   init_stage_config();
   _orchestratorDeps = {
     now: () => Date.now(),
-    uuid: () => randomUUID2(),
-    getLogger
+    uuid: () => randomUUID3(),
+    getLogger,
+    rebuild
   };
 });
 
@@ -30432,9 +30546,10 @@ function resetFailedStoriesToPending(prd, opts = {}) {
 }
 function markStorySkipped(prd, storyId) {
   const story = prd.userStories.find((s) => s.id === storyId);
-  if (story) {
-    story.status = "skipped";
-  }
+  if (!story)
+    return false;
+  story.status = "skipped";
+  return true;
 }
 function resetStoryToPending(prd, storyId) {
   const story = prd.userStories.find((s) => s.id === storyId);
@@ -32804,6 +32919,7 @@ var init_engine = __esm(() => {
   init_packing();
   init_render();
   init_digest();
+  init_rebuild();
   init_available_budget();
   init_stage_config();
   init_static_rules();
@@ -33384,15 +33500,23 @@ Set \`approved: false\` when ANY of these conditions are true:
 - The implementer loosened test assertions to mask bugs
 - The implementer made illegitimate test changes
 
+When tests fail but the implementation satisfies every acceptance criterion and
+a specific test assertion contradicts the specification, set
+\`testFailureDiagnosis.cause\` to \`"test-incorrect"\` and identify each
+assertion with its file, test name, and reasoning. Do not use this diagnosis if
+the implementer modified tests or any acceptance criterion is unmet.
+
 **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":"..."},"acceptanceCriteria":{"allMet":true,"criteria":[{"criterion":"...","met":true}]},"quality":{"rating":"good","issues":[]},"fixes":[],"reasoning":"..."}
+{"version":1,"approved":true,"tests":{"allPassing":true,"passCount":42,"failCount":0},"testModifications":{"detected":false,"files":[],"legitimate":true,"reasoning":"..."},"testFailureDiagnosis":null,"acceptanceCriteria":{"allMet":true,"criteria":[{"criterion":"...","met":true}]},"quality":{"rating":"good","issues":[]},"fixes":[],"reasoning":"..."}
 \`\`\`
 
 **Field notes:**
 - \`quality.rating\` must be one of: \`"good"\`, \`"acceptable"\`, \`"poor"\`
 - \`testModifications.files\` \u2014 list any test files the implementer changed
+- \`testFailureDiagnosis\` \u2014 normally \`null\`; for a concrete incorrect-test
+  diagnosis use \`{"cause":"test-incorrect","assertions":[{"file":"...","testName":"...","reasoning":"..."}]}\`
 - \`acceptanceCriteria\` and \`quality\` are advisory in this TDD verifier verdict; do not use them to reject semantic correctness
 - \`fixes\` \u2014 keep this empty; the verifier must not apply code or test fixes
 - \`reasoning\` \u2014 brief summary of your overall assessment
@@ -33833,7 +33957,8 @@ class TddPromptBuilder {
 ` + `Re-emit the verdict as the FINAL content of your reply.
 ` + `Output ONLY the JSON object \u2014 no markdown fences, no explanation, no prose.
 ` + `The reply must start with { and end with } on its own line.
-` + "Required top-level fields: version, approved, tests, testModifications, acceptanceCriteria, quality, fixes, reasoning.";
+` + `Required top-level fields: version, approved, tests, testModifications, acceptanceCriteria, quality, fixes, reasoning.
+` + 'Optional testFailureDiagnosis: null, or {"cause":"test-incorrect","assertions":[{"file":"...","testName":"...","reasoning":"..."}]}.';
   }
   static verdictRetryCondensed() {
     return `Your previous reply was truncated and could not be parsed as valid JSON.
@@ -33844,7 +33969,7 @@ class TddPromptBuilder {
 ` + `- Set reasoning to a single sentence.
 ` + `Output ONLY the JSON object \u2014 no markdown fences, no prose.
 ` + `Schema (minimal):
-` + `{"version":1,"approved":boolean,"tests":{"allPassing":boolean,"passCount":number,"failCount":number},"testModifications":{"detected":boolean,"files":[],"legitimate":boolean,"reasoning":"..."},"acceptanceCriteria":{"allMet":boolean,"criteria":[]},"quality":{"rating":"good"|"acceptable"|"poor","issues":[]},"fixes":[],"reasoning":"..."}`;
+` + `{"version":1,"approved":boolean,"tests":{"allPassing":boolean,"passCount":number,"failCount":number},"testModifications":{"detected":boolean,"files":[],"legitimate":boolean,"reasoning":"..."},"testFailureDiagnosis":null,"acceptanceCriteria":{"allMet":boolean,"criteria":[]},"quality":{"rating":"good"|"acceptable"|"poor","issues":[]},"fixes":[],"reasoning":"..."}`;
   }
   s(id, content) {
     return { id, content, overridable: false };
@@ -39861,6 +39986,21 @@ var init_implement = __esm(() => {
 // src/tdd/verdict-reader.ts
 import { unlink } from "fs/promises";
 import path4 from "path";
+function isValidTestFailureDiagnosis(value) {
+  if (!value || typeof value !== "object")
+    return false;
+  const diagnosis = value;
+  if (!["implementation", "test-incorrect", "unknown"].includes(diagnosis.cause))
+    return false;
+  if (!Array.isArray(diagnosis.assertions))
+    return false;
+  return diagnosis.assertions.every((assertion) => {
+    if (!assertion || typeof assertion !== "object")
+      return false;
+    const item = assertion;
+    return typeof item.file === "string" && typeof item.reasoning === "string" && (item.testName === undefined || typeof item.testName === "string");
+  });
+}
 function isValidVerdict(obj) {
   if (!obj || typeof obj !== "object")
     return false;
@@ -39889,6 +40029,9 @@ function isValidVerdict(obj) {
     return false;
   if (typeof mods.reasoning !== "string")
     return false;
+  if (v.testFailureDiagnosis !== undefined && v.testFailureDiagnosis !== null && !isValidTestFailureDiagnosis(v.testFailureDiagnosis)) {
+    return false;
+  }
   if (!v.acceptanceCriteria || typeof v.acceptanceCriteria !== "object")
     return false;
   const ac = v.acceptanceCriteria;
@@ -39989,6 +40132,7 @@ function coerceVerdict(obj) {
         legitimate: true,
         reasoning: "Not assessed in free-form verdict"
       },
+      ...isValidTestFailureDiagnosis(obj.testFailureDiagnosis) ? { testFailureDiagnosis: obj.testFailureDiagnosis } : {},
       acceptanceCriteria: { allMet, criteria },
       quality: { rating, issues: [] },
       fixes: Array.isArray(obj.fixes) ? obj.fixes : [],
@@ -40088,9 +40232,6 @@ function categorizeVerdict(verdict, testsPass) {
       reviewReason: "Tests failing after all sessions (no verdict file)"
     };
   }
-  if (verdict.approved) {
-    return { success: true };
-  }
   if (verdict.testModifications.detected && !verdict.testModifications.legitimate) {
     const files = verdict.testModifications.files.join(", ") || "unknown files";
     return {
@@ -40100,6 +40241,14 @@ function categorizeVerdict(verdict, testsPass) {
     };
   }
   if (!verdict.tests.allPassing) {
+    if (hasAdmissibleIncorrectTestDiagnosis(verdict)) {
+      const files = verdict.testFailureDiagnosis?.assertions.map((assertion) => assertion.file).join(", ");
+      return {
+        success: false,
+        failureCategory: "test-incorrect",
+        reviewReason: `Verifier identified incorrect test assertion(s) in ${files}; human review required before changing tests or source.`
+      };
+    }
     return {
       success: false,
       failureCategory: "tests-failing",
@@ -40108,6 +40257,10 @@ function categorizeVerdict(verdict, testsPass) {
   }
   return { success: true };
 }
+function hasAdmissibleIncorrectTestDiagnosis(verdict) {
+  const diagnosis = verdict.testFailureDiagnosis;
+  return verdict.approved === false && verdict.testModifications.detected === false && verdict.acceptanceCriteria.allMet === true && diagnosis?.cause === "test-incorrect" && diagnosis.assertions.length > 0 && diagnosis.assertions.every((assertion) => assertion.file.trim() !== "" && assertion.reasoning.trim() !== "");
+}
 var init_verdict = __esm(() => {
   init_verdict_reader();
 });
@@ -40149,6 +40302,23 @@ function buildVerifierFindings(verdict, categorization) {
         }
       ];
     }
+    case "test-incorrect": {
+      const assertions = verdict.testFailureDiagnosis?.assertions ?? [];
+      const files = assertions.map((assertion) => assertion.file);
+      return [
+        {
+          source: "tdd-verifier",
+          severity: "error",
+          category: "incorrect-test-assertion",
+          fixTarget: "test",
+          message: `Verifier identified incorrect test assertion(s) in ${files.join(", ")}; human review required`,
+          meta: {
+            assertions,
+            reasoning: verdict.reasoning
+          }
+        }
+      ];
+    }
     default:
       return [];
   }
@@ -44093,6 +44263,7 @@ async function runFixCycle(cycle, ctx, cycleName, _deps = {}) {
   const now = _deps.now ?? _cycleDeps.now;
   const storyId = ctx.storyId;
   const packageDir = ctx.packageDir;
+  const logCtx = { storyId, packageDir, cycleName };
   let totalCostUsd = 0;
   const declines = createDeclineLedger(_deps.declineBacking);
   let unresolvedDetail;
@@ -44108,9 +44279,7 @@ async function runFixCycle(cycle, ctx, cycleName, _deps = {}) {
       const orphanSources = [...new Set(cycle.findings.map((f) => f.source))];
       const retiredStrategies = declines.retiredNames(cycle.strategies, cycle.findings);
       logger?.warn("findings.cycle", "cycle exited \u2014 no matching strategy (orphaned findings)", {
-        storyId,
-        packageDir,
-        cycleName,
+        ...logCtx,
         reason: "no-strategy",
         findingsCount: cycle.findings.length,
         orphanSources,
@@ -44127,9 +44296,7 @@ async function runFixCycle(cycle, ctx, cycleName, _deps = {}) {
     if (uncappedActive.length === 0) {
       const exhaustedStrategy = active.find((s) => countStrategyAttempts(history, s.name) >= s.maxAttempts);
       logger?.info("findings.cycle", "cycle exited \u2014 all active strategies exhausted", {
-        storyId,
-        packageDir,
-        cycleName,
+        ...logCtx,
         reason: "max-attempts-per-strategy",
         exhaustedStrategy: exhaustedStrategy?.name
       });
@@ -44144,9 +44311,7 @@ async function runFixCycle(cycle, ctx, cycleName, _deps = {}) {
     const totalAttempts = countTotalAttempts(history);
     if (totalAttempts >= cycle.config.maxAttemptsTotal) {
       logger?.info("findings.cycle", "cycle exited \u2014 total attempt cap reached", {
-        storyId,
-        packageDir,
-        cycleName,
+        ...logCtx,
         reason: "max-attempts-total",
         totalAttempts,
         maxAttemptsTotal: cycle.config.maxAttemptsTotal
@@ -44161,13 +44326,14 @@ async function runFixCycle(cycle, ctx, cycleName, _deps = {}) {
     for (const strategy of uncappedActive) {
       const bailReason = strategy.bailWhen?.(history) ?? null;
       if (bailReason !== null) {
+        const inheritedIterations = cycle.priorIterations?.length ?? 0;
         logger?.info("findings.cycle", "cycle exited \u2014 bail predicate fired", {
-          storyId,
-          packageDir,
-          cycleName,
+          ...logCtx,
           reason: "bail-when",
           strategyName: strategy.name,
-          bailDetail: bailReason
+          bailDetail: bailReason,
+          cycleIterations: cycle.iterations.length,
+          ...inheritedIterations > 0 ? { inheritedIterations } : {}
         });
         return finish({
           iterations: cycle.iterations,
@@ -44222,9 +44388,7 @@ async function runFixCycle(cycle, ctx, cycleName, _deps = {}) {
         }, { storyId, packageDir, cycleName }, logger);
         totalCostUsd += fixesApplied.reduce((sum, fa) => sum + (fa.costUsd ?? 0), 0);
         logger?.info("findings.cycle", "cycle exited \u2014 agent gave up", {
-          storyId,
-          packageDir,
-          cycleName,
+          ...logCtx,
           reason: "agent-gave-up",
           strategyName: firstUnresolved.strategyName,
           unresolvedDetail: firstUnresolved.unresolved
@@ -44238,9 +44402,7 @@ async function runFixCycle(cycle, ctx, cycleName, _deps = {}) {
         });
       }
       logger?.info("findings.cycle", "strategy gave up \u2014 retired, continuing with co-run siblings", {
-        storyId,
-        packageDir,
-        cycleName,
+        ...logCtx,
         strategyName: firstUnresolved.strategyName,
         unresolvedDetail: firstUnresolved.unresolved,
         ranWithoutGivingUp: fixesApplied.filter((fa) => !fa.unresolved).map((fa) => fa.strategyName)
@@ -44271,9 +44433,7 @@ async function runFixCycle(cycle, ctx, cycleName, _deps = {}) {
           finishedAt: finishedAt3
         }, { storyId, packageDir, cycleName }, logger);
         logger?.warn("findings.cycle", "lite validate failed on terminal exhausted branch", {
-          storyId,
-          packageDir,
-          cycleName,
+          ...logCtx,
           error: errorMessage(err)
         });
         return finish({
@@ -44297,9 +44457,7 @@ async function runFixCycle(cycle, ctx, cycleName, _deps = {}) {
       cycle.findings = liteFindingsAfter;
       if (liteFindingsAfter.length === 0 && !liteShortCircuited) {
         logger?.info("findings.cycle", "cycle exited \u2014 resolved after terminal lite validate", {
-          storyId,
-          packageDir,
-          cycleName,
+          ...logCtx,
           reason: "resolved"
         });
         return finish({
@@ -44313,18 +44471,14 @@ async function runFixCycle(cycle, ctx, cycleName, _deps = {}) {
         const companions = uncappedActive.filter((s) => !group.includes(s));
         if (companions.length > 0) {
           logger?.info("findings.cycle", "exclusive strategy exhausted \u2014 continuing to companion strategies", {
-            storyId,
-            packageDir,
-            cycleName,
+            ...logCtx,
             exhaustedStrategies: group.map((s) => s.name),
             remainingStrategies: companions.map((s) => s.name)
           });
           continue;
         }
         logger?.info("findings.cycle", "cycle exited \u2014 validate short-circuited", {
-          storyId,
-          packageDir,
-          cycleName,
+          ...logCtx,
           reason: "validate-short-circuit",
           liteFindingsAfterCount: liteFindingsAfter.length
         });
@@ -44336,9 +44490,7 @@ async function runFixCycle(cycle, ctx, cycleName, _deps = {}) {
         });
       }
       logger?.info("findings.cycle", "cycle exited \u2014 strategy attempt cap reached (lite validate)", {
-        storyId,
-        packageDir,
-        cycleName,
+        ...logCtx,
         reason: "max-attempts-per-strategy",
         exhaustedStrategy: group[0]?.name,
         liteFindingsAfterCount: liteFindingsAfter.length
@@ -44375,9 +44527,7 @@ async function runFixCycle(cycle, ctx, cycleName, _deps = {}) {
           });
         }
         logger?.warn("findings.cycle", "validator retry", {
-          storyId,
-          packageDir,
-          cycleName,
+          ...logCtx,
           attempt: validatorAttempt + 1,
           error: errorMessage(err)
         });
@@ -44431,8 +44581,8 @@ var NAX_BAIL_WRAPPER = "__naxBailWrapper";
 function createStoryFixHistory() {
   return new Map;
 }
-function storyFixKey(storyId, tier) {
-  return `${storyId}::${tier ?? "default"}`;
+function storyFixKey(storyId, tier, agent) {
+  return `${storyId}::${tier ?? "default"}::${agent ?? "default"}`;
 }
 function getStoryFixState(store, key) {
   let existing = store.get(key);
@@ -44958,7 +45108,7 @@ var package_default;
 var init_package = __esm(() => {
   package_default = {
     name: "@nathapp/nax",
-    version: "0.77.3",
+    version: "0.78.0",
     description: "AI Coding Agent Orchestrator \u2014 loops until done",
     type: "module",
     bin: {
@@ -44997,13 +45147,17 @@ var init_package = __esm(() => {
       "test:e2e": "timeout -k 5s 180s bun test test/e2e/ --timeout=60000",
       "test:coverage": "bun run scripts/check-coverage.ts",
       "test:coverage:report": "bun run scripts/check-coverage.ts --report",
-      "check-test-overlap": "bun run scripts/check-test-overlap.ts",
-      "check-dead-tests": "bun run scripts/check-dead-tests.ts",
-      "check:test-sizes": "bun run scripts/check-test-sizes.ts",
+      "report:test-overlap": "bun run scripts/report-test-overlap.ts",
+      "report:dead-tests": "bun run scripts/report-dead-tests.ts",
       "check:test-mocks": "bun scripts/check-inline-test-mocks.ts --strict",
       "check:process-cwd": "bash scripts/check-process-cwd.sh",
       "check:no-adapter-wrap": "bash scripts/check-no-adapter-wrap.sh",
       "check:dispatch-context": "bash scripts/check-dispatch-context.sh",
+      "check:naxconfig-cast": "bash scripts/check-no-silent-naxconfig-cast.sh",
+      "check:runtime-cleanup": "bash scripts/check-runtime-cleanup.sh",
+      "check:adapter-no-config-import": "bash scripts/check-adapter-no-config-import.sh",
+      "check:gate-reachability": "bun run scripts/check-gate-reachability.ts",
+      "check:all": "bun run lint && bun run check:test-mocks && bun run check:process-cwd && bun run check:no-adapter-wrap && bun run check:dispatch-context && bun run check:naxconfig-cast && bun run check:runtime-cleanup && bun run check:adapter-no-config-import && bun run check:gate-reachability",
       prepublishOnly: "bun run build",
       "test:full": "FULL=1 NAX_PRECHECK=1 bun test test/ --timeout=60000"
     },
@@ -45062,8 +45216,8 @@ var init_version = __esm(() => {
   NAX_VERSION = package_default.version;
   NAX_COMMIT = (() => {
     try {
-      if (/^[0-9a-f]{6,10}$/.test("e42ce962"))
-        return "e42ce962";
+      if (/^[0-9a-f]{6,10}$/.test("af86acb4"))
+        return "af86acb4";
     } catch {}
     try {
       const result = Bun.spawnSync(["git", "rev-parse", "--short", "HEAD"], {
@@ -51129,7 +51283,7 @@ var init_pid_registry = __esm(() => {
 });
 
 // src/session/manager-deps.ts
-import { randomUUID as randomUUID3 } from "crypto";
+import { randomUUID as randomUUID4 } from "crypto";
 import { mkdir as mkdir5 } from "fs/promises";
 import { isAbsolute as isAbsolute11, join as join32, relative as relative12, sep as sep3 } from "path";
 function resolveProjectDirFromScratchDir(scratchDir) {
@@ -51151,7 +51305,7 @@ var init_manager_deps = __esm(() => {
   _sessionManagerDeps = {
     now: () => new Date().toISOString(),
     nowMs: () => Date.now(),
-    uuid: () => randomUUID3(),
+    uuid: () => randomUUID4(),
     sessionScratchDir: (projectDir, featureName, sessionId) => join32(projectDir, ".nax", "features", featureName, "sessions", sessionId),
     writeDescriptor: async (scratchDir, descriptor, projectDir) => {
       await mkdir5(scratchDir, { recursive: true });
@@ -60272,7 +60426,7 @@ var init_completion = __esm(() => {
       const isBatch = ctx.stories.length > 1;
       const sessionCost = ctx.runtime.costAggregator.byStory()[ctx.story.id]?.totalCostUsd ?? 0;
       const persistPrd2 = ctx.skipPrdPersistence !== true;
-      const prdPath = ctx.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);
@@ -60719,7 +60873,7 @@ var init_helpers = __esm(() => {
 });
 
 // src/pipeline/stages/context.ts
-import { randomUUID as randomUUID4 } from "crypto";
+import { randomUUID as randomUUID5 } from "crypto";
 async function runV2Path(ctx) {
   const logger = getLogger();
   const agentName = ctx.routing.agent ?? ctx.agentManager?.getDefault() ?? "claude";
@@ -60943,7 +61097,7 @@ var init_context2 = __esm(() => {
     createOrchestrator: createDefaultOrchestrator,
     loadPlugins: loadPluginProviders,
     v1FeatureProvider: () => new FeatureContextProvider,
-    uuid: () => randomUUID4(),
+    uuid: () => randomUUID5(),
     readDigest: readDigestFile,
     writeDigest: writeDigestFile
   };
@@ -60991,6 +61145,23 @@ async function spawnWithTimeout(proc, timeoutMs) {
 function captureFailureSentinel() {
   return `__capture_failed__:${Date.now()}:${Math.random().toString(36).slice(2)}`;
 }
+async function untrackedDigestInput(deps, workdir) {
+  const listed = await spawnWithTimeout(spawnGit(deps, ["ls-files", "--others", "--exclude-standard", "-z"], workdir), TREE_CAPTURE_TIMEOUT_MS);
+  if (listed.exitCode !== 0)
+    return null;
+  const paths = listed.stdout.split("\x00").filter((p) => p !== "");
+  if (paths.length === 0)
+    return "0";
+  paths.sort();
+  const capped = paths.slice(0, MAX_UNTRACKED_HASHED);
+  const hashed = await spawnWithTimeout(spawnGit(deps, ["hash-object", "--", ...capped], workdir), UNTRACKED_HASH_TIMEOUT_MS);
+  if (hashed.exitCode !== 0)
+    return null;
+  return `${paths.length}
+${capped.join(`
+`)}
+${hashed.stdout.trim()}`;
+}
 async function captureTreeState(workdir, options) {
   let headSha = "";
   let dirtyDigest = "";
@@ -61002,14 +61173,29 @@ async function captureTreeState(workdir, options) {
     headSha = captureFailureSentinel();
   }
   try {
-    const proc = spawnGit(options._deps, ["status", "--porcelain"], workdir);
-    const { stdout, exitCode } = await spawnWithTimeout(proc, TREE_CAPTURE_TIMEOUT_MS);
-    if (exitCode === 0) {
-      const trimmed = stdout.trim();
-      if (trimmed) {
-        const hasher = new Bun.CryptoHasher("sha256");
-        hasher.update(trimmed);
-        dirtyDigest = hasher.digest("hex");
+    const statusProc = spawnGit(options._deps, ["status", "--porcelain"], workdir);
+    const status = await spawnWithTimeout(statusProc, TREE_CAPTURE_TIMEOUT_MS);
+    if (status.exitCode === 0) {
+      const trimmedStatus = status.stdout.trim();
+      if (trimmedStatus) {
+        const diffProc = spawnGit(options._deps, ["diff"], workdir);
+        const diff = await spawnWithTimeout(diffProc, TREE_CAPTURE_TIMEOUT_MS);
+        const cachedDiffProc = spawnGit(options._deps, ["diff", "--cached"], workdir);
+        const cachedDiff = await spawnWithTimeout(cachedDiffProc, TREE_CAPTURE_TIMEOUT_MS);
+        const untracked = await untrackedDigestInput(options._deps, workdir);
+        if (diff.exitCode === 0 && cachedDiff.exitCode === 0 && untracked !== null) {
+          const hasher = new Bun.CryptoHasher("sha256");
+          hasher.update(trimmedStatus);
+          hasher.update("\x00");
+          hasher.update(diff.stdout);
+          hasher.update("\x00");
+          hasher.update(cachedDiff.stdout);
+          hasher.update("\x00");
+          hasher.update(untracked);
+          dirtyDigest = hasher.digest("hex");
+        } else {
+          dirtyDigest = captureFailureSentinel();
+        }
       }
     } else {
       dirtyDigest = captureFailureSentinel();
@@ -61028,7 +61214,7 @@ function buildCheckpointLogData(meta3) {
   const { storyId, ...rest } = meta3;
   return { storyId, ...rest };
 }
-var TREE_CAPTURE_TIMEOUT_MS = 75;
+var TREE_CAPTURE_TIMEOUT_MS = 75, MAX_UNTRACKED_HASHED = 500, UNTRACKED_HASH_TIMEOUT_MS = 250;
 
 // src/tdd/rollback.ts
 async function rollbackToRef(workdir, ref) {
@@ -62350,12 +62536,19 @@ async function runRectification(ctx, state, phaseCosts, phaseOutputs, overrides)
   if (initialFindings.length === 0) {
     return {};
   }
+  if (initialFindings.some((finding) => finding.category === "incorrect-test-assertion")) {
+    getSafeLogger()?.warn("story-orchestrator", "Incorrect test diagnosis requires human review", {
+      storyId: ctx.storyId,
+      findingCount: initialFindings.length
+    });
+    return { terminalReviewRequired: true, unfixedFindings: initialFindings };
+  }
   if (!ctx.storyId) {
     return {};
   }
   const storyFixBudgetEnabled = !nbfPath && ctx.runtime.configLoader.current().execution?.rectification?.storyScopedFixBudget === true;
   const store = ctx.runtime.storyFixHistory;
-  const fixKey = storyFixBudgetEnabled ? storyFixKey(ctx.storyId, ctx.phaseTelemetry?.tier) : undefined;
+  const fixKey = storyFixBudgetEnabled ? storyFixKey(ctx.storyId, ctx.phaseTelemetry?.tier, ctx.agentName) : undefined;
   const fixState = fixKey !== undefined && store ? getStoryFixState(store, fixKey) : undefined;
   const priorIterationCount = fixState?.iterations.length ?? 0;
   const declineSnapshot = fixState ? new Map([...fixState.declines].map(([name, keys]) => [name, new Set(keys)])) : undefined;
@@ -62570,7 +62763,7 @@ class ExecutionPlan {
     const rectResult = await runRectification(this.ctx, this.state, phaseCosts, phaseOutputs, {
       gateBaselineKeys: preRectGateFailureKeys
     });
-    if (this.state.rectification && (!rectResult.rectificationExhausted || rectResult.liteScopeIncomplete)) {
+    if (this.state.rectification && !rectResult.terminalReviewRequired && (!rectResult.rectificationExhausted || rectResult.liteScopeIncomplete)) {
       let resumeRectifyUsed = false;
       for (const phase of collectOrderedPhases(this.state)) {
         const name = phase.slot.op.name;
@@ -63342,6 +63535,8 @@ function routeTddFailure(failureCategory, isLiteMode, ctx, reviewReason, failure
       };
     case "dependency-prep":
       return pauseFallback;
+    case "test-incorrect":
+      return pauseFallback;
     default:
       return pauseFallback;
   }
@@ -64220,6 +64415,7 @@ function parseQueueFile(content) {
 var init_queue = () => {};
 
 // src/execution/queue-handler.ts
+import { rename, unlink as unlink3 } from "fs/promises";
 import path15 from "path";
 function getSafeLogger4() {
   try {
@@ -64239,8 +64435,11 @@ async function readQueueFile(workdir) {
       return [];
     }
     try {
-      await Bun.spawn(["mv", queuePath, processingPath], { stdout: "pipe" }).exited;
+      await rename(queuePath, processingPath);
     } catch (error48) {
+      logger?.warn("queue", "Failed to rename queue file for processing", {
+        error: error48.message
+      });
       return [];
     }
     const processingFile = Bun.file(processingPath);
@@ -64261,7 +64460,7 @@ async function clearQueueFile(workdir) {
     const file3 = Bun.file(processingPath);
     const exists = await file3.exists();
     if (exists) {
-      await Bun.spawn(["rm", processingPath], { stdout: "pipe" }).exited;
+      await unlink3(processingPath);
     }
   } catch (error48) {
     logger?.warn("queue", "Failed to clear queue file", {
@@ -64276,6 +64475,20 @@ var init_queue_handler = __esm(() => {
 
 // src/pipeline/stages/queue-check.ts
 import path16 from "path";
+function resolvePrdPath(ctx) {
+  return ctx.featureDir ? `${ctx.featureDir}/prd.json` : `${ctx.workdir}/.nax/features/unknown/prd.json`;
+}
+function logDroppedCommands(logger, ctx, queueCommands, currentIndex) {
+  const dropped = queueCommands.slice(currentIndex + 1);
+  if (dropped.length === 0) {
+    return;
+  }
+  logger.warn("queue", "Dropped unprocessed queue commands", {
+    storyId: ctx.story?.id ?? "unknown",
+    droppedCount: dropped.length,
+    droppedTypes: dropped.map((c) => c.type)
+  });
+}
 var queueCheckStage;
 var init_queue_check = __esm(() => {
   init_config();
@@ -64292,9 +64505,10 @@ var init_queue_check = __esm(() => {
       if (queueCommands.length === 0) {
         return { action: "continue" };
       }
-      for (const cmd of queueCommands) {
+      for (const [index, cmd] of queueCommands.entries()) {
         if (cmd.type === "PAUSE") {
           logger.warn("queue", "Paused by user", { storyId: ctx.story?.id ?? "unknown", command: "PAUSE" });
+          logDroppedCommands(logger, ctx, queueCommands, index);
           await clearQueueFile(ctx.workdir);
           return { action: "pause", reason: "User requested pause via .queue.txt" };
         }
@@ -64305,16 +64519,15 @@ var init_queue_check = __esm(() => {
               markStorySkipped(ctx.prd, s.id);
             }
           }
-          const prdPath = ctx.featureDir ? `${ctx.featureDir}/prd.json` : `${ctx.workdir}/nax/features/unknown/prd.json`;
-          await savePRD(ctx.prd, prdPath);
+          await savePRD(ctx.prd, resolvePrdPath(ctx));
+          logDroppedCommands(logger, ctx, queueCommands, index);
           await clearQueueFile(ctx.workdir);
           return { action: "pause", reason: "User requested abort" };
         }
         if (cmd.type === "RETRY") {
           logger.warn("queue", "Retrying story by user request", { storyId: cmd.storyId });
           resetStoryToPending(ctx.prd, cmd.storyId);
-          const prdPath = ctx.featureDir ? `${ctx.featureDir}/prd.json` : `${ctx.workdir}/nax/features/unknown/prd.json`;
-          await savePRD(ctx.prd, prdPath);
+          await savePRD(ctx.prd, resolvePrdPath(ctx));
           continue;
         }
         if (cmd.type === "PRIORITY") {
@@ -64323,8 +64536,7 @@ var init_queue_check = __esm(() => {
             priority: cmd.value
           });
           setStoryPriority(ctx.prd, cmd.storyId, cmd.value);
-          const prdPath = ctx.featureDir ? `${ctx.featureDir}/prd.json` : `${ctx.workdir}/nax/features/unknown/prd.json`;
-          await savePRD(ctx.prd, prdPath);
+          await savePRD(ctx.prd, resolvePrdPath(ctx));
           continue;
         }
         if (cmd.type === "INJECT") {
@@ -64342,8 +64554,7 @@ var init_queue_check = __esm(() => {
               injectedStoryId: story.id,
               storyFile: cmd.storyFile
             });
-            const prdPath = ctx.featureDir ? `${ctx.featureDir}/prd.json` : `${ctx.workdir}/nax/features/unknown/prd.json`;
-            await savePRD(ctx.prd, prdPath);
+            await savePRD(ctx.prd, resolvePrdPath(ctx));
           } catch (err) {
             logger.error("queue", "Failed to inject story \u2014 skipping INJECT command", {
               storyId: ctx.story?.id ?? "unknown",
@@ -64354,16 +64565,19 @@ var init_queue_check = __esm(() => {
           continue;
         }
         if (cmd.type === "SKIP") {
-          const isTargeted = ctx.stories.some((s) => s.id === cmd.storyId);
-          if (isTargeted) {
-            logger.warn("queue", "Skipping story by user request", {
+          if (markStorySkipped(ctx.prd, cmd.storyId)) {
+            logger.warn("queue", "Skipping story by user request", { storyId: cmd.storyId });
+            await savePRD(ctx.prd, resolvePrdPath(ctx));
+          } else {
+            logger.warn("queue", "SKIP names a story that is not in the PRD \u2014 ignoring", {
               storyId: cmd.storyId
             });
-            markStorySkipped(ctx.prd, cmd.storyId);
-            const prdPath = ctx.featureDir ? `${ctx.featureDir}/prd.json` : `${ctx.workdir}/nax/features/unknown/prd.json`;
-            await savePRD(ctx.prd, prdPath);
+          }
+          const isTargeted = ctx.stories.some((s) => s.id === cmd.storyId);
+          if (isTargeted) {
             ctx.stories = ctx.stories.filter((s) => s.id !== cmd.storyId);
             if (ctx.stories.length === 0) {
+              logDroppedCommands(logger, ctx, queueCommands, index);
               await clearQueueFile(ctx.workdir);
               return { action: "skip", reason: "All stories in batch were skipped" };
             }
@@ -64409,7 +64623,7 @@ var init_routing2 = __esm(() => {
           candidateTier
         });
       }
-      const isEscalated = previousTier !== undefined && (previousRank !== undefined && candidateRank !== undefined ? previousRank > candidateRank : hasEscalationRecords);
+      const isEscalated = previousTier !== undefined && (hasEscalationRecords || previousRank !== undefined && candidateRank !== undefined && previousRank > candidateRank);
       const modelTier = isEscalated ? previousTier : candidateTier;
       const routing = { ...decision, modelTier, agent: ctx.story.routing?.agent ?? decision.agent };
       const neverEscalated = !hasEscalationRecords;
@@ -69779,7 +69993,7 @@ var init_writer = __esm(() => {
 });
 
 // src/execution/checkpoint/reader.ts
-import { join as join85 } from "path";
+import { join as join86 } from "path";
 function isValidRecord(value) {
   if (!value || typeof value !== "object")
     return false;
@@ -69812,7 +70026,7 @@ async function defaultRead(filePath) {
   return file3.text();
 }
 async function loadCheckpoints(featureDir, options = { _deps: { read: defaultRead } }) {
-  const filePath = join85(featureDir, "checkpoint.jsonl");
+  const filePath = join86(featureDir, "checkpoint.jsonl");
   const deps = options._deps ?? { read: defaultRead };
   let content;
   try {
@@ -69882,7 +70096,7 @@ var init_reader = __esm(() => {
 });
 
 // src/execution/checkpoint/resume-cli.ts
-import { join as join86 } from "path";
+import { join as join87 } from "path";
 function applyResumeModeDeps(featureDir, mode = "auto") {
   if (mode === "fresh" || mode === "no-resume") {
     _storyOrchestratorDeps.loadCheckpoints = async (_fd) => new Map;
@@ -69892,7 +70106,7 @@ function applyResumeModeDeps(featureDir, mode = "auto") {
   _storyOrchestratorDeps.loadCheckpoints = async (_fd) => loadCheckpoints(target);
 }
 function applyRecordGreenDeps(featureDir, runId) {
-  const writer = createCheckpointWriter(join86(featureDir, "checkpoint.jsonl"), runId);
+  const writer = createCheckpointWriter(join87(featureDir, "checkpoint.jsonl"), runId);
   _storyOrchestratorDeps.recordGreen = (storyId, phase, tree) => writer.recordGreen(storyId, phase, tree);
 }
 var init_resume_cli = __esm(() => {
@@ -69941,11 +70155,11 @@ var init_types10 = __esm(() => {
 });
 
 // src/hooks/runner.ts
-import { join as join87 } from "path";
+import { join as join88 } from "path";
 function createDrainDeadline2(deadlineMs) {
   let timeoutId;
-  const promise2 = new Promise((resolve20) => {
-    timeoutId = setTimeout(() => resolve20(""), deadlineMs);
+  const promise2 = new Promise((resolve21) => {
+    timeoutId = setTimeout(() => resolve21(""), deadlineMs);
   });
   return {
     promise: promise2,
@@ -69960,14 +70174,14 @@ async function loadHooksConfig(projectDir, globalDir) {
   let globalHooks = { hooks: {} };
   let projectHooks = { hooks: {} };
   let skipGlobal = false;
-  const projectPath = join87(projectDir, "hooks.json");
+  const projectPath = join88(projectDir, "hooks.json");
   const projectData = await loadJsonFile(projectPath, "hooks");
   if (projectData) {
     projectHooks = projectData;
     skipGlobal = projectData.skipGlobal ?? false;
   }
   if (!skipGlobal && globalDir) {
-    const globalPath = join87(globalDir, "hooks.json");
+    const globalPath = join88(globalDir, "hooks.json");
     const globalData = await loadJsonFile(globalPath, "hooks");
     if (globalData) {
       globalHooks = globalData;
@@ -70483,7 +70697,7 @@ var init_crash_recovery = __esm(() => {
 });
 
 // src/acceptance/import-resolution.ts
-import { resolve as resolve20, sep as sep8 } from "path";
+import { resolve as resolve21, sep as sep9 } from "path";
 function languageFromExtension(testFilePath) {
   if (!testFilePath)
     return;
@@ -70505,9 +70719,9 @@ async function resolveLanguage(opts) {
   return "typescript";
 }
 async function readCapped(relPath, packageDir) {
-  const resolvedPackageDir = resolve20(packageDir);
-  const fullPath = resolve20(resolvedPackageDir, relPath);
-  if (fullPath !== resolvedPackageDir && !fullPath.startsWith(resolvedPackageDir + sep8)) {
+  const resolvedPackageDir = resolve21(packageDir);
+  const fullPath = resolve21(resolvedPackageDir, relPath);
+  if (fullPath !== resolvedPackageDir && !fullPath.startsWith(resolvedPackageDir + sep9)) {
     return null;
   }
   try {
@@ -70754,12 +70968,12 @@ async function regenerateAcceptanceTest(testPath, acceptanceContext) {
   const content = await Bun.file(testPath).text();
   await Bun.write(bakPath, content);
   logger?.info("acceptance", `Backed up acceptance test -> ${bakPath}`);
-  const { unlink: unlink3 } = await import("fs/promises");
-  await unlink3(testPath);
+  const { unlink: unlink4 } = await import("fs/promises");
+  await unlink4(testPath);
   if (acceptanceContext.featureDir) {
     const metaPath = path25.join(acceptanceContext.featureDir, "acceptance-meta.json");
     try {
-      await unlink3(metaPath);
+      await unlink4(metaPath);
     } catch {}
   }
   let implementationContext;
@@ -71226,16 +71440,16 @@ var init_acceptance_loop = __esm(() => {
 });
 
 // src/session/scratch-purge.ts
-import { mkdir as mkdir12, rename, rm } from "fs/promises";
-import { dirname as dirname15, join as join88 } from "path";
+import { mkdir as mkdir12, rename as rename2, rm } from "fs/promises";
+import { dirname as dirname15, join as join89 } from "path";
 async function purgeStaleScratch(projectDir, featureName, retentionDays, archiveInsteadOfDelete = false) {
-  const sessionsDir = join88(projectDir, ".nax", "features", featureName, "sessions");
+  const sessionsDir = join89(projectDir, ".nax", "features", featureName, "sessions");
   const sessionIds = await _scratchPurgeDeps.listSessionDirs(sessionsDir);
   const cutoffMs = _scratchPurgeDeps.now() - retentionDays * 86400000;
   let purged = 0;
   for (const sessionId of sessionIds) {
-    const sessionDir = join88(sessionsDir, sessionId);
-    const descriptorPath = join88(sessionDir, "descriptor.json");
+    const sessionDir = join89(sessionsDir, sessionId);
+    const descriptorPath = join89(sessionDir, "descriptor.json");
     if (!await _scratchPurgeDeps.fileExists(descriptorPath))
       continue;
     let lastActivityAt;
@@ -71251,7 +71465,7 @@ async function purgeStaleScratch(projectDir, featureName, retentionDays, archive
     if (new Date(lastActivityAt).getTime() >= cutoffMs)
       continue;
     if (archiveInsteadOfDelete) {
-      const archiveDest = join88(projectDir, ".nax", "features", featureName, "_archive", "sessions", sessionId);
+      const archiveDest = join89(projectDir, ".nax", "features", featureName, "_archive", "sessions", sessionId);
       await _scratchPurgeDeps.move(sessionDir, archiveDest);
     } else {
       await _scratchPurgeDeps.remove(sessionDir);
@@ -71279,7 +71493,7 @@ var init_scratch_purge = __esm(() => {
     remove: (path26) => rm(path26, { recursive: true, force: true }),
     move: async (src, dest) => {
       await mkdir12(dirname15(dest), { recursive: true });
-      await rename(src, dest);
+      await rename2(src, dest);
     },
     now: () => Date.now()
   };
@@ -71432,18 +71646,6 @@ ${rawOutput.slice(0, SYNTHETIC_FINDING_OUTPUT_LIMIT)}`,
     }
   ];
 }
-async function findResponsibleStory(testFile, workdir, passedStories) {
-  const logger = getSafeLogger();
-  for (let i = passedStories.length - 1;i >= 0; i--) {
-    const story = passedStories[i];
-    const hasCommits = await hasCommitsForStory(workdir, story.id, 50);
-    if (hasCommits) {
-      logger?.info("regression", `Mapped test to story ${story.id}`, { testFile });
-      return story;
-    }
-  }
-  return;
-}
 function findResponsibleStoryByTransition(testFile, snapshots) {
   const ordered = [...snapshots].sort((a, b) => a.completedAt.localeCompare(b.completedAt) || a.storyId.localeCompare(b.storyId));
   for (const snap of ordered) {
@@ -71587,32 +71789,25 @@ async function runDeferredRegression(options) {
   const affectedStoriesObjs = new Map;
   if (testFilesInFailures.size === 0) {
     logger?.warn("regression", "No test files found in failures (unmapped)");
-    for (const story of passedStories) {
-      affectedStories.add(story.id);
-      affectedStoriesObjs.set(story.id, story);
-    }
   } else {
     const testFilesArray = Array.from(testFilesInFailures);
     const snapshots = options.storyMetrics ?? [];
     const passedById = new Map(passedStories.map((s) => [s.id, s]));
     for (const testFile of testFilesArray) {
-      let responsibleStory;
       const transitionId = findResponsibleStoryByTransition(testFile, snapshots);
-      if (transitionId && passedById.has(transitionId)) {
-        responsibleStory = passedById.get(transitionId);
+      const responsibleStory = transitionId ? passedById.get(transitionId) : undefined;
+      if (responsibleStory) {
         logger?.info("regression", "Mapped test to story via gate transition", {
           storyId: transitionId,
           testFile
         });
-      }
-      if (!responsibleStory) {
-        responsibleStory = await findResponsibleStory(testFile, workdir, passedStories);
-      }
-      if (responsibleStory) {
         affectedStories.add(responsibleStory.id);
         affectedStoriesObjs.set(responsibleStory.id, responsibleStory);
       } else {
-        logger?.warn("regression", "Could not map test file to story", { testFile });
+        logger?.warn("regression", "Could not safely map test file to a passed story", {
+          testFile,
+          ...transitionId ? { transitionStoryId: transitionId } : {}
+        });
       }
     }
   }
@@ -71756,7 +71951,6 @@ var init_run_regression = __esm(() => {
   init_pipeline();
   init_prd();
   init_test_runners();
-  init_git();
   init_verification();
   init_run_regression_triage();
   _regressionDeps = {
@@ -72316,7 +72510,8 @@ async function runCompletionPhase(options) {
     deferredReviewStartedAt: options.deferredReviewStartedAt,
     exitReason: options.exitReason,
     runtime: options.runtime,
-    abortSignal: options.abortSignal
+    abortSignal: options.abortSignal,
+    isSequential: options.parallel === undefined
   });
   const { durationMs, runCompletedAt, finalCounts, reportedTotal, pluginGateFailed } = completionResult;
   if (options.featureDir) {
@@ -72528,12 +72723,12 @@ var init_ensure_package_dirs = __esm(() => {
 
 // src/pipeline/subscribers/events-writer.ts
 import { appendFile as appendFile5, mkdir as mkdir13 } from "fs/promises";
-import { basename as basename17, join as join89 } from "path";
+import { basename as basename17, join as join90 } from "path";
 function wireEventsWriter(bus, feature, runId, workdir) {
   const logger = getSafeLogger();
   const project = basename17(workdir);
-  const eventsDir = join89(getEventsRootDir(), project);
-  const eventsFile = join89(eventsDir, "events.jsonl");
+  const eventsDir = join90(getEventsRootDir(), project);
+  const eventsFile = join90(eventsDir, "events.jsonl");
   let dirReady = false;
   const write = (line) => {
     return (async () => {
@@ -72714,12 +72909,12 @@ var init_interaction2 = __esm(() => {
 
 // src/pipeline/subscribers/registry.ts
 import { mkdir as mkdir14, writeFile as writeFile2 } from "fs/promises";
-import { basename as basename18, join as join90 } from "path";
+import { basename as basename18, join as join91 } from "path";
 function wireRegistry(bus, feature, runId, workdir, outputDir) {
   const logger = getSafeLogger();
   const project = basename18(workdir);
-  const runDir = join90(getRunsDir(), `${project}-${feature}-${runId}`);
-  const metaFile = join90(runDir, "meta.json");
+  const runDir = join91(getRunsDir(), `${project}-${feature}-${runId}`);
+  const metaFile = join91(runDir, "meta.json");
   const unsub = bus.on("run:started", (_ev) => {
     return (async () => {
       try {
@@ -72729,8 +72924,8 @@ function wireRegistry(bus, feature, runId, workdir, outputDir) {
           project,
           feature,
           workdir,
-          statusPath: join90(outputDir, "features", feature, "status.json"),
-          eventsDir: join90(outputDir, "features", feature, "runs"),
+          statusPath: join91(outputDir, "features", feature, "status.json"),
+          eventsDir: join91(outputDir, "features", feature, "runs"),
           registeredAt: new Date().toISOString()
         };
         await writeFile2(metaFile, JSON.stringify(meta3, null, 2));
@@ -72851,7 +73046,7 @@ var init_types11 = __esm(() => {
 
 // src/worktree/dependencies.ts
 import { existsSync as existsSync33 } from "fs";
-import { join as join91 } from "path";
+import { join as join92 } from "path";
 async function prepareWorktreeDependencies(options) {
   const mode = options.config.execution.worktreeDependencies.mode;
   const resolvedCwd = resolveDependencyCwd(options);
@@ -72865,7 +73060,7 @@ async function prepareWorktreeDependencies(options) {
   }
 }
 function resolveDependencyCwd(options) {
-  return options.storyWorkdir ? join91(options.worktreeRoot, options.storyWorkdir) : options.worktreeRoot;
+  return options.storyWorkdir ? join92(options.worktreeRoot, options.storyWorkdir) : options.worktreeRoot;
 }
 function resolveInheritedDependencies(options, resolvedCwd) {
   if (hasDependencyManifests(options.worktreeRoot, resolvedCwd)) {
@@ -72875,7 +73070,7 @@ function resolveInheritedDependencies(options, resolvedCwd) {
 }
 function hasDependencyManifests(worktreeRoot, resolvedCwd) {
   const directories = resolvedCwd === worktreeRoot ? [worktreeRoot] : [worktreeRoot, resolvedCwd];
-  return directories.some((directory) => PHASE_ONE_INHERIT_UNSUPPORTED_FILES.some((filename) => _worktreeDependencyDeps.existsSync(join91(directory, filename))));
+  return directories.some((directory) => PHASE_ONE_INHERIT_UNSUPPORTED_FILES.some((filename) => _worktreeDependencyDeps.existsSync(join92(directory, filename))));
 }
 async function provisionDependencies(config2, worktreeRoot, resolvedCwd) {
   const setupCommand2 = config2.execution.worktreeDependencies.setupCommand;
@@ -72932,20 +73127,15 @@ var init_dependencies = __esm(() => {
 });
 
 // src/worktree/manager.ts
-var exports_manager = {};
-__export(exports_manager, {
-  _managerDeps: () => _managerDeps,
-  WorktreeManager: () => WorktreeManager
-});
 import { existsSync as existsSync34, symlinkSync } from "fs";
 import { mkdir as mkdir15 } from "fs/promises";
-import { join as join92 } from "path";
+import { join as join93 } from "path";
 
 class WorktreeManager {
   async ensureGitExcludes(projectRoot) {
     const logger = getSafeLogger();
-    const infoDir = join92(projectRoot, ".git", "info");
-    const excludePath = join92(infoDir, "exclude");
+    const infoDir = join93(projectRoot, ".git", "info");
+    const excludePath = join93(infoDir, "exclude");
     try {
       await mkdir15(infoDir, { recursive: true });
       let existing = "";
@@ -72972,7 +73162,7 @@ ${missing.join(`
   }
   async create(projectRoot, storyId) {
     validateStoryId(storyId);
-    const worktreePath = join92(projectRoot, ".nax-wt", storyId);
+    const worktreePath = join93(projectRoot, ".nax-wt", storyId);
     const branchName = `nax/${storyId}`;
     try {
       const pruneProc = _managerDeps.spawn(["git", "worktree", "prune"], {
@@ -73033,9 +73223,9 @@ ${missing.join(`
         projectRoot
       });
     }
-    const envSource = join92(projectRoot, ".env");
+    const envSource = join93(projectRoot, ".env");
     if (existsSync34(envSource)) {
-      const envTarget = join92(worktreePath, ".env");
+      const envTarget = join93(worktreePath, ".env");
       try {
         symlinkSync(envSource, envTarget, "file");
       } catch (error48) {
@@ -73051,7 +73241,7 @@ ${missing.join(`
   }
   async remove(projectRoot, storyId) {
     validateStoryId(storyId);
-    const worktreePath = join92(projectRoot, ".nax-wt", storyId);
+    const worktreePath = join93(projectRoot, ".nax-wt", storyId);
     const branchName = `nax/${storyId}`;
     try {
       const proc = _managerDeps.spawn(["git", "worktree", "remove", worktreePath, "--force"], {
@@ -73222,20 +73412,30 @@ var init_dry_run = __esm(() => {
 });
 
 // src/worktree/merge.ts
-var exports_merge = {};
-__export(exports_merge, {
-  _mergeDeps: () => _mergeDeps,
-  MergeEngine: () => MergeEngine
-});
-
 class MergeEngine {
   worktreeManager;
   constructor(worktreeManager) {
     this.worktreeManager = worktreeManager;
   }
+  async isMidMerge(projectRoot) {
+    const proc = _mergeDeps.spawn(["git", "rev-parse", "-q", "--verify", "MERGE_HEAD"], {
+      cwd: projectRoot,
+      stdout: "pipe",
+      stderr: "pipe"
+    });
+    return await proc.exited === 0;
+  }
   async merge(projectRoot, storyId) {
     const branchName = `nax/${storyId}`;
     try {
+      if (await this.isMidMerge(projectRoot)) {
+        const error48 = `Repository has an unresolved merge in progress; refusing to merge ${branchName}`;
+        getSafeLogger()?.error("worktree", "Refusing to merge into a mid-merge repository", {
+          storyId,
+          projectRoot
+        });
+        return { success: false, failureKind: "error", error: error48 };
+      }
       const mergeProc = _mergeDeps.spawn(["git", "merge", "--no-ff", branchName, "-m", `Merge branch '${branchName}'`], {
         cwd: projectRoot,
         stdout: "pipe",
@@ -73257,24 +73457,38 @@ class MergeEngine {
         }
         return { success: true };
       }
-      const output = `${stdout}
-${stderr}`;
-      if (output.includes("CONFLICT") || output.includes("conflict") || output.includes("Automatic merge failed")) {
-        const conflictFiles = await this.getConflictFiles(projectRoot);
-        await this.abortMerge(projectRoot);
-        return {
-          success: false,
-          conflictFiles
-        };
-      }
-      throw new Error(`Merge failed: ${stderr || stdout || "unknown error"}`);
+      return await this.classifyMergeFailure(projectRoot, storyId, `${stdout}
+${stderr}`);
     } catch (error48) {
-      if (error48 instanceof Error) {
-        throw error48;
-      }
-      throw new Error(`Failed to merge branch ${branchName}: ${String(error48)}`);
+      getSafeLogger()?.error("worktree", "Merge failed before git could report", {
+        storyId,
+        error: errorMessage(error48)
+      });
+      return { success: false, failureKind: "error", error: errorMessage(error48) };
     }
   }
+  async classifyMergeFailure(projectRoot, storyId, output) {
+    const logger = getSafeLogger();
+    const conflictFiles = await this.getConflictFiles(projectRoot);
+    const midMerge = await this.isMidMerge(projectRoot);
+    if (!midMerge && conflictFiles.length === 0) {
+      const error48 = output.trim() || "unknown error";
+      logger?.error("worktree", "Merge failed for a non-conflict reason", {
+        storyId,
+        error: error48
+      });
+      return { success: false, failureKind: "error", error: error48 };
+    }
+    if (!await this.abortMerge(projectRoot)) {
+      const error48 = `Merge conflict in ${storyId} could not be aborted; repository left mid-merge`;
+      logger?.error("worktree", "git merge --abort failed \u2014 repository left mid-merge", {
+        storyId,
+        conflictFiles
+      });
+      return { success: false, failureKind: "error", conflictFiles, error: error48 };
+    }
+    return { success: false, failureKind: "conflict", conflictFiles };
+  }
   async mergeAll(projectRoot, storyIds, dependencies) {
     const orderedStories = this.topologicalSort(storyIds, dependencies);
     const results = [];
@@ -73286,13 +73500,15 @@ ${stderr}`;
         results.push({
           success: false,
           storyId,
-          conflictFiles: []
+          conflictFiles: [],
+          failureKind: "error",
+          error: `Skipped: depends on a story that failed to merge (${deps.filter((d) => failedStories.has(d)).join(", ")})`
         });
         failedStories.add(storyId);
         continue;
       }
       let result = await this.merge(projectRoot, storyId);
-      if (!result.success && result.conflictFiles) {
+      if (result.failureKind === "conflict") {
         try {
           await this.rebaseWorktree(projectRoot, storyId);
           result = await this.merge(projectRoot, storyId);
@@ -73301,7 +73517,9 @@ ${stderr}`;
               success: false,
               storyId,
               conflictFiles: result.conflictFiles,
-              retryCount: 1
+              retryCount: 1,
+              failureKind: result.failureKind ?? "error",
+              error: result.error
             });
             failedStories.add(storyId);
             continue;
@@ -73316,7 +73534,9 @@ ${stderr}`;
             success: false,
             storyId,
             conflictFiles: result.conflictFiles,
-            retryCount: 1
+            retryCount: 1,
+            failureKind: "error",
+            error: errorMessage(error48)
           });
           failedStories.add(storyId);
         }
@@ -73330,7 +73550,9 @@ ${stderr}`;
         results.push({
           success: false,
           storyId,
-          retryCount: 0
+          retryCount: 0,
+          failureKind: result.failureKind ?? "error",
+          error: result.error
         });
         failedStories.add(storyId);
       }
@@ -73430,12 +73652,20 @@ ${stderr}`;
         stdout: "pipe",
         stderr: "pipe"
       });
-      await proc.exited;
+      const [exitCode, stderr] = await Promise.all([proc.exited, new Response(proc.stderr).text()]);
+      if (exitCode !== 0) {
+        getSafeLogger()?.error("worktree", "Failed to abort merge", {
+          exitCode,
+          stderr: stderr.trim()
+        });
+        return false;
+      }
+      return true;
     } catch (error48) {
-      const logger = getSafeLogger();
-      logger?.warn("worktree", "Failed to abort merge", {
+      getSafeLogger()?.error("worktree", "Failed to abort merge", {
         error: errorMessage(error48)
       });
+      return false;
     }
   }
 }
@@ -73448,6 +73678,21 @@ var init_merge = __esm(() => {
   };
 });
 
+// src/worktree/index.ts
+var exports_worktree = {};
+__export(exports_worktree, {
+  prepareWorktreeDependencies: () => prepareWorktreeDependencies,
+  _mergeDeps: () => _mergeDeps,
+  WorktreeManager: () => WorktreeManager,
+  WorktreeDependencyPreparationError: () => WorktreeDependencyPreparationError,
+  MergeEngine: () => MergeEngine
+});
+var init_worktree = __esm(() => {
+  init_manager3();
+  init_merge();
+  init_dependencies();
+});
+
 // src/execution/escalation/escalation.ts
 function escalateTier(currentRung, tierOrder) {
   const i = currentRung.agent !== undefined ? tierOrder.findIndex((t) => t.tier === currentRung.tier && t.agent === currentRung.agent) : tierOrder.findIndex((t) => t.tier === currentRung.tier);
@@ -73659,6 +73904,7 @@ function resolveMaxAttemptsOutcome(failureCategory) {
     case "verifier-rejected":
     case "greenfield-no-tests":
     case "no-tests-authored":
+    case "test-incorrect":
       return "pause";
     case "runtime-crash":
       return "pause";
@@ -73809,6 +74055,7 @@ var init_escalation = __esm(() => {
 // src/execution/merge-conflict-rectify.ts
 var exports_merge_conflict_rectify = {};
 __export(exports_merge_conflict_rectify, {
+  rectifyMergeFailure: () => rectifyMergeFailure,
   rectifyConflictedStory: () => rectifyConflictedStory
 });
 import path28 from "path";
@@ -73822,13 +74069,22 @@ async function closeStaleAcpSession(worktreePath, sessionName) {
     await proc.exited;
   } catch {}
 }
+function rectifyMergeFailure(storyId, cost, mergeResult) {
+  return {
+    success: false,
+    storyId,
+    cost,
+    finalConflict: mergeResult?.failureKind !== "error",
+    conflictFiles: mergeResult?.conflictFiles ?? []
+  };
+}
 async function rectifyConflictedStory(options) {
   const { storyId, workdir, config: config2, hooks, pluginRegistry, prd, eventEmitter, agentGetFn } = options;
   const logger = getSafeLogger();
   logger?.info("parallel", "Rectifying story on updated base", { storyId, attempt: "rectification" });
   try {
-    const { WorktreeManager: WorktreeManager2 } = await Promise.resolve().then(() => (init_manager3(), exports_manager));
-    const { MergeEngine: MergeEngine2 } = await Promise.resolve().then(() => (init_merge(), exports_merge));
+    const { WorktreeManager: WorktreeManager2 } = await Promise.resolve().then(() => (init_worktree(), exports_worktree));
+    const { MergeEngine: MergeEngine2 } = await Promise.resolve().then(() => (init_worktree(), exports_worktree));
     const { runPipeline: runPipeline2 } = await Promise.resolve().then(() => (init_runner4(), exports_runner));
     const { defaultPipeline: defaultPipeline2 } = await Promise.resolve().then(() => (init_stages(), exports_stages));
     const { routeTask: routeTask2 } = await Promise.resolve().then(() => (init_routing(), exports_routing));
@@ -73880,9 +74136,12 @@ async function rectifyConflictedStory(options) {
     const mergeResults2 = await mergeEngine.mergeAll(workdir, [storyId], { [storyId]: [] });
     const mergeResult = mergeResults2[0];
     if (!mergeResult || !mergeResult.success) {
-      const conflictFiles = mergeResult?.conflictFiles ?? [];
-      logger?.info("parallel", "Rectification failed - preserving worktree", { storyId });
-      return { success: false, storyId, cost, finalConflict: true, conflictFiles };
+      logger?.info("parallel", "Rectification failed - preserving worktree", {
+        storyId,
+        failureKind: mergeResult?.failureKind,
+        error: mergeResult?.error
+      });
+      return rectifyMergeFailure(storyId, cost, mergeResult);
     }
     logger?.info("parallel", "Rectification succeeded - story merged", {
       storyId,
@@ -73903,10 +74162,10 @@ var init_merge_conflict_rectify = __esm(() => {
 });
 
 // src/execution/pipeline-result-handler.ts
-import { join as join93 } from "path";
+import { join as join94 } from "path";
 async function removeWorktreeDirectory(projectRoot, storyId) {
   const logger = getSafeLogger();
-  const worktreePath = join93(projectRoot, ".nax-wt", storyId);
+  const worktreePath = join94(projectRoot, ".nax-wt", storyId);
   try {
     const proc = _resultHandlerDeps.spawn(["git", "worktree", "remove", worktreePath, "--force"], {
       cwd: projectRoot,
@@ -73922,6 +74181,23 @@ async function removeWorktreeDirectory(projectRoot, storyId) {
     });
   }
 }
+async function failStoryAfterMerge(ctx, prd, reason) {
+  markStoryFailed(prd, ctx.story.id, undefined, undefined, ctx.statusWriter);
+  await savePRD(prd, ctx.prdPath);
+  if (ctx.featureDir) {
+    await appendProgress(ctx.featureDir, ctx.story.id, "failed", `${ctx.story.title} \u2014 ${reason}`);
+  }
+  pipelineEventBus.emit({
+    type: "story:failed",
+    storyId: ctx.story.id,
+    story: { id: ctx.story.id, title: ctx.story.title, status: ctx.story.status, attempts: ctx.story.attempts },
+    reason,
+    countsTowardEscalation: false,
+    feature: ctx.feature,
+    attempts: ctx.story.attempts,
+    cost: ctx.runtime.costAggregator.byStory()[ctx.story.id]?.totalCostUsd ?? ctx.totalCost
+  });
+}
 function filterOutputFiles(files) {
   const NOISE = [
     /\.test\.(ts|js|tsx|jsx)$/,
@@ -73974,6 +74250,16 @@ async function handlePipelineSuccess(ctx, pipelineResult) {
   if (ctx.config.execution.storyIsolation === "worktree") {
     const story = ctx.story;
     const mergeResult = await _resultHandlerDeps.mergeEngine.merge(ctx.workdir, story.id);
+    if (!mergeResult.success && mergeResult.failureKind === "error") {
+      const reason = `Merge failed for a non-conflict reason: ${mergeResult.error ?? "unknown error"}`;
+      logger?.error("worktree", "Merge failed for a non-conflict reason \u2014 marking story as failed", {
+        storyId: story.id,
+        error: mergeResult.error
+      });
+      await failStoryAfterMerge(ctx, prd, reason);
+      await removeWorktreeDirectory(ctx.workdir, story.id);
+      return { storiesCompletedDelta: 0, costDelta, prd, prdDirty: true };
+    }
     if (!mergeResult.success) {
       const { rectifyConflictedStory: rectifyConflictedStory2 } = await Promise.resolve().then(() => (init_merge_conflict_rectify(), exports_merge_conflict_rectify));
       const rectifyResult = await rectifyConflictedStory2({
@@ -73995,7 +74281,9 @@ async function handlePipelineSuccess(ctx, pipelineResult) {
           storyId: story.id,
           conflictFiles: mergeResult.conflictFiles
         });
-        return { storiesCompletedDelta: 0, costDelta, prd, prdDirty: false };
+        const files = (mergeResult.conflictFiles ?? []).join(", ");
+        await failStoryAfterMerge(ctx, prd, `Merge conflict could not be rectified${files ? ` (${files})` : ""} \u2014 the branch did not land`);
+        return { storiesCompletedDelta: 0, costDelta, prd, prdDirty: true };
       }
     }
     logger?.info("worktree", "Merged story to main", { storyId: story.id });
@@ -74110,8 +74398,7 @@ var init_pipeline_result_handler = __esm(() => {
   init_prd();
   init_bun_deps();
   init_git();
-  init_manager3();
-  init_merge();
+  init_worktree();
   init_escalation();
   init_progress();
   _resultHandlerDeps = {
@@ -74123,7 +74410,7 @@ var init_pipeline_result_handler = __esm(() => {
 
 // src/execution/iteration-runner.ts
 import { existsSync as existsSync35 } from "fs";
-import { join as join94 } from "path";
+import { join as join95 } from "path";
 function releaseHeavyPipelineContext(ctx) {
   ctx.agentResult = undefined;
   ctx.prompt = undefined;
@@ -74162,7 +74449,7 @@ async function runIteration(ctx, prd, selection, iterations, totalCost2, allStor
   const storyStartTime = Date.now();
   let effectiveWorkdir = ctx.workdir;
   if (ctx.config.execution.storyIsolation === "worktree") {
-    const worktreePath = join94(ctx.workdir, ".nax-wt", story.id);
+    const worktreePath = join95(ctx.workdir, ".nax-wt", story.id);
     const worktreeExists = _iterationRunnerDeps.existsSync(worktreePath);
     if (!worktreeExists) {
       await _iterationRunnerDeps.worktreeManager.ensureGitExcludes(ctx.workdir);
@@ -74182,7 +74469,7 @@ async function runIteration(ctx, prd, selection, iterations, totalCost2, allStor
   }
   const accumulatedAttemptCost = (story.priorFailures || []).reduce((sum, f) => sum + (f.cost || 0), 0);
   const profileOverride = profileOverrideFromConfig(ctx.config);
-  const effectiveConfig = story.workdir ? await _iterationRunnerDeps.loadConfigForWorkdir(join94(ctx.workdir, ".nax", "config.json"), story.workdir, profileOverride) : ctx.config;
+  const effectiveConfig = story.workdir ? await _iterationRunnerDeps.loadConfigForWorkdir(join95(ctx.workdir, ".nax", "config.json"), story.workdir, profileOverride) : ctx.config;
   let dependencyContext;
   if (ctx.config.execution.storyIsolation === "worktree") {
     try {
@@ -74209,7 +74496,7 @@ async function runIteration(ctx, prd, selection, iterations, totalCost2, allStor
       };
     }
   }
-  const resolvedWorkdir = dependencyContext?.cwd ? dependencyContext.cwd : ctx.config.execution.storyIsolation === "worktree" ? story.workdir ? join94(effectiveWorkdir, story.workdir) : effectiveWorkdir : story.workdir ? join94(ctx.workdir, story.workdir) : ctx.workdir;
+  const resolvedWorkdir = dependencyContext?.cwd ? dependencyContext.cwd : ctx.config.execution.storyIsolation === "worktree" ? story.workdir ? join95(effectiveWorkdir, story.workdir) : effectiveWorkdir : story.workdir ? join95(ctx.workdir, story.workdir) : ctx.workdir;
   const pipelineContext = {
     config: effectiveConfig,
     rootConfig: ctx.config,
@@ -74408,7 +74695,7 @@ __export(exports_parallel_worker, {
   buildWorktreePipelineContext: () => buildWorktreePipelineContext,
   _parallelWorkerDeps: () => _parallelWorkerDeps
 });
-import { join as join95 } from "path";
+import { join as join96 } from "path";
 function buildWorktreePipelineContext(base, _story) {
   return { ...base, prd: structuredClone(base.prd) };
 }
@@ -74431,7 +74718,7 @@ async function executeStoryInWorktree(story, worktreePath, dependencyContext, co
       story,
       stories: [story],
       projectDir: context.projectDir,
-      workdir: dependencyContext.cwd ?? (story.workdir ? join95(worktreePath, story.workdir) : worktreePath),
+      workdir: dependencyContext.cwd ?? (story.workdir ? join96(worktreePath, story.workdir) : worktreePath),
       worktreeDependencyContext: dependencyContext,
       routing,
       storyGitRef: storyGitRef ?? undefined
@@ -74644,6 +74931,12 @@ async function runParallelBatch(options) {
         logger?.info("parallel-batch", "Story merged successfully", {
           storyId: mergeResult.storyId
         });
+      } else if (mergeResult.failureKind === "error") {
+        workerResult.failed.push({ story, error: mergeResult.error ?? "merge failed" });
+        logger?.error("parallel-batch", "Merge failed for a non-conflict reason", {
+          storyId: mergeResult.storyId,
+          error: mergeResult.error
+        });
       } else {
         workerResult.mergeConflicts.push({
           storyId: mergeResult.storyId,
@@ -74731,11 +75024,11 @@ var init_parallel_batch = __esm(() => {
       return executeParallelBatch2(_stories, _projectRoot, _config, _context, _worktreePaths, _dependencyContexts, _maxConcurrency, _eventEmitter, _storyEffectiveConfigs);
     },
     createWorktreeManager: async () => {
-      const { WorktreeManager: WorktreeManager2 } = await Promise.resolve().then(() => (init_manager3(), exports_manager));
+      const { WorktreeManager: WorktreeManager2 } = await Promise.resolve().then(() => (init_worktree(), exports_worktree));
       return new WorktreeManager2;
     },
     createMergeEngine: async (worktreeManager) => {
-      const { MergeEngine: MergeEngine2 } = await Promise.resolve().then(() => (init_merge(), exports_merge));
+      const { MergeEngine: MergeEngine2 } = await Promise.resolve().then(() => (init_worktree(), exports_worktree));
       return new MergeEngine2(worktreeManager);
     },
     rectifyConflictedStory: async (opts) => {
@@ -75401,8 +75694,8 @@ var init_runner_execution = __esm(() => {
 });
 
 // src/execution/status-file.ts
-import { rename as rename2, unlink as unlink3 } from "fs/promises";
-import { resolve as resolve21 } from "path";
+import { rename as rename3, unlink as unlink4 } from "fs/promises";
+import { resolve as resolve22 } from "path";
 function countProgress(prd) {
   const stories = prd.userStories;
   const passed = stories.filter((s) => s.status === "passed").length;
@@ -75447,21 +75740,21 @@ function buildStatusSnapshot(state) {
   return snapshot;
 }
 async function writeStatusFile(filePath, status) {
-  const resolvedPath = resolve21(filePath);
+  const resolvedPath = resolve22(filePath);
   if (filePath.includes("../") || filePath.includes("..\\")) {
     throw new Error("Invalid status file path: path traversal detected");
   }
   const tmpPath = `${resolvedPath}.tmp`;
   try {
-    await unlink3(tmpPath);
+    await unlink4(tmpPath);
   } catch {}
   await Bun.write(tmpPath, JSON.stringify(status, null, 2));
-  await rename2(tmpPath, resolvedPath);
+  await rename3(tmpPath, resolvedPath);
 }
 var init_status_file = () => {};
 
 // src/execution/status-writer.ts
-import { join as join96 } from "path";
+import { join as join97 } from "path";
 
 class StatusWriter {
   statusFile;
@@ -75580,7 +75873,7 @@ class StatusWriter {
     if (!this._prd)
       return;
     const safeLogger = getSafeLogger();
-    const featureStatusPath = join96(featureDir, "status.json");
+    const featureStatusPath = join97(featureDir, "status.json");
     const write = async () => {
       try {
         const base = this.getSnapshot(totalCost2, iterations);
@@ -75612,7 +75905,7 @@ __export(exports_migrate, {
   detectGeneratedContent: () => detectGeneratedContent
 });
 import { existsSync as existsSync36 } from "fs";
-import { mkdir as mkdir16, readdir as readdir5, rename as rename3 } from "fs/promises";
+import { mkdir as mkdir16, readdir as readdir5, rename as rename4 } from "fs/promises";
 import path30 from "path";
 async function detectGeneratedContent(naxDir) {
   if (!existsSync36(naxDir))
@@ -75701,7 +75994,7 @@ async function migrateCommand(options) {
     const archiveBase = path30.join(globalConfigDir(), "_archive");
     const archiveDest = path30.join(archiveBase, `${options.reclaim}-${Date.now()}`);
     await mkdir16(archiveBase, { recursive: true });
-    await rename3(src, archiveDest);
+    await rename4(src, archiveDest);
     logger.info("migrate", `Reclaimed: archived to ${archiveDest}`, { storyId: "_migrate" });
     return;
   }
@@ -75780,7 +76073,7 @@ async function migrateCommand(options) {
   Remove the destination or run nax migrate --dry-run to inspect.`, "MIGRATE_CONFLICT", { stage: "migrate", src: candidate.srcPath, dest });
     }
     try {
-      await rename3(candidate.srcPath, dest);
+      await rename4(candidate.srcPath, dest);
     } catch (err) {
       const isXdev = err instanceof Error && "code" in err && err.code === "EXDEV";
       if (isXdev) {
@@ -76024,7 +76317,7 @@ __export(exports_run_initialization, {
   initializeRun: () => initializeRun,
   _reconcileDeps: () => _reconcileDeps
 });
-import { join as join97 } from "path";
+import { join as join98 } from "path";
 async function reconcileState(prd, prdPath, workdir, config2) {
   const logger = getSafeLogger();
   let reconciledCount = 0;
@@ -76041,7 +76334,7 @@ async function reconcileState(prd, prdPath, workdir, config2) {
       });
       continue;
     }
-    const effectiveWorkdir = story.workdir ? join97(workdir, story.workdir) : workdir;
+    const effectiveWorkdir = story.workdir ? join98(workdir, story.workdir) : workdir;
     try {
       const reviewResult = await _reconcileDeps.runReview(config2.review, effectiveWorkdir, config2.execution);
       if (!reviewResult.success) {
@@ -76857,6 +77150,7 @@ async function run(options) {
       hooks,
       feature,
       workdir,
+      parallel,
       prdPath,
       statusFile,
       logFilePath,
@@ -77446,14 +77740,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, resolve22, reject) {
+    function recursivelyFlushAsyncActWork(returnValue, resolve23, reject) {
       var queue = ReactSharedInternals.actQueue;
       if (queue !== null)
         if (queue.length !== 0)
           try {
             flushActQueue(queue);
             enqueueTask(function() {
-              return recursivelyFlushAsyncActWork(returnValue, resolve22, reject);
+              return recursivelyFlushAsyncActWork(returnValue, resolve23, reject);
             });
             return;
           } catch (error48) {
@@ -77461,7 +77755,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)) : resolve22(returnValue);
+      0 < ReactSharedInternals.thrownErrors.length ? (queue = aggregateErrors(ReactSharedInternals.thrownErrors), ReactSharedInternals.thrownErrors.length = 0, reject(queue)) : resolve23(returnValue);
     }
     function flushActQueue(queue) {
       if (!isFlushing) {
@@ -77637,14 +77931,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(resolve22, reject) {
+          then: function(resolve23, reject) {
             didAwaitActCall = true;
             thenable.then(function(returnValue) {
               popActScope(prevActQueue, prevActScopeDepth);
               if (prevActScopeDepth === 0) {
                 try {
                   flushActQueue(queue), enqueueTask(function() {
-                    return recursivelyFlushAsyncActWork(returnValue, resolve22, reject);
+                    return recursivelyFlushAsyncActWork(returnValue, resolve23, reject);
                   });
                 } catch (error$0) {
                   ReactSharedInternals.thrownErrors.push(error$0);
@@ -77655,7 +77949,7 @@ See https://react.dev/link/invalid-hook-call for tips about how to debug and fix
                   reject(_thrownError);
                 }
               } else
-                resolve22(returnValue);
+                resolve23(returnValue);
             }, function(error48) {
               popActScope(prevActQueue, prevActScopeDepth);
               0 < ReactSharedInternals.thrownErrors.length ? (error48 = aggregateErrors(ReactSharedInternals.thrownErrors), ReactSharedInternals.thrownErrors.length = 0, reject(error48)) : reject(error48);
@@ -77671,11 +77965,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(resolve22, reject) {
+        then: function(resolve23, reject) {
           didAwaitActCall = true;
           prevActScopeDepth === 0 ? (ReactSharedInternals.actQueue = queue, enqueueTask(function() {
-            return recursivelyFlushAsyncActWork(returnValue$jscomp$0, resolve22, reject);
-          })) : resolve22(returnValue$jscomp$0);
+            return recursivelyFlushAsyncActWork(returnValue$jscomp$0, resolve23, reject);
+          })) : resolve23(returnValue$jscomp$0);
         }
       };
     };
@@ -80517,8 +80811,8 @@ It can also happen if the client has a browser extension installed which messes
         currentEntangledActionThenable = {
           status: "pending",
           value: undefined,
-          then: function(resolve22) {
-            entangledListeners.push(resolve22);
+          then: function(resolve23) {
+            entangledListeners.push(resolve23);
           }
         };
       }
@@ -80542,8 +80836,8 @@ It can also happen if the client has a browser extension installed which messes
         status: "pending",
         value: null,
         reason: null,
-        then: function(resolve22) {
-          listeners.push(resolve22);
+        then: function(resolve23) {
+          listeners.push(resolve23);
         }
       };
       thenable.then(function() {
@@ -106442,9 +106736,9 @@ var init_ranking = __esm(() => {
 });
 
 // src/bakeoff/coordinator.ts
-import { join as join102 } from "path";
+import { join as join103 } from "path";
 async function persistBakeoffResult(result2, outputDir) {
-  const filePath = join102(outputDir, "bakeoff.json");
+  const filePath = join103(outputDir, "bakeoff.json");
   await Bun.write(filePath, JSON.stringify(result2, null, 2));
 }
 async function runBakeoff(options, deps = {}) {
@@ -106622,7 +106916,7 @@ var init_bakeoff = __esm(() => {
 });
 
 // src/plugins/builtin/curator/rollup-prune.ts
-import { rename as rename4, unlink as unlink4, writeFile as writeFile3 } from "fs/promises";
+import { rename as rename5, unlink as unlink5, writeFile as writeFile3 } from "fs/promises";
 import { appendFile as appendFile6 } from "fs/promises";
 async function scanProjectRunIds(rollupPath, projectKey) {
   const maxTsByRunId = new Map;
@@ -106691,9 +106985,9 @@ async function pruneRollup(input) {
         await flush();
     }
     await flush();
-    await rename4(tmpPath, rollupPath);
+    await rename5(tmpPath, rollupPath);
   } catch (err) {
-    await unlink4(tmpPath).catch(() => {});
+    await unlink5(tmpPath).catch(() => {});
     throw err;
   }
   return result2;
@@ -106714,8 +107008,8 @@ __export(exports_curator, {
   _curatorCmdDeps: () => _curatorCmdDeps
 });
 import { readdirSync as readdirSync9 } from "fs";
-import { unlink as unlink5 } from "fs/promises";
-import { join as join103, resolve as resolve22, sep as sep9 } from "path";
+import { unlink as unlink6 } from "fs/promises";
+import { join as join104, resolve as resolve23, sep as sep10 } from "path";
 function listRunIds(runsDir) {
   try {
     return readdirSync9(runsDir, { withFileTypes: true }).filter((e) => e.isDirectory()).map((e) => e.name).sort();
@@ -106795,7 +107089,7 @@ async function curatorStatus(options) {
   const config2 = await _curatorCmdDeps.loadConfig(resolved.projectDir);
   const projectKey = getProjectKey(config2, resolved.projectDir);
   const outputDir = _curatorCmdDeps.projectOutputDir(projectKey, config2.outputDir);
-  const runsDir = join103(outputDir, "runs");
+  const runsDir = join104(outputDir, "runs");
   const runIds = listRunIds(runsDir);
   let runId;
   if (options.run) {
@@ -106812,8 +107106,8 @@ async function curatorStatus(options) {
     runId = runIds[runIds.length - 1];
   }
   console.log(`Run: ${runId}`);
-  const runDir = join103(runsDir, runId);
-  const observationsPath = join103(runDir, "observations.jsonl");
+  const runDir = join104(runsDir, runId);
+  const observationsPath = join104(runDir, "observations.jsonl");
   const observations = await parseObservations(observationsPath);
   const counts = new Map;
   for (const obs of observations) {
@@ -106823,7 +107117,7 @@ async function curatorStatus(options) {
   for (const [kind, count] of counts.entries()) {
     console.log(`  ${kind}: ${count}`);
   }
-  const proposalsPath = join103(runDir, "curator-proposals.md");
+  const proposalsPath = join104(runDir, "curator-proposals.md");
   const proposalText = await _curatorCmdDeps.readFile(proposalsPath).catch(() => null);
   if (proposalText !== null) {
     console.log("");
@@ -106833,24 +107127,24 @@ async function curatorStatus(options) {
   }
 }
 function resolveCanonicalTargetPath(projectDir, canonicalFile) {
-  const target = resolve22(projectDir, canonicalFile);
-  const root = resolve22(projectDir);
-  if (target !== root && !target.startsWith(root + sep9))
+  const target = resolve23(projectDir, canonicalFile);
+  const root = resolve23(projectDir);
+  if (target !== root && !target.startsWith(root + sep10))
     return null;
-  const relative18 = target.slice(root.length + 1).replaceAll(sep9, "/");
+  const relative18 = target.slice(root.length + 1).replaceAll(sep10, "/");
   return CURATOR_TARGET_SHAPES.some((shape) => shape.test(relative18)) ? target : null;
 }
 function isWithinCanonicalRulesDir(projectDir, targetPath) {
-  const rulesRoot = resolve22(projectDir, CANONICAL_RULES_DIR);
-  return targetPath === rulesRoot || targetPath.startsWith(rulesRoot + sep9);
+  const rulesRoot = resolve23(projectDir, CANONICAL_RULES_DIR);
+  return targetPath === rulesRoot || targetPath.startsWith(rulesRoot + sep10);
 }
 async function curatorCommit(options) {
   const resolved = await _curatorCmdDeps.resolveProject({ dir: options.project });
   const config2 = await _curatorCmdDeps.loadConfig(resolved.projectDir);
   const projectKey = getProjectKey(config2, resolved.projectDir);
   const outputDir = _curatorCmdDeps.projectOutputDir(projectKey, config2.outputDir);
-  const runDir = join103(outputDir, "runs", options.runId);
-  const proposalsPath = join103(runDir, "curator-proposals.md");
+  const runDir = join104(outputDir, "runs", options.runId);
+  const proposalsPath = join104(runDir, "curator-proposals.md");
   const proposalText = await _curatorCmdDeps.readFile(proposalsPath).catch(() => null);
   if (proposalText === null) {
     console.log(`curator-proposals.md not found for run ${options.runId}.`);
@@ -106977,7 +107271,7 @@ async function curatorDryrun(options) {
   const config2 = await _curatorCmdDeps.loadConfig(resolved.projectDir);
   const projectKey = getProjectKey(config2, resolved.projectDir);
   const outputDir = _curatorCmdDeps.projectOutputDir(projectKey, config2.outputDir);
-  const runsDir = join103(outputDir, "runs");
+  const runsDir = join104(outputDir, "runs");
   const runIds = listRunIds(runsDir);
   if (runIds.length === 0) {
     console.log("No runs found.");
@@ -106988,7 +107282,7 @@ async function curatorDryrun(options) {
     console.log(`Run ${options.run} not found in ${runsDir}.`);
     return;
   }
-  const observationsPath = join103(runsDir, runId, "observations.jsonl");
+  const observationsPath = join104(runsDir, runId, "observations.jsonl");
   const observations = await parseObservations(observationsPath);
   const thresholds = getThresholds(config2);
   const proposals = runHeuristics(observations, thresholds);
@@ -107020,12 +107314,12 @@ async function curatorGc(options) {
     dropUnattributed: sweep
   });
   const outputDir = _curatorCmdDeps.projectOutputDir(projectKey, config2.outputDir);
-  const perRunsDir = join103(outputDir, "runs");
+  const perRunsDir = join104(outputDir, "runs");
   for (const runId of uniqueRunIds) {
     if (!keepSet.has(runId)) {
-      const runDir = join103(perRunsDir, runId);
-      await _curatorCmdDeps.removeFile(join103(runDir, "observations.jsonl"));
-      await _curatorCmdDeps.removeFile(join103(runDir, "curator-proposals.md"));
+      const runDir = join104(perRunsDir, runId);
+      await _curatorCmdDeps.removeFile(join104(runDir, "observations.jsonl"));
+      await _curatorCmdDeps.removeFile(join104(runDir, "curator-proposals.md"));
     }
   }
   const droppedRuns = Math.max(0, uniqueRunIds.length - keepSet.size);
@@ -107065,7 +107359,7 @@ var init_curator2 = __esm(() => {
     },
     removeFile: async (p) => {
       try {
-        await unlink5(p);
+        await unlink6(p);
       } catch {}
     },
     openInEditor: async (filePath) => {
@@ -107084,7 +107378,7 @@ var init_curator2 = __esm(() => {
 init_source();
 import { existsSync as existsSync39, mkdirSync as mkdirSync8 } from "fs";
 import { homedir as homedir3 } from "os";
-import { basename as basename21, join as join104 } from "path";
+import { basename as basename21, join as join105 } from "path";
 
 // node_modules/commander/esm.mjs
 var import__ = __toESM(require_commander(), 1);
@@ -108139,12 +108433,7 @@ var FIELD_DESCRIPTIONS = {
   "autoMode.escalation.tierOrder": 'Ordered tier escalation chain with per-tier attempt budgets. Format: [{"tier": "fast", "attempts": 2}, {"tier": "balanced", "attempts": 2}, {"tier": "powerful", "attempts": 1}]. Allows each tier to attempt fixes before escalating to the next.',
   "autoMode.escalation.escalateEntireBatch": "When enabled, escalate all stories in a batch if one fails. When disabled, only the failing story escalates (allows parallel attempts at different tiers).",
   routing: "Model routing strategy configuration",
-  "routing.strategy": "Routing strategy: keyword | llm | manual | adaptive | custom",
-  "routing.customStrategyPath": "Path to custom routing strategy (if strategy=custom)",
-  "routing.adaptive": "Adaptive routing settings",
-  "routing.adaptive.minSamples": "Minimum samples before adaptive routing activates",
-  "routing.adaptive.costThreshold": "Cost threshold for strategy switching (0-1)",
-  "routing.adaptive.fallbackStrategy": "Fallback strategy if adaptive fails",
+  "routing.strategy": "Routing strategy: keyword | llm",
   "routing.llm": "LLM-based routing settings",
   "routing.llm.model": 'Model selector for routing decisions. Accepts a tier string (for example "fast") or an explicit object like { agent: "codex", model: "gpt-5.4" }.',
   "routing.llm.fallbackToKeywords": "Fall back to keyword routing on LLM failure",
@@ -108809,11 +109098,12 @@ init_canonical_loader();
 init_errors();
 init_logger2();
 import { mkdir as mkdir11 } from "fs/promises";
-import { basename as basename15, join as join75, resolve as resolve19, sep as sep7 } from "path";
+import { join as join76, resolve as resolve20, sep as sep8 } from "path";
 
 // src/cli/rules-lint.ts
 init_engine();
 init_canonical_loader();
+init_errors();
 init_logger2();
 init_test_runners();
 import { join as join74 } from "path";
@@ -108894,8 +109184,15 @@ async function rulesLintCommand(options, deps = _rulesLintDeps) {
   }
   let totalRuleFiles = 0;
   let warningCount = 0;
+  const failedRoots = [];
   for (const root of roots) {
-    const rules = await deps.loadCanonicalRules(root);
+    let rules;
+    try {
+      rules = await deps.loadCanonicalRules(root);
+    } catch (err) {
+      failedRoots.push({ root, cause: err });
+      continue;
+    }
     totalRuleFiles += rules.length;
     for (const rule of rules) {
       for (const warning of rule.warnings ?? []) {
@@ -108927,6 +109224,18 @@ async function rulesLintCommand(options, deps = _rulesLintDeps) {
       }
     }
   }
+  if (totalRuleFiles === 0 && failedRoots.length === 0) {
+    warningCount++;
+    logger.warn("rules-lint", "Canonical rules store is empty \u2014 no rule files found across any rule root. Run `nax rules migrate` to seed the store.", { code: "EMPTY_STORE", roots: roots.length });
+  }
+  if (failedRoots.length > 0) {
+    const failedRootPaths = failedRoots.map((f) => f.root);
+    throw new NaxError(`Failed to load canonical rules from ${failedRootPaths.length} rule root(s): ${failedRootPaths.join(", ")}`, "RULES_LINT_ROOT_FAILED", {
+      stage: "rules-lint",
+      failedRoots: failedRootPaths,
+      causes: failedRoots.map((f) => f.cause)
+    });
+  }
   const scopeLabel = roots.length === 1 ? "repo root" : `${roots.length} rule roots`;
   if (warningCount > 0) {
     console.log(`[WARN] Canonical rules lint completed with ${warningCount} warning(s) (${totalRuleFiles} file(s) across ${scopeLabel}).`);
@@ -108934,6 +109243,150 @@ async function rulesLintCommand(options, deps = _rulesLintDeps) {
     console.log(`[OK] Canonical rules lint passed (${totalRuleFiles} file(s) across ${scopeLabel}).`);
   }
 }
+// src/cli/rules-migrate.ts
+init_canonical_loader();
+init_errors();
+import { basename as basename15, join as join75 } from "path";
+
+// src/cli/rules-migrate-plan.ts
+init_errors();
+import { resolve as resolve19, sep as sep7 } from "path";
+async function planMigration(sources, options) {
+  const writes = [];
+  const skips = [];
+  const resolvedTargetDir = resolve19(options.targetDir);
+  for (const source of sources) {
+    const resolvedTargetPath = resolve19(source.targetPath);
+    if (!resolvedTargetPath.startsWith(`${resolvedTargetDir}${sep7}`) && resolvedTargetPath !== resolvedTargetDir) {
+      throw new NaxError(`Migration target escapes ${options.targetDir}: ${source.targetFileName} -> ${source.targetPath}`, "RULES_MIGRATE_TARGET_ESCAPE", { stage: "rules-migrate-plan", targetDir: options.targetDir, entry: source.targetPath });
+    }
+    const exists = await options.fileExists(source.targetPath);
+    if (exists && !options.force) {
+      skips.push(source);
+    } else {
+      writes.push(source);
+    }
+  }
+  return { writes, skips };
+}
+
+// src/cli/rules-migrate.ts
+function neutralizeContent(content) {
+  let result = content;
+  let replacements = 0;
+  for (const rule of NEUTRALITY_RULES) {
+    for (const { pattern, replacement } of rule.neutralizeSteps ?? []) {
+      const matches = [...result.matchAll(pattern)].length;
+      if (matches > 0) {
+        result = result.replace(pattern, replacement);
+        replacements += matches;
+      }
+    }
+  }
+  return { content: result.trim(), replacements };
+}
+function toYamlListLiteral(scalar) {
+  const trimmed = scalar.trim();
+  const unquoted = trimmed.replace(/^"(.*)"$/, "$1").replace(/^'(.*)'$/, "$1");
+  return `[${JSON.stringify(unquoted)}]`;
+}
+function translateLegacyFrontmatter(content) {
+  const fm = /^---(\r?\n)([\s\S]*?)\r?\n---\r?\n/.exec(content);
+  if (!fm?.[2])
+    return { content, translated: false };
+  const eol = fm[1] ?? `
+`;
+  const block = fm[2];
+  if (!/^paths:/m.test(block) || /^appliesTo:/m.test(block))
+    return { content, translated: false };
+  const scalarMatch = /^paths:[ \t]*(\S.*)$/m.exec(block);
+  const isInlineList = scalarMatch?.[1]?.trim().startsWith("[") ?? false;
+  const rewritten = scalarMatch && !isInlineList ? block.replace(/^paths:[ \t]*(\S.*)$/m, `appliesTo: ${toYamlListLiteral(scalarMatch[1])}`) : block.replace(/^paths:/m, "appliesTo:");
+  const head = content.slice(0, fm.index);
+  const tail = content.slice(fm.index + fm[0].length);
+  return { content: `${head}---${eol}${rewritten}${eol}---${eol}${tail}`, translated: true };
+}
+function withReviewNotice(content, replacements) {
+  if (replacements <= 0)
+    return content;
+  const notice = `<!-- NOTE: ${replacements} neutralization(s) applied \u2014 review before committing -->
+
+`;
+  const fm = /^---\r?\n[\s\S]*?\r?\n---\r?\n/.exec(content);
+  if (!fm)
+    return notice + content;
+  return content.slice(0, fm[0].length) + notice + content.slice(fm[0].length).replace(/^(?:\r?\n)+/, "");
+}
+async function collectMigrationSources(workdir) {
+  const sources = [];
+  const rulesDir = join75(workdir, ".claude", "rules");
+  const ruleFiles = _rulesCLIDeps.globInDir(rulesDir);
+  for (const filePath of ruleFiles) {
+    try {
+      const content = await _rulesCLIDeps.readFile(filePath);
+      if (content.trim()) {
+        sources.push({ sourcePath: filePath, targetFileName: basename15(filePath), content });
+      }
+    } catch {}
+  }
+  return sources;
+}
+async function rulesMigrateCommand(options) {
+  const workdir = options.dir ?? process.cwd();
+  const force = options.force ?? false;
+  const dryRun = options.dryRun === true;
+  const sources = await collectMigrationSources(workdir);
+  if (sources.length === 0) {
+    console.log("[WARN] No source files found (checked .claude/rules/*.md). Nothing to migrate.");
+    console.log("[WARN] Root CLAUDE.md is not a migration source. Move the rules you want migrated into .claude/rules/, or author .nax/rules/ directly.");
+    return { written: [], skipped: [] };
+  }
+  const targetDir = join75(workdir, CANONICAL_RULES_DIR);
+  const planEntries = sources.map((source) => ({
+    sourcePath: source.sourcePath,
+    targetFileName: source.targetFileName,
+    targetPath: join75(targetDir, source.targetFileName),
+    content: source.content
+  }));
+  const plan = await planMigration(planEntries, {
+    targetDir,
+    force,
+    fileExists: _rulesCLIDeps.fileExists
+  });
+  if (!dryRun) {
+    try {
+      await _rulesCLIDeps.mkdir(targetDir);
+    } catch (err) {
+      throw new NaxError(`Failed to create ${CANONICAL_RULES_DIR}: ${errorMessage(err)}`, "RULES_MIGRATE_MKDIR_FAILED", { stage: "rules-migrate", targetDir });
+    }
+  }
+  const written = [];
+  const skipped = [];
+  for (const entry of plan.writes) {
+    const { content: scoped2 } = translateLegacyFrontmatter(entry.content);
+    const { content: neutralized, replacements } = neutralizeContent(scoped2);
+    const output = withReviewNotice(neutralized, replacements);
+    if (dryRun) {
+      console.log(`[dry-run] Would write ${entry.targetFileName} from ${entry.sourcePath} (${replacements} replacements)`);
+    } else {
+      await _rulesCLIDeps.writeFile(entry.targetPath, output);
+      console.log(`[OK] ${entry.targetFileName} <- ${entry.sourcePath}${replacements > 0 ? ` (${replacements} replacements)` : ""}`);
+    }
+    written.push(entry.targetFileName);
+  }
+  for (const entry of plan.skips) {
+    console.log(`[skip] ${entry.targetFileName} already exists (use --force to overwrite)`);
+    skipped.push(entry.targetFileName);
+  }
+  console.log(dryRun ? `
+Dry run: ${written.length} file(s) would be written, ${skipped.length} skipped.` : `
+Migration complete: ${written.length} file(s) written, ${skipped.length} skipped.`);
+  if (!dryRun && written.length > 0) {
+    console.log(`Review ${CANONICAL_RULES_DIR}/ before committing. Run \`nax rules export --agent=claude\` to regenerate CLAUDE.md.`);
+  }
+  return { written, skipped };
+}
+
 // src/cli/rules.ts
 var _rulesCLIDeps = {
   readFile: async (path25) => Bun.file(path25).text(),
@@ -108943,7 +109396,7 @@ var _rulesCLIDeps = {
   fileExists: async (path25) => Bun.file(path25).exists(),
   globInDir: (dir) => {
     try {
-      return [...new Bun.Glob("*.md").scanSync({ cwd: dir })].sort().map((f) => join75(dir, f));
+      return [...new Bun.Glob("*.md").scanSync({ cwd: dir })].sort().map((f) => join76(dir, f));
     } catch {
       return [];
     }
@@ -109016,8 +109469,8 @@ async function exportRuleDirectory(input) {
   const drifted = [];
   for (const rule of rules) {
     const rel = rule.path ?? rule.fileName;
-    const target = resolve19(workdir, ruleDir, rel);
-    if (!target.startsWith(`${resolve19(workdir, ruleDir)}${sep7}`)) {
+    const target = resolve20(workdir, ruleDir, rel);
+    if (!target.startsWith(`${resolve20(workdir, ruleDir)}${sep8}`)) {
       throw new NaxError(`Rule path escapes ${ruleDir}: ${rel}`, "RULES_EXPORT_PATH_ESCAPE", {
         stage: "rules-export",
         rule: rel
@@ -109037,9 +109490,9 @@ async function exportRuleDirectory(input) {
     }
     await _rulesCLIDeps.writeFile(target, content);
   }
-  const expected = new Set(rules.map((r) => resolve19(workdir, ruleDir, r.path ?? r.fileName)));
-  for (const existing of _rulesCLIDeps.globInDir(join75(workdir, ruleDir))) {
-    if (!expected.has(resolve19(existing))) {
+  const expected = new Set(rules.map((r) => resolve20(workdir, ruleDir, r.path ?? r.fileName)));
+  for (const existing of _rulesCLIDeps.globInDir(join76(workdir, ruleDir))) {
+    if (!expected.has(resolve20(existing))) {
       _rulesCLIDeps.getLogger().warn("rules-export", "Generated rules dir contains a file with no canonical source", {
         file: existing,
         hint: `Delete it, or add the rule to ${CANONICAL_RULES_DIR}/`
@@ -109094,7 +109547,7 @@ ${r.content}`).join(`
 `);
   const shimContent = `${header + body}
 `;
-  const shimPath = join75(workdir, shimFileName);
+  const shimPath = join76(workdir, shimFileName);
   if (options.dryRun) {
     console.log(`[dry-run] Would write ${shimPath} (${shimContent.length} bytes)`);
     return;
@@ -109102,117 +109555,6 @@ ${r.content}`).join(`
   await _rulesCLIDeps.writeFile(shimPath, shimContent);
   console.log(`[OK] Wrote ${shimFileName} (${rules.length} rule file(s) from ${CANONICAL_RULES_DIR}/)`);
 }
-function neutralizeContent(content) {
-  let result = content;
-  let replacements = 0;
-  for (const rule of NEUTRALITY_RULES) {
-    for (const { pattern, replacement } of rule.neutralizeSteps ?? []) {
-      const matches = [...result.matchAll(pattern)].length;
-      if (matches > 0) {
-        result = result.replace(pattern, replacement);
-        replacements += matches;
-      }
-    }
-  }
-  return { content: result.trim(), replacements };
-}
-function toYamlListLiteral(scalar) {
-  const trimmed = scalar.trim();
-  const unquoted = trimmed.replace(/^"(.*)"$/, "$1").replace(/^'(.*)'$/, "$1");
-  return `[${JSON.stringify(unquoted)}]`;
-}
-function translateLegacyFrontmatter(content) {
-  const fm = /^---(\r?\n)([\s\S]*?)\r?\n---\r?\n/.exec(content);
-  if (!fm?.[2])
-    return { content, translated: false };
-  const eol = fm[1] ?? `
-`;
-  const block = fm[2];
-  if (!/^paths:/m.test(block) || /^appliesTo:/m.test(block))
-    return { content, translated: false };
-  const scalarMatch = /^paths:[ \t]*(\S.*)$/m.exec(block);
-  const isInlineList = scalarMatch?.[1]?.trim().startsWith("[") ?? false;
-  const rewritten = scalarMatch && !isInlineList ? block.replace(/^paths:[ \t]*(\S.*)$/m, `appliesTo: ${toYamlListLiteral(scalarMatch[1])}`) : block.replace(/^paths:/m, "appliesTo:");
-  const head = content.slice(0, fm.index);
-  const tail = content.slice(fm.index + fm[0].length);
-  return { content: `${head}---${eol}${rewritten}${eol}---${eol}${tail}`, translated: true };
-}
-function withReviewNotice(content, replacements) {
-  if (replacements <= 0)
-    return content;
-  const notice = `<!-- NOTE: ${replacements} neutralization(s) applied \u2014 review before committing -->
-
-`;
-  const fm = /^---\r?\n[\s\S]*?\r?\n---\r?\n/.exec(content);
-  if (!fm)
-    return notice + content;
-  return content.slice(0, fm[0].length) + notice + content.slice(fm[0].length).replace(/^(?:\r?\n)+/, "");
-}
-async function collectMigrationSources(workdir) {
-  const sources = [];
-  const claudeMdPath = join75(workdir, "CLAUDE.md");
-  if (await _rulesCLIDeps.fileExists(claudeMdPath)) {
-    const content = await _rulesCLIDeps.readFile(claudeMdPath);
-    if (content.trim()) {
-      sources.push({ sourcePath: claudeMdPath, targetFileName: "project-conventions.md", content });
-    }
-  }
-  const rulesDir = join75(workdir, ".claude", "rules");
-  const ruleFiles = _rulesCLIDeps.globInDir(rulesDir);
-  for (const filePath of ruleFiles) {
-    try {
-      const content = await _rulesCLIDeps.readFile(filePath);
-      if (content.trim()) {
-        sources.push({ sourcePath: filePath, targetFileName: basename15(filePath), content });
-      }
-    } catch {}
-  }
-  return sources;
-}
-async function rulesMigrateCommand(options) {
-  const workdir = options.dir ?? process.cwd();
-  const force = options.force ?? false;
-  const sources = await collectMigrationSources(workdir);
-  if (sources.length === 0) {
-    console.log("[WARN] No source files found (checked CLAUDE.md and .claude/rules/*.md). Nothing to migrate.");
-    return;
-  }
-  const targetDir = join75(workdir, CANONICAL_RULES_DIR);
-  if (!options.dryRun) {
-    try {
-      await _rulesCLIDeps.mkdir(targetDir);
-    } catch (err) {
-      throw new NaxError(`Failed to create ${CANONICAL_RULES_DIR}: ${errorMessage(err)}`, "RULES_MIGRATE_MKDIR_FAILED", { stage: "rules-migrate", targetDir });
-    }
-  }
-  let written = 0;
-  let skipped = 0;
-  for (const { sourcePath, targetFileName, content } of sources) {
-    const targetPath = join75(targetDir, targetFileName);
-    if (!force && !options.dryRun && await _rulesCLIDeps.fileExists(targetPath)) {
-      console.log(`[skip] ${targetFileName} already exists (use --force to overwrite)`);
-      skipped++;
-      continue;
-    }
-    const { content: scoped2 } = translateLegacyFrontmatter(content);
-    const { content: neutralized, replacements } = neutralizeContent(scoped2);
-    const output = withReviewNotice(neutralized, replacements);
-    if (options.dryRun) {
-      console.log(`[dry-run] Would write ${targetFileName} from ${sourcePath} (${replacements} replacements)`);
-    } else {
-      await _rulesCLIDeps.writeFile(targetPath, output);
-      console.log(`[OK] ${targetFileName} <- ${sourcePath}${replacements > 0 ? ` (${replacements} replacements)` : ""}`);
-    }
-    written++;
-  }
-  if (!options.dryRun) {
-    console.log(`
-Migration complete: ${written} file(s) written, ${skipped} skipped.`);
-    if (written > 0) {
-      console.log(`Review ${CANONICAL_RULES_DIR}/ before committing. Run \`nax rules export --agent=claude\` to regenerate CLAUDE.md.`);
-    }
-  }
-}
 // src/cli/resolve-run-profile.ts
 init_config();
 init_logger2();
@@ -109247,7 +109589,7 @@ async function resolveRunProfileOverride(opts) {
 init_config();
 init_test_runners();
 import { existsSync as existsSync28, readdirSync as readdirSync6 } from "fs";
-import { join as join77, relative as relative17 } from "path";
+import { join as join78, relative as relative17 } from "path";
 
 // src/cli/features-acceptance.ts
 init_acceptance2();
@@ -109255,7 +109597,7 @@ init_config();
 init_logger2();
 init_prd();
 import { existsSync as existsSync27 } from "fs";
-import { join as join76, relative as relative16 } from "path";
+import { join as join77, relative as relative16 } from "path";
 async function resolveFeatureAcceptance(featureName, workdir) {
   let enabled = true;
   try {
@@ -109263,13 +109605,13 @@ async function resolveFeatureAcceptance(featureName, workdir) {
     if (!naxDir) {
       return { status: "no-prd", enabled, groups: [] };
     }
-    const repoRoot = join76(naxDir, "..");
+    const repoRoot = join77(naxDir, "..");
     const config2 = await loadConfig(workdir);
     enabled = config2.acceptance?.enabled ?? true;
     if (!enabled) {
       return { status: "disabled", enabled: false, groups: [] };
     }
-    const prdPath = join76(naxDir, "features", featureName, "prd.json");
+    const prdPath = join77(naxDir, "features", featureName, "prd.json");
     if (!existsSync27(prdPath)) {
       return { status: "no-prd", enabled, groups: [] };
     }
@@ -109321,10 +109663,10 @@ async function isNonEmptyFile(absolutePath) {
 }
 async function searchSpecSource(naxDir, repoRoot, name) {
   const candidates = [
-    { abs: join77(naxDir, "features", name, "spec.md"), kind: "markdown" },
-    { abs: join77(naxDir, "specs", `${name}.md`), kind: "markdown" }
+    { abs: join78(naxDir, "features", name, "spec.md"), kind: "markdown" },
+    { abs: join78(naxDir, "specs", `${name}.md`), kind: "markdown" }
   ];
-  const docsSpecExact = join77(repoRoot, "docs", "specs", `SPEC-${name}.md`);
+  const docsSpecExact = join78(repoRoot, "docs", "specs", `SPEC-${name}.md`);
   candidates.push({ abs: docsSpecExact, kind: "markdown" });
   const checked = candidates.map((c) => relative17(repoRoot, c.abs));
   for (const { abs, kind } of candidates.slice(0, 2)) {
@@ -109338,11 +109680,11 @@ async function searchSpecSource(naxDir, repoRoot, name) {
   if (await isNonEmptyFile(docsSpecExact)) {
     return { source: { kind: "markdown", path: relative17(repoRoot, docsSpecExact) }, checked };
   }
-  const docsSpecsDir = join77(repoRoot, "docs", "specs");
+  const docsSpecsDir = join78(repoRoot, "docs", "specs");
   if (existsSync28(docsSpecsDir)) {
     const glob = new Bun.Glob(`*${name}*.md`);
     for (const match of glob.scanSync({ cwd: docsSpecsDir, absolute: false })) {
-      const abs = join77(docsSpecsDir, match);
+      const abs = join78(docsSpecsDir, match);
       if (await isNonEmptyFile(abs)) {
         const relPath = relative17(repoRoot, abs);
         if (!checked.includes(relPath))
@@ -109351,7 +109693,7 @@ async function searchSpecSource(naxDir, repoRoot, name) {
       }
     }
   }
-  const prdAbs = join77(naxDir, "features", name, "prd.json");
+  const prdAbs = join78(naxDir, "features", name, "prd.json");
   const prdRel = relative17(repoRoot, prdAbs);
   if (!checked.includes(prdRel))
     checked.push(prdRel);
@@ -109361,14 +109703,14 @@ async function searchSpecSource(naxDir, repoRoot, name) {
   return { source: null, checked };
 }
 function discoverCandidates(naxDir) {
-  const featuresDir = join77(naxDir, "features");
+  const featuresDir = join78(naxDir, "features");
   if (!existsSync28(featuresDir))
     return [];
   return readdirSync6(featuresDir, { withFileTypes: true }).filter((e) => {
     if (!e.isDirectory())
       return false;
-    const dir = join77(featuresDir, e.name);
-    return existsSync28(join77(dir, "prd.json")) || existsSync28(join77(dir, "spec.md"));
+    const dir = join78(featuresDir, e.name);
+    return existsSync28(join78(dir, "prd.json")) || existsSync28(join78(dir, "spec.md"));
   }).map((e) => e.name).sort();
 }
 async function resolveFeatureSpec(name, workdir) {
@@ -109379,9 +109721,9 @@ async function resolveFeatureSpec(name, workdir) {
       message: `not a nax repo: no .nax/config.json found from ${workdir}`
     };
   }
-  const repoRoot = join77(naxDir, "..");
+  const repoRoot = join78(naxDir, "..");
   if (name !== undefined && (name.startsWith("./") || name.startsWith("/") || name.endsWith(".md"))) {
-    const abs = name.startsWith("/") ? name : join77(workdir, name);
+    const abs = name.startsWith("/") ? name : join78(workdir, name);
     if (!existsSync28(abs)) {
       return {
         status: "missing",
@@ -109421,7 +109763,7 @@ async function resolveFeatureSpec(name, workdir) {
         message: `resolved spec: ${source2.path}`
       };
     }
-    const featureDir = join77(naxDir, "features", name);
+    const featureDir = join78(naxDir, "features", name);
     if (existsSync28(featureDir)) {
       return {
         status: "missing",
@@ -109484,14 +109826,14 @@ init_runtime();
 init_json_file();
 init_routing();
 import { mkdirSync as mkdirSync6 } from "fs";
-import { basename as basename16, join as join78 } from "path";
+import { basename as basename16, join as join79 } from "path";
 var _routingCalibrateDeps = {
   loadRunMetrics: (outputDir) => loadRunMetrics(outputDir),
   readConfig: (workdir) => loadConfig(workdir),
   writeConfig: async (workdir, config2) => {
     const dir = projectInputDir(workdir);
     mkdirSync6(dir, { recursive: true });
-    const filePath = join78(dir, "config.json");
+    const filePath = join79(dir, "config.json");
     await saveJsonFile(filePath, config2, "routing-calibrate");
   },
   stdout: (msg) => {
@@ -109618,7 +109960,7 @@ init_logger2();
 init_detect2();
 init_workspace();
 init_common();
-import { join as join79 } from "path";
+import { join as join80 } from "path";
 function resolveEffective(detected, configPatterns) {
   if (configPatterns !== undefined)
     return "config";
@@ -109703,7 +110045,7 @@ async function detectCommand(options) {
   const rootDetected = detectionMap[""] ?? { patterns: [], confidence: "empty", sources: [] };
   const pkgEntries = await Promise.all(packageDirs.map(async (dir) => {
     const det = detectionMap[dir] ?? { patterns: [], confidence: "empty", sources: [] };
-    const pkgConfigPath = join79(workdir, ".nax", "mono", dir, "config.json");
+    const pkgConfigPath = join80(workdir, ".nax", "mono", dir, "config.json");
     const pkgRaw = await loadRawConfig(pkgConfigPath);
     const pkgPatterns = deepGet(pkgRaw, TEST_PATTERNS_KEY);
     const effective = Array.isArray(pkgPatterns) ? pkgPatterns : undefined;
@@ -109757,13 +110099,13 @@ async function detectCommand(options) {
     if (rootDetected.confidence === "empty") {
       console.log(source_default.yellow("  root: skipped (empty detection)"));
     } else {
-      const rootConfigPath = join79(workdir, ".nax", "config.json");
+      const rootConfigPath = join80(workdir, ".nax", "config.json");
       try {
         const status = await applyToConfig(rootConfigPath, rootDetected.patterns, options.force ?? false);
         if (status === "skipped") {
           console.log(source_default.dim("  root: skipped (testFilePatterns already set; use --force to overwrite)"));
         } else {
-          console.log(source_default.green(`  root: ${status} \u2192 ${join79(".nax", "config.json")}`));
+          console.log(source_default.green(`  root: ${status} \u2192 ${join80(".nax", "config.json")}`));
         }
       } catch (err) {
         console.error(source_default.red(`  root: write failed \u2014 ${err.message}`));
@@ -109776,13 +110118,13 @@ async function detectCommand(options) {
         console.log(source_default.dim(`  ${dir}: skipped (empty detection)`));
         continue;
       }
-      const pkgConfigPath = join79(workdir, ".nax", "mono", dir, "config.json");
+      const pkgConfigPath = join80(workdir, ".nax", "mono", dir, "config.json");
       try {
         const status = await applyToConfig(pkgConfigPath, det.patterns, options.force ?? false);
         if (status === "skipped") {
           console.log(source_default.dim(`  ${dir}: skipped (already set)`));
         } else {
-          console.log(source_default.green(`  ${dir}: ${status} \u2192 ${join79(".nax", "mono", dir, "config.json")}`));
+          console.log(source_default.green(`  ${dir}: ${status} \u2192 ${join80(".nax", "mono", dir, "config.json")}`));
         }
       } catch (err) {
         console.error(source_default.red(`  ${dir}: write failed \u2014 ${err.message}`));
@@ -109800,19 +110142,19 @@ async function detectCommand(options) {
 // src/commands/logs.ts
 init_common();
 import { existsSync as existsSync30 } from "fs";
-import { join as join82 } from "path";
+import { join as join83 } from "path";
 
 // src/commands/logs-formatter.ts
 init_source();
 init_formatter();
 import { readdirSync as readdirSync8 } from "fs";
-import { join as join81 } from "path";
+import { join as join82 } from "path";
 
 // src/commands/logs-reader.ts
 init_paths3();
 import { existsSync as existsSync29, readdirSync as readdirSync7 } from "fs";
 import { readdir as readdir3 } from "fs/promises";
-import { join as join80 } from "path";
+import { join as join81 } from "path";
 var _logsReaderDeps = {
   getRunsDir
 };
@@ -109826,7 +110168,7 @@ async function resolveRunFileFromRegistry(runId) {
   }
   let matched = null;
   for (const entry of entries) {
-    const metaPath = join80(runsDir, entry, "meta.json");
+    const metaPath = join81(runsDir, entry, "meta.json");
     try {
       const meta3 = await Bun.file(metaPath).json();
       if (meta3.runId === runId || meta3.runId.startsWith(runId)) {
@@ -109848,14 +110190,14 @@ async function resolveRunFileFromRegistry(runId) {
     return null;
   }
   const specificFile = files.find((f) => f === `${matched.runId}.jsonl`);
-  return join80(matched.eventsDir, specificFile ?? files[0]);
+  return join81(matched.eventsDir, specificFile ?? files[0]);
 }
 async function selectRunFile(runsDir) {
   const files = readdirSync7(runsDir).filter((f) => f.endsWith(".jsonl") && f !== "latest.jsonl").sort().reverse();
   if (files.length === 0) {
     return null;
   }
-  return join80(runsDir, files[0]);
+  return join81(runsDir, files[0]);
 }
 async function extractRunSummary(filePath) {
   const file3 = Bun.file(filePath);
@@ -109941,7 +110283,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 = join81(runsDir, file3);
+    const filePath = join82(runsDir, file3);
     const summary = await extractRunSummary(filePath);
     const timestamp = file3.replace(".jsonl", "");
     const stories = summary ? `${summary.passed}/${summary.total}` : "?/?";
@@ -110055,7 +110397,7 @@ async function logsCommand(options) {
     return;
   }
   const resolved = resolveProject2({ dir: options.dir });
-  const naxDir = join82(resolved.projectDir, ".nax");
+  const naxDir = join83(resolved.projectDir, ".nax");
   const configPath = resolved.configPath;
   const configFile = Bun.file(configPath);
   const config2 = await configFile.json();
@@ -110063,8 +110405,8 @@ async function logsCommand(options) {
   if (!featureName) {
     throw new Error("No feature specified in config.json");
   }
-  const featureDir = join82(naxDir, "features", featureName);
-  const runsDir = join82(featureDir, "runs");
+  const featureDir = join83(naxDir, "features", featureName);
+  const runsDir = join83(featureDir, "runs");
   if (!existsSync30(runsDir)) {
     throw new Error(`No runs directory found for feature: ${featureName}`);
   }
@@ -110090,7 +110432,7 @@ init_prd();
 init_precheck();
 init_common();
 import { existsSync as existsSync31 } from "fs";
-import { join as join83 } from "path";
+import { join as join84 } from "path";
 async function precheckCommand(options) {
   const resolved = resolveProject2({
     dir: options.dir,
@@ -110112,9 +110454,9 @@ async function precheckCommand(options) {
       process.exit(1);
     }
   }
-  const naxDir = join83(resolved.projectDir, ".nax");
-  const featureDir = join83(naxDir, "features", featureName);
-  const prdPath = join83(featureDir, "prd.json");
+  const naxDir = join84(resolved.projectDir, ".nax");
+  const featureDir = join84(naxDir, "features", featureName);
+  const prdPath = join84(featureDir, "prd.json");
   if (!existsSync31(featureDir)) {
     console.error(source_default.red(`Feature not found: ${featureName}`));
     process.exit(1);
@@ -110142,7 +110484,7 @@ import { dirname as dirname14 } from "path";
 init_errors();
 init_paths3();
 import { readdir as readdir4 } from "fs/promises";
-import { join as join84 } from "path";
+import { join as join85 } from "path";
 var _discoveryDeps = {
   getRunsDir
 };
@@ -110156,7 +110498,7 @@ async function loadMetas(runsDir) {
   const metas = [];
   for (const entry of entries) {
     try {
-      const meta3 = await Bun.file(join84(runsDir, entry, "meta.json")).json();
+      const meta3 = await Bun.file(join85(runsDir, entry, "meta.json")).json();
       metas.push(meta3);
     } catch {}
   }
@@ -110173,7 +110515,7 @@ async function discoverRun(query, depsArg = _discoveryDeps) {
       throw new NaxError("No runs registered", "RUN_NOT_FOUND", { runsDir });
     }
     const latest = metas.reduce((acc, m) => m.runId > acc.runId ? m : acc);
-    return { meta: latest, jsonlPath: join84(latest.eventsDir, `${latest.runId}.jsonl`) };
+    return { meta: latest, jsonlPath: join85(latest.eventsDir, `${latest.runId}.jsonl`) };
   }
   const matched = metas.filter((m) => matches(m, query));
   if (matched.length === 0) {
@@ -110190,7 +110532,7 @@ async function discoverRun(query, depsArg = _discoveryDeps) {
     });
   }
   const meta3 = matched[0];
-  return { meta: meta3, jsonlPath: join84(meta3.eventsDir, `${meta3.runId}.jsonl`) };
+  return { meta: meta3, jsonlPath: join85(meta3.eventsDir, `${meta3.runId}.jsonl`) };
 }
 
 // src/replay/json.ts
@@ -110528,11 +110870,11 @@ init_errors();
 init_checkpoint();
 init_runtime();
 import { existsSync as existsSync37 } from "fs";
-import { basename as basename19, join as join98 } from "path";
+import { basename as basename19, join as join99 } from "path";
 async function defaultCheckpointExists(featureDir) {
   if (!featureDir || !existsSync37(featureDir))
     return false;
-  return existsSync37(join98(featureDir, "checkpoint.jsonl"));
+  return existsSync37(join99(featureDir, "checkpoint.jsonl"));
 }
 async function defaultLoadCheckpoints(featureDir) {
   return loadCheckpoints(featureDir);
@@ -110592,12 +110934,12 @@ function registerResumeCommand(program2) {
 `);
       process.exit(1);
     }
-    const featureDir = join98(naxDir, "features", cmdOpts.feature);
+    const featureDir = join99(naxDir, "features", cmdOpts.feature);
     const deps = {
       ..._resumeCmdDeps,
       runInvocation: async (feature, opts) => {
         const config2 = await loadConfig2(naxDir ?? undefined);
-        const prdPath = join98(opts.featureDir ?? "", "prd.json");
+        const prdPath = join99(opts.featureDir ?? "", "prd.json");
         if (!existsSync38(prdPath)) {
           process.stderr.write(`Feature "${feature}" not found or missing prd.json
 `);
@@ -110609,7 +110951,7 @@ function registerResumeCommand(program2) {
         applyResumeModeDeps2(opts.featureDir ?? "", "auto");
         const projectKey = config2.name?.trim() || basename19(cmdOpts.dir);
         const outputDir = projectOutputDir(projectKey, config2.outputDir);
-        const statusFilePath = join98(outputDir, "status.json");
+        const statusFilePath = join99(outputDir, "status.json");
         const result = await run2({
           prdPath,
           workdir: cmdOpts.dir,
@@ -110644,7 +110986,7 @@ function registerResumeCommand(program2) {
 init_source();
 init_paths3();
 import { readdir as readdir6 } from "fs/promises";
-import { join as join99 } from "path";
+import { join as join100 } from "path";
 var DEFAULT_LIMIT = 20;
 var _runsCmdDeps = {
   getRunsDir
@@ -110701,7 +111043,7 @@ async function runsCommand(options = {}) {
   }
   const rows = [];
   for (const entry of entries) {
-    const metaPath = join99(runsDir, entry, "meta.json");
+    const metaPath = join100(runsDir, entry, "meta.json");
     let meta3;
     try {
       meta3 = await Bun.file(metaPath).json();
@@ -110778,7 +111120,7 @@ async function runsCommand(options = {}) {
 
 // src/commands/unlock.ts
 init_source();
-import { join as join100 } from "path";
+import { join as join101 } from "path";
 function isProcessAlive2(pid) {
   try {
     process.kill(pid, 0);
@@ -110793,7 +111135,7 @@ function formatLockAge(ageMs) {
 }
 async function unlockCommand(options) {
   const workdir = options.dir ?? process.cwd();
-  const lockPath = join100(workdir, "nax.lock");
+  const lockPath = join101(workdir, "nax.lock");
   const lockFile = Bun.file(lockPath);
   const exists = await lockFile.exists();
   if (!exists) {
@@ -116443,8 +116785,8 @@ class Ink {
     }
   }
   async waitUntilExit() {
-    this.exitPromise ||= new Promise((resolve22, reject2) => {
-      this.resolveExitPromise = resolve22;
+    this.exitPromise ||= new Promise((resolve23, reject2) => {
+      this.resolveExitPromise = resolve23;
       this.rejectExitPromise = reject2;
     });
     if (!this.beforeExitHandler) {
@@ -118709,7 +119051,7 @@ async function promptForConfirmation(question) {
   if (!process.stdin.isTTY) {
     return true;
   }
-  return new Promise((resolve23) => {
+  return new Promise((resolve24) => {
     process.stdout.write(source_default.bold(`${question} [Y/n] `));
     process.stdin.setRawMode(true);
     process.stdin.resume();
@@ -118722,9 +119064,9 @@ async function promptForConfirmation(question) {
       process.stdout.write(`
 `);
       if (answer === "n") {
-        resolve23(false);
+        resolve24(false);
       } else {
-        resolve23(true);
+        resolve24(true);
       }
     };
     process.stdin.on("data", handler);
@@ -118753,7 +119095,7 @@ Next: nax generate --package ${options.package}`));
     }
     return;
   }
-  const naxDir = join104(workdir, ".nax");
+  const naxDir = join105(workdir, ".nax");
   if (existsSync39(naxDir) && !options.force) {
     console.log(source_default.yellow("nax already initialized. Use --force to overwrite."));
     return;
@@ -118782,11 +119124,11 @@ Next: nax generate --package ${options.package}`));
       }
     }
   }
-  mkdirSync8(join104(naxDir, "features"), { recursive: true });
-  mkdirSync8(join104(naxDir, "hooks"), { recursive: true });
+  mkdirSync8(join105(naxDir, "features"), { recursive: true });
+  mkdirSync8(join105(naxDir, "hooks"), { recursive: true });
   const initConfig = options.name ? { ...DEFAULT_CONFIG, name: options.name } : DEFAULT_CONFIG;
-  await Bun.write(join104(naxDir, "config.json"), JSON.stringify(initConfig, null, 2));
-  await Bun.write(join104(naxDir, "hooks.json"), JSON.stringify({
+  await Bun.write(join105(naxDir, "config.json"), JSON.stringify(initConfig, null, 2));
+  await Bun.write(join105(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 },
@@ -118794,12 +119136,12 @@ Next: nax generate --package ${options.package}`));
       "on-error": { command: 'echo "nax error: $NAX_REASON"', enabled: false }
     }
   }, null, 2));
-  await Bun.write(join104(naxDir, ".gitignore"), `# nax temp files
+  await Bun.write(join105(naxDir, ".gitignore"), `# nax temp files
 *.tmp
 .paused.json
 .nax-verifier-verdict.json
 `);
-  await Bun.write(join104(naxDir, "context.md"), `# Project Context
+  await Bun.write(join105(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.
@@ -118983,7 +119325,7 @@ program2.command("run").description("Run the orchestration loop for a feature").
   const cliOverrides = {};
   const cliProfiles = options.profile ?? [];
   const profileOverride = naxDir ? await resolveRunProfileOverride({
-    prdPath: join104(naxDir, "features", options.feature, "prd.json"),
+    prdPath: join105(naxDir, "features", options.feature, "prd.json"),
     projectRoot: workdir,
     cliProfile: cliProfiles,
     envProfile: process.env.NAX_PROFILE
@@ -118996,8 +119338,8 @@ 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 = join104(naxDir, "features", options.feature);
-  const prdPath = join104(featureDir, "prd.json");
+  const featureDir = join105(naxDir, "features", options.feature);
+  const prdPath = join105(featureDir, "prd.json");
   if (options.plan && options.from) {
     if (existsSync39(prdPath) && !options.force) {
       console.error(source_default.red(`Error: prd.json already exists for feature "${options.feature}".`));
@@ -119019,10 +119361,10 @@ program2.command("run").description("Run the orchestration loop for a feature").
       }
     }
     try {
-      const planLogDir = join104(featureDir, "plan");
+      const planLogDir = join105(featureDir, "plan");
       mkdirSync8(planLogDir, { recursive: true });
       const planLogId = new Date().toISOString().replace(/:/g, "-").replace(/\..+/, "");
-      const planLogPath = join104(planLogDir, `${planLogId}.jsonl`);
+      const planLogPath = join105(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]"));
@@ -119070,10 +119412,10 @@ program2.command("run").description("Run the orchestration loop for a feature").
   resetLogger();
   const projectKey = config2.name?.trim() || basename21(workdir);
   const outputDir = projectOutputDir(projectKey, config2.outputDir);
-  const runsDir = join104(outputDir, "features", options.feature, "runs");
+  const runsDir = join105(outputDir, "features", options.feature, "runs");
   mkdirSync8(runsDir, { recursive: true });
   const runId = new Date().toISOString().replace(/:/g, "-").replace(/\..+/, "");
-  const logFilePath = join104(runsDir, `${runId}.jsonl`);
+  const logFilePath = join105(runsDir, `${runId}.jsonl`);
   const isTTY = process.stdout.isTTY ?? false;
   const headlessFlag = options.headless ?? false;
   const headlessEnv = process.env.NAX_HEADLESS === "1";
@@ -119099,7 +119441,7 @@ program2.command("run").description("Run the orchestration loop for a feature").
     }
     config2.execution.costLimit = maxCost;
   }
-  const globalNaxDir = join104(homedir3(), ".nax");
+  const globalNaxDir = join105(homedir3(), ".nax");
   const hooks = await loadHooksConfig(naxDir, globalNaxDir);
   const eventEmitter = new PipelineEventEmitter;
   const agentStreamEvents = useHeadless ? undefined : new AgentStreamEventBus;
@@ -119118,12 +119460,12 @@ program2.command("run").description("Run the orchestration loop for a feature").
       stories: initialStories,
       events: eventEmitter,
       agentStreamEvents,
-      queueFilePath: join104(workdir, ".queue.txt")
+      queueFilePath: join105(workdir, ".queue.txt")
     });
   } else {
     console.log(source_default.dim("   [Headless mode \u2014 pipe output]"));
   }
-  const statusFilePath = join104(outputDir, "status.json");
+  const statusFilePath = join105(outputDir, "status.json");
   let parallel;
   if (options.parallel !== undefined) {
     parallel = Number.parseInt(options.parallel, 10);
@@ -119186,7 +119528,7 @@ Scheduled run cancelled.`));
     agentStreamEvents,
     resumeMode: options.fresh === true || options.resume === false ? "fresh" : "auto"
   });
-  const latestSymlink = join104(runsDir, "latest.jsonl");
+  const latestSymlink = join105(runsDir, "latest.jsonl");
   try {
     if (existsSync39(latestSymlink)) {
       Bun.spawnSync(["rm", latestSymlink]);
@@ -119283,9 +119625,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 = join104(naxDir, "features", name);
+  const featureDir = join105(naxDir, "features", name);
   mkdirSync8(featureDir, { recursive: true });
-  await Bun.write(join104(featureDir, "spec.md"), `# Feature: ${name}
+  await Bun.write(join105(featureDir, "spec.md"), `# Feature: ${name}
 
 ## Overview
 
@@ -119318,7 +119660,7 @@ features.command("create <name>").description("Create a new feature").option("-d
 
 <!-- What this feature explicitly does NOT cover. -->
 `);
-  await Bun.write(join104(featureDir, "progress.txt"), `# Progress: ${name}
+  await Bun.write(join105(featureDir, "progress.txt"), `# Progress: ${name}
 
 Created: ${new Date().toISOString()}
 
@@ -119344,7 +119686,7 @@ features.command("list").description("List all features").option("-d, --dir <pat
     console.error(source_default.red("nax not initialized."));
     process.exit(1);
   }
-  const featuresDir = join104(naxDir, "features");
+  const featuresDir = join105(naxDir, "features");
   if (!existsSync39(featuresDir)) {
     console.log(source_default.dim("No features yet."));
     return;
@@ -119359,7 +119701,7 @@ features.command("list").description("List all features").option("-d, --dir <pat
 Features:
 `));
   for (const name of entries) {
-    const prdPath = join104(featuresDir, name, "prd.json");
+    const prdPath = join105(featuresDir, name, "prd.json");
     if (existsSync39(prdPath)) {
       const prd = await loadPRD(prdPath);
       const c = countStories(prd);
@@ -119432,10 +119774,10 @@ Use: nax plan -f <feature> --from <spec>`));
     cliOverrides.profile = cliProfiles;
   }
   const config2 = await loadConfig(workdir, cliOverrides);
-  const featureLogDir = join104(naxDir, "features", options.feature, "plan");
+  const featureLogDir = join105(naxDir, "features", options.feature, "plan");
   mkdirSync8(featureLogDir, { recursive: true });
   const planLogId = new Date().toISOString().replace(/:/g, "-").replace(/\..+/, "");
-  const planLogPath = join104(featureLogDir, `${planLogId}.jsonl`);
+  const planLogPath = join105(featureLogDir, `${planLogId}.jsonl`);
   initLogger({ level: "info", filePath: planLogPath, useChalk: false, headless: true });
   console.log(source_default.dim(`   [Plan log: ${planLogPath}]`));
   try {