@nathapp/nax 0.73.4 → 0.74.0

package/dist/nax.js

@@ -17787,6 +17787,40 @@ var init_schemas3 = __esm(() => {
       enabled: exports_external.boolean().default(false),
       draft: exports_external.boolean().default(true)
     }).optional().default({ enabled: false, draft: true }),
+    finish: exports_external.object({
+      autoFlow: exports_external.object({
+        enabled: exports_external.boolean().default(false),
+        flowPath: exports_external.string().default("flows/nax-finish/nax-finish.flow.ts"),
+        defaultAgent: exports_external.string().nullable().default(null),
+        reviewers: exports_external.object({
+          spec: exports_external.string().nullable().default(null),
+          quality: exports_external.string().nullable().default(null)
+        }).default({ spec: null, quality: null }),
+        escalate: exports_external.object({ telegram: exports_external.boolean().default(true) }).default({ telegram: true }),
+        timeouts: exports_external.object({
+          acceptanceMs: exports_external.number().int().positive().default(600000),
+          gateMs: exports_external.number().int().positive().default(900000),
+          flowMs: exports_external.number().int().positive().default(5400000),
+          stepMs: exports_external.number().int().positive().nullable().default(null)
+        }).default({ acceptanceMs: 600000, gateMs: 900000, flowMs: 5400000, stepMs: null })
+      }).default({
+        enabled: false,
+        flowPath: "flows/nax-finish/nax-finish.flow.ts",
+        defaultAgent: null,
+        reviewers: { spec: null, quality: null },
+        escalate: { telegram: true },
+        timeouts: { acceptanceMs: 600000, gateMs: 900000, flowMs: 5400000, stepMs: null }
+      })
+    }).default({
+      autoFlow: {
+        enabled: false,
+        flowPath: "flows/nax-finish/nax-finish.flow.ts",
+        defaultAgent: null,
+        reviewers: { spec: null, quality: null },
+        escalate: { telegram: true },
+        timeouts: { acceptanceMs: 600000, gateMs: 900000, flowMs: 5400000, stepMs: null }
+      }
+    }),
     reporters: ReportersConfigSchema,
     profile: exports_external.string().default("default"),
     profileChain: exports_external.array(exports_external.string()).default([])
@@ -19476,7 +19510,7 @@ function reshapeSelector(name, fn) {
 }
 
 // src/config/selectors.ts
-var reviewConfigSelector, planConfigSelector, decomposeConfigSelector, rectifyConfigSelector, acceptanceConfigSelector, acceptanceFixConfigSelector, acceptanceGenConfigSelector, tddConfigSelector, debateConfigSelector, routingConfigSelector, verifyConfigSelector, mutationCheckConfigSelector, rectificationGateConfigSelector, agentConfigSelector, agentManagerConfigSelector, interactionConfigSelector, precheckConfigSelector, qualityConfigSelector, autofixConfigSelector, executionGatesConfigSelector, testPatternConfigSelector, contextConfigSelector, contextToolRuntimeConfigSelector, promptLoaderConfigSelector, llmRoutingConfigSelector;
+var reviewConfigSelector, planConfigSelector, decomposeConfigSelector, rectifyConfigSelector, acceptanceConfigSelector, acceptanceFixConfigSelector, acceptanceGenConfigSelector, tddConfigSelector, debateConfigSelector, routingConfigSelector, verifyConfigSelector, mutationCheckConfigSelector, rectificationGateConfigSelector, agentConfigSelector, agentManagerConfigSelector, interactionConfigSelector, precheckConfigSelector, qualityConfigSelector, autofixConfigSelector, executionGatesConfigSelector, testPatternConfigSelector, contextConfigSelector, contextToolRuntimeConfigSelector, promptLoaderConfigSelector, llmRoutingConfigSelector, finishConfigSelector;
 var init_selectors = __esm(() => {
   reviewConfigSelector = pickSelector("review", "review", "debate", "models", "execution", "project", "quality", "agent");
   planConfigSelector = pickSelector("plan", "plan", "debate", "agent", "project", "routing");
@@ -19506,6 +19540,7 @@ var init_selectors = __esm(() => {
   contextToolRuntimeConfigSelector = pickSelector("context-tool-runtime", "context", "execution", "project", "quality");
   promptLoaderConfigSelector = pickSelector("prompt-loader", "prompts", "context", "project");
   llmRoutingConfigSelector = pickSelector("llm-routing", "routing", "models", "agent", "tdd", "execution", "precheck");
+  finishConfigSelector = pickSelector("finish", "finish", "interaction", "quality");
 });
 
 // src/config/loader-runtime.ts
@@ -19649,7 +19684,8 @@ When a spec is provided, these rules govern acceptance criteria generation:
 3. **Respect story scope.** Each story's criteria must only cover what the spec says for that story. Do not assign criteria that belong to a different story's scope (wrong feature area, wrong file, wrong dependency chain).
 4. **\`suggestedCriteria\` format.** Each element must be a plain behavioral assertion \u2014 an observable output, return value, state change, or error condition that a test can assert. Never include implementation details (imports, internal structure), design suggestions, or vague descriptions.
 5. **Enumerate failure-mode tables.** If the spec contains a "Failure handling", "Error handling", "Failure modes", or equivalent table/section enumerating error/exception scenarios, every row MUST produce at least one acceptance criterion in the matching story. Walk the table row by row; do not skip rows because they look minor. A failure-mode row without an AC is treated as a missing AC and will cause rejection.
-6. **Resolve internal spec contradictions toward the AC.** If the spec's prose, design table, or interface block contradicts a stated acceptance criterion (e.g. design table says \`lookback or strategy_lookback\` but the AC says \`lookback=None\`), the AC is authoritative. Implement the AC; do NOT echo the contradicting prose into the description.`, DESCRIPTION_QUALITY_RULES = `## Description Quality Rules
+6. **Preserve the spec's out-of-scope statements.** If the spec has an "Out of Scope", "Non-Goals", or "Not in scope" section \u2014 or an inline \`**Out of scope \u2026:**\` lead-in \u2014 copy every item **verbatim** into the top-level \`outOfScope\` string array. This is what the feature deliberately does NOT do; it is the only channel by which a deferred arc reaches the implementer, which never sees the spec. Never drop an item, never merge two into one, and never turn one into an acceptance criterion. Echo an item into a story's \`**Scope** \u2014 Out:\` bullet as well whenever that story sits close enough to the boundary that an implementer might stray across it. Omit \`outOfScope\` only when the spec declares nothing.
+7. **Resolve internal spec contradictions toward the AC.** If the spec's prose, design table, or interface block contradicts a stated acceptance criterion (e.g. design table says \`lookback or strategy_lookback\` but the AC says \`lookback=None\`), the AC is authoritative. Implement the AC; do NOT echo the contradicting prose into the description.`, DESCRIPTION_QUALITY_RULES = `## Description Quality Rules
 
 When a spec contains a design subsection for a story (e.g. \`### N. <Topic>\` under \`## Design\`), the story description MUST embed that subsection's interface declarations, algorithms, and design notes verbatim.
 
@@ -19666,6 +19702,7 @@ When a spec contains a design subsection for a story (e.g. \`### N. <Topic>\` un
 ### Rules
 
 1. Do NOT paraphrase spec design sections \u2014 embed them verbatim.
+1a. \`**Scope** \u2014 Out:\` states *inter-story* boundaries \u2014 work that belongs to a different story in this PRD. Feature-level exclusions (what the whole feature defers) belong in the top-level \`outOfScope\` array, not here. List an item in both places when this story sits close enough to a feature-level boundary that an implementer might stray across it.
 2. A one-sentence description is almost always too short for implementation stories that have spec design content.
 3. The implementer receives only this description \u2014 no access to the spec. Design decisions lost here are permanently invisible to the implementer.
 4. **Self-check before emitting.** After drafting each description, re-read it against the story's \`acceptanceCriteria\`. If any sentence in the description contradicts an AC (e.g. description says behaviour X, AC says behaviour not-X), the description is wrong \u2014 rewrite the offending sentence to match the AC, or delete it. The AC is authoritative. Embedding contradicting spec prose verbatim still counts as a contradiction; resolve it.
@@ -19784,6 +19821,7 @@ __export(exports_config, {
   globalConfigPath: () => globalConfigPath,
   globalConfigDir: () => globalConfigDir,
   getAcQualityRules: () => getAcQualityRules,
+  finishConfigSelector: () => finishConfigSelector,
   findProjectDir: () => findProjectDir,
   executionGatesConfigSelector: () => executionGatesConfigSelector,
   deepMergeConfig: () => deepMergeConfig,
@@ -28368,6 +28406,247 @@ var init_static_rules = __esm(() => {
   LEGACY_CANDIDATE_FILES = ["CLAUDE.md", ".cursorrules", "AGENTS.md"];
 });
 
+// src/prd/out-of-scope.ts
+function stripEmphasis(text) {
+  return text.replace(/\*\*/g, "").replace(/[*`_]/g, "");
+}
+function outOfScopeHeadingLevel(line, nextLine) {
+  const atx = stripEmphasis(line).match(OUT_OF_SCOPE_HEADING);
+  if (atx)
+    return atx[1].length;
+  if (nextLine !== undefined && SETEXT_UNDERLINE.test(nextLine)) {
+    const title = stripEmphasis(line).trim().replace(/:$/, "");
+    if (OUT_OF_SCOPE_TITLE.test(title))
+      return nextLine.trim().startsWith("=") ? 1 : 2;
+  }
+  return null;
+}
+function isSetextUnderline(lines, index) {
+  if (!SETEXT_UNDERLINE.test(lines[index]))
+    return false;
+  const prev = lines[index - 1];
+  return prev !== undefined && prev.trim().length > 0 && !ANY_HEADING.test(prev);
+}
+function canonical(text) {
+  return text.replace(/`/g, "").replace(/\s+/g, " ").trim().toLowerCase();
+}
+function stripBullet(line) {
+  return line.replace(LIST_ITEM_START, "").trim();
+}
+function sectionLines(lines, startIndex, level) {
+  const collected = [];
+  let inFence = false;
+  for (let i = startIndex + 1;i < lines.length; i++) {
+    const line = lines[i];
+    if (FENCE.test(line)) {
+      inFence = !inFence;
+      continue;
+    }
+    if (inFence)
+      continue;
+    const heading = line.match(ANY_HEADING);
+    if (heading && (heading[1].length <= level || level === 1))
+      break;
+    if (heading) {
+      collected.push("");
+      continue;
+    }
+    if (isSetextUnderline(lines, i)) {
+      const setextLevel = line.trim().startsWith("=") ? 1 : 2;
+      if (setextLevel <= level) {
+        collected.pop();
+        break;
+      }
+      collected.pop();
+      continue;
+    }
+    collected.push(line);
+  }
+  return collected;
+}
+function itemsFromSection(body) {
+  const items = [];
+  let current = [];
+  const flush = () => {
+    const text = current.join(" ").replace(INLINE_MARKER, "").replace(/\s+/g, " ").trim();
+    if (text)
+      items.push(text);
+    current = [];
+  };
+  const hasBullets = body.some((line) => LIST_ITEM_START.test(line));
+  for (const [index, line] of body.entries()) {
+    if (line.trim().length === 0) {
+      flush();
+      continue;
+    }
+    if (TABLE_ROW.test(line) && TABLE_SEPARATOR.test(body[index + 1] ?? ""))
+      continue;
+    if (TABLE_SEPARATOR.test(line))
+      continue;
+    if (TABLE_ROW.test(line)) {
+      flush();
+      const cells = line.trim().replace(/^\||\|$/g, "").split("|").map((c) => c.trim()).filter((c) => c.length > 0);
+      if (cells.length > 0)
+        current.push(cells.join(" \u2014 "));
+      flush();
+      continue;
+    }
+    if (hasBullets && LIST_ITEM_START.test(line)) {
+      flush();
+      current.push(stripBullet(line));
+      continue;
+    }
+    current.push(line.trim());
+  }
+  flush();
+  return items;
+}
+function fencedLineIndices(lines) {
+  const fenced = new Set;
+  let inFence = false;
+  for (const [i, line] of lines.entries()) {
+    if (FENCE.test(line)) {
+      fenced.add(i);
+      inFence = !inFence;
+      continue;
+    }
+    if (inFence)
+      fenced.add(i);
+  }
+  return fenced;
+}
+function itemsFromInlineMarkers(lines, fenced, boundary) {
+  const items = [];
+  for (let i = 0;i < boundary; i++) {
+    if (fenced.has(i) || !INLINE_MARKER.test(lines[i]))
+      continue;
+    const remainder = lines[i].replace(INLINE_MARKER, "").trim();
+    let j = i + 1;
+    if (remainder.length === 0) {
+      const body = [];
+      while (j < lines.length && !fenced.has(j) && lines[j].trim().length > 0 && !ANY_HEADING.test(lines[j])) {
+        body.push(lines[j]);
+        j += 1;
+      }
+      items.push(...itemsFromSection(body));
+      i = j - 1;
+      continue;
+    }
+    const parts = [remainder];
+    while (j < lines.length && !fenced.has(j) && lines[j].trim().length > 0 && !ANY_HEADING.test(lines[j]) && !LIST_ITEM_START.test(lines[j])) {
+      parts.push(lines[j].trim());
+      j += 1;
+    }
+    const text = parts.join(" ").replace(/\s+/g, " ").trim();
+    if (text)
+      items.push(text);
+    i = j - 1;
+  }
+  return items;
+}
+function isListLeadIn(item) {
+  return item.trimEnd().endsWith(":");
+}
+function dedupeAndCap(items) {
+  const seen = new Set;
+  const out = [];
+  for (const item of items) {
+    const key = canonical(item);
+    if (EMPTY_SENTINELS.has(key) || isListLeadIn(item))
+      continue;
+    if (key.length === 0 || seen.has(key))
+      continue;
+    seen.add(key);
+    out.push(item);
+    if (out.length >= MAX_OUT_OF_SCOPE_ITEMS)
+      break;
+  }
+  return out;
+}
+function storyScopeBoundary(lines) {
+  const index = lines.findIndex((line) => STORY_SECTION_HEADING.test(stripEmphasis(line)));
+  return index === -1 ? lines.length : index;
+}
+function normalizeOutOfScopeList(raw) {
+  if (!Array.isArray(raw))
+    return;
+  const strings = raw.filter((item) => typeof item === "string" && item.trim().length > 0);
+  const items = dedupeAndCap(strings.map((item) => item.trim()));
+  return items.length > 0 ? items : undefined;
+}
+function extractSpecOutOfScope(specContent) {
+  if (!specContent.trim())
+    return [];
+  const lines = specContent.split(`
+`);
+  const fenced = fencedLineIndices(lines);
+  const boundary = storyScopeBoundary(lines);
+  const items = [];
+  for (let i = 0;i < lines.length; i++) {
+    if (fenced.has(i))
+      continue;
+    const level = outOfScopeHeadingLevel(lines[i], lines[i + 1]);
+    if (level === null)
+      continue;
+    if (level > 2 && i > boundary)
+      continue;
+    const bodyStart = SETEXT_UNDERLINE.test(lines[i + 1] ?? "") ? i + 1 : i;
+    items.push(...itemsFromSection(sectionLines(lines, bodyStart, level)));
+  }
+  items.push(...itemsFromInlineMarkers(lines, fenced, boundary));
+  return dedupeAndCap(items);
+}
+function findMissingOutOfScope(specContent, prd) {
+  const declared = extractSpecOutOfScope(specContent);
+  if (declared.length === 0)
+    return [];
+  const present = (prd.outOfScope ?? []).map(canonical);
+  return declared.filter((item) => !present.some((entry) => entry.includes(canonical(item))));
+}
+function applyOutOfScopeFallback(prd, specContent) {
+  const missing = findMissingOutOfScope(specContent, prd);
+  if (missing.length === 0)
+    return prd;
+  return { ...prd, outOfScope: dedupeAndCap([...missing, ...prd.outOfScope ?? []]) };
+}
+function propagateOutOfScopeToStories(prd) {
+  const featureLevel = prd.outOfScope ?? [];
+  if (featureLevel.length === 0)
+    return prd;
+  const userStories = prd.userStories.map((story) => ({
+    ...story,
+    outOfScope: dedupeAndCap([...featureLevel, ...story.outOfScope ?? []])
+  }));
+  return { ...prd, userStories };
+}
+function stripPropagatedOutOfScope(prd) {
+  const featureLevel = new Set((prd.outOfScope ?? []).map(canonical));
+  if (featureLevel.size === 0)
+    return prd;
+  if (!prd.userStories.some((story) => (story.outOfScope ?? []).length > 0))
+    return prd;
+  const userStories = prd.userStories.map((story) => {
+    const specific = (story.outOfScope ?? []).filter((item) => !featureLevel.has(canonical(item)));
+    const { outOfScope: _dropped, ...rest } = story;
+    return specific.length > 0 ? { ...rest, outOfScope: specific } : rest;
+  });
+  return { ...prd, userStories };
+}
+var MAX_OUT_OF_SCOPE_ITEMS = 25, OUT_OF_SCOPE_TITLE, OUT_OF_SCOPE_HEADING, ANY_HEADING, FENCE, TABLE_SEPARATOR, TABLE_ROW, STORY_SECTION_HEADING, SETEXT_UNDERLINE, INLINE_MARKER, LIST_ITEM_START, EMPTY_SENTINELS;
+var init_out_of_scope = __esm(() => {
+  OUT_OF_SCOPE_TITLE = /^(?:out[\s-]?of[\s-]?scope|non[\s-]?goals?|not[\s-]in[\s-]scope)\b/i;
+  OUT_OF_SCOPE_HEADING = /^(#{1,6})\s*(?:out[\s-]?of[\s-]?scope|non[\s-]?goals?|not[\s-]in[\s-]scope)\b/i;
+  ANY_HEADING = /^(#{1,6})\s/;
+  FENCE = /^\s*(?:```|~~~)/;
+  TABLE_SEPARATOR = /^\s*\|?[\s:|-]+\|[\s:|-]*$/;
+  TABLE_ROW = /^\s*\|.*\|\s*$/;
+  STORY_SECTION_HEADING = /^#{1,3}\s*(?:stories|acceptance\s+criteria|user\s+stories)\b/i;
+  SETEXT_UNDERLINE = /^\s*(?:=+|-+)\s*$/;
+  INLINE_MARKER = /^\s*(?:[-*]\s*)?\*\*\s*(?:out[\s-]?of[\s-]?scope|non[\s-]?goals?)[^*]*\*\*\s*:?\s*/i;
+  LIST_ITEM_START = /^\s*(?:[-*+\u2022\u2023\u25E6\u2043\u2219]|\d+\.)\s+/;
+  EMPTY_SENTINELS = new Set(["none", "none.", "n/a", "na", "nothing", "nothing.", "tbd", "-"]);
+});
+
 // src/prd/types.ts
 function getContextFiles(story) {
   const legacyFiles = story.relevantFiles;
@@ -28425,7 +28704,7 @@ function normalizeWs(text) {
 function stripBackticks(text) {
   return text.replace(/`/g, "");
 }
-function canonical(text) {
+function canonical2(text) {
   return normalizeWs(stripBackticks(text));
 }
 function leadingTagGroup(line) {
@@ -28440,7 +28719,7 @@ function isContinuation(line) {
     return false;
   if (HEADING.test(line))
     return false;
-  if (LIST_ITEM_START.test(line))
+  if (LIST_ITEM_START2.test(line))
     return false;
   return true;
 }
@@ -28466,13 +28745,13 @@ function extractVerbatimAcs(specContent) {
   return blocks;
 }
 function prdAcPayloads(prd) {
-  return (prd.userStories ?? []).flatMap((story) => (story.acceptanceCriteria ?? []).map(canonical));
+  return (prd.userStories ?? []).flatMap((story) => (story.acceptanceCriteria ?? []).map(canonical2));
 }
 function findMissingVerbatimAcs(specContent, prd) {
   const prdAcs = prdAcPayloads(prd);
   const missing = [];
   for (const block of extractVerbatimAcs(specContent)) {
-    const payload = canonical(stripTagPrefix(block));
+    const payload = canonical2(stripTagPrefix(block));
     if (payload.length === 0)
       continue;
     if (!prdAcs.some((ac) => ac.includes(payload)))
@@ -28480,10 +28759,10 @@ function findMissingVerbatimAcs(specContent, prd) {
   }
   return missing;
 }
-var LEADING_TAG_GROUP, LIST_ITEM_START, HEADING;
+var LEADING_TAG_GROUP, LIST_ITEM_START2, HEADING;
 var init_verbatim_fidelity = __esm(() => {
   LEADING_TAG_GROUP = /^\s*(?:[-*]|\d+\.)?\s*((?:\[[a-z][a-z-]*\]\s*)+)/i;
-  LIST_ITEM_START = /^\s*(?:[-*]|\d+\.)\s/;
+  LIST_ITEM_START2 = /^\s*(?:[-*]|\d+\.)\s/;
   HEADING = /^\s*#/;
 });
 
@@ -28699,6 +28978,7 @@ function validateStory(raw, index, allIds) {
       suggestedCriteria = coerced;
     }
   }
+  const storyOutOfScope = normalizeOutOfScopeList(s.outOfScope);
   const routing = typeof s.routing === "object" && s.routing !== null ? s.routing : {};
   const rawComplexity = routing.complexity ?? s.complexity;
   if (rawComplexity === undefined || rawComplexity === null) {
@@ -28839,6 +29119,7 @@ function validateStory(raw, index, allIds) {
     ...contextFiles.length > 0 ? { contextFiles } : {},
     ...expectedFiles.length > 0 ? { expectedFiles } : {},
     ...suggestedCriteria !== undefined ? { suggestedCriteria } : {},
+    ...storyOutOfScope !== undefined ? { outOfScope: storyOutOfScope } : {},
     ...verifiedBy !== undefined ? { verifiedBy } : {},
     ...intent !== undefined ? { intent } : {}
   };
@@ -28893,6 +29174,7 @@ function validatePlanOutput(raw, feature, branch) {
   }
   const userStories = rawStories.map((story, index) => validateStory(story, index, allIds));
   const now = new Date().toISOString();
+  const featureOutOfScope = normalizeOutOfScopeList(obj.outOfScope);
   return {
     project: typeof obj.project === "string" && obj.project !== "" ? obj.project : feature,
     feature,
@@ -28900,13 +29182,15 @@ function validatePlanOutput(raw, feature, branch) {
     createdAt: typeof obj.createdAt === "string" ? obj.createdAt : now,
     updatedAt: now,
     userStories,
-    ...typeof obj.analysis === "string" && obj.analysis.trim() !== "" ? { analysis: obj.analysis.trim() } : {}
+    ...typeof obj.analysis === "string" && obj.analysis.trim() !== "" ? { analysis: obj.analysis.trim() } : {},
+    ...featureOutOfScope !== undefined ? { outOfScope: featureOutOfScope } : {}
   };
 }
 var VALID_COMPLEXITY, STORY_ID_NO_SEPARATOR;
 var init_schema2 = __esm(() => {
   init_test_strategy();
   init_errors();
+  init_out_of_scope();
   VALID_COMPLEXITY = ["simple", "medium", "complex", "expert"];
   STORY_ID_NO_SEPARATOR = /^([A-Za-z]+)(\d+)$/;
 });
@@ -28916,10 +29200,13 @@ var exports_prd = {};
 __export(exports_prd, {
   validatePlanOutput: () => validatePlanOutput,
   validateInjectedStory: () => validateInjectedStory,
+  stripPropagatedOutOfScope: () => stripPropagatedOutOfScope,
   setStoryPriority: () => setStoryPriority,
   savePRD: () => savePRD,
   resetStoryToPending: () => resetStoryToPending,
   resetFailedStoriesToPending: () => resetFailedStoriesToPending,
+  propagateOutOfScopeToStories: () => propagateOutOfScopeToStories,
+  normalizeOutOfScopeList: () => normalizeOutOfScopeList,
   markStorySkipped: () => markStorySkipped,
   markStoryPaused: () => markStoryPaused,
   markStoryPassed: () => markStoryPassed,
@@ -28935,10 +29222,14 @@ __export(exports_prd, {
   generateHumanHaltSummary: () => generateHumanHaltSummary,
   findSpecDriftViolations: () => findSpecDriftViolations,
   findMissingVerbatimAcs: () => findMissingVerbatimAcs,
+  findMissingOutOfScope: () => findMissingOutOfScope,
   extractVerbatimAcs: () => extractVerbatimAcs,
+  extractSpecOutOfScope: () => extractSpecOutOfScope,
   deriveNextStoryId: () => deriveNextStoryId,
   countStories: () => countStories,
-  PRD_MAX_FILE_SIZE: () => PRD_MAX_FILE_SIZE
+  applyOutOfScopeFallback: () => applyOutOfScopeFallback,
+  PRD_MAX_FILE_SIZE: () => PRD_MAX_FILE_SIZE,
+  MAX_OUT_OF_SCOPE_ITEMS: () => MAX_OUT_OF_SCOPE_ITEMS
 });
 import { existsSync as existsSync4, statSync } from "fs";
 async function loadPRD(path) {
@@ -28971,11 +29262,11 @@ async function loadPRD(path) {
     }
     story.storyPoints = story.storyPoints ?? 1;
   }
-  return prd;
+  return propagateOutOfScopeToStories(prd);
 }
 async function savePRD(prd, path) {
   prd.updatedAt = new Date().toISOString();
-  await saveJsonFile(path, prd, "prd");
+  await saveJsonFile(path, stripPropagatedOutOfScope(prd), "prd");
 }
 function hasSatisfiedDependencies(story, storyIds, completedIds) {
   return story.dependencies.every((dep) => !storyIds.has(dep) || completedIds.has(dep));
@@ -29129,8 +29420,10 @@ var PRD_MAX_FILE_SIZE;
 var init_prd = __esm(() => {
   init_errors();
   init_json_file();
+  init_out_of_scope();
   init_verbatim_fidelity();
   init_spec_drift();
+  init_out_of_scope();
   init_inject();
   init_schema2();
   PRD_MAX_FILE_SIZE = 5 * 1024 * 1024;
@@ -31204,7 +31497,49 @@ var init_role_task = __esm(() => {
   init_test_runners();
 });
 
+// src/prompts/sections/out-of-scope.ts
+function buildOutOfScopeLines(items) {
+  if (!items || items.length === 0)
+    return [];
+  return [
+    "",
+    "**Out of Scope \u2014 do NOT implement these:**",
+    ...items.map((item) => `- ${item}`),
+    "",
+    "Treat the list above as a hard boundary. If satisfying an acceptance criterion appears to require",
+    "one of these, implement only what the criterion states and note the tension in your final message \u2014",
+    "do not expand into the excluded work."
+  ];
+}
+function buildReviewOutOfScopeBlock(items, opts = {}) {
+  if (!items || items.length === 0)
+    return "";
+  const header = [
+    "",
+    "**Out of Scope (feature-level \u2014 NOT acceptance criteria):**",
+    ...items.map((item, i) => `${i + 1}. ${item}`),
+    "",
+    "These state what the feature deliberately does not do. They are not acceptance criteria:",
+    "never cite one as `acQuote`/`acIndex`, and never treat the absence of this work as a defect."
+  ];
+  if (!opts.citable) {
+    return [...header, "Report nothing against this list; it is context so you do not demand excluded work."].join(`
+`);
+  }
+  return [
+    ...header,
+    'To report work that crossed one of these boundaries, set `category` to `"out-of-scope"`, quote the',
+    "entry verbatim in `scopeQuote`, and set `scopeIndex` to its number above. Emit these as",
+    '`severity: "warning"` \u2014 never `"error"`. Set `scopeQuote`/`scopeIndex` ONLY on an `"out-of-scope"`',
+    "finding; on any other finding they are ignored."
+  ].join(`
+`);
+}
+
 // src/prompts/sections/story.ts
+function outOfScopeLines(story) {
+  return buildOutOfScopeLines(story.outOfScope);
+}
 function buildBatchStorySection(stories) {
   const storyBlocks = stories.map((story, i) => {
     const criteria = story.acceptanceCriteria.map((c, j) => `${j + 1}. ${c}`).join(`
@@ -31215,7 +31550,8 @@ function buildBatchStorySection(stories) {
       story.description,
       "",
       "**Acceptance Criteria:**",
-      criteria
+      criteria,
+      ...outOfScopeLines(story)
     ].join(`
 `);
   });
@@ -31255,6 +31591,7 @@ function buildStoryReminderSection(story) {
     "",
     "**Acceptance Criteria:**",
     criteria,
+    ...outOfScopeLines(story),
     "",
     "<!-- END USER-SUPPLIED DATA -->"
   ].join(`
@@ -31277,11 +31614,13 @@ function buildStorySection(story) {
     "",
     "**Acceptance Criteria:**",
     criteria,
+    ...outOfScopeLines(story),
     "",
     "<!-- END USER-SUPPLIED DATA -->"
   ].join(`
 `);
 }
+var init_story = () => {};
 
 // src/prompts/sections/verdict.ts
 function buildVerdictSection(story) {
@@ -31528,6 +31867,7 @@ When the story is ambiguous, pick an interpretation, proceed, and document the c
 var init_sections2 = __esm(() => {
   init_hermetic();
   init_role_task();
+  init_story();
   init_acceptance();
 });
 
@@ -32292,6 +32632,7 @@ Notes:
 - \`inspectedFiles\` must list the relative paths you actually opened while reviewing. A \`passed:true\` verdict with an empty or absent \`inspectedFiles\` is invalid \u2014 walk each AC against the real files before passing.
 If all ACs are correctly implemented after inspecting the code, respond with { "passed": true, "inspectedFiles": ["..."], "findings": [] }.`, ReviewPromptBuilder;
 var init_review_builder = __esm(() => {
+  init_sections2();
   SEMANTIC_ROLE = "You are a semantic code reviewer with access to the repository files. " + "Your job is to walk each acceptance criterion (AC) and judge whether the production code fulfills it \u2014 fully, partially, or not at all. " + "Test coverage gaps and convention/lint issues are out of scope \u2014 adversarial review and lint/typecheck handle those.";
   ReviewPromptBuilder = class ReviewPromptBuilder {
     buildSemanticReviewPrompt(story, semanticConfig, options) {
@@ -32317,7 +32658,7 @@ ${semanticConfig.rules.map((r, i) => `${i + 1}. ${r}`).join(`
 ${story.description}
 
 ### Acceptance Criteria
-${acList}
+${acList}${buildReviewOutOfScopeBlock(story.outOfScope)}
 ${customRulesBlock}${priorIterationsBlock}
 ${SEMANTIC_INSTRUCTIONS}
 ${SEMANTIC_OUTPUT_SCHEMA}
@@ -32557,13 +32898,15 @@ Respond with ONLY a JSON object \u2014 no preamble, no explanation outside the J
   "findings": [
     {
       "severity": "error" | "warning" | "info" | "unverifiable",
-      "category": "input" | "error-path" | "abandonment" | "test-gap" | "convention" | "assumption",
+      "category": "input" | "error-path" | "abandonment" | "test-gap" | "convention" | "assumption" | "out-of-scope",
       "file": "relative/path/to/file.ts",
       "line": 42,
       "issue": "Precise description of the weakness",
       "suggestion": "Concrete fix or mitigation",
       "acQuote": "<verbatim substring of one AC bullet constraining this locus \u2014 required for 'error'>",
       "acIndex": 2,
+      "scopeQuote": "<out-of-scope findings ONLY: verbatim substring of one Out of Scope entry>",
+      "scopeIndex": 1,
       "verifiedBy": {
         "command": "command used to inspect the current codebase",
         "file": "relative/path/to/file.ts",
@@ -32609,10 +32952,19 @@ Worked example:
 **Exception \u2014 the trap does NOT apply to \`category:"test-gap"\` findings.** A fake/placeholder/missing test is the *absence* of verification for an AC's behaviour; it cannot name a symbol that is present in the (worthless) test file, because the defect is precisely that the symbol-under-test is never exercised. A \`test-gap\` finding is grounded by the AC whose behaviour goes unverified \u2014 cite that AC's \`acIndex\` and a verbatim \`acQuote\` substring from it, and keep severity \`"error"\`. The symbol-naming requirement is waived for this category.
 
 **Scope constraints are not Acceptance Criteria:**
-The story description may contain a "Scope" section with "In:" and "Out:" bullets. These are implementation guidelines, not ACs. A finding about code changed outside the stated scope (e.g., a file listed under "Out:") cannot cite a scope constraint as its \`acQuote\`/\`acIndex\` because scope text is not in the numbered AC list. Emit scope-violation findings as \`"warning"\` \u2014 never \`"error"\`. Never use \`acIndex: 0\`; \`acIndex\` is 1-based (first AC bullet = 1).
+Scope boundaries reach you two ways: the story description may contain a "Scope" section with "In:" and "Out:" bullets (inter-story boundaries), and the story may carry a numbered **Out of Scope** list (feature-level exclusions the spec declared). Neither is an AC.
+
+A finding about code that crossed one of these boundaries must NOT cite an AC \u2014 \`acQuote\`/\`acIndex\` are for acceptance criteria only, and scope text is not in the numbered AC list. Instead:
+- Set \`category\` to \`"out-of-scope"\`.
+- When the boundary comes from the numbered **Out of Scope** list, set \`scopeQuote\` to a verbatim substring of that entry and \`scopeIndex\` to its 1-based number. A \`scopeQuote\` that is not a verbatim substring of the entry you indexed is discarded.
+- When the boundary is only a description "Out:" bullet, quote it in \`issue\` and leave \`scopeQuote\`/\`scopeIndex\` unset.
+- Emit scope-violation findings as \`"warning"\` \u2014 never \`"error"\`. Reporting the boundary is the goal; it does not block the story.
+
+Never use \`acIndex: 0\`; \`acIndex\` is 1-based (first AC bullet = 1). The same applies to \`scopeIndex\`.
 
 If you cannot find an AC that names the **specific symbol** in your finding, downgrade to \`"info"\` or \`"warning"\`. A finding dropped by the validator is worse than one correctly classified as advisory.`, AdversarialReviewPromptBuilder;
 var init_adversarial_review_builder = __esm(() => {
+  init_sections2();
   AdversarialReviewPromptBuilder = class AdversarialReviewPromptBuilder {
     buildAdversarialReviewPrompt(story, config2, options) {
       const {
@@ -32636,7 +32988,7 @@ var init_adversarial_review_builder = __esm(() => {
 
 **Acceptance Criteria:**
 ${story.acceptanceCriteria.map((ac, i) => `${i + 1}. ${ac}`).join(`
-`)}
+`)}${buildReviewOutOfScopeBlock(story.outOfScope, { citable: true })}
 
 `;
       const customRulesBlock = config2.rules.length > 0 ? `## Project-Specific Adversarial Rules
@@ -33190,7 +33542,49 @@ function filterByAcGroundingMinimal(findings, acceptanceCriteria) {
   }
   return { accepted, dropped };
 }
-var BLOCKING_SEVERITIES;
+function claimsScopeViolation(finding) {
+  return finding.category === "out-of-scope";
+}
+function validateScopeQuote(finding, outOfScope) {
+  if (!claimsScopeViolation(finding))
+    return { valid: true };
+  const { scopeQuote, scopeIndex } = finding;
+  if (scopeQuote === undefined)
+    return { valid: true };
+  if (typeof scopeQuote !== "string" || scopeQuote.trim().length < MIN_SCOPE_QUOTE_LENGTH) {
+    return { valid: false, code: "missing_scope_quote" };
+  }
+  if (outOfScope.length === 0) {
+    return { valid: false, code: "no_out_of_scope_declared" };
+  }
+  if (typeof scopeIndex !== "number" || scopeIndex < 1 || scopeIndex > outOfScope.length) {
+    return { valid: false, code: "scope_index_out_of_range" };
+  }
+  const entry = normalizeWs2(stripMarkdownInline(outOfScope[scopeIndex - 1]));
+  const quote = normalizeWs2(stripMarkdownInline(scopeQuote));
+  if (!entry.toLowerCase().includes(quote.toLowerCase())) {
+    return { valid: false, code: "scope_quote_not_substring" };
+  }
+  return { valid: true };
+}
+function filterByScopeQuote(findings, outOfScope) {
+  const accepted = [];
+  const dropped = [];
+  for (const finding of findings) {
+    if (!claimsScopeViolation(finding)) {
+      accepted.push(finding.scopeQuote === undefined && finding.scopeIndex === undefined ? finding : { ...finding, scopeQuote: undefined, scopeIndex: undefined });
+      continue;
+    }
+    const result = validateScopeQuote(finding, outOfScope);
+    if (result.valid) {
+      accepted.push(finding);
+    } else {
+      dropped.push({ finding, code: result.code });
+    }
+  }
+  return { accepted, dropped };
+}
+var BLOCKING_SEVERITIES, MIN_SCOPE_QUOTE_LENGTH = 3;
 var init_ac_quote_validator = __esm(() => {
   BLOCKING_SEVERITIES = new Set(["error", "critical"]);
 });
@@ -33393,6 +33787,17 @@ function warnOnDroppedVerbatimAcs(prd, specContent, featureName) {
     getSafeLogger()?.warn("plan", "[verbatim] spec acceptance criteria dropped from PRD \u2014 run spec-review --prd before executing", { featureName, missingCount: missing.length, missing });
   }
 }
+function backfillOutOfScope(prd, specContent, featureName) {
+  const missing = findMissingOutOfScope(specContent, prd);
+  if (missing.length === 0)
+    return prd;
+  getSafeLogger()?.warn("plan", "Spec out-of-scope statements dropped from PRD \u2014 backfilled verbatim from the spec", {
+    featureName,
+    missingCount: missing.length,
+    missing
+  });
+  return applyOutOfScopeFallback(prd, specContent);
+}
 function warnOnSpecDrift(prd, featureName) {
   const violations = findSpecDriftViolations(prd);
   if (violations.length > 0) {
@@ -33461,7 +33866,7 @@ ${outputFormat}`, overridable: false }
       if (!parsed.userStories || parsed.userStories.length === 0)
         return null;
       warnOnDroppedVerbatimAcs(parsed, input.specContent, input.featureName);
-      return parsed;
+      return backfillOutOfScope(parsed, input.specContent, input.featureName);
     },
     recover: async (input, ctx) => {
       const content = await ctx.readFile(input.outputPath);
@@ -33659,6 +34064,32 @@ function verbatimSelfHealStep(builder) {
     }
   });
 }
+async function readMissingOutOfScope(input) {
+  const content = await _planRefineDeps.readFile(input.outputPath);
+  if (!content)
+    return [];
+  try {
+    const prd = validatePlanOutput(content, input.featureName, input.branchName);
+    return findMissingOutOfScope(input.specContent, prd);
+  } catch (err) {
+    getSafeLogger()?.debug("plan", "Skipped out-of-scope self-heal \u2014 draft PRD not yet parseable", {
+      featureName: input.featureName,
+      error: errorMessage(err)
+    });
+    return [];
+  }
+}
+function outOfScopeSelfHealStep(builder) {
+  return makeSelfHealStep({
+    detect: (input) => readMissingOutOfScope(input),
+    buildRepair: (missing, input) => builder.buildOutOfScopeRepair(missing, input.outputPath),
+    log: {
+      kind: "plan",
+      message: "Refine dropped spec out-of-scope statements \u2014 issuing one repair turn",
+      meta: (input, missing) => ({ featureName: input.featureName, missingCount: missing.length })
+    }
+  });
+}
 function specDriftSelfHealStep(builder) {
   return makeSelfHealStep({
     detect: (input) => readSpecDriftViolations(input),
@@ -33765,6 +34196,7 @@ ${outputFormat}`,
       };
       const steps = [
         verbatimSelfHealStep(builder),
+        outOfScopeSelfHealStep(builder),
         ...specGuard ? [specDriftSelfHealStep(builder)] : []
       ];
       return runSelfHealChain(ctx, seed, steps);
@@ -33778,7 +34210,8 @@ ${outputFormat}`,
       if (ctx.config.plan.specGuard) {
         warnOnSpecDrift(validated, input.featureName);
       }
-      return await normalizeCreatedContextFiles(validated, input.workdir, ctx.fileExists);
+      const scoped = backfillOutOfScope(validated, input.specContent, input.featureName);
+      return await normalizeCreatedContextFiles(scoped, input.workdir, ctx.fileExists);
     },
     recover: async (input, ctx) => {
       const content = await ctx.readFile(input.outputPath);
@@ -35201,6 +35634,8 @@ var init_ac_structural_counterfactual = __esm(() => {
 
 // src/review/category-fix-target.ts
 function categoryToFixTarget(category) {
+  if (category === "out-of-scope")
+    return "source";
   return category != null && BLOCKING_CATEGORIES.has(category) ? "source" : "test";
 }
 var init_category_fix_target = __esm(() => {
@@ -35239,6 +35674,10 @@ function toAdversarialReviewFindings(findings) {
       metaExtras.acIndex = f.acIndex;
     if (f.verifiedBy)
       metaExtras.verifiedBy = f.verifiedBy;
+    if (f.scopeQuote)
+      metaExtras.scopeQuote = f.scopeQuote;
+    if (f.scopeIndex != null)
+      metaExtras.scopeIndex = f.scopeIndex;
     return {
       source: "adversarial-review",
       severity: normalizeSeverity(f.severity),
@@ -35479,9 +35918,9 @@ function parseRequoteResponse(output) {
   const parsed = tryParseLLMJson(output);
   if (!isRecord(parsed))
     return null;
-  const canonical2 = extractCanonical(parsed);
-  if (canonical2)
-    return canonical2;
+  const canonical3 = extractCanonical(parsed);
+  if (canonical3)
+    return canonical3;
   const findings = parsed.findings;
   if (!Array.isArray(findings) || findings.length !== 1)
     return null;
@@ -36195,7 +36634,28 @@ var init_adversarial_review = __esm(() => {
         storyId: input.story.id,
         blockingThreshold: threshold
       });
-      const { accepted, dropped } = filterByAcQuote(substantiated, input.story.acceptanceCriteria);
+      const { accepted: scopeGrounded, dropped: scopeDropped } = filterByScopeQuote(substantiated, input.story.outOfScope ?? []);
+      for (const entry of scopeDropped) {
+        getSafeLogger()?.info("review", "Adversarial scope finding dropped (ungrounded scopeQuote)", {
+          storyId: input.story.id,
+          event: "review.adversarial.scope_quote_dropped",
+          file: entry.finding.file,
+          code: entry.code
+        });
+      }
+      for (const finding of scopeGrounded) {
+        if (finding.category !== "out-of-scope" && finding.scopeQuote === undefined)
+          continue;
+        getSafeLogger()?.info("review", "Adversarial scope finding accepted (advisory)", {
+          storyId: input.story.id,
+          event: "review.adversarial.scope_finding_accepted",
+          file: finding.file,
+          severity: finding.severity,
+          grounded: finding.scopeQuote !== undefined,
+          declaredExclusions: (input.story.outOfScope ?? []).length
+        });
+      }
+      const { accepted, dropped } = filterByAcQuote(scopeGrounded, input.story.acceptanceCriteria);
       const recurrenceCfg = input.adversarialConfig.recurrenceDemotion ?? { enabled: true, maxBlockingRounds: 2 };
       const patterns = input.resolvedTestPatterns?.regex ?? [];
       const testFileMatch = (file3) => patterns.some((re) => re.test(file3));
@@ -41815,7 +42275,7 @@ var package_default;
 var init_package = __esm(() => {
   package_default = {
     name: "@nathapp/nax",
-    version: "0.73.4",
+    version: "0.74.0",
     description: "AI Coding Agent Orchestrator \u2014 loops until done",
     type: "module",
     bin: {
@@ -41826,9 +42286,9 @@ var init_package = __esm(() => {
       dev: "bun run bin/nax.ts",
       build: 'bun build bin/nax.ts --outdir dist --target bun --define "GIT_COMMIT=\\"$(git rev-parse --short HEAD)\\""',
       typecheck: "bun x tsc --noEmit && bun x tsc --noEmit -p tsconfig.contracts.json",
-      lint: "bun x biome check src/ bin/ && bun run check:no-real-global-nax && bun run check:alias-internals && bun run check:deep-relatives && bun run check:nax-error && bun run check:logger-storyid && bun run check:log-format-layering && bun run check:file-sizes",
-      "lint:json": "bun x biome check src/ bin/ --reporter json && bun run check:nax-error 1>&2 && bun run check:logger-storyid 1>&2",
-      "lint:fix": "bun x biome check --write src/ bin/",
+      lint: "bun x biome check src/ bin/ flows/ && bun run check:no-real-global-nax && bun run check:alias-internals && bun run check:deep-relatives && bun run check:nax-error && bun run check:logger-storyid && bun run check:log-format-layering && bun run check:file-sizes",
+      "lint:json": "bun x biome check src/ bin/ flows/ --reporter json && bun run check:nax-error 1>&2 && bun run check:logger-storyid 1>&2",
+      "lint:fix": "bun x biome check --write src/ bin/ flows/",
       "check:no-real-global-nax": "bun run scripts/check-no-real-global-nax.ts",
       "check:alias-internals": "bun run scripts/check-alias-internals.ts",
       "check:deep-relatives": "bun run scripts/check-deep-relatives.ts",
@@ -41865,6 +42325,7 @@ var init_package = __esm(() => {
     },
     dependencies: {
       "@types/react": "^19.2.14",
+      acpx: "^0.12.1",
       chalk: "^5.6.2",
       commander: "^13.1.0",
       ink: "^6.7.0",
@@ -41890,6 +42351,7 @@ var init_package = __esm(() => {
     ],
     files: [
       "dist/",
+      "flows/",
       "README.md",
       "CHANGELOG.md"
     ],
@@ -41916,8 +42378,8 @@ var init_version = __esm(() => {
   NAX_VERSION = package_default.version;
   NAX_COMMIT = (() => {
     try {
-      if (/^[0-9a-f]{6,10}$/.test("ec04b570"))
-        return "ec04b570";
+      if (/^[0-9a-f]{6,10}$/.test("91bb7306"))
+        return "91bb7306";
     } catch {}
     try {
       const result = Bun.spawnSync(["git", "rev-parse", "--short", "HEAD"], {
@@ -45067,6 +45529,9 @@ Re-check routing.complexity and routing.testStrategy against the current codebas
 #### regression-coverage
 If a story changes existing behavior, extracts a shared helper, extends an existing function signature, or replaces a warning/stub path with real behavior, ensure there is at least one acceptance criterion protecting backward compatibility or proving the old placeholder behavior is gone.
 
+#### out-of-scope-preservation
+If the spec has an "Out of Scope", "Non-Goals", or "Not in scope" section \u2014 or an inline \`**Out of scope \u2026:**\` lead-in \u2014 enumerate every item it states and confirm each appears in the top-level \`outOfScope\` array. Restore any that are missing, verbatim. Never convert one into an acceptance criterion, and never delete one because it looks obvious. Where a story sits close to one of these boundaries, echo the item into that story's \`**Scope** \u2014 Out:\` bullet too.
+
 #### scope-consistency
 Check each story's title, description, scope, contextFiles, and acceptance criteria for internal consistency. If the story says a file or command is in scope anywhere else, do not list it as out of scope. If the title or acceptance criteria clearly include CLI, output, tests, or helper extraction work, the Scope section must reflect that accurately.${specGuardItems}
 
@@ -45105,6 +45570,24 @@ For each one:
 - Preserve every backtick-quoted command, file path, regex, and count exactly as written in the spec. Do not paraphrase, retag, split, or move them into a description.
 - Do not remove or weaken any acceptance criteria that are already correct.
 
+Write the corrected PRD to this file path: ${outputFilePath}
+Do not output the PRD in chat. After writing the file, reply with a brief text confirmation only.`;
+  }
+  buildOutOfScopeRepair(missing, outputFilePath) {
+    const list = missing.map((item) => `- ${item}`).join(`
+`);
+    return `Your revised PRD dropped feature-level exclusions the spec declared out of scope. These are the only channel by which a deferred arc reaches the implementer \u2014 the implementer never sees the spec, so a dropped exclusion means nothing stops it from building work this feature deliberately defers.
+
+The following out-of-scope statements are missing from the top-level \`outOfScope\` array:
+
+${list}
+
+For each one:
+- Add it to the top-level \`outOfScope\` array, preserving the spec's wording. You may append a short clarifier, but never drop or merge an item.
+- Never convert an out-of-scope statement into an acceptance criterion \u2014 it describes work NOT to do.
+- Where a story sits close enough to the boundary that an implementer might stray across it, also echo the item into that story's \`**Scope** \u2014 Out:\` bullet.
+- Do not remove or weaken anything already correct.
+
 Write the corrected PRD to this file path: ${outputFilePath}
 Do not output the PRD in chat. After writing the file, reply with a brief text confirmation only.`;
   }
@@ -45185,6 +45668,7 @@ Generate a JSON object with this exact structure (no markdown, no explanation \u
   "branchName": "string \u2014 git branch (e.g. feat/my-feature)",
   "createdAt": "ISO 8601 timestamp",
   "updatedAt": "ISO 8601 timestamp",
+  ${OUT_OF_SCOPE_SCHEMA_FIELD}
   "userStories": [
     {
       "id": "string \u2014 e.g. US-001",
@@ -45193,6 +45677,7 @@ Generate a JSON object with this exact structure (no markdown, no explanation \u
       "acceptanceCriteria": ["string \u2014 behavioral, testable criteria. Format: 'When [X], then [Y]'. One assertion per AC. Never include quality gates."],${suggestedCriteriaField}
       "contextFiles": ["string \u2014 EXISTING source files the agent should read (max 5, relative paths)"],
       ${EXPECTED_FILES_SCHEMA_FIELD}
+      ${STORY_OUT_OF_SCOPE_SCHEMA_FIELD}
       "tags": ["string \u2014 routing tags, e.g. feature, security, api"],
       "dependencies": ["string \u2014 story IDs this story depends on"],${workdirField}
       "status": "pending",
@@ -45284,6 +45769,7 @@ Produce a JSON object with this exact structure. Field names are mandatory \u201
   "project": "string \u2014 project name",
   "feature": "string \u2014 feature name (copy from above)",
   "branchName": "string \u2014 git branch name",
+  ${OUT_OF_SCOPE_SCHEMA_FIELD}
   "userStories": [
     {
       "id": "string \u2014 e.g. US-001",
@@ -45292,6 +45778,7 @@ Produce a JSON object with this exact structure. Field names are mandatory \u201
       "acceptanceCriteria": ["string \u2014 behavioral criterion, format: 'When [X], then [Y]'. One assertion per item."],${suggestedCriteriaField}
       "contextFiles": ["string \u2014 EXISTING relative paths the implementer should read (max 5)"],
       ${EXPECTED_FILES_SCHEMA_FIELD}
+      ${STORY_OUT_OF_SCOPE_SCHEMA_FIELD}
       "tags": ["string"],
       "dependencies": ["string \u2014 story IDs this story depends on"],${workdirField}
       "routing": {
@@ -45335,7 +45822,7 @@ ${rows.join(`
 }
 var CONTEXT_VS_EXPECTED_FILES_RULE = `**\`contextFiles\` rule \u2014 files readable when this story runs.** List paths that already exist in the repo today, PLUS any file an UPSTREAM dependency story creates (it does not exist now but will exist by the time this story runs, because dependencies execute first). The pipeline verifies every \`contextFiles\` entry against the filesystem; a path that exists neither on disk nor in an upstream dependency's outputs is treated as a missing-context warning.
 
-**\`expectedFiles\` rule \u2014 files THIS story CREATES.** List every NEW file this story authors (relative paths). A file this story creates belongs here, NEVER in \`contextFiles\` \u2014 these are the story's outputs, not files to read first. A file created by an upstream dependency and only read/modified here belongs in \`contextFiles\`, NOT here (this story does not author it). A single path may appear in \`contextFiles\` (an existing sibling to mirror) AND \`expectedFiles\` (the new file itself), but the same path must never be in both.`, EXPECTED_FILES_SCHEMA_FIELD = `"expectedFiles": ["string \u2014 NEW files this story creates (relative paths, omit if none)"],`;
+**\`expectedFiles\` rule \u2014 files THIS story CREATES.** List every NEW file this story authors (relative paths). A file this story creates belongs here, NEVER in \`contextFiles\` \u2014 these are the story's outputs, not files to read first. A file created by an upstream dependency and only read/modified here belongs in \`contextFiles\`, NOT here (this story does not author it). A single path may appear in \`contextFiles\` (an existing sibling to mirror) AND \`expectedFiles\` (the new file itself), but the same path must never be in both.`, EXPECTED_FILES_SCHEMA_FIELD = `"expectedFiles": ["string \u2014 NEW files this story creates (relative paths, omit if none)"],`, OUT_OF_SCOPE_SCHEMA_FIELD = `"outOfScope": ["string \u2014 verbatim from the spec's Out of Scope / Non-Goals section: what this feature deliberately does NOT do. Omit if the spec declares none."],`, STORY_OUT_OF_SCOPE_SCHEMA_FIELD = `"outOfScope": ["string \u2014 optional, exclusions specific to THIS story beyond the feature-level list. Omit if none."],`;
 var init_plan_builder = __esm(() => {
   init_config();
   init_one_shot_builder();
@@ -45775,6 +46262,7 @@ var init_prompts = __esm(() => {
   init_tdd_builder();
   init_tdd_builder();
   init_debate_builder();
+  init_sections2();
   init_review_builder();
   init_adversarial_review_builder();
   init_acceptance_builder();
@@ -57896,15 +58384,26 @@ function recordOscillations(store, storyId, delta) {
 function getOscillations(store, storyId) {
   return store.get(storyId) ?? 0;
 }
+function sourceSet(findings) {
+  return new Set((Array.isArray(findings) ? findings : []).map((f) => f.source));
+}
 function countOscillationOutcomes(iterations) {
+  const resolvedSources = new Set;
   let count = 0;
   for (const iteration of iterations) {
-    if (iteration.outcome === OSCILLATION_OUTCOME)
-      count += 1;
+    const beforeSources = sourceSet(iteration.findingsBefore);
+    const afterSources = sourceSet(iteration.findingsAfter);
+    for (const source of afterSources) {
+      if (resolvedSources.has(source))
+        count += 1;
+    }
+    for (const source of beforeSources) {
+      if (!afterSources.has(source))
+        resolvedSources.add(source);
+    }
   }
   return count;
 }
-var OSCILLATION_OUTCOME = "regressed-different-source";
 
 // src/execution/checkpoint/resume-plan.ts
 function buildResumePlan(cp, current) {
@@ -63473,6 +63972,218 @@ var init_curator = __esm(() => {
   };
 });
 
+// src/plugins/builtin/nax-finish/config.ts
+function selectFinish(config2) {
+  if (!config2 || typeof config2 !== "object")
+    return;
+  return finishConfigSelector.select(config2)?.finish;
+}
+function getFinishAutoFlowConfig(ctx) {
+  const autoFlow = selectFinish(ctx.config)?.autoFlow;
+  if (!autoFlow)
+    return DEFAULT_FINISH_AUTO_FLOW_CONFIG;
+  const defaults = DEFAULT_FINISH_AUTO_FLOW_CONFIG;
+  return {
+    enabled: autoFlow.enabled === true,
+    flowPath: autoFlow.flowPath ?? defaults.flowPath,
+    defaultAgent: autoFlow.defaultAgent ?? null,
+    reviewers: {
+      spec: autoFlow.reviewers?.spec ?? null,
+      quality: autoFlow.reviewers?.quality ?? null
+    },
+    escalate: { telegram: autoFlow.escalate?.telegram !== false },
+    timeouts: {
+      acceptanceMs: autoFlow.timeouts?.acceptanceMs ?? defaults.timeouts.acceptanceMs,
+      gateMs: autoFlow.timeouts?.gateMs ?? defaults.timeouts.gateMs,
+      flowMs: autoFlow.timeouts?.flowMs ?? defaults.timeouts.flowMs,
+      stepMs: autoFlow.timeouts?.stepMs ?? defaults.timeouts.stepMs
+    }
+  };
+}
+function telegramCreds(config2) {
+  const interaction = config2?.interaction;
+  const tg = interaction?.plugin === "telegram" ? interaction.config ?? {} : {};
+  const token = tg.botToken ?? process.env.NAX_TELEGRAM_TOKEN ?? process.env.TELEGRAM_BOT_TOKEN ?? null;
+  const chatId = tg.chatId ?? process.env.NAX_TELEGRAM_CHAT_ID ?? null;
+  return token && chatId ? { token, chatId } : null;
+}
+var DEFAULT_FINISH_AUTO_FLOW_CONFIG;
+var init_config2 = __esm(() => {
+  init_config();
+  DEFAULT_FINISH_AUTO_FLOW_CONFIG = {
+    enabled: false,
+    flowPath: "flows/nax-finish/nax-finish.flow.ts",
+    defaultAgent: null,
+    reviewers: { spec: null, quality: null },
+    escalate: { telegram: true },
+    timeouts: { acceptanceMs: 600000, gateMs: 900000, flowMs: 5400000, stepMs: null }
+  };
+});
+
+// src/plugins/builtin/nax-finish/telegram.ts
+async function sendTelegramNotify(cfg, text) {
+  const res = await _telegramDeps.fetch(`https://api.telegram.org/bot${cfg.token}/sendMessage`, {
+    method: "POST",
+    headers: { "content-type": "application/json" },
+    body: JSON.stringify({ chat_id: cfg.chatId, text, parse_mode: "Markdown" })
+  });
+  return res.ok;
+}
+var _telegramDeps;
+var init_telegram2 = __esm(() => {
+  _telegramDeps = { fetch: (...a) => fetch(...a) };
+});
+
+// src/plugins/builtin/nax-finish/index.ts
+import * as path21 from "path";
+async function defaultRun2(cmd, opts) {
+  const proc = Bun.spawn(cmd, { cwd: opts.cwd, env: opts.env, stdout: "pipe", stderr: "pipe" });
+  let timedOut = false;
+  const timer = opts.timeoutMs && opts.timeoutMs > 0 ? setTimeout(() => {
+    timedOut = true;
+    proc.kill();
+  }, opts.timeoutMs) : undefined;
+  try {
+    const [exitCode, stdout, stderr] = await Promise.all([
+      proc.exited,
+      new Response(proc.stdout).text(),
+      new Response(proc.stderr).text()
+    ]);
+    return timedOut ? {
+      exitCode: exitCode === 0 ? 124 : exitCode,
+      stdout,
+      stderr: `${stderr}
+[nax-finish] flow killed after ${opts.timeoutMs}ms timeout`
+    } : { exitCode, stdout, stderr };
+  } finally {
+    if (timer)
+      clearTimeout(timer);
+  }
+}
+async function defaultReadResult(workdir) {
+  const f = Bun.file(path21.join(workdir, ".nax", "nax-finish-result.json"));
+  if (!await f.exists())
+    return null;
+  return JSON.parse(await f.text());
+}
+function isFeatureBranch(b) {
+  return b !== "main" && b !== "master" && b.length > 0;
+}
+async function resolveFlowPath(workdir, flowPath, deps = _naxFinishDeps) {
+  if (path21.isAbsolute(flowPath)) {
+    return await deps.exists(flowPath) ? flowPath : null;
+  }
+  const candidates = [];
+  let dir = deps.moduleDir;
+  for (let i = 0;i < PACKAGE_ROOT_SEARCH_DEPTH; i += 1) {
+    dir = path21.dirname(dir);
+    if (await deps.exists(path21.join(dir, "package.json")))
+      candidates.push(path21.resolve(dir, flowPath));
+  }
+  candidates.push(path21.resolve(workdir, flowPath));
+  for (const candidate of candidates) {
+    if (await deps.exists(candidate))
+      return candidate;
+  }
+  return null;
+}
+function buildFlowArgv(flowPath, inputJson, defaultAgent, stepMs) {
+  const stepTimeout = stepMs && stepMs > 0 ? ["--timeout", String(Math.ceil(stepMs / 1000))] : [];
+  return [
+    "acpx",
+    "--approve-all",
+    ...stepTimeout,
+    "flow",
+    "run",
+    flowPath,
+    "--input-json",
+    inputJson,
+    ...defaultAgent ? ["--default-agent", defaultAgent] : []
+  ];
+}
+function buildFlowEnv(cfg) {
+  const env2 = { ...process.env };
+  if (cfg.reviewers.spec)
+    env2.NAX_FINISH_SPEC_PROFILE = cfg.reviewers.spec;
+  if (cfg.reviewers.quality)
+    env2.NAX_FINISH_QUALITY_PROFILE = cfg.reviewers.quality;
+  return env2;
+}
+var PLUGIN_NAME4 = "nax-finish", PLUGIN_VERSION4 = "0.1.0", PACKAGE_ROOT_SEARCH_DEPTH = 6, _naxFinishDeps, naxFinishAction, naxFinishPlugin;
+var init_nax_finish = __esm(() => {
+  init_config2();
+  init_telegram2();
+  _naxFinishDeps = {
+    run: defaultRun2,
+    readResult: defaultReadResult,
+    exists: (p) => Bun.file(p).exists(),
+    moduleDir: import.meta.dir,
+    notify: sendTelegramNotify
+  };
+  naxFinishAction = {
+    name: PLUGIN_NAME4,
+    description: "Autonomously finishes a feature (acceptance -> review -> gates -> PR) via an acpx flow after a successful run",
+    async shouldRun(ctx) {
+      const cfg = getFinishAutoFlowConfig(ctx);
+      if (!cfg.enabled)
+        return false;
+      const s = ctx.storySummary;
+      if (s.completed === 0 || s.failed > 0 || s.paused > 0)
+        return false;
+      return isFeatureBranch(ctx.branch);
+    },
+    async execute(ctx) {
+      try {
+        const cfg = getFinishAutoFlowConfig(ctx);
+        const flowPath = await resolveFlowPath(ctx.workdir, cfg.flowPath);
+        if (!flowPath) {
+          return {
+            success: false,
+            message: `nax-finish: flow module "${cfg.flowPath}" not found in the nax install or ${ctx.workdir}`
+          };
+        }
+        const creds = telegramCreds(ctx.config);
+        const escalateTelegram = cfg.escalate.telegram && creds !== null;
+        const input = {
+          feature: ctx.feature,
+          workdir: ctx.workdir,
+          branch: ctx.branch,
+          prdPath: ctx.prdPath,
+          escalateTelegram,
+          timeouts: { acceptanceMs: cfg.timeouts.acceptanceMs, gateMs: cfg.timeouts.gateMs }
+        };
+        const cmd = buildFlowArgv(flowPath, JSON.stringify(input), cfg.defaultAgent, cfg.timeouts.stepMs);
+        const res = await _naxFinishDeps.run(cmd, {
+          cwd: ctx.workdir,
+          env: buildFlowEnv(cfg),
+          timeoutMs: cfg.timeouts.flowMs
+        });
+        const result = await _naxFinishDeps.readResult(ctx.workdir);
+        if (!result) {
+          return { success: res.exitCode === 0, message: `nax-finish flow exited ${res.exitCode} (no result file)` };
+        }
+        if (result.status === "escalated" && escalateTelegram && creds) {
+          await _naxFinishDeps.notify(creds, `nax-finish escalated *${result.feature}*: ${result.escalationReason ?? ""}`);
+        }
+        return { success: true, message: `nax-finish: ${result.status}`, url: result.url };
+      } catch (err) {
+        ctx.logger.warn("nax-finish execute failed", { error: String(err) });
+        return { success: false, message: `nax-finish failed: ${String(err)}` };
+      }
+    }
+  };
+  naxFinishPlugin = {
+    name: PLUGIN_NAME4,
+    version: PLUGIN_VERSION4,
+    provides: ["post-run-action"],
+    async setup(_config, _logger) {},
+    async teardown() {},
+    extensions: {
+      postRunAction: naxFinishAction
+    }
+  };
+});
+
 // src/plugins/builtin/reporter-shared/interpolate.ts
 function interpolateHeaders(headers, env2 = process.env) {
   const resolved = {};
@@ -64075,14 +64786,14 @@ var init_validator = __esm(() => {
 
 // src/plugins/loader.ts
 import * as fs from "fs/promises";
-import * as path21 from "path";
+import * as path22 from "path";
 function getSafeLogger6() {
   return getSafeLogger();
 }
 function extractPluginName(pluginPath) {
-  const basename12 = path21.basename(pluginPath);
+  const basename12 = path22.basename(pluginPath);
   if (basename12 === "index.ts" || basename12 === "index.js" || basename12 === "index.mjs") {
-    return path21.basename(path21.dirname(pluginPath));
+    return path22.basename(path22.dirname(pluginPath));
   }
   return basename12.replace(/\.(ts|js|mjs)$/, "");
 }
@@ -64118,6 +64829,17 @@ async function loadPlugins(globalDir, projectDir, configPlugins, projectRoot, di
   } else {
     logger?.info("plugins", `Skipping disabled plugin: '${autoPrPlugin.name}' (built-in)`);
   }
+  if (!disabledSet.has(naxFinishPlugin.name)) {
+    if (naxFinishPlugin.setup) {
+      const pluginLogger = createPluginLogger(naxFinishPlugin.name);
+      await naxFinishPlugin.setup({}, pluginLogger);
+    }
+    const action = naxFinishPlugin.extensions.postRunAction;
+    if (action)
+      builtinPostRunActions.push(action);
+  } else {
+    logger?.info("plugins", `Skipping disabled plugin: '${naxFinishPlugin.name}' (built-in)`);
+  }
   if (!disabledSet.has(autoRoutePlugin.name)) {
     if (autoRoutePlugin.setup) {
       const pluginLogger = createPluginLogger(autoRoutePlugin.name);
@@ -64219,7 +64941,7 @@ async function discoverPlugins(dir, isTestFileFn) {
   try {
     const entries = await fs.readdir(dir, { withFileTypes: true });
     for (const entry of entries) {
-      const fullPath = path21.join(dir, entry.name);
+      const fullPath = path22.join(dir, entry.name);
       if (entry.isFile()) {
         if (isPluginFile(entry.name, isTestFileFn)) {
           discovered.push({ path: fullPath });
@@ -64227,7 +64949,7 @@ async function discoverPlugins(dir, isTestFileFn) {
       } else if (entry.isDirectory()) {
         const indexPaths = ["index.ts", "index.js", "index.mjs"];
         for (const indexFile of indexPaths) {
-          const indexPath = path21.join(fullPath, indexFile);
+          const indexPath = path22.join(fullPath, indexFile);
           try {
             await fs.access(indexPath);
             discovered.push({ path: indexPath });
@@ -64252,13 +64974,13 @@ function isPluginFile(filename, isTestFileFn) {
   return !FALLBACK_TEST_FILE_RE.test(filename);
 }
 function resolveModulePath(modulePath, projectRoot) {
-  if (path21.isAbsolute(modulePath) || !modulePath.startsWith("./") && !modulePath.startsWith("../")) {
+  if (path22.isAbsolute(modulePath) || !modulePath.startsWith("./") && !modulePath.startsWith("../")) {
     return modulePath;
   }
   if (projectRoot) {
-    return path21.resolve(projectRoot, modulePath);
+    return path22.resolve(projectRoot, modulePath);
   }
-  return path21.resolve(modulePath);
+  return path22.resolve(modulePath);
 }
 async function loadAndValidatePlugin(initialModulePath, config2, allowedRoots = [], originalPath) {
   let attemptedPath = initialModulePath;
@@ -64320,6 +65042,7 @@ var init_loader4 = __esm(() => {
   init_auto_pr();
   init_auto_route();
   init_curator();
+  init_nax_finish();
   init_otel_reporter();
   init_webhook_reporter();
   init_plugin_logger();
@@ -64376,7 +65099,7 @@ var init_writer = __esm(() => {
 });
 
 // src/execution/checkpoint/reader.ts
-import { join as join81 } from "path";
+import { join as join82 } from "path";
 function isValidRecord(value) {
   if (!value || typeof value !== "object")
     return false;
@@ -64409,7 +65132,7 @@ async function defaultRead(filePath) {
   return file3.text();
 }
 async function loadCheckpoints(featureDir, options = { _deps: { read: defaultRead } }) {
-  const filePath = join81(featureDir, "checkpoint.jsonl");
+  const filePath = join82(featureDir, "checkpoint.jsonl");
   const deps = options._deps ?? { read: defaultRead };
   let content;
   try {
@@ -64479,7 +65202,7 @@ var init_reader = __esm(() => {
 });
 
 // src/execution/checkpoint/resume-cli.ts
-import { join as join82 } from "path";
+import { join as join83 } from "path";
 function applyResumeModeDeps(featureDir, mode = "auto") {
   if (mode === "fresh" || mode === "no-resume") {
     _storyOrchestratorDeps.loadCheckpoints = async (_fd) => new Map;
@@ -64489,7 +65212,7 @@ function applyResumeModeDeps(featureDir, mode = "auto") {
   _storyOrchestratorDeps.loadCheckpoints = async (_fd) => loadCheckpoints(target);
 }
 function applyRecordGreenDeps(featureDir, runId) {
-  const writer = createCheckpointWriter(join82(featureDir, "checkpoint.jsonl"), runId);
+  const writer = createCheckpointWriter(join83(featureDir, "checkpoint.jsonl"), runId);
   _storyOrchestratorDeps.recordGreen = (storyId, phase, tree) => writer.recordGreen(storyId, phase, tree);
 }
 var init_resume_cli = __esm(() => {
@@ -64519,11 +65242,11 @@ var init_checkpoint = __esm(() => {
 });
 
 // src/hooks/runner.ts
-import { join as join83 } from "path";
+import { join as join84 } from "path";
 function createDrainDeadline2(deadlineMs) {
   let timeoutId;
-  const promise2 = new Promise((resolve16) => {
-    timeoutId = setTimeout(() => resolve16(""), deadlineMs);
+  const promise2 = new Promise((resolve17) => {
+    timeoutId = setTimeout(() => resolve17(""), deadlineMs);
   });
   return {
     promise: promise2,
@@ -64538,14 +65261,14 @@ async function loadHooksConfig(projectDir, globalDir) {
   let globalHooks = { hooks: {} };
   let projectHooks = { hooks: {} };
   let skipGlobal = false;
-  const projectPath = join83(projectDir, "hooks.json");
+  const projectPath = join84(projectDir, "hooks.json");
   const projectData = await loadJsonFile(projectPath, "hooks");
   if (projectData) {
     projectHooks = projectData;
     skipGlobal = projectData.skipGlobal ?? false;
   }
   if (!skipGlobal && globalDir) {
-    const globalPath = join83(globalDir, "hooks.json");
+    const globalPath = join84(globalDir, "hooks.json");
     const globalData = await loadJsonFile(globalPath, "hooks");
     if (globalData) {
       globalHooks = globalData;
@@ -65053,7 +65776,7 @@ var init_crash_recovery = __esm(() => {
 });
 
 // src/acceptance/import-resolution.ts
-import { resolve as resolve16, sep as sep5 } from "path";
+import { resolve as resolve17, sep as sep5 } from "path";
 function languageFromExtension(testFilePath) {
   if (!testFilePath)
     return;
@@ -65075,8 +65798,8 @@ async function resolveLanguage(opts) {
   return "typescript";
 }
 async function readCapped(relPath, packageDir) {
-  const resolvedPackageDir = resolve16(packageDir);
-  const fullPath = resolve16(resolvedPackageDir, relPath);
+  const resolvedPackageDir = resolve17(packageDir);
+  const fullPath = resolve17(resolvedPackageDir, relPath);
   if (fullPath !== resolvedPackageDir && !fullPath.startsWith(resolvedPackageDir + sep5)) {
     return null;
   }
@@ -65258,7 +65981,7 @@ var init_fix_diagnosis = __esm(() => {
 });
 
 // src/execution/lifecycle/acceptance-helpers.ts
-import path23 from "path";
+import path24 from "path";
 function isStubTestFile(content) {
   return isStubTestContent(content);
 }
@@ -65277,7 +66000,7 @@ function isTestLevelFailure(failedACs, totalACs, semanticVerdicts) {
 async function loadSpecContent(featureDir) {
   if (!featureDir)
     return "";
-  const specPath = path23.join(featureDir, "spec.md");
+  const specPath = path24.join(featureDir, "spec.md");
   const specFile = Bun.file(specPath);
   return await specFile.exists() ? await specFile.text() : "";
 }
@@ -65297,7 +66020,7 @@ async function loadAcceptanceTestContent2(featureDir, testPaths, configuredTestP
   }
   if (!configuredTestPath)
     return [];
-  const resolvedPath = path23.join(featureDir, configuredTestPath);
+  const resolvedPath = path24.join(featureDir, configuredTestPath);
   const testFile = Bun.file(resolvedPath);
   const content = await testFile.exists() ? await testFile.text() : "";
   return [{ content, path: resolvedPath }];
@@ -65314,7 +66037,7 @@ async function regenerateAcceptanceTest(testPath, acceptanceContext) {
   const { unlink: unlink3 } = await import("fs/promises");
   await unlink3(testPath);
   if (acceptanceContext.featureDir) {
-    const metaPath = path23.join(acceptanceContext.featureDir, "acceptance-meta.json");
+    const metaPath = path24.join(acceptanceContext.featureDir, "acceptance-meta.json");
     try {
       await unlink3(metaPath);
     } catch {}
@@ -65328,7 +66051,7 @@ async function regenerateAcceptanceTest(testPath, acceptanceContext) {
       const changedFilesRaw = diffOutput.split(`
 `).map((f) => f.trim()).filter((f) => f.length > 0);
       const repoRoot = acceptanceContext.projectDir ?? workdir;
-      const packageDir = acceptanceContext.story.workdir && acceptanceContext.projectDir ? path23.join(acceptanceContext.projectDir, acceptanceContext.story.workdir) : undefined;
+      const packageDir = acceptanceContext.story.workdir && acceptanceContext.projectDir ? path24.join(acceptanceContext.projectDir, acceptanceContext.story.workdir) : undefined;
       const ignoreMatchers = acceptanceContext.naxIgnoreIndex?.getMatchers(packageDir) ?? await resolveNaxIgnorePatterns(repoRoot, packageDir);
       const changedFiles = filterNaxInternalPaths(changedFilesRaw, ignoreMatchers);
       const MAX_BYTES = 51200;
@@ -65337,7 +66060,7 @@ async function regenerateAcceptanceTest(testPath, acceptanceContext) {
       for (const file3 of changedFiles) {
         if (totalBytes >= MAX_BYTES)
           break;
-        const filePath = path23.join(workdir, file3);
+        const filePath = path24.join(workdir, file3);
         try {
           const fileContent = await _regenerateDeps.readFile(filePath);
           const remaining = MAX_BYTES - totalBytes;
@@ -65775,15 +66498,15 @@ var init_acceptance_loop = __esm(() => {
 
 // src/session/scratch-purge.ts
 import { mkdir as mkdir12, rename, rm } from "fs/promises";
-import { dirname as dirname13, join as join84 } from "path";
+import { dirname as dirname14, join as join85 } from "path";
 async function purgeStaleScratch(projectDir, featureName, retentionDays, archiveInsteadOfDelete = false) {
-  const sessionsDir = join84(projectDir, ".nax", "features", featureName, "sessions");
+  const sessionsDir = join85(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 = join84(sessionsDir, sessionId);
-    const descriptorPath = join84(sessionDir, "descriptor.json");
+    const sessionDir = join85(sessionsDir, sessionId);
+    const descriptorPath = join85(sessionDir, "descriptor.json");
     if (!await _scratchPurgeDeps.fileExists(descriptorPath))
       continue;
     let lastActivityAt;
@@ -65799,7 +66522,7 @@ async function purgeStaleScratch(projectDir, featureName, retentionDays, archive
     if (new Date(lastActivityAt).getTime() >= cutoffMs)
       continue;
     if (archiveInsteadOfDelete) {
-      const archiveDest = join84(projectDir, ".nax", "features", featureName, "_archive", "sessions", sessionId);
+      const archiveDest = join85(projectDir, ".nax", "features", featureName, "_archive", "sessions", sessionId);
       await _scratchPurgeDeps.move(sessionDir, archiveDest);
     } else {
       await _scratchPurgeDeps.remove(sessionDir);
@@ -65822,11 +66545,11 @@ var init_scratch_purge = __esm(() => {
         return [];
       }
     },
-    fileExists: (path24) => Bun.file(path24).exists(),
-    readFile: (path24) => Bun.file(path24).text(),
-    remove: (path24) => rm(path24, { recursive: true, force: true }),
+    fileExists: (path25) => Bun.file(path25).exists(),
+    readFile: (path25) => Bun.file(path25).text(),
+    remove: (path25) => rm(path25, { recursive: true, force: true }),
     move: async (src, dest) => {
-      await mkdir12(dirname13(dest), { recursive: true });
+      await mkdir12(dirname14(dest), { recursive: true });
       await rename(src, dest);
     },
     now: () => Date.now()
@@ -66670,7 +67393,7 @@ var init_headless_formatter = __esm(() => {
 });
 
 // src/execution/runner-completion.ts
-import path24 from "path";
+import path25 from "path";
 async function runCompletionPhase(options) {
   const logger = getSafeLogger();
   logger?.debug("execution", "Completion phase started", {
@@ -66690,11 +67413,11 @@ async function runCompletionPhase(options) {
       options.statusWriter.setPostRunPhase("acceptance", { status: "running" });
       pipelineEventBus.emit({ type: "postrun:phase:started", phase: "acceptance" });
       const acceptanceTestPaths = options.featureDir ? await Promise.all((await groupStoriesByPackage(options.prd, options.workdir, options.feature, options.config.acceptance.testPath, options.config.project?.language)).map(async (g) => {
-        const relativeWorkdir = path24.relative(options.workdir, g.packageDir);
+        const relativeWorkdir = path25.relative(options.workdir, g.packageDir);
         let groupConfig = options.config;
         if (relativeWorkdir && relativeWorkdir !== ".") {
           try {
-            groupConfig = await _runnerCompletionDeps.loadConfigForWorkdir(path24.join(options.workdir, ".nax", "config.json"), relativeWorkdir);
+            groupConfig = await _runnerCompletionDeps.loadConfigForWorkdir(path25.join(options.workdir, ".nax", "config.json"), relativeWorkdir);
           } catch (error48) {
             logger?.warn("execution", "Falling back to root config for package acceptance settings", {
               packageDir: g.packageDir,
@@ -66924,7 +67647,7 @@ function precomputeBatchPlan(stories, maxBatchSize = DEFAULT_MAX_BATCH_SIZE) {
 var DEFAULT_MAX_BATCH_SIZE = 4;
 
 // src/execution/ensure-package-dirs.ts
-import path25 from "path";
+import path26 from "path";
 async function ensureStoryPackageDirs(prd, workdir, deps = _ensurePackageDirsDeps) {
   const logger = getSafeLogger();
   const relToStoryId = new Map;
@@ -66937,8 +67660,8 @@ async function ensureStoryPackageDirs(prd, workdir, deps = _ensurePackageDirsDep
   }
   const created = [];
   for (const [rel, storyId] of relToStoryId) {
-    const abs = path25.resolve(workdir, rel);
-    const rootWithSep = workdir.endsWith(path25.sep) ? workdir : workdir + path25.sep;
+    const abs = path26.resolve(workdir, rel);
+    const rootWithSep = workdir.endsWith(path26.sep) ? workdir : workdir + path26.sep;
     if (abs !== workdir && !abs.startsWith(rootWithSep)) {
       logger?.warn("execution", "Skipping story workdir outside repo root", {
         storyId,
@@ -66980,12 +67703,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 basename15, join as join85 } from "path";
+import { basename as basename15, join as join86 } from "path";
 function wireEventsWriter(bus, feature, runId, workdir) {
   const logger = getSafeLogger();
   const project = basename15(workdir);
-  const eventsDir = join85(getEventsRootDir(), project);
-  const eventsFile = join85(eventsDir, "events.jsonl");
+  const eventsDir = join86(getEventsRootDir(), project);
+  const eventsFile = join86(eventsDir, "events.jsonl");
   let dirReady = false;
   const write = (line) => {
     return (async () => {
@@ -67166,12 +67889,12 @@ var init_interaction2 = __esm(() => {
 
 // src/pipeline/subscribers/registry.ts
 import { mkdir as mkdir14, writeFile as writeFile2 } from "fs/promises";
-import { basename as basename16, join as join86 } from "path";
+import { basename as basename16, join as join87 } from "path";
 function wireRegistry(bus, feature, runId, workdir, outputDir) {
   const logger = getSafeLogger();
   const project = basename16(workdir);
-  const runDir = join86(getRunsDir(), `${project}-${feature}-${runId}`);
-  const metaFile = join86(runDir, "meta.json");
+  const runDir = join87(getRunsDir(), `${project}-${feature}-${runId}`);
+  const metaFile = join87(runDir, "meta.json");
   const unsub = bus.on("run:started", (_ev) => {
     return (async () => {
       try {
@@ -67181,8 +67904,8 @@ function wireRegistry(bus, feature, runId, workdir, outputDir) {
           project,
           feature,
           workdir,
-          statusPath: join86(outputDir, "features", feature, "status.json"),
-          eventsDir: join86(outputDir, "features", feature, "runs"),
+          statusPath: join87(outputDir, "features", feature, "status.json"),
+          eventsDir: join87(outputDir, "features", feature, "runs"),
           registeredAt: new Date().toISOString()
         };
         await writeFile2(metaFile, JSON.stringify(meta3, null, 2));
@@ -67428,7 +68151,7 @@ var init_types10 = __esm(() => {
 
 // src/worktree/dependencies.ts
 import { existsSync as existsSync33 } from "fs";
-import { join as join87 } from "path";
+import { join as join88 } from "path";
 async function prepareWorktreeDependencies(options) {
   const mode = options.config.execution.worktreeDependencies.mode;
   const resolvedCwd = resolveDependencyCwd(options);
@@ -67442,7 +68165,7 @@ async function prepareWorktreeDependencies(options) {
   }
 }
 function resolveDependencyCwd(options) {
-  return options.storyWorkdir ? join87(options.worktreeRoot, options.storyWorkdir) : options.worktreeRoot;
+  return options.storyWorkdir ? join88(options.worktreeRoot, options.storyWorkdir) : options.worktreeRoot;
 }
 function resolveInheritedDependencies(options, resolvedCwd) {
   if (hasDependencyManifests(options.worktreeRoot, resolvedCwd)) {
@@ -67452,7 +68175,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(join87(directory, filename))));
+  return directories.some((directory) => PHASE_ONE_INHERIT_UNSUPPORTED_FILES.some((filename) => _worktreeDependencyDeps.existsSync(join88(directory, filename))));
 }
 async function provisionDependencies(config2, worktreeRoot, resolvedCwd) {
   const setupCommand2 = config2.execution.worktreeDependencies.setupCommand;
@@ -67516,13 +68239,13 @@ __export(exports_manager, {
 });
 import { existsSync as existsSync34, symlinkSync } from "fs";
 import { mkdir as mkdir15 } from "fs/promises";
-import { join as join88 } from "path";
+import { join as join89 } from "path";
 
 class WorktreeManager {
   async ensureGitExcludes(projectRoot) {
     const logger = getSafeLogger();
-    const infoDir = join88(projectRoot, ".git", "info");
-    const excludePath = join88(infoDir, "exclude");
+    const infoDir = join89(projectRoot, ".git", "info");
+    const excludePath = join89(infoDir, "exclude");
     try {
       await mkdir15(infoDir, { recursive: true });
       let existing = "";
@@ -67549,7 +68272,7 @@ ${missing.join(`
   }
   async create(projectRoot, storyId) {
     validateStoryId(storyId);
-    const worktreePath = join88(projectRoot, ".nax-wt", storyId);
+    const worktreePath = join89(projectRoot, ".nax-wt", storyId);
     const branchName = `nax/${storyId}`;
     try {
       const pruneProc = _managerDeps.spawn(["git", "worktree", "prune"], {
@@ -67610,9 +68333,9 @@ ${missing.join(`
         projectRoot
       });
     }
-    const envSource = join88(projectRoot, ".env");
+    const envSource = join89(projectRoot, ".env");
     if (existsSync34(envSource)) {
-      const envTarget = join88(worktreePath, ".env");
+      const envTarget = join89(worktreePath, ".env");
       try {
         symlinkSync(envSource, envTarget, "file");
       } catch (error48) {
@@ -67628,7 +68351,7 @@ ${missing.join(`
   }
   async remove(projectRoot, storyId) {
     validateStoryId(storyId);
-    const worktreePath = join88(projectRoot, ".nax-wt", storyId);
+    const worktreePath = join89(projectRoot, ".nax-wt", storyId);
     const branchName = `nax/${storyId}`;
     try {
       const proc = _managerDeps.spawn(["git", "worktree", "remove", worktreePath, "--force"], {
@@ -68097,9 +68820,9 @@ var _quoteIntegrityDeps, CONTEXT_LINES = 3;
 var init_quote_integrity = __esm(() => {
   init_logger2();
   _quoteIntegrityDeps = {
-    readFile: async (path26) => {
+    readFile: async (path27) => {
       try {
-        return await Bun.file(path26).text();
+        return await Bun.file(path27).text();
       } catch {
         return null;
       }
@@ -68388,7 +69111,7 @@ var exports_merge_conflict_rectify = {};
 __export(exports_merge_conflict_rectify, {
   rectifyConflictedStory: () => rectifyConflictedStory
 });
-import path26 from "path";
+import path27 from "path";
 async function closeStaleAcpSession(worktreePath, sessionName) {
   const logger = getSafeLogger();
   try {
@@ -68415,7 +69138,7 @@ async function rectifyConflictedStory(options) {
       await worktreeManager.remove(workdir, storyId);
     } catch {}
     await worktreeManager.create(workdir, storyId);
-    const worktreePath = path26.join(workdir, ".nax-wt", storyId);
+    const worktreePath = path27.join(workdir, ".nax-wt", storyId);
     const { formatSessionName: formatSessionName2 } = await Promise.resolve().then(() => (init_naming(), exports_naming));
     const staleSessionName = formatSessionName2({
       workdir: worktreePath,
@@ -68480,10 +69203,10 @@ var init_merge_conflict_rectify = __esm(() => {
 });
 
 // src/execution/pipeline-result-handler.ts
-import { join as join89 } from "path";
+import { join as join90 } from "path";
 async function removeWorktreeDirectory(projectRoot, storyId) {
   const logger = getSafeLogger();
-  const worktreePath = join89(projectRoot, ".nax-wt", storyId);
+  const worktreePath = join90(projectRoot, ".nax-wt", storyId);
   try {
     const proc = _resultHandlerDeps.spawn(["git", "worktree", "remove", worktreePath, "--force"], {
       cwd: projectRoot,
@@ -68700,7 +69423,7 @@ var init_pipeline_result_handler = __esm(() => {
 
 // src/execution/iteration-runner.ts
 import { existsSync as existsSync35 } from "fs";
-import { join as join90 } from "path";
+import { join as join91 } from "path";
 async function runIteration(ctx, prd, selection, iterations, totalCost2, allStoryMetrics) {
   const { story, storiesToExecute, routing, isBatchExecution } = selection;
   if (ctx.dryRun) {
@@ -68725,7 +69448,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 = join90(ctx.workdir, ".nax-wt", story.id);
+    const worktreePath = join91(ctx.workdir, ".nax-wt", story.id);
     const worktreeExists = _iterationRunnerDeps.existsSync(worktreePath);
     if (!worktreeExists) {
       await _iterationRunnerDeps.worktreeManager.ensureGitExcludes(ctx.workdir);
@@ -68745,7 +69468,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(join90(ctx.workdir, ".nax", "config.json"), story.workdir, profileOverride) : ctx.config;
+  const effectiveConfig = story.workdir ? await _iterationRunnerDeps.loadConfigForWorkdir(join91(ctx.workdir, ".nax", "config.json"), story.workdir, profileOverride) : ctx.config;
   let dependencyContext;
   if (ctx.config.execution.storyIsolation === "worktree") {
     try {
@@ -68772,7 +69495,7 @@ async function runIteration(ctx, prd, selection, iterations, totalCost2, allStor
       };
     }
   }
-  const resolvedWorkdir = dependencyContext?.cwd ? dependencyContext.cwd : ctx.config.execution.storyIsolation === "worktree" ? story.workdir ? join90(effectiveWorkdir, story.workdir) : effectiveWorkdir : story.workdir ? join90(ctx.workdir, story.workdir) : ctx.workdir;
+  const resolvedWorkdir = dependencyContext?.cwd ? dependencyContext.cwd : ctx.config.execution.storyIsolation === "worktree" ? story.workdir ? join91(effectiveWorkdir, story.workdir) : effectiveWorkdir : story.workdir ? join91(ctx.workdir, story.workdir) : ctx.workdir;
   const pipelineContext = {
     config: effectiveConfig,
     rootConfig: ctx.config,
@@ -68975,7 +69698,7 @@ __export(exports_parallel_worker, {
   buildWorktreePipelineContext: () => buildWorktreePipelineContext,
   _parallelWorkerDeps: () => _parallelWorkerDeps
 });
-import { join as join91 } from "path";
+import { join as join92 } from "path";
 function buildWorktreePipelineContext(base, _story) {
   return { ...base, prd: structuredClone(base.prd) };
 }
@@ -68998,7 +69721,7 @@ async function executeStoryInWorktree(story, worktreePath, dependencyContext, co
       story,
       stories: [story],
       projectDir: context.projectDir,
-      workdir: dependencyContext.cwd ?? (story.workdir ? join91(worktreePath, story.workdir) : worktreePath),
+      workdir: dependencyContext.cwd ?? (story.workdir ? join92(worktreePath, story.workdir) : worktreePath),
       worktreeDependencyContext: dependencyContext,
       routing,
       storyGitRef: storyGitRef ?? undefined
@@ -69099,7 +69822,7 @@ __export(exports_parallel_batch, {
   runParallelBatch: () => runParallelBatch,
   _parallelBatchDeps: () => _parallelBatchDeps
 });
-import path27 from "path";
+import path28 from "path";
 async function runParallelBatch(options) {
   const { stories, ctx, prd } = options;
   const { workdir, config: config2, maxConcurrency, pipelineContext, eventEmitter, agentGetFn, hooks, pluginRegistry } = ctx;
@@ -69118,9 +69841,9 @@ async function runParallelBatch(options) {
       });
       throw error48;
     }
-    worktreePaths.set(story.id, path27.join(workdir, ".nax-wt", story.id));
+    worktreePaths.set(story.id, path28.join(workdir, ".nax-wt", story.id));
   }
-  const rootConfigPath = path27.join(workdir, ".nax", "config.json");
+  const rootConfigPath = path28.join(workdir, ".nax", "config.json");
   const profileOverride = profileOverrideFromConfig(config2);
   const storyEffectiveConfigs = new Map;
   const configResults = await Promise.allSettled(stories.filter((story) => story.workdir).map(async (story) => {
@@ -69958,7 +70681,7 @@ var init_runner_execution = __esm(() => {
 
 // src/execution/status-file.ts
 import { rename as rename2, unlink as unlink3 } from "fs/promises";
-import { resolve as resolve17 } from "path";
+import { resolve as resolve18 } from "path";
 function countProgress(prd) {
   const stories = prd.userStories;
   const passed = stories.filter((s) => s.status === "passed").length;
@@ -70003,7 +70726,7 @@ function buildStatusSnapshot(state) {
   return snapshot;
 }
 async function writeStatusFile(filePath, status) {
-  const resolvedPath = resolve17(filePath);
+  const resolvedPath = resolve18(filePath);
   if (filePath.includes("../") || filePath.includes("..\\")) {
     throw new Error("Invalid status file path: path traversal detected");
   }
@@ -70017,7 +70740,7 @@ async function writeStatusFile(filePath, status) {
 var init_status_file = () => {};
 
 // src/execution/status-writer.ts
-import { join as join92 } from "path";
+import { join as join93 } from "path";
 
 class StatusWriter {
   statusFile;
@@ -70136,7 +70859,7 @@ class StatusWriter {
     if (!this._prd)
       return;
     const safeLogger = getSafeLogger();
-    const featureStatusPath = join92(featureDir, "status.json");
+    const featureStatusPath = join93(featureDir, "status.json");
     const write = async () => {
       try {
         const base = this.getSnapshot(totalCost2, iterations);
@@ -70169,7 +70892,7 @@ __export(exports_migrate, {
 });
 import { existsSync as existsSync36 } from "fs";
 import { mkdir as mkdir16, readdir as readdir5, rename as rename3 } from "fs/promises";
-import path28 from "path";
+import path29 from "path";
 async function detectGeneratedContent(naxDir) {
   if (!existsSync36(naxDir))
     return [];
@@ -70182,17 +70905,17 @@ async function detectGeneratedContent(naxDir) {
   }
   for (const entry of entries) {
     if (GENERATED_NAMES.has(entry)) {
-      candidates.push({ name: entry, srcPath: path28.join(naxDir, entry) });
+      candidates.push({ name: entry, srcPath: path29.join(naxDir, entry) });
     }
   }
-  const featuresDir = path28.join(naxDir, "features");
+  const featuresDir = path29.join(naxDir, "features");
   if (existsSync36(featuresDir)) {
     let featureDirs = [];
     try {
       featureDirs = await readdir5(featuresDir);
     } catch {}
     for (const fid of featureDirs) {
-      const featureDir = path28.join(featuresDir, fid);
+      const featureDir = path29.join(featuresDir, fid);
       let subEntries = [];
       try {
         subEntries = await readdir5(featureDir);
@@ -70202,12 +70925,12 @@ async function detectGeneratedContent(naxDir) {
       for (const sub of subEntries) {
         if (GENERATED_FEATURE_SUBNAMES.has(sub)) {
           candidates.push({
-            name: path28.join("features", fid, sub),
-            srcPath: path28.join(featureDir, sub)
+            name: path29.join("features", fid, sub),
+            srcPath: path29.join(featureDir, sub)
           });
         }
         if (sub === "stories") {
-          const storiesDir = path28.join(featureDir, "stories");
+          const storiesDir = path29.join(featureDir, "stories");
           let storyDirs = [];
           try {
             storyDirs = await readdir5(storiesDir);
@@ -70215,7 +70938,7 @@ async function detectGeneratedContent(naxDir) {
             continue;
           }
           for (const sid of storyDirs) {
-            const storyDir = path28.join(storiesDir, sid);
+            const storyDir = path29.join(storiesDir, sid);
             let storyEntries = [];
             try {
               storyEntries = await readdir5(storyDir);
@@ -70225,8 +70948,8 @@ async function detectGeneratedContent(naxDir) {
             for (const se of storyEntries) {
               if (se.startsWith("context-manifest-") && se.endsWith(".json")) {
                 candidates.push({
-                  name: path28.join("features", fid, "stories", sid, se),
-                  srcPath: path28.join(storyDir, se)
+                  name: path29.join("features", fid, "stories", sid, se),
+                  srcPath: path29.join(storyDir, se)
                 });
               }
             }
@@ -70247,15 +70970,15 @@ async function migrateCommand(options) {
         name: options.reclaim
       });
     }
-    const src = path28.join(globalConfigDir(), options.reclaim);
+    const src = path29.join(globalConfigDir(), options.reclaim);
     if (!existsSync36(src)) {
       throw new NaxError(`Nothing to reclaim: ~/.nax/${options.reclaim} does not exist`, "MIGRATE_RECLAIM_NOT_FOUND", {
         stage: "migrate",
         name: options.reclaim
       });
     }
-    const archiveBase = path28.join(globalConfigDir(), "_archive");
-    const archiveDest = path28.join(archiveBase, `${options.reclaim}-${Date.now()}`);
+    const archiveBase = path29.join(globalConfigDir(), "_archive");
+    const archiveDest = path29.join(archiveBase, `${options.reclaim}-${Date.now()}`);
     await mkdir16(archiveBase, { recursive: true });
     await rename3(src, archiveDest);
     logger.info("migrate", `Reclaimed: archived to ${archiveDest}`, { storyId: "_migrate" });
@@ -70292,8 +71015,8 @@ async function migrateCommand(options) {
     logger.info("migrate", `Merged: identity for "${options.merge}" updated`, { storyId: "_migrate" });
     return;
   }
-  const naxDir = path28.join(options.workdir, ".nax");
-  const configPath = path28.join(naxDir, "config.json");
+  const naxDir = path29.join(options.workdir, ".nax");
+  const configPath = path29.join(naxDir, "config.json");
   if (!existsSync36(configPath)) {
     throw new NaxError("No .nax/config.json found \u2014 run nax init first", "MIGRATE_NO_CONFIG", {
       stage: "migrate",
@@ -70309,7 +71032,7 @@ async function migrateCommand(options) {
       cause: e
     });
   }
-  const projectKey = config2.name?.trim() || path28.basename(options.workdir);
+  const projectKey = config2.name?.trim() || path29.basename(options.workdir);
   const destBase = projectOutputDir(projectKey, config2.outputDir);
   const candidates = await detectGeneratedContent(naxDir);
   if (candidates.length === 0) {
@@ -70318,7 +71041,7 @@ async function migrateCommand(options) {
   }
   if (options.dryRun) {
     for (const c of candidates) {
-      logger.info("migrate", `[dry-run] Would move: ${c.srcPath} -> ${path28.join(destBase, c.name)}`, {
+      logger.info("migrate", `[dry-run] Would move: ${c.srcPath} -> ${path29.join(destBase, c.name)}`, {
         storyId: "_migrate"
       });
     }
@@ -70327,8 +71050,8 @@ async function migrateCommand(options) {
   await mkdir16(destBase, { recursive: true });
   let moved = 0;
   for (const candidate of candidates) {
-    const dest = path28.join(destBase, candidate.name);
-    await mkdir16(path28.dirname(dest), { recursive: true });
+    const dest = path29.join(destBase, candidate.name);
+    await mkdir16(path29.dirname(dest), { recursive: true });
     if (existsSync36(dest)) {
       throw new NaxError(`Migration conflict: destination already exists.
   Source:      ${candidate.srcPath}
@@ -70358,7 +71081,7 @@ async function migrateCommand(options) {
     moved++;
     logger.info("migrate", `Moved: ${candidate.name}`, { storyId: "_migrate" });
   }
-  await Bun.write(path28.join(destBase, ".migrated-from"), JSON.stringify({ from: options.workdir, migratedAt: new Date().toISOString() }, null, 2));
+  await Bun.write(path29.join(destBase, ".migrated-from"), JSON.stringify({ from: options.workdir, migratedAt: new Date().toISOString() }, null, 2));
   logger.info("migrate", `Migration complete: ${moved} entries moved`, {
     storyId: "_migrate",
     destBase
@@ -70475,7 +71198,7 @@ __export(exports_precheck_runner, {
   runPrecheckValidation: () => runPrecheckValidation
 });
 import { mkdirSync as mkdirSync7 } from "fs";
-import path29 from "path";
+import path30 from "path";
 async function runPrecheckValidation(ctx) {
   const logger = getSafeLogger();
   if (process.env.NAX_PRECHECK !== "1") {
@@ -70490,7 +71213,7 @@ async function runPrecheckValidation(ctx) {
     silent: true
   });
   if (ctx.logFilePath) {
-    mkdirSync7(path29.dirname(ctx.logFilePath), { recursive: true });
+    mkdirSync7(path30.dirname(ctx.logFilePath), { recursive: true });
     const precheckLog = {
       type: "precheck",
       timestamp: new Date().toISOString(),
@@ -70580,7 +71303,7 @@ __export(exports_run_initialization, {
   initializeRun: () => initializeRun,
   _reconcileDeps: () => _reconcileDeps
 });
-import { join as join93 } from "path";
+import { join as join94 } from "path";
 async function reconcileState(prd, prdPath, workdir, config2) {
   const logger = getSafeLogger();
   let reconciledCount = 0;
@@ -70597,7 +71320,7 @@ async function reconcileState(prd, prdPath, workdir, config2) {
       });
       continue;
     }
-    const effectiveWorkdir = story.workdir ? join93(workdir, story.workdir) : workdir;
+    const effectiveWorkdir = story.workdir ? join94(workdir, story.workdir) : workdir;
     try {
       const reviewResult = await _reconcileDeps.runReview(config2.review, effectiveWorkdir, config2.execution);
       if (!reviewResult.success) {
@@ -70803,7 +71526,7 @@ __export(exports_run_setup, {
   setupRun: () => setupRun,
   _runSetupDeps: () => _runSetupDeps
 });
-import path30 from "path";
+import path31 from "path";
 function warnProfileMismatch(prd, config2, logger) {
   const profiles = config2.routing?.agents?.profiles ?? [];
   const profileIds = new Set(profiles.map((p) => p.id));
@@ -70924,7 +71647,7 @@ async function setupRun(options) {
   statusWriter.setPrd(prd);
   {
     const { detectGeneratedContent: detectGeneratedContent2, migrateCommand: migrateCommand2 } = await Promise.resolve().then(() => (init_migrate(), exports_migrate));
-    const naxDir = path30.join(workdir, ".nax");
+    const naxDir = path31.join(workdir, ".nax");
     const candidates = await detectGeneratedContent2(naxDir).catch(() => []);
     if (candidates.length > 0) {
       logger?.info("setup", "Found generated content under .nax/ \u2014 migrating to output dir", {
@@ -70951,7 +71674,7 @@ async function setupRun(options) {
         remoteUrl = new TextDecoder().decode(gitResult.stdout).trim() || null;
       }
     } catch {}
-    const projectKey = config2.name?.trim() || path30.basename(workdir);
+    const projectKey = config2.name?.trim() || path31.basename(workdir);
     await claimProjectIdentity2(projectKey, workdir, remoteUrl).catch((err) => {
       if (err instanceof NaxError && err.code === "RUN_NAME_COLLISION") {
         throw err;
@@ -71006,8 +71729,8 @@ async function setupRun(options) {
       explicit: Object.fromEntries(explicitFields.map((f) => [f, existingProjectConfig[f]])),
       detected: Object.fromEntries(autodetectedFields.map((f) => [f, detectedProfile[f]]))
     });
-    const globalPluginsDir = path30.join(globalConfigDir(), "plugins");
-    const projectPluginsDir = path30.join(workdir, ".nax", "plugins");
+    const globalPluginsDir = path31.join(globalConfigDir(), "plugins");
+    const projectPluginsDir = path31.join(workdir, ".nax", "plugins");
     const configPlugins = config2.plugins || [];
     const resolvedPatterns = await resolveTestFilePatterns(config2, workdir);
     const isTestFileFn = (filename) => resolvedPatterns.regex.some((re) => re.test(filename));
@@ -71941,14 +72664,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, resolve18, reject) {
+    function recursivelyFlushAsyncActWork(returnValue, resolve19, reject) {
       var queue = ReactSharedInternals.actQueue;
       if (queue !== null)
         if (queue.length !== 0)
           try {
             flushActQueue(queue);
             enqueueTask(function() {
-              return recursivelyFlushAsyncActWork(returnValue, resolve18, reject);
+              return recursivelyFlushAsyncActWork(returnValue, resolve19, reject);
             });
             return;
           } catch (error48) {
@@ -71956,7 +72679,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)) : resolve18(returnValue);
+      0 < ReactSharedInternals.thrownErrors.length ? (queue = aggregateErrors(ReactSharedInternals.thrownErrors), ReactSharedInternals.thrownErrors.length = 0, reject(queue)) : resolve19(returnValue);
     }
     function flushActQueue(queue) {
       if (!isFlushing) {
@@ -72132,14 +72855,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(resolve18, reject) {
+          then: function(resolve19, reject) {
             didAwaitActCall = true;
             thenable.then(function(returnValue) {
               popActScope(prevActQueue, prevActScopeDepth);
               if (prevActScopeDepth === 0) {
                 try {
                   flushActQueue(queue), enqueueTask(function() {
-                    return recursivelyFlushAsyncActWork(returnValue, resolve18, reject);
+                    return recursivelyFlushAsyncActWork(returnValue, resolve19, reject);
                   });
                 } catch (error$0) {
                   ReactSharedInternals.thrownErrors.push(error$0);
@@ -72150,7 +72873,7 @@ See https://react.dev/link/invalid-hook-call for tips about how to debug and fix
                   reject(_thrownError);
                 }
               } else
-                resolve18(returnValue);
+                resolve19(returnValue);
             }, function(error48) {
               popActScope(prevActQueue, prevActScopeDepth);
               0 < ReactSharedInternals.thrownErrors.length ? (error48 = aggregateErrors(ReactSharedInternals.thrownErrors), ReactSharedInternals.thrownErrors.length = 0, reject(error48)) : reject(error48);
@@ -72166,11 +72889,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(resolve18, reject) {
+        then: function(resolve19, reject) {
           didAwaitActCall = true;
           prevActScopeDepth === 0 ? (ReactSharedInternals.actQueue = queue, enqueueTask(function() {
-            return recursivelyFlushAsyncActWork(returnValue$jscomp$0, resolve18, reject);
-          })) : resolve18(returnValue$jscomp$0);
+            return recursivelyFlushAsyncActWork(returnValue$jscomp$0, resolve19, reject);
+          })) : resolve19(returnValue$jscomp$0);
         }
       };
     };
@@ -72870,11 +73593,11 @@ var require_react_reconciler_development = __commonJS((exports, module) => {
         fiber = fiber.next, id--;
       return fiber;
     }
-    function copyWithSetImpl(obj, path31, index, value) {
-      if (index >= path31.length)
+    function copyWithSetImpl(obj, path32, index, value) {
+      if (index >= path32.length)
         return value;
-      var key = path31[index], updated = isArrayImpl(obj) ? obj.slice() : assign2({}, obj);
-      updated[key] = copyWithSetImpl(obj[key], path31, index + 1, value);
+      var key = path32[index], updated = isArrayImpl(obj) ? obj.slice() : assign2({}, obj);
+      updated[key] = copyWithSetImpl(obj[key], path32, index + 1, value);
       return updated;
     }
     function copyWithRename(obj, oldPath, newPath) {
@@ -72894,11 +73617,11 @@ var require_react_reconciler_development = __commonJS((exports, module) => {
       index + 1 === oldPath.length ? (updated[newPath[index]] = updated[oldKey], isArrayImpl(updated) ? updated.splice(oldKey, 1) : delete updated[oldKey]) : updated[oldKey] = copyWithRenameImpl(obj[oldKey], oldPath, newPath, index + 1);
       return updated;
     }
-    function copyWithDeleteImpl(obj, path31, index) {
-      var key = path31[index], updated = isArrayImpl(obj) ? obj.slice() : assign2({}, obj);
-      if (index + 1 === path31.length)
+    function copyWithDeleteImpl(obj, path32, index) {
+      var key = path32[index], updated = isArrayImpl(obj) ? obj.slice() : assign2({}, obj);
+      if (index + 1 === path32.length)
         return isArrayImpl(updated) ? updated.splice(key, 1) : delete updated[key], updated;
-      updated[key] = copyWithDeleteImpl(obj[key], path31, index + 1);
+      updated[key] = copyWithDeleteImpl(obj[key], path32, index + 1);
       return updated;
     }
     function shouldSuspendImpl() {
@@ -75012,8 +75735,8 @@ It can also happen if the client has a browser extension installed which messes
         currentEntangledActionThenable = {
           status: "pending",
           value: undefined,
-          then: function(resolve18) {
-            entangledListeners.push(resolve18);
+          then: function(resolve19) {
+            entangledListeners.push(resolve19);
           }
         };
       }
@@ -75037,8 +75760,8 @@ It can also happen if the client has a browser extension installed which messes
         status: "pending",
         value: null,
         reason: null,
-        then: function(resolve18) {
-          listeners.push(resolve18);
+        then: function(resolve19) {
+          listeners.push(resolve19);
         }
       };
       thenable.then(function() {
@@ -82921,29 +83644,29 @@ Check the top-level render call using <` + componentName2 + ">.");
     var didWarnAboutNestedUpdates = false;
     var didWarnAboutFindNodeInStrictMode = {};
     var overrideHookState = null, overrideHookStateDeletePath = null, overrideHookStateRenamePath = null, overrideProps = null, overridePropsDeletePath = null, overridePropsRenamePath = null, scheduleUpdate = null, scheduleRetry = null, setErrorHandler = null, setSuspenseHandler = null;
-    overrideHookState = function(fiber, id, path31, value) {
+    overrideHookState = function(fiber, id, path32, value) {
       id = findHook(fiber, id);
-      id !== null && (path31 = copyWithSetImpl(id.memoizedState, path31, 0, value), id.memoizedState = path31, id.baseState = path31, fiber.memoizedProps = assign2({}, fiber.memoizedProps), path31 = enqueueConcurrentRenderForLane(fiber, 2), path31 !== null && scheduleUpdateOnFiber(path31, fiber, 2));
+      id !== null && (path32 = copyWithSetImpl(id.memoizedState, path32, 0, value), id.memoizedState = path32, id.baseState = path32, fiber.memoizedProps = assign2({}, fiber.memoizedProps), path32 = enqueueConcurrentRenderForLane(fiber, 2), path32 !== null && scheduleUpdateOnFiber(path32, fiber, 2));
     };
-    overrideHookStateDeletePath = function(fiber, id, path31) {
+    overrideHookStateDeletePath = function(fiber, id, path32) {
       id = findHook(fiber, id);
-      id !== null && (path31 = copyWithDeleteImpl(id.memoizedState, path31, 0), id.memoizedState = path31, id.baseState = path31, fiber.memoizedProps = assign2({}, fiber.memoizedProps), path31 = enqueueConcurrentRenderForLane(fiber, 2), path31 !== null && scheduleUpdateOnFiber(path31, fiber, 2));
+      id !== null && (path32 = copyWithDeleteImpl(id.memoizedState, path32, 0), id.memoizedState = path32, id.baseState = path32, fiber.memoizedProps = assign2({}, fiber.memoizedProps), path32 = enqueueConcurrentRenderForLane(fiber, 2), path32 !== null && scheduleUpdateOnFiber(path32, fiber, 2));
     };
     overrideHookStateRenamePath = function(fiber, id, oldPath, newPath) {
       id = findHook(fiber, id);
       id !== null && (oldPath = copyWithRename(id.memoizedState, oldPath, newPath), id.memoizedState = oldPath, id.baseState = oldPath, fiber.memoizedProps = assign2({}, fiber.memoizedProps), oldPath = enqueueConcurrentRenderForLane(fiber, 2), oldPath !== null && scheduleUpdateOnFiber(oldPath, fiber, 2));
     };
-    overrideProps = function(fiber, path31, value) {
-      fiber.pendingProps = copyWithSetImpl(fiber.memoizedProps, path31, 0, value);
+    overrideProps = function(fiber, path32, value) {
+      fiber.pendingProps = copyWithSetImpl(fiber.memoizedProps, path32, 0, value);
       fiber.alternate && (fiber.alternate.pendingProps = fiber.pendingProps);
-      path31 = enqueueConcurrentRenderForLane(fiber, 2);
-      path31 !== null && scheduleUpdateOnFiber(path31, fiber, 2);
+      path32 = enqueueConcurrentRenderForLane(fiber, 2);
+      path32 !== null && scheduleUpdateOnFiber(path32, fiber, 2);
     };
-    overridePropsDeletePath = function(fiber, path31) {
-      fiber.pendingProps = copyWithDeleteImpl(fiber.memoizedProps, path31, 0);
+    overridePropsDeletePath = function(fiber, path32) {
+      fiber.pendingProps = copyWithDeleteImpl(fiber.memoizedProps, path32, 0);
       fiber.alternate && (fiber.alternate.pendingProps = fiber.pendingProps);
-      path31 = enqueueConcurrentRenderForLane(fiber, 2);
-      path31 !== null && scheduleUpdateOnFiber(path31, fiber, 2);
+      path32 = enqueueConcurrentRenderForLane(fiber, 2);
+      path32 !== null && scheduleUpdateOnFiber(path32, fiber, 2);
     };
     overridePropsRenamePath = function(fiber, oldPath, newPath) {
       fiber.pendingProps = copyWithRename(fiber.memoizedProps, oldPath, newPath);
@@ -86998,8 +87721,8 @@ In order to be iterable, non-array objects must have a [Symbol.iterator]() metho
           }
           return false;
         }
-        function utils_getInObject(object2, path31) {
-          return path31.reduce(function(reduced, attr2) {
+        function utils_getInObject(object2, path32) {
+          return path32.reduce(function(reduced, attr2) {
             if (reduced) {
               if (utils_hasOwnProperty.call(reduced, attr2)) {
                 return reduced[attr2];
@@ -87011,11 +87734,11 @@ In order to be iterable, non-array objects must have a [Symbol.iterator]() metho
             return null;
           }, object2);
         }
-        function deletePathInObject(object2, path31) {
-          var length = path31.length;
-          var last2 = path31[length - 1];
+        function deletePathInObject(object2, path32) {
+          var length = path32.length;
+          var last2 = path32[length - 1];
           if (object2 != null) {
-            var parent = utils_getInObject(object2, path31.slice(0, length - 1));
+            var parent = utils_getInObject(object2, path32.slice(0, length - 1));
             if (parent) {
               if (src_isArray(parent)) {
                 parent.splice(last2, 1);
@@ -87041,11 +87764,11 @@ In order to be iterable, non-array objects must have a [Symbol.iterator]() metho
             }
           }
         }
-        function utils_setInObject(object2, path31, value) {
-          var length = path31.length;
-          var last2 = path31[length - 1];
+        function utils_setInObject(object2, path32, value) {
+          var length = path32.length;
+          var last2 = path32[length - 1];
           if (object2 != null) {
-            var parent = utils_getInObject(object2, path31.slice(0, length - 1));
+            var parent = utils_getInObject(object2, path32.slice(0, length - 1));
             if (parent) {
               parent[last2] = value;
             }
@@ -87576,8 +88299,8 @@ In order to be iterable, non-array objects must have a [Symbol.iterator]() metho
           unserializable: Symbol("unserializable")
         };
         var LEVEL_THRESHOLD = 2;
-        function createDehydrated(type, inspectable, data, cleaned, path31) {
-          cleaned.push(path31);
+        function createDehydrated(type, inspectable, data, cleaned, path32) {
+          cleaned.push(path32);
           var dehydrated = {
             inspectable,
             type,
@@ -87595,13 +88318,13 @@ In order to be iterable, non-array objects must have a [Symbol.iterator]() metho
           }
           return dehydrated;
         }
-        function dehydrate(data, cleaned, unserializable, path31, isPathAllowed) {
+        function dehydrate(data, cleaned, unserializable, path32, isPathAllowed) {
           var level = arguments.length > 5 && arguments[5] !== undefined ? arguments[5] : 0;
           var type = getDataType(data);
           var isPathAllowedCheck;
           switch (type) {
             case "html_element":
-              cleaned.push(path31);
+              cleaned.push(path32);
               return {
                 inspectable: false,
                 preview_short: formatDataForPreview(data, false),
@@ -87610,7 +88333,7 @@ In order to be iterable, non-array objects must have a [Symbol.iterator]() metho
                 type
               };
             case "function":
-              cleaned.push(path31);
+              cleaned.push(path32);
               return {
                 inspectable: false,
                 preview_short: formatDataForPreview(data, false),
@@ -87619,14 +88342,14 @@ In order to be iterable, non-array objects must have a [Symbol.iterator]() metho
                 type
               };
             case "string":
-              isPathAllowedCheck = isPathAllowed(path31);
+              isPathAllowedCheck = isPathAllowed(path32);
               if (isPathAllowedCheck) {
                 return data;
               } else {
                 return data.length <= 500 ? data : data.slice(0, 500) + "...";
               }
             case "bigint":
-              cleaned.push(path31);
+              cleaned.push(path32);
               return {
                 inspectable: false,
                 preview_short: formatDataForPreview(data, false),
@@ -87635,7 +88358,7 @@ In order to be iterable, non-array objects must have a [Symbol.iterator]() metho
                 type
               };
             case "symbol":
-              cleaned.push(path31);
+              cleaned.push(path32);
               return {
                 inspectable: false,
                 preview_short: formatDataForPreview(data, false),
@@ -87644,9 +88367,9 @@ In order to be iterable, non-array objects must have a [Symbol.iterator]() metho
                 type
               };
             case "react_element": {
-              isPathAllowedCheck = isPathAllowed(path31);
+              isPathAllowedCheck = isPathAllowed(path32);
               if (level >= LEVEL_THRESHOLD && !isPathAllowedCheck) {
-                cleaned.push(path31);
+                cleaned.push(path32);
                 return {
                   inspectable: true,
                   preview_short: formatDataForPreview(data, false),
@@ -87663,19 +88386,19 @@ In order to be iterable, non-array objects must have a [Symbol.iterator]() metho
                 preview_long: formatDataForPreview(data, true),
                 name: getDisplayNameForReactElement(data) || "Unknown"
               };
-              unserializableValue.key = dehydrate(data.key, cleaned, unserializable, path31.concat(["key"]), isPathAllowed, isPathAllowedCheck ? 1 : level + 1);
+              unserializableValue.key = dehydrate(data.key, cleaned, unserializable, path32.concat(["key"]), isPathAllowed, isPathAllowedCheck ? 1 : level + 1);
               if (data.$$typeof === REACT_LEGACY_ELEMENT_TYPE) {
-                unserializableValue.ref = dehydrate(data.ref, cleaned, unserializable, path31.concat(["ref"]), isPathAllowed, isPathAllowedCheck ? 1 : level + 1);
+                unserializableValue.ref = dehydrate(data.ref, cleaned, unserializable, path32.concat(["ref"]), isPathAllowed, isPathAllowedCheck ? 1 : level + 1);
               }
-              unserializableValue.props = dehydrate(data.props, cleaned, unserializable, path31.concat(["props"]), isPathAllowed, isPathAllowedCheck ? 1 : level + 1);
-              unserializable.push(path31);
+              unserializableValue.props = dehydrate(data.props, cleaned, unserializable, path32.concat(["props"]), isPathAllowed, isPathAllowedCheck ? 1 : level + 1);
+              unserializable.push(path32);
               return unserializableValue;
             }
             case "react_lazy": {
-              isPathAllowedCheck = isPathAllowed(path31);
+              isPathAllowedCheck = isPathAllowed(path32);
               var payload = data._payload;
               if (level >= LEVEL_THRESHOLD && !isPathAllowedCheck) {
-                cleaned.push(path31);
+                cleaned.push(path32);
                 var inspectable = payload !== null && hydration_typeof(payload) === "object" && (payload._status === 1 || payload._status === 2 || payload.status === "fulfilled" || payload.status === "rejected");
                 return {
                   inspectable,
@@ -87692,13 +88415,13 @@ In order to be iterable, non-array objects must have a [Symbol.iterator]() metho
                 preview_long: formatDataForPreview(data, true),
                 name: "lazy()"
               };
-              _unserializableValue._payload = dehydrate(payload, cleaned, unserializable, path31.concat(["_payload"]), isPathAllowed, isPathAllowedCheck ? 1 : level + 1);
-              unserializable.push(path31);
+              _unserializableValue._payload = dehydrate(payload, cleaned, unserializable, path32.concat(["_payload"]), isPathAllowed, isPathAllowedCheck ? 1 : level + 1);
+              unserializable.push(path32);
               return _unserializableValue;
             }
             case "array_buffer":
             case "data_view":
-              cleaned.push(path31);
+              cleaned.push(path32);
               return {
                 inspectable: false,
                 preview_short: formatDataForPreview(data, false),
@@ -87708,21 +88431,21 @@ In order to be iterable, non-array objects must have a [Symbol.iterator]() metho
                 type
               };
             case "array":
-              isPathAllowedCheck = isPathAllowed(path31);
+              isPathAllowedCheck = isPathAllowed(path32);
               if (level >= LEVEL_THRESHOLD && !isPathAllowedCheck) {
-                return createDehydrated(type, true, data, cleaned, path31);
+                return createDehydrated(type, true, data, cleaned, path32);
               }
               var arr = [];
               for (var i = 0;i < data.length; i++) {
-                arr[i] = dehydrateKey(data, i, cleaned, unserializable, path31.concat([i]), isPathAllowed, isPathAllowedCheck ? 1 : level + 1);
+                arr[i] = dehydrateKey(data, i, cleaned, unserializable, path32.concat([i]), isPathAllowed, isPathAllowedCheck ? 1 : level + 1);
               }
               return arr;
             case "html_all_collection":
             case "typed_array":
             case "iterator":
-              isPathAllowedCheck = isPathAllowed(path31);
+              isPathAllowedCheck = isPathAllowed(path32);
               if (level >= LEVEL_THRESHOLD && !isPathAllowedCheck) {
-                return createDehydrated(type, true, data, cleaned, path31);
+                return createDehydrated(type, true, data, cleaned, path32);
               } else {
                 var _unserializableValue2 = {
                   unserializable: true,
@@ -87734,13 +88457,13 @@ In order to be iterable, non-array objects must have a [Symbol.iterator]() metho
                   name: typeof data.constructor !== "function" || typeof data.constructor.name !== "string" || data.constructor.name === "Object" ? "" : data.constructor.name
                 };
                 Array.from(data).forEach(function(item, i2) {
-                  return _unserializableValue2[i2] = dehydrate(item, cleaned, unserializable, path31.concat([i2]), isPathAllowed, isPathAllowedCheck ? 1 : level + 1);
+                  return _unserializableValue2[i2] = dehydrate(item, cleaned, unserializable, path32.concat([i2]), isPathAllowed, isPathAllowedCheck ? 1 : level + 1);
                 });
-                unserializable.push(path31);
+                unserializable.push(path32);
                 return _unserializableValue2;
               }
             case "opaque_iterator":
-              cleaned.push(path31);
+              cleaned.push(path32);
               return {
                 inspectable: false,
                 preview_short: formatDataForPreview(data, false),
@@ -87749,7 +88472,7 @@ In order to be iterable, non-array objects must have a [Symbol.iterator]() metho
                 type
               };
             case "date":
-              cleaned.push(path31);
+              cleaned.push(path32);
               return {
                 inspectable: false,
                 preview_short: formatDataForPreview(data, false),
@@ -87758,7 +88481,7 @@ In order to be iterable, non-array objects must have a [Symbol.iterator]() metho
                 type
               };
             case "regexp":
-              cleaned.push(path31);
+              cleaned.push(path32);
               return {
                 inspectable: false,
                 preview_short: formatDataForPreview(data, false),
@@ -87767,9 +88490,9 @@ In order to be iterable, non-array objects must have a [Symbol.iterator]() metho
                 type
               };
             case "thenable":
-              isPathAllowedCheck = isPathAllowed(path31);
+              isPathAllowedCheck = isPathAllowed(path32);
               if (level >= LEVEL_THRESHOLD && !isPathAllowedCheck) {
-                cleaned.push(path31);
+                cleaned.push(path32);
                 return {
                   inspectable: data.status === "fulfilled" || data.status === "rejected",
                   preview_short: formatDataForPreview(data, false),
@@ -87790,8 +88513,8 @@ In order to be iterable, non-array objects must have a [Symbol.iterator]() metho
                     preview_long: formatDataForPreview(data, true),
                     name: "fulfilled Thenable"
                   };
-                  _unserializableValue3.value = dehydrate(data.value, cleaned, unserializable, path31.concat(["value"]), isPathAllowed, isPathAllowedCheck ? 1 : level + 1);
-                  unserializable.push(path31);
+                  _unserializableValue3.value = dehydrate(data.value, cleaned, unserializable, path32.concat(["value"]), isPathAllowed, isPathAllowedCheck ? 1 : level + 1);
+                  unserializable.push(path32);
                   return _unserializableValue3;
                 }
                 case "rejected": {
@@ -87802,12 +88525,12 @@ In order to be iterable, non-array objects must have a [Symbol.iterator]() metho
                     preview_long: formatDataForPreview(data, true),
                     name: "rejected Thenable"
                   };
-                  _unserializableValue4.reason = dehydrate(data.reason, cleaned, unserializable, path31.concat(["reason"]), isPathAllowed, isPathAllowedCheck ? 1 : level + 1);
-                  unserializable.push(path31);
+                  _unserializableValue4.reason = dehydrate(data.reason, cleaned, unserializable, path32.concat(["reason"]), isPathAllowed, isPathAllowedCheck ? 1 : level + 1);
+                  unserializable.push(path32);
                   return _unserializableValue4;
                 }
                 default:
-                  cleaned.push(path31);
+                  cleaned.push(path32);
                   return {
                     inspectable: false,
                     preview_short: formatDataForPreview(data, false),
@@ -87817,21 +88540,21 @@ In order to be iterable, non-array objects must have a [Symbol.iterator]() metho
                   };
               }
             case "object":
-              isPathAllowedCheck = isPathAllowed(path31);
+              isPathAllowedCheck = isPathAllowed(path32);
               if (level >= LEVEL_THRESHOLD && !isPathAllowedCheck) {
-                return createDehydrated(type, true, data, cleaned, path31);
+                return createDehydrated(type, true, data, cleaned, path32);
               } else {
                 var object2 = {};
                 getAllEnumerableKeys(data).forEach(function(key) {
                   var name = key.toString();
-                  object2[name] = dehydrateKey(data, key, cleaned, unserializable, path31.concat([name]), isPathAllowed, isPathAllowedCheck ? 1 : level + 1);
+                  object2[name] = dehydrateKey(data, key, cleaned, unserializable, path32.concat([name]), isPathAllowed, isPathAllowedCheck ? 1 : level + 1);
                 });
                 return object2;
               }
             case "class_instance": {
-              isPathAllowedCheck = isPathAllowed(path31);
+              isPathAllowedCheck = isPathAllowed(path32);
               if (level >= LEVEL_THRESHOLD && !isPathAllowedCheck) {
-                return createDehydrated(type, true, data, cleaned, path31);
+                return createDehydrated(type, true, data, cleaned, path32);
               }
               var value = {
                 unserializable: true,
@@ -87843,15 +88566,15 @@ In order to be iterable, non-array objects must have a [Symbol.iterator]() metho
               };
               getAllEnumerableKeys(data).forEach(function(key) {
                 var keyAsString = key.toString();
-                value[keyAsString] = dehydrate(data[key], cleaned, unserializable, path31.concat([keyAsString]), isPathAllowed, isPathAllowedCheck ? 1 : level + 1);
+                value[keyAsString] = dehydrate(data[key], cleaned, unserializable, path32.concat([keyAsString]), isPathAllowed, isPathAllowedCheck ? 1 : level + 1);
               });
-              unserializable.push(path31);
+              unserializable.push(path32);
               return value;
             }
             case "error": {
-              isPathAllowedCheck = isPathAllowed(path31);
+              isPathAllowedCheck = isPathAllowed(path32);
               if (level >= LEVEL_THRESHOLD && !isPathAllowedCheck) {
-                return createDehydrated(type, true, data, cleaned, path31);
+                return createDehydrated(type, true, data, cleaned, path32);
               }
               var _value = {
                 unserializable: true,
@@ -87861,22 +88584,22 @@ In order to be iterable, non-array objects must have a [Symbol.iterator]() metho
                 preview_long: formatDataForPreview(data, true),
                 name: data.name
               };
-              _value.message = dehydrate(data.message, cleaned, unserializable, path31.concat(["message"]), isPathAllowed, isPathAllowedCheck ? 1 : level + 1);
-              _value.stack = dehydrate(data.stack, cleaned, unserializable, path31.concat(["stack"]), isPathAllowed, isPathAllowedCheck ? 1 : level + 1);
+              _value.message = dehydrate(data.message, cleaned, unserializable, path32.concat(["message"]), isPathAllowed, isPathAllowedCheck ? 1 : level + 1);
+              _value.stack = dehydrate(data.stack, cleaned, unserializable, path32.concat(["stack"]), isPathAllowed, isPathAllowedCheck ? 1 : level + 1);
               if ("cause" in data) {
-                _value.cause = dehydrate(data.cause, cleaned, unserializable, path31.concat(["cause"]), isPathAllowed, isPathAllowedCheck ? 1 : level + 1);
+                _value.cause = dehydrate(data.cause, cleaned, unserializable, path32.concat(["cause"]), isPathAllowed, isPathAllowedCheck ? 1 : level + 1);
               }
               getAllEnumerableKeys(data).forEach(function(key) {
                 var keyAsString = key.toString();
-                _value[keyAsString] = dehydrate(data[key], cleaned, unserializable, path31.concat([keyAsString]), isPathAllowed, isPathAllowedCheck ? 1 : level + 1);
+                _value[keyAsString] = dehydrate(data[key], cleaned, unserializable, path32.concat([keyAsString]), isPathAllowed, isPathAllowedCheck ? 1 : level + 1);
               });
-              unserializable.push(path31);
+              unserializable.push(path32);
               return _value;
             }
             case "infinity":
             case "nan":
             case "undefined":
-              cleaned.push(path31);
+              cleaned.push(path32);
               return {
                 type
               };
@@ -87884,10 +88607,10 @@ In order to be iterable, non-array objects must have a [Symbol.iterator]() metho
               return data;
           }
         }
-        function dehydrateKey(parent, key, cleaned, unserializable, path31, isPathAllowed) {
+        function dehydrateKey(parent, key, cleaned, unserializable, path32, isPathAllowed) {
           var level = arguments.length > 6 && arguments[6] !== undefined ? arguments[6] : 0;
           try {
-            return dehydrate(parent[key], cleaned, unserializable, path31, isPathAllowed, level);
+            return dehydrate(parent[key], cleaned, unserializable, path32, isPathAllowed, level);
           } catch (error48) {
             var preview = "";
             if (hydration_typeof(error48) === "object" && error48 !== null && typeof error48.stack === "string") {
@@ -87895,7 +88618,7 @@ In order to be iterable, non-array objects must have a [Symbol.iterator]() metho
             } else if (typeof error48 === "string") {
               preview = error48;
             }
-            cleaned.push(path31);
+            cleaned.push(path32);
             return {
               inspectable: false,
               preview_short: "[Exception]",
@@ -87905,8 +88628,8 @@ In order to be iterable, non-array objects must have a [Symbol.iterator]() metho
             };
           }
         }
-        function fillInPath(object2, data, path31, value) {
-          var target = getInObject(object2, path31);
+        function fillInPath(object2, data, path32, value) {
+          var target = getInObject(object2, path32);
           if (target != null) {
             if (!target[meta3.unserializable]) {
               delete target[meta3.inspectable];
@@ -87921,9 +88644,9 @@ In order to be iterable, non-array objects must have a [Symbol.iterator]() metho
           }
           if (value !== null && data.unserializable.length > 0) {
             var unserializablePath = data.unserializable[0];
-            var isMatch2 = unserializablePath.length === path31.length;
-            for (var i = 0;i < path31.length; i++) {
-              if (path31[i] !== unserializablePath[i]) {
+            var isMatch2 = unserializablePath.length === path32.length;
+            for (var i = 0;i < path32.length; i++) {
+              if (path32[i] !== unserializablePath[i]) {
                 isMatch2 = false;
                 break;
               }
@@ -87932,13 +88655,13 @@ In order to be iterable, non-array objects must have a [Symbol.iterator]() metho
               upgradeUnserializable(value, value);
             }
           }
-          setInObject(object2, path31, value);
+          setInObject(object2, path32, value);
         }
         function hydrate(object2, cleaned, unserializable) {
-          cleaned.forEach(function(path31) {
-            var length = path31.length;
-            var last2 = path31[length - 1];
-            var parent = getInObject(object2, path31.slice(0, length - 1));
+          cleaned.forEach(function(path32) {
+            var length = path32.length;
+            var last2 = path32[length - 1];
+            var parent = getInObject(object2, path32.slice(0, length - 1));
             if (!parent || !parent.hasOwnProperty(last2)) {
               return;
             }
@@ -87964,10 +88687,10 @@ In order to be iterable, non-array objects must have a [Symbol.iterator]() metho
               parent[last2] = replaced;
             }
           });
-          unserializable.forEach(function(path31) {
-            var length = path31.length;
-            var last2 = path31[length - 1];
-            var parent = getInObject(object2, path31.slice(0, length - 1));
+          unserializable.forEach(function(path32) {
+            var length = path32.length;
+            var last2 = path32[length - 1];
+            var parent = getInObject(object2, path32.slice(0, length - 1));
             if (!parent || !parent.hasOwnProperty(last2)) {
               return;
             }
@@ -88088,11 +88811,11 @@ In order to be iterable, non-array objects must have a [Symbol.iterator]() metho
           return gte2(version2, FIRST_DEVTOOLS_BACKEND_LOCKSTEP_VER);
         }
         function cleanForBridge(data, isPathAllowed) {
-          var path31 = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : [];
+          var path32 = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : [];
           if (data !== null) {
             var cleanedPaths = [];
             var unserializablePaths = [];
-            var cleanedData = dehydrate(data, cleanedPaths, unserializablePaths, path31, isPathAllowed);
+            var cleanedData = dehydrate(data, cleanedPaths, unserializablePaths, path32, isPathAllowed);
             return {
               data: cleanedData,
               cleaned: cleanedPaths,
@@ -88102,18 +88825,18 @@ In order to be iterable, non-array objects must have a [Symbol.iterator]() metho
             return null;
           }
         }
-        function copyWithDelete(obj, path31) {
+        function copyWithDelete(obj, path32) {
           var index = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : 0;
-          var key = path31[index];
+          var key = path32[index];
           var updated = shared_isArray(obj) ? obj.slice() : utils_objectSpread({}, obj);
-          if (index + 1 === path31.length) {
+          if (index + 1 === path32.length) {
             if (shared_isArray(updated)) {
               updated.splice(key, 1);
             } else {
               delete updated[key];
             }
           } else {
-            updated[key] = copyWithDelete(obj[key], path31, index + 1);
+            updated[key] = copyWithDelete(obj[key], path32, index + 1);
           }
           return updated;
         }
@@ -88134,14 +88857,14 @@ In order to be iterable, non-array objects must have a [Symbol.iterator]() metho
           }
           return updated;
         }
-        function copyWithSet(obj, path31, value) {
+        function copyWithSet(obj, path32, value) {
           var index = arguments.length > 3 && arguments[3] !== undefined ? arguments[3] : 0;
-          if (index >= path31.length) {
+          if (index >= path32.length) {
             return value;
           }
-          var key = path31[index];
+          var key = path32[index];
           var updated = shared_isArray(obj) ? obj.slice() : utils_objectSpread({}, obj);
-          updated[key] = copyWithSet(obj[key], path31, value, index + 1);
+          updated[key] = copyWithSet(obj[key], path32, value, index + 1);
           return updated;
         }
         function getEffectDurations(root) {
@@ -89469,12 +90192,12 @@ In order to be iterable, non-array objects must have a [Symbol.iterator]() metho
               }
             });
             bridge_defineProperty(_this, "overrideValueAtPath", function(_ref) {
-              var { id, path: path31, rendererID, type, value } = _ref;
+              var { id, path: path32, rendererID, type, value } = _ref;
               switch (type) {
                 case "context":
                   _this.send("overrideContext", {
                     id,
-                    path: path31,
+                    path: path32,
                     rendererID,
                     wasForwarded: true,
                     value
@@ -89483,7 +90206,7 @@ In order to be iterable, non-array objects must have a [Symbol.iterator]() metho
                 case "hooks":
                   _this.send("overrideHookState", {
                     id,
-                    path: path31,
+                    path: path32,
                     rendererID,
                     wasForwarded: true,
                     value
@@ -89492,7 +90215,7 @@ In order to be iterable, non-array objects must have a [Symbol.iterator]() metho
                 case "props":
                   _this.send("overrideProps", {
                     id,
-                    path: path31,
+                    path: path32,
                     rendererID,
                     wasForwarded: true,
                     value
@@ -89501,7 +90224,7 @@ In order to be iterable, non-array objects must have a [Symbol.iterator]() metho
                 case "state":
                   _this.send("overrideState", {
                     id,
-                    path: path31,
+                    path: path32,
                     rendererID,
                     wasForwarded: true,
                     value
@@ -89835,12 +90558,12 @@ In order to be iterable, non-array objects must have a [Symbol.iterator]() metho
               }
             });
             agent_defineProperty(_this, "copyElementPath", function(_ref5) {
-              var { id, path: path31, rendererID } = _ref5;
+              var { id, path: path32, rendererID } = _ref5;
               var renderer = _this._rendererInterfaces[rendererID];
               if (renderer == null) {
                 console.warn('Invalid renderer id "'.concat(rendererID, '" for element "').concat(id, '"'));
               } else {
-                var value = renderer.getSerializedElementValueByPath(id, path31);
+                var value = renderer.getSerializedElementValueByPath(id, path32);
                 if (value != null) {
                   _this._bridge.send("saveToClipboard", value);
                 } else {
@@ -89849,12 +90572,12 @@ In order to be iterable, non-array objects must have a [Symbol.iterator]() metho
               }
             });
             agent_defineProperty(_this, "deletePath", function(_ref6) {
-              var { hookID, id, path: path31, rendererID, type } = _ref6;
+              var { hookID, id, path: path32, rendererID, type } = _ref6;
               var renderer = _this._rendererInterfaces[rendererID];
               if (renderer == null) {
                 console.warn('Invalid renderer id "'.concat(rendererID, '" for element "').concat(id, '"'));
               } else {
-                renderer.deletePath(type, id, hookID, path31);
+                renderer.deletePath(type, id, hookID, path32);
               }
             });
             agent_defineProperty(_this, "getBackendVersion", function() {
@@ -89891,12 +90614,12 @@ In order to be iterable, non-array objects must have a [Symbol.iterator]() metho
               }
             });
             agent_defineProperty(_this, "inspectElement", function(_ref9) {
-              var { forceFullData, id, path: path31, rendererID, requestID } = _ref9;
+              var { forceFullData, id, path: path32, rendererID, requestID } = _ref9;
               var renderer = _this._rendererInterfaces[rendererID];
               if (renderer == null) {
                 console.warn('Invalid renderer id "'.concat(rendererID, '" for element "').concat(id, '"'));
               } else {
-                _this._bridge.send("inspectedElement", renderer.inspectElement(requestID, id, path31, forceFullData));
+                _this._bridge.send("inspectedElement", renderer.inspectElement(requestID, id, path32, forceFullData));
                 if (_this._persistedSelectionMatch === null || _this._persistedSelectionMatch.id !== id) {
                   _this._persistedSelection = null;
                   _this._persistedSelectionMatch = null;
@@ -89930,15 +90653,15 @@ In order to be iterable, non-array objects must have a [Symbol.iterator]() metho
               }
               for (var rendererID in _this._rendererInterfaces) {
                 var renderer = _this._rendererInterfaces[rendererID];
-                var path31 = null;
+                var path32 = null;
                 if (suspendedByPathIndex !== null && rendererPath !== null) {
                   var suspendedByPathRendererIndex = suspendedByPathIndex - suspendedByOffset;
                   var rendererHasRequestedSuspendedByPath = renderer.getElementAttributeByPath(id, ["suspendedBy", suspendedByPathRendererIndex]) !== undefined;
                   if (rendererHasRequestedSuspendedByPath) {
-                    path31 = ["suspendedBy", suspendedByPathRendererIndex].concat(rendererPath);
+                    path32 = ["suspendedBy", suspendedByPathRendererIndex].concat(rendererPath);
                   }
                 }
-                var inspectedRootsPayload = renderer.inspectElement(requestID, id, path31, forceFullData);
+                var inspectedRootsPayload = renderer.inspectElement(requestID, id, path32, forceFullData);
                 switch (inspectedRootsPayload.type) {
                   case "hydrated-path":
                     inspectedRootsPayload.path[1] += suspendedByOffset;
@@ -90032,20 +90755,20 @@ In order to be iterable, non-array objects must have a [Symbol.iterator]() metho
               }
             });
             agent_defineProperty(_this, "overrideValueAtPath", function(_ref15) {
-              var { hookID, id, path: path31, rendererID, type, value } = _ref15;
+              var { hookID, id, path: path32, rendererID, type, value } = _ref15;
               var renderer = _this._rendererInterfaces[rendererID];
               if (renderer == null) {
                 console.warn('Invalid renderer id "'.concat(rendererID, '" for element "').concat(id, '"'));
               } else {
-                renderer.overrideValueAtPath(type, id, hookID, path31, value);
+                renderer.overrideValueAtPath(type, id, hookID, path32, value);
               }
             });
             agent_defineProperty(_this, "overrideContext", function(_ref16) {
-              var { id, path: path31, rendererID, wasForwarded, value } = _ref16;
+              var { id, path: path32, rendererID, wasForwarded, value } = _ref16;
               if (!wasForwarded) {
                 _this.overrideValueAtPath({
                   id,
-                  path: path31,
+                  path: path32,
                   rendererID,
                   type: "context",
                   value
@@ -90053,11 +90776,11 @@ In order to be iterable, non-array objects must have a [Symbol.iterator]() metho
               }
             });
             agent_defineProperty(_this, "overrideHookState", function(_ref17) {
-              var { id, hookID, path: path31, rendererID, wasForwarded, value } = _ref17;
+              var { id, hookID, path: path32, rendererID, wasForwarded, value } = _ref17;
               if (!wasForwarded) {
                 _this.overrideValueAtPath({
                   id,
-                  path: path31,
+                  path: path32,
                   rendererID,
                   type: "hooks",
                   value
@@ -90065,11 +90788,11 @@ In order to be iterable, non-array objects must have a [Symbol.iterator]() metho
               }
             });
             agent_defineProperty(_this, "overrideProps", function(_ref18) {
-              var { id, path: path31, rendererID, wasForwarded, value } = _ref18;
+              var { id, path: path32, rendererID, wasForwarded, value } = _ref18;
               if (!wasForwarded) {
                 _this.overrideValueAtPath({
                   id,
-                  path: path31,
+                  path: path32,
                   rendererID,
                   type: "props",
                   value
@@ -90077,11 +90800,11 @@ In order to be iterable, non-array objects must have a [Symbol.iterator]() metho
               }
             });
             agent_defineProperty(_this, "overrideState", function(_ref19) {
-              var { id, path: path31, rendererID, wasForwarded, value } = _ref19;
+              var { id, path: path32, rendererID, wasForwarded, value } = _ref19;
               if (!wasForwarded) {
                 _this.overrideValueAtPath({
                   id,
-                  path: path31,
+                  path: path32,
                   rendererID,
                   type: "state",
                   value
@@ -90148,12 +90871,12 @@ In order to be iterable, non-array objects must have a [Symbol.iterator]() metho
               _this._bridge.send("stopInspectingHost", selected);
             });
             agent_defineProperty(_this, "storeAsGlobal", function(_ref23) {
-              var { count, id, path: path31, rendererID } = _ref23;
+              var { count, id, path: path32, rendererID } = _ref23;
               var renderer = _this._rendererInterfaces[rendererID];
               if (renderer == null) {
                 console.warn('Invalid renderer id "'.concat(rendererID, '" for element "').concat(id, '"'));
               } else {
-                renderer.storeAsGlobal(id, path31, count);
+                renderer.storeAsGlobal(id, path32, count);
               }
             });
             agent_defineProperty(_this, "updateHookSettings", function(settings) {
@@ -90170,12 +90893,12 @@ In order to be iterable, non-array objects must have a [Symbol.iterator]() metho
                 var rendererID = +rendererIDString;
                 var renderer = _this._rendererInterfaces[rendererID];
                 if (_this._lastSelectedRendererID === rendererID) {
-                  var path31 = renderer.getPathForElement(_this._lastSelectedElementID);
-                  if (path31 !== null) {
-                    renderer.setTrackedPath(path31);
+                  var path32 = renderer.getPathForElement(_this._lastSelectedElementID);
+                  if (path32 !== null) {
+                    renderer.setTrackedPath(path32);
                     _this._persistedSelection = {
                       rendererID,
-                      path: path31
+                      path: path32
                     };
                   }
                 }
@@ -90250,11 +90973,11 @@ In order to be iterable, non-array objects must have a [Symbol.iterator]() metho
               var rendererID = _this._lastSelectedRendererID;
               var id = _this._lastSelectedElementID;
               var renderer = _this._rendererInterfaces[rendererID];
-              var path31 = renderer != null ? renderer.getPathForElement(id) : null;
-              if (path31 !== null) {
+              var path32 = renderer != null ? renderer.getPathForElement(id) : null;
+              if (path32 !== null) {
                 storage_sessionStorageSetItem(SESSION_STORAGE_LAST_SELECTION_KEY, JSON.stringify({
                   rendererID,
-                  path: path31
+                  path: path32
                 }));
               } else {
                 storage_sessionStorageRemoveItem(SESSION_STORAGE_LAST_SELECTION_KEY);
@@ -90977,7 +91700,7 @@ In order to be iterable, non-array objects must have a [Symbol.iterator]() metho
             hasElementWithId: function hasElementWithId() {
               return false;
             },
-            inspectElement: function inspectElement(requestID, id, path31) {
+            inspectElement: function inspectElement(requestID, id, path32) {
               return {
                 id,
                 responseID: requestID,
@@ -96247,9 +96970,9 @@ In order to be iterable, non-array objects must have a [Symbol.iterator]() metho
             }
             return null;
           }
-          function getElementAttributeByPath(id, path31) {
+          function getElementAttributeByPath(id, path32) {
             if (isMostRecentlyInspectedElement(id)) {
-              return utils_getInObject(mostRecentlyInspectedElement, path31);
+              return utils_getInObject(mostRecentlyInspectedElement, path32);
             }
             return;
           }
@@ -96952,9 +97675,9 @@ In order to be iterable, non-array objects must have a [Symbol.iterator]() metho
           function isMostRecentlyInspectedElementCurrent(id) {
             return isMostRecentlyInspectedElement(id) && !hasElementUpdatedSinceLastInspected;
           }
-          function mergeInspectedPaths(path31) {
+          function mergeInspectedPaths(path32) {
             var current = currentlyInspectedPaths;
-            path31.forEach(function(key) {
+            path32.forEach(function(key) {
               if (!current[key]) {
                 current[key] = {};
               }
@@ -96962,21 +97685,21 @@ In order to be iterable, non-array objects must have a [Symbol.iterator]() metho
             });
           }
           function createIsPathAllowed(key, secondaryCategory) {
-            return function isPathAllowed(path31) {
+            return function isPathAllowed(path32) {
               switch (secondaryCategory) {
                 case "hooks":
-                  if (path31.length === 1) {
+                  if (path32.length === 1) {
                     return true;
                   }
-                  if (path31[path31.length - 2] === "hookSource" && path31[path31.length - 1] === "fileName") {
+                  if (path32[path32.length - 2] === "hookSource" && path32[path32.length - 1] === "fileName") {
                     return true;
                   }
-                  if (path31[path31.length - 1] === "subHooks" || path31[path31.length - 2] === "subHooks") {
+                  if (path32[path32.length - 1] === "subHooks" || path32[path32.length - 2] === "subHooks") {
                     return true;
                   }
                   break;
                 case "suspendedBy":
-                  if (path31.length < 5) {
+                  if (path32.length < 5) {
                     return true;
                   }
                   break;
@@ -96987,8 +97710,8 @@ In order to be iterable, non-array objects must have a [Symbol.iterator]() metho
               if (!current) {
                 return false;
               }
-              for (var i = 0;i < path31.length; i++) {
-                current = current[path31[i]];
+              for (var i = 0;i < path32.length; i++) {
+                current = current[path32[i]];
                 if (!current) {
                   return false;
                 }
@@ -97042,38 +97765,38 @@ In order to be iterable, non-array objects must have a [Symbol.iterator]() metho
                 break;
             }
           }
-          function storeAsGlobal(id, path31, count) {
+          function storeAsGlobal(id, path32, count) {
             if (isMostRecentlyInspectedElement(id)) {
-              var value = utils_getInObject(mostRecentlyInspectedElement, path31);
+              var value = utils_getInObject(mostRecentlyInspectedElement, path32);
               var key = "$reactTemp".concat(count);
               window[key] = value;
               console.log(key);
               console.log(value);
             }
           }
-          function getSerializedElementValueByPath(id, path31) {
+          function getSerializedElementValueByPath(id, path32) {
             if (isMostRecentlyInspectedElement(id)) {
-              var valueToCopy = utils_getInObject(mostRecentlyInspectedElement, path31);
+              var valueToCopy = utils_getInObject(mostRecentlyInspectedElement, path32);
               return serializeToString(valueToCopy);
             }
           }
-          function inspectElement(requestID, id, path31, forceFullData) {
-            if (path31 !== null) {
-              mergeInspectedPaths(path31);
+          function inspectElement(requestID, id, path32, forceFullData) {
+            if (path32 !== null) {
+              mergeInspectedPaths(path32);
             }
             if (isMostRecentlyInspectedElement(id) && !forceFullData) {
               if (!hasElementUpdatedSinceLastInspected) {
-                if (path31 !== null) {
+                if (path32 !== null) {
                   var secondaryCategory = null;
-                  if (path31[0] === "hooks" || path31[0] === "suspendedBy") {
-                    secondaryCategory = path31[0];
+                  if (path32[0] === "hooks" || path32[0] === "suspendedBy") {
+                    secondaryCategory = path32[0];
                   }
                   return {
                     id,
                     responseID: requestID,
                     type: "hydrated-path",
-                    path: path31,
-                    value: cleanForBridge(utils_getInObject(mostRecentlyInspectedElement, path31), createIsPathAllowed(null, secondaryCategory), path31)
+                    path: path32,
+                    value: cleanForBridge(utils_getInObject(mostRecentlyInspectedElement, path32), createIsPathAllowed(null, secondaryCategory), path32)
                   };
                 } else {
                   return {
@@ -97269,7 +97992,7 @@ The error thrown in the component is:
               console.groupEnd();
             }
           }
-          function deletePath(type, id, hookID, path31) {
+          function deletePath(type, id, hookID, path32) {
             var devtoolsInstance = idToDevToolsInstanceMap.get(id);
             if (devtoolsInstance === undefined) {
               console.warn('Could not find DevToolsInstance with id "'.concat(id, '"'));
@@ -97283,11 +98006,11 @@ The error thrown in the component is:
               var instance2 = fiber.stateNode;
               switch (type) {
                 case "context":
-                  path31 = path31.slice(1);
+                  path32 = path32.slice(1);
                   switch (fiber.tag) {
                     case ClassComponent:
-                      if (path31.length === 0) {} else {
-                        deletePathInObject(instance2.context, path31);
+                      if (path32.length === 0) {} else {
+                        deletePathInObject(instance2.context, path32);
                       }
                       instance2.forceUpdate();
                       break;
@@ -97297,21 +98020,21 @@ The error thrown in the component is:
                   break;
                 case "hooks":
                   if (typeof overrideHookStateDeletePath === "function") {
-                    overrideHookStateDeletePath(fiber, hookID, path31);
+                    overrideHookStateDeletePath(fiber, hookID, path32);
                   }
                   break;
                 case "props":
                   if (instance2 === null) {
                     if (typeof overridePropsDeletePath === "function") {
-                      overridePropsDeletePath(fiber, path31);
+                      overridePropsDeletePath(fiber, path32);
                     }
                   } else {
-                    fiber.pendingProps = copyWithDelete(instance2.props, path31);
+                    fiber.pendingProps = copyWithDelete(instance2.props, path32);
                     instance2.forceUpdate();
                   }
                   break;
                 case "state":
-                  deletePathInObject(instance2.state, path31);
+                  deletePathInObject(instance2.state, path32);
                   instance2.forceUpdate();
                   break;
               }
@@ -97366,7 +98089,7 @@ The error thrown in the component is:
               }
             }
           }
-          function overrideValueAtPath(type, id, hookID, path31, value) {
+          function overrideValueAtPath(type, id, hookID, path32, value) {
             var devtoolsInstance = idToDevToolsInstanceMap.get(id);
             if (devtoolsInstance === undefined) {
               console.warn('Could not find DevToolsInstance with id "'.concat(id, '"'));
@@ -97380,13 +98103,13 @@ The error thrown in the component is:
               var instance2 = fiber.stateNode;
               switch (type) {
                 case "context":
-                  path31 = path31.slice(1);
+                  path32 = path32.slice(1);
                   switch (fiber.tag) {
                     case ClassComponent:
-                      if (path31.length === 0) {
+                      if (path32.length === 0) {
                         instance2.context = value;
                       } else {
-                        utils_setInObject(instance2.context, path31, value);
+                        utils_setInObject(instance2.context, path32, value);
                       }
                       instance2.forceUpdate();
                       break;
@@ -97396,18 +98119,18 @@ The error thrown in the component is:
                   break;
                 case "hooks":
                   if (typeof overrideHookState === "function") {
-                    overrideHookState(fiber, hookID, path31, value);
+                    overrideHookState(fiber, hookID, path32, value);
                   }
                   break;
                 case "props":
                   switch (fiber.tag) {
                     case ClassComponent:
-                      fiber.pendingProps = copyWithSet(instance2.props, path31, value);
+                      fiber.pendingProps = copyWithSet(instance2.props, path32, value);
                       instance2.forceUpdate();
                       break;
                     default:
                       if (typeof overrideProps === "function") {
-                        overrideProps(fiber, path31, value);
+                        overrideProps(fiber, path32, value);
                       }
                       break;
                   }
@@ -97415,7 +98138,7 @@ The error thrown in the component is:
                 case "state":
                   switch (fiber.tag) {
                     case ClassComponent:
-                      utils_setInObject(instance2.state, path31, value);
+                      utils_setInObject(instance2.state, path32, value);
                       instance2.forceUpdate();
                       break;
                   }
@@ -97701,14 +98424,14 @@ The error thrown in the component is:
           var trackedPathMatchInstance = null;
           var trackedPathMatchDepth = -1;
           var mightBeOnTrackedPath = false;
-          function setTrackedPath(path31) {
-            if (path31 === null) {
+          function setTrackedPath(path32) {
+            if (path32 === null) {
               trackedPathMatchFiber = null;
               trackedPathMatchInstance = null;
               trackedPathMatchDepth = -1;
               mightBeOnTrackedPath = false;
             }
-            trackedPath = path31;
+            trackedPath = path32;
           }
           function updateTrackedPathStateBeforeMount(fiber, fiberInstance) {
             if (trackedPath === null || !mightBeOnTrackedPath) {
@@ -98472,9 +99195,9 @@ The error thrown in the component is:
           }
           var currentlyInspectedElementID = null;
           var currentlyInspectedPaths = {};
-          function mergeInspectedPaths(path31) {
+          function mergeInspectedPaths(path32) {
             var current = currentlyInspectedPaths;
-            path31.forEach(function(key) {
+            path32.forEach(function(key) {
               if (!current[key]) {
                 current[key] = {};
               }
@@ -98482,13 +99205,13 @@ The error thrown in the component is:
             });
           }
           function createIsPathAllowed(key) {
-            return function isPathAllowed(path31) {
+            return function isPathAllowed(path32) {
               var current = currentlyInspectedPaths[key];
               if (!current) {
                 return false;
               }
-              for (var i = 0;i < path31.length; i++) {
-                current = current[path31[i]];
+              for (var i = 0;i < path32.length; i++) {
+                current = current[path32[i]];
                 if (!current) {
                   return false;
                 }
@@ -98538,24 +99261,24 @@ The error thrown in the component is:
                 break;
             }
           }
-          function storeAsGlobal(id, path31, count) {
+          function storeAsGlobal(id, path32, count) {
             var inspectedElement = inspectElementRaw(id);
             if (inspectedElement !== null) {
-              var value = utils_getInObject(inspectedElement, path31);
+              var value = utils_getInObject(inspectedElement, path32);
               var key = "$reactTemp".concat(count);
               window[key] = value;
               console.log(key);
               console.log(value);
             }
           }
-          function getSerializedElementValueByPath(id, path31) {
+          function getSerializedElementValueByPath(id, path32) {
             var inspectedElement = inspectElementRaw(id);
             if (inspectedElement !== null) {
-              var valueToCopy = utils_getInObject(inspectedElement, path31);
+              var valueToCopy = utils_getInObject(inspectedElement, path32);
               return serializeToString(valueToCopy);
             }
           }
-          function inspectElement(requestID, id, path31, forceFullData) {
+          function inspectElement(requestID, id, path32, forceFullData) {
             if (forceFullData || currentlyInspectedElementID !== id) {
               currentlyInspectedElementID = id;
               currentlyInspectedPaths = {};
@@ -98568,8 +99291,8 @@ The error thrown in the component is:
                 type: "not-found"
               };
             }
-            if (path31 !== null) {
-              mergeInspectedPaths(path31);
+            if (path32 !== null) {
+              mergeInspectedPaths(path32);
             }
             updateSelectedElement(id);
             inspectedElement.context = cleanForBridge(inspectedElement.context, createIsPathAllowed("context"));
@@ -98772,10 +99495,10 @@ The error thrown in the component is:
               console.groupEnd();
             }
           }
-          function getElementAttributeByPath(id, path31) {
+          function getElementAttributeByPath(id, path32) {
             var inspectedElement = inspectElementRaw(id);
             if (inspectedElement !== null) {
-              return utils_getInObject(inspectedElement, path31);
+              return utils_getInObject(inspectedElement, path32);
             }
             return;
           }
@@ -98792,14 +99515,14 @@ The error thrown in the component is:
             }
             return element.type;
           }
-          function deletePath(type, id, hookID, path31) {
+          function deletePath(type, id, hookID, path32) {
             var internalInstance = idToInternalInstanceMap.get(id);
             if (internalInstance != null) {
               var publicInstance = internalInstance._instance;
               if (publicInstance != null) {
                 switch (type) {
                   case "context":
-                    deletePathInObject(publicInstance.context, path31);
+                    deletePathInObject(publicInstance.context, path32);
                     forceUpdate(publicInstance);
                     break;
                   case "hooks":
@@ -98807,12 +99530,12 @@ The error thrown in the component is:
                   case "props":
                     var element = internalInstance._currentElement;
                     internalInstance._currentElement = legacy_renderer_objectSpread(legacy_renderer_objectSpread({}, element), {}, {
-                      props: copyWithDelete(element.props, path31)
+                      props: copyWithDelete(element.props, path32)
                     });
                     forceUpdate(publicInstance);
                     break;
                   case "state":
-                    deletePathInObject(publicInstance.state, path31);
+                    deletePathInObject(publicInstance.state, path32);
                     forceUpdate(publicInstance);
                     break;
                 }
@@ -98846,14 +99569,14 @@ The error thrown in the component is:
               }
             }
           }
-          function overrideValueAtPath(type, id, hookID, path31, value) {
+          function overrideValueAtPath(type, id, hookID, path32, value) {
             var internalInstance = idToInternalInstanceMap.get(id);
             if (internalInstance != null) {
               var publicInstance = internalInstance._instance;
               if (publicInstance != null) {
                 switch (type) {
                   case "context":
-                    utils_setInObject(publicInstance.context, path31, value);
+                    utils_setInObject(publicInstance.context, path32, value);
                     forceUpdate(publicInstance);
                     break;
                   case "hooks":
@@ -98861,12 +99584,12 @@ The error thrown in the component is:
                   case "props":
                     var element = internalInstance._currentElement;
                     internalInstance._currentElement = legacy_renderer_objectSpread(legacy_renderer_objectSpread({}, element), {}, {
-                      props: copyWithSet(element.props, path31, value)
+                      props: copyWithSet(element.props, path32, value)
                     });
                     forceUpdate(publicInstance);
                     break;
                   case "state":
-                    utils_setInObject(publicInstance.state, path31, value);
+                    utils_setInObject(publicInstance.state, path32, value);
                     forceUpdate(publicInstance);
                     break;
                 }
@@ -98907,7 +99630,7 @@ The error thrown in the component is:
             return [];
           }
           function setTraceUpdatesEnabled(enabled) {}
-          function setTrackedPath(path31) {}
+          function setTrackedPath(path32) {}
           function getOwnersList(id) {
             return null;
           }
@@ -100937,9 +101660,9 @@ var init_ranking = __esm(() => {
 });
 
 // src/bakeoff/coordinator.ts
-import { join as join98 } from "path";
+import { join as join99 } from "path";
 async function persistBakeoffResult(result2, outputDir) {
-  const filePath = join98(outputDir, "bakeoff.json");
+  const filePath = join99(outputDir, "bakeoff.json");
   await Bun.write(filePath, JSON.stringify(result2, null, 2));
 }
 async function runBakeoff(options, deps = {}) {
@@ -101127,7 +101850,7 @@ __export(exports_curator, {
 });
 import { readdirSync as readdirSync9 } from "fs";
 import { unlink as unlink4 } from "fs/promises";
-import { basename as basename18, join as join99 } from "path";
+import { basename as basename18, join as join100 } from "path";
 function getProjectKey(config2, projectDir) {
   return config2.name?.trim() || basename18(projectDir);
 }
@@ -101210,7 +101933,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 = join99(outputDir, "runs");
+  const runsDir = join100(outputDir, "runs");
   const runIds = listRunIds(runsDir);
   let runId;
   if (options.run) {
@@ -101227,8 +101950,8 @@ async function curatorStatus(options) {
     runId = runIds[runIds.length - 1];
   }
   console.log(`Run: ${runId}`);
-  const runDir = join99(runsDir, runId);
-  const observationsPath = join99(runDir, "observations.jsonl");
+  const runDir = join100(runsDir, runId);
+  const observationsPath = join100(runDir, "observations.jsonl");
   const observations = await parseObservations(observationsPath);
   const counts = new Map;
   for (const obs of observations) {
@@ -101238,7 +101961,7 @@ async function curatorStatus(options) {
   for (const [kind, count] of counts.entries()) {
     console.log(`  ${kind}: ${count}`);
   }
-  const proposalsPath = join99(runDir, "curator-proposals.md");
+  const proposalsPath = join100(runDir, "curator-proposals.md");
   const proposalText = await _curatorCmdDeps.readFile(proposalsPath).catch(() => null);
   if (proposalText !== null) {
     console.log("");
@@ -101252,8 +101975,8 @@ async function curatorCommit(options) {
   const config2 = await _curatorCmdDeps.loadConfig(resolved.projectDir);
   const projectKey = getProjectKey(config2, resolved.projectDir);
   const outputDir = _curatorCmdDeps.projectOutputDir(projectKey, config2.outputDir);
-  const runDir = join99(outputDir, "runs", options.runId);
-  const proposalsPath = join99(runDir, "curator-proposals.md");
+  const runDir = join100(outputDir, "runs", options.runId);
+  const proposalsPath = join100(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}.`);
@@ -101269,7 +101992,7 @@ async function curatorCommit(options) {
   const dropFileState = new Map;
   const skippedDrops = new Set;
   for (const drop2 of drops) {
-    const targetPath = join99(resolved.projectDir, drop2.canonicalFile);
+    const targetPath = join100(resolved.projectDir, drop2.canonicalFile);
     if (!dropFileState.has(targetPath)) {
       const fileExists2 = await Bun.file(targetPath).exists();
       const existing = fileExists2 ? await _curatorCmdDeps.readFile(targetPath).catch(() => "") : "";
@@ -101303,7 +102026,7 @@ async function curatorCommit(options) {
     if (skippedDrops.has(drop2)) {
       continue;
     }
-    const targetPath = join99(resolved.projectDir, drop2.canonicalFile);
+    const targetPath = join100(resolved.projectDir, drop2.canonicalFile);
     const existing = await _curatorCmdDeps.readFile(targetPath).catch(() => "");
     const filtered = filterDropContent(existing, drop2.description);
     await _curatorCmdDeps.writeFile(targetPath, filtered);
@@ -101312,7 +102035,7 @@ async function curatorCommit(options) {
   }
   const adds = proposals.filter((p) => p.action === "add" || p.action === "advisory");
   for (const add2 of adds) {
-    const targetPath = join99(resolved.projectDir, add2.canonicalFile);
+    const targetPath = join100(resolved.projectDir, add2.canonicalFile);
     const content = buildAddContent(add2);
     await _curatorCmdDeps.appendFile(targetPath, content);
     modifiedFiles.add(targetPath);
@@ -101349,7 +102072,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 = join99(outputDir, "runs");
+  const runsDir = join100(outputDir, "runs");
   const runIds = listRunIds(runsDir);
   if (runIds.length === 0) {
     console.log("No runs found.");
@@ -101360,7 +102083,7 @@ async function curatorDryrun(options) {
     console.log(`Run ${options.run} not found in ${runsDir}.`);
     return;
   }
-  const observationsPath = join99(runsDir, runId, "observations.jsonl");
+  const observationsPath = join100(runsDir, runId, "observations.jsonl");
   const observations = await parseObservations(observationsPath);
   const thresholds = getThresholds(config2);
   const proposals = runHeuristics(observations, thresholds);
@@ -101401,12 +102124,12 @@ async function curatorGc(options) {
   await _curatorCmdDeps.writeFile(rollupPath, newContent);
   const projectKey = getProjectKey(config2, resolved.projectDir);
   const outputDir = _curatorCmdDeps.projectOutputDir(projectKey, config2.outputDir);
-  const perRunsDir = join99(outputDir, "runs");
+  const perRunsDir = join100(outputDir, "runs");
   for (const runId of uniqueRunIds) {
     if (!keepSet.has(runId)) {
-      const runDir = join99(perRunsDir, runId);
-      await _curatorCmdDeps.removeFile(join99(runDir, "observations.jsonl"));
-      await _curatorCmdDeps.removeFile(join99(runDir, "curator-proposals.md"));
+      const runDir = join100(perRunsDir, runId);
+      await _curatorCmdDeps.removeFile(join100(runDir, "observations.jsonl"));
+      await _curatorCmdDeps.removeFile(join100(runDir, "curator-proposals.md"));
     }
   }
   console.log(`[gc] Pruned rollup to ${keep} most recent runs (was ${uniqueRunIds.length}).`);
@@ -101451,7 +102174,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 basename19, join as join100 } from "path";
+import { basename as basename19, join as join101 } from "path";
 
 // node_modules/commander/esm.mjs
 var import__ = __toESM(require_commander(), 1);
@@ -101716,7 +102439,8 @@ class DebatePlanStrategy {
       if (debateResult.outcome !== "failed" && debateResult.output) {
         const prd2 = validatePlanOutput(debateResult.output, ctx.options.feature, ctx.branchName);
         warnOnDroppedVerbatimAcs(prd2, ctx.specContent, ctx.options.feature);
-        const withProject2 = { ...prd2, project: ctx.projectName };
+        const scoped2 = backfillOutOfScope(prd2, ctx.specContent, ctx.options.feature);
+        const withProject2 = { ...scoped2, project: ctx.projectName };
         return _debatePlanDeps.writeOrRecoverPrd(ctx, withProject2);
       }
       const prd = await callOp({
@@ -101814,7 +102538,8 @@ class PipelinePlanStrategy {
       if (verdict.outcome !== "passed") {
         throw new NaxError(verdict.specDeltasPath ? `Plan pipeline failed; see ${verdict.specDeltasPath}` : "Plan pipeline failed with no spec-deltas path", "PLAN_CRITIC_BLOCKED", { stage: "plan", specDeltasPath: verdict.specDeltasPath });
       }
-      const prdToWrite = finalizePrdRouting({ ...verdict.prd, project: ctx.projectName }, ctx.config.routing?.agents, ctx.profileName);
+      const scoped2 = backfillOutOfScope(verdict.prd, ctx.specContent, ctx.options.feature);
+      const prdToWrite = finalizePrdRouting({ ...scoped2, project: ctx.projectName }, ctx.config.routing?.agents, ctx.profileName);
       await ctx.deps.writeFile(ctx.outputPath, JSON.stringify(prdToWrite, null, 2));
       return ctx.outputPath;
     } finally {
@@ -102216,10 +102941,10 @@ init_setup_write();
 // src/cli/plugins.ts
 init_paths();
 init_loader4();
-import * as path22 from "path";
+import * as path23 from "path";
 async function pluginsListCommand(config2, workdir, overrideGlobalPluginsDir) {
-  const globalPluginsDir = overrideGlobalPluginsDir ?? path22.join(globalConfigDir(), "plugins");
-  const projectPluginsDir = path22.join(workdir, ".nax", "plugins");
+  const globalPluginsDir = overrideGlobalPluginsDir ?? path23.join(globalConfigDir(), "plugins");
+  const projectPluginsDir = path23.join(workdir, ".nax", "plugins");
   const configPlugins = config2.plugins || [];
   const registry3 = await loadPlugins(globalPluginsDir, projectPluginsDir, configPlugins, workdir, config2.disabledPlugins);
   const plugins = registry3.plugins;
@@ -102269,10 +102994,10 @@ function formatSource(type, sourcePath) {
     return `built-in (${sourcePath})`;
   }
   if (type === "global") {
-    return `global (${path22.basename(sourcePath)})`;
+    return `global (${path23.basename(sourcePath)})`;
   }
   if (type === "project") {
-    return `project (${path22.basename(sourcePath)})`;
+    return `project (${path23.basename(sourcePath)})`;
   }
   return `config (${sourcePath})`;
 }
@@ -102287,7 +103012,7 @@ init_source();
 init_loader();
 init_generator2();
 import { existsSync as existsSync24 } from "fs";
-import { join as join67 } from "path";
+import { join as join68 } from "path";
 var VALID_AGENTS = ["claude", "codex", "opencode", "cursor", "windsurf", "aider", "gemini"];
 async function generateCommand(options) {
   const workdir = options.dir ?? process.cwd();
@@ -102330,7 +103055,7 @@ async function generateCommand(options) {
     return;
   }
   if (options.package) {
-    const packageDir = join67(workdir, options.package);
+    const packageDir = join68(workdir, options.package);
     if (dryRun) {
       console.log(source_default.yellow("\u26A0 Dry run \u2014 no files will be written"));
     }
@@ -102350,8 +103075,8 @@ async function generateCommand(options) {
       process.exit(1);
     return;
   }
-  const contextPath = options.context ? join67(workdir, options.context) : join67(workdir, ".nax/context.md");
-  const outputDir = options.output ? join67(workdir, options.output) : workdir;
+  const contextPath = options.context ? join68(workdir, options.context) : join68(workdir, ".nax/context.md");
+  const outputDir = options.output ? join68(workdir, options.output) : workdir;
   const autoInject = !options.noAutoInject;
   if (!existsSync24(contextPath)) {
     console.error(source_default.red(`\u2717 Context file not found: ${contextPath}`));
@@ -102457,7 +103182,7 @@ async function generateCommand(options) {
 // src/cli/config-display.ts
 init_loader();
 import { existsSync as existsSync26 } from "fs";
-import { join as join69 } from "path";
+import { join as join70 } from "path";
 
 // src/cli/config-descriptions.ts
 var FIELD_DESCRIPTIONS = {
@@ -102665,10 +103390,10 @@ function deepDiffConfigs(global2, project, currentPath = []) {
   for (const key of Object.keys(project)) {
     const projectValue = project[key];
     const globalValue = global2[key];
-    const path23 = [...currentPath, key];
-    const pathStr = path23.join(".");
+    const path24 = [...currentPath, key];
+    const pathStr = path24.join(".");
     if (projectValue !== null && typeof projectValue === "object" && !Array.isArray(projectValue) && globalValue !== null && typeof globalValue === "object" && !Array.isArray(globalValue)) {
-      const nestedDiffs = deepDiffConfigs(globalValue, projectValue, path23);
+      const nestedDiffs = deepDiffConfigs(globalValue, projectValue, path24);
       diffs.push(...nestedDiffs);
     } else {
       if (!deepEqual(projectValue, globalValue)) {
@@ -102710,12 +103435,12 @@ function deepEqual(a, b) {
 init_defaults();
 init_loader();
 import { existsSync as existsSync25 } from "fs";
-import { join as join68 } from "path";
-async function loadConfigFile(path23) {
-  if (!existsSync25(path23))
+import { join as join69 } from "path";
+async function loadConfigFile(path24) {
+  if (!existsSync25(path24))
     return null;
   try {
-    return await Bun.file(path23).json();
+    return await Bun.file(path24).json();
   } catch {
     return null;
   }
@@ -102732,7 +103457,7 @@ async function loadProjectConfig() {
   const projectDir = findProjectDir();
   if (!projectDir)
     return null;
-  const projectPath = join68(projectDir, "config.json");
+  const projectPath = join69(projectDir, "config.json");
   return await loadConfigFile(projectPath);
 }
 
@@ -102762,10 +103487,10 @@ async function configCommand(config2, options = {}) {
     console.log(`${"Field".padEnd(40)}${"Project Value".padEnd(20)}Global Value`);
     console.log("\u2500".repeat(80));
     for (const diff2 of diffs) {
-      const path23 = diff2.path.padEnd(40);
+      const path24 = diff2.path.padEnd(40);
       const projectVal = formatValueForTable(diff2.projectValue);
       const globalVal = formatValueForTable(diff2.globalValue);
-      console.log(`${path23}${projectVal.padEnd(20)}${globalVal}`);
+      console.log(`${path24}${projectVal.padEnd(20)}${globalVal}`);
       const description = FIELD_DESCRIPTIONS[diff2.path];
       if (description) {
         console.log(`${"".padEnd(40)}\u21B3 ${description}`);
@@ -102792,32 +103517,32 @@ async function configCommand(config2, options = {}) {
 function determineConfigSources() {
   const globalPath = globalConfigPath();
   const projectDir = findProjectDir();
-  const projectPath = projectDir ? join69(projectDir, "config.json") : null;
+  const projectPath = projectDir ? join70(projectDir, "config.json") : null;
   return {
     global: fileExists(globalPath) ? globalPath : null,
     project: projectPath && fileExists(projectPath) ? projectPath : null
   };
 }
-function fileExists(path23) {
-  return existsSync26(path23);
+function fileExists(path24) {
+  return existsSync26(path24);
 }
-function displayConfigWithDescriptions(obj, path23, sources, indent = 0) {
+function displayConfigWithDescriptions(obj, path24, sources, indent = 0) {
   const indentStr = "  ".repeat(indent);
-  const pathStr = path23.join(".");
+  const pathStr = path24.join(".");
   if (obj === null || obj === undefined || typeof obj !== "object" || Array.isArray(obj)) {
     const description = FIELD_DESCRIPTIONS[pathStr];
     const value = formatValue(obj);
     if (description) {
       console.log(`${indentStr}# ${description}`);
     }
-    const key = path23[path23.length - 1] || "";
+    const key = path24[path24.length - 1] || "";
     console.log(`${indentStr}${key}: ${value}`);
     console.log();
     return;
   }
   const entries = Object.entries(obj);
   const objAsRecord = obj;
-  const isPromptsSection = path23.join(".") === "prompts";
+  const isPromptsSection = path24.join(".") === "prompts";
   if (isPromptsSection && !objAsRecord.overrides) {
     const description = FIELD_DESCRIPTIONS["prompts.overrides"];
     if (description) {
@@ -102840,7 +103565,7 @@ function displayConfigWithDescriptions(obj, path23, sources, indent = 0) {
   }
   for (let i = 0;i < entries.length; i++) {
     const [key, value] = entries[i];
-    const currentPath = [...path23, key];
+    const currentPath = [...path24, key];
     const currentPathStr = currentPath.join(".");
     const description = FIELD_DESCRIPTIONS[currentPathStr];
     if (description) {
@@ -102941,15 +103666,15 @@ init_paths();
 init_profile();
 import { mkdirSync as mkdirSync5 } from "fs";
 import { readdirSync as readdirSync5 } from "fs";
-import { join as join70 } from "path";
+import { join as join71 } from "path";
 var _profileCLIDeps = {
   env: process.env
 };
 var SENSITIVE_KEY_PATTERN = /key|token|secret|password|credential/i;
 var VAR_PATTERN = /\$[A-Za-z_][A-Za-z0-9_]*/;
 async function profileListCommand(startDir) {
-  const globalProfilesDir = join70(globalConfigDir(), "profiles");
-  const projectProfilesDir = join70(projectConfigDir(startDir), "profiles");
+  const globalProfilesDir = join71(globalConfigDir(), "profiles");
+  const projectProfilesDir = join71(projectConfigDir(startDir), "profiles");
   const globalProfiles = scanProfileDir(globalProfilesDir);
   const projectProfiles = scanProfileDir(projectProfilesDir);
   const activeProfile = await resolveProfileName({}, _profileCLIDeps.env, startDir);
@@ -103008,7 +103733,7 @@ function maskProfileValues(obj) {
   return result;
 }
 async function profileUseCommand(profileName, startDir) {
-  const configPath = join70(projectConfigDir(startDir), "config.json");
+  const configPath = join71(projectConfigDir(startDir), "config.json");
   const configFile = Bun.file(configPath);
   let existing = {};
   if (await configFile.exists()) {
@@ -103027,8 +103752,8 @@ async function profileCurrentCommand(startDir) {
   return resolveProfileName({}, _profileCLIDeps.env, startDir);
 }
 async function profileCreateCommand(profileName, startDir) {
-  const profilesDir = join70(projectConfigDir(startDir), "profiles");
-  const profilePath = join70(profilesDir, `${profileName}.json`);
+  const profilesDir = join71(projectConfigDir(startDir), "profiles");
+  const profilePath = join71(profilesDir, `${profileName}.json`);
   const profileFile = Bun.file(profilePath);
   if (await profileFile.exists()) {
     throw new Error(`Profile "${profileName}" already exists at ${profilePath}`);
@@ -103150,22 +103875,22 @@ async function contextInspectCommand(options) {
 init_canonical_loader();
 init_errors();
 import { mkdir as mkdir11 } from "fs/promises";
-import { basename as basename13, join as join71 } from "path";
+import { basename as basename13, join as join72 } from "path";
 var _rulesCLIDeps = {
-  readFile: async (path23) => Bun.file(path23).text(),
-  writeFile: async (path23, content) => {
-    await Bun.write(path23, content);
+  readFile: async (path24) => Bun.file(path24).text(),
+  writeFile: async (path24, content) => {
+    await Bun.write(path24, content);
   },
-  fileExists: async (path23) => Bun.file(path23).exists(),
+  fileExists: async (path24) => Bun.file(path24).exists(),
   globInDir: (dir) => {
     try {
-      return [...new Bun.Glob("*.md").scanSync({ cwd: dir })].sort().map((f) => join71(dir, f));
+      return [...new Bun.Glob("*.md").scanSync({ cwd: dir })].sort().map((f) => join72(dir, f));
     } catch {
       return [];
     }
   },
-  mkdir: async (path23) => {
-    await mkdir11(path23, { recursive: true });
+  mkdir: async (path24) => {
+    await mkdir11(path24, { recursive: true });
   },
   globCanonicalRuleFiles: (workdir) => {
     try {
@@ -103208,7 +103933,7 @@ ${r.content}`).join(`
 `);
   const shimContent = `${header + body}
 `;
-  const shimPath = join71(workdir, shimFileName);
+  const shimPath = join72(workdir, shimFileName);
   if (options.dryRun) {
     console.log(`[dry-run] Would write ${shimPath} (${shimContent.length} bytes)`);
     return;
@@ -103237,14 +103962,14 @@ function neutralizeContent(content) {
 }
 async function collectMigrationSources(workdir) {
   const sources = [];
-  const claudeMdPath = join71(workdir, "CLAUDE.md");
+  const claudeMdPath = join72(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 = join71(workdir, ".claude", "rules");
+  const rulesDir = join72(workdir, ".claude", "rules");
   const ruleFiles = _rulesCLIDeps.globInDir(rulesDir);
   for (const filePath of ruleFiles) {
     try {
@@ -103264,7 +103989,7 @@ async function rulesMigrateCommand(options) {
     console.log("[WARN] No source files found (checked CLAUDE.md and .claude/rules/*.md). Nothing to migrate.");
     return;
   }
-  const targetDir = join71(workdir, CANONICAL_RULES_DIR);
+  const targetDir = join72(workdir, CANONICAL_RULES_DIR);
   if (!options.dryRun) {
     try {
       await _rulesCLIDeps.mkdir(targetDir);
@@ -103275,7 +104000,7 @@ async function rulesMigrateCommand(options) {
   let written = 0;
   let skipped = 0;
   for (const { sourcePath, targetFileName, content } of sources) {
-    const targetPath = join71(targetDir, targetFileName);
+    const targetPath = join72(targetDir, targetFileName);
     if (!force && !options.dryRun && await _rulesCLIDeps.fileExists(targetPath)) {
       console.log(`[skip] ${targetFileName} already exists (use --force to overwrite)`);
       skipped++;
@@ -103314,7 +104039,7 @@ function collectCanonicalRuleRoots(workdir) {
     const packageRel = normalized.slice(0, idx);
     if (!packageRel)
       continue;
-    roots.add(join71(workdir, packageRel));
+    roots.add(join72(workdir, packageRel));
   }
   return [...roots].sort();
 }
@@ -103338,8 +104063,8 @@ async function resolveRunProfileOverride(opts) {
     return cliChain;
   if (opts.envProfile)
     return;
-  const readJson = opts._readJson ?? (async (path23) => {
-    const file3 = Bun.file(path23);
+  const readJson = opts._readJson ?? (async (path24) => {
+    const file3 = Bun.file(path24);
     if (!await file3.exists())
       return;
     return file3.json();
@@ -103362,7 +104087,7 @@ async function resolveRunProfileOverride(opts) {
 // src/cli/features-resolve.ts
 init_config();
 import { existsSync as existsSync28, readdirSync as readdirSync6 } from "fs";
-import { join as join73, relative as relative16 } from "path";
+import { join as join74, relative as relative16 } from "path";
 
 // src/cli/features-acceptance.ts
 init_acceptance2();
@@ -103370,7 +104095,7 @@ init_config();
 init_logger2();
 init_prd();
 import { existsSync as existsSync27 } from "fs";
-import { join as join72, relative as relative15 } from "path";
+import { join as join73, relative as relative15 } from "path";
 async function resolveFeatureAcceptance(featureName, workdir) {
   let enabled = true;
   try {
@@ -103378,13 +104103,13 @@ async function resolveFeatureAcceptance(featureName, workdir) {
     if (!naxDir) {
       return { status: "no-prd", enabled, groups: [] };
     }
-    const repoRoot = join72(naxDir, "..");
+    const repoRoot = join73(naxDir, "..");
     const config2 = await loadConfig(workdir);
     enabled = config2.acceptance?.enabled ?? true;
     if (!enabled) {
       return { status: "disabled", enabled: false, groups: [] };
     }
-    const prdPath = join72(naxDir, "features", featureName, "prd.json");
+    const prdPath = join73(naxDir, "features", featureName, "prd.json");
     if (!existsSync27(prdPath)) {
       return { status: "no-prd", enabled, groups: [] };
     }
@@ -103427,10 +104152,10 @@ async function isNonEmptyFile(absolutePath) {
 }
 async function searchSpecSource(naxDir, repoRoot, name) {
   const candidates = [
-    { abs: join73(naxDir, "features", name, "spec.md"), kind: "markdown" },
-    { abs: join73(naxDir, "specs", `${name}.md`), kind: "markdown" }
+    { abs: join74(naxDir, "features", name, "spec.md"), kind: "markdown" },
+    { abs: join74(naxDir, "specs", `${name}.md`), kind: "markdown" }
   ];
-  const docsSpecExact = join73(repoRoot, "docs", "specs", `SPEC-${name}.md`);
+  const docsSpecExact = join74(repoRoot, "docs", "specs", `SPEC-${name}.md`);
   candidates.push({ abs: docsSpecExact, kind: "markdown" });
   const checked = candidates.map((c) => relative16(repoRoot, c.abs));
   for (const { abs, kind } of candidates.slice(0, 2)) {
@@ -103444,11 +104169,11 @@ async function searchSpecSource(naxDir, repoRoot, name) {
   if (await isNonEmptyFile(docsSpecExact)) {
     return { source: { kind: "markdown", path: relative16(repoRoot, docsSpecExact) }, checked };
   }
-  const docsSpecsDir = join73(repoRoot, "docs", "specs");
+  const docsSpecsDir = join74(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 = join73(docsSpecsDir, match);
+      const abs = join74(docsSpecsDir, match);
       if (await isNonEmptyFile(abs)) {
         const relPath = relative16(repoRoot, abs);
         if (!checked.includes(relPath))
@@ -103457,7 +104182,7 @@ async function searchSpecSource(naxDir, repoRoot, name) {
       }
     }
   }
-  const prdAbs = join73(naxDir, "features", name, "prd.json");
+  const prdAbs = join74(naxDir, "features", name, "prd.json");
   const prdRel = relative16(repoRoot, prdAbs);
   if (!checked.includes(prdRel))
     checked.push(prdRel);
@@ -103467,14 +104192,14 @@ async function searchSpecSource(naxDir, repoRoot, name) {
   return { source: null, checked };
 }
 function discoverCandidates(naxDir) {
-  const featuresDir = join73(naxDir, "features");
+  const featuresDir = join74(naxDir, "features");
   if (!existsSync28(featuresDir))
     return [];
   return readdirSync6(featuresDir, { withFileTypes: true }).filter((e) => {
     if (!e.isDirectory())
       return false;
-    const dir = join73(featuresDir, e.name);
-    return existsSync28(join73(dir, "prd.json")) || existsSync28(join73(dir, "spec.md"));
+    const dir = join74(featuresDir, e.name);
+    return existsSync28(join74(dir, "prd.json")) || existsSync28(join74(dir, "spec.md"));
   }).map((e) => e.name).sort();
 }
 async function resolveFeatureSpec(name, workdir) {
@@ -103485,9 +104210,9 @@ async function resolveFeatureSpec(name, workdir) {
       message: `not a nax repo: no .nax/config.json found from ${workdir}`
     };
   }
-  const repoRoot = join73(naxDir, "..");
+  const repoRoot = join74(naxDir, "..");
   if (name !== undefined && (name.startsWith("./") || name.startsWith("/") || name.endsWith(".md"))) {
-    const abs = name.startsWith("/") ? name : join73(workdir, name);
+    const abs = name.startsWith("/") ? name : join74(workdir, name);
     if (!existsSync28(abs)) {
       return {
         status: "missing",
@@ -103526,7 +104251,7 @@ async function resolveFeatureSpec(name, workdir) {
         message: `resolved spec: ${source2.path}`
       };
     }
-    const featureDir = join73(naxDir, "features", name);
+    const featureDir = join74(naxDir, "features", name);
     if (existsSync28(featureDir)) {
       return {
         status: "missing",
@@ -103588,14 +104313,14 @@ init_runtime();
 init_json_file();
 init_routing();
 import { mkdirSync as mkdirSync6 } from "fs";
-import { basename as basename14, join as join74 } from "path";
+import { basename as basename14, join as join75 } 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 = join74(dir, "config.json");
+    const filePath = join75(dir, "config.json");
     await saveJsonFile(filePath, config2, "routing-calibrate");
   },
   stdout: (msg) => {
@@ -103722,7 +104447,7 @@ init_logger2();
 init_detect2();
 init_workspace();
 init_common();
-import { join as join75 } from "path";
+import { join as join76 } from "path";
 function resolveEffective(detected, configPatterns) {
   if (configPatterns !== undefined)
     return "config";
@@ -103730,14 +104455,14 @@ function resolveEffective(detected, configPatterns) {
     return "detected";
   return "none";
 }
-async function loadRawConfig(path23) {
-  const f = Bun.file(path23);
+async function loadRawConfig(path24) {
+  const f = Bun.file(path24);
   if (!await f.exists())
     return {};
   return JSON.parse(await f.text());
 }
-async function writeRawConfig(path23, data) {
-  await Bun.write(path23, `${JSON.stringify(data, null, 2)}
+async function writeRawConfig(path24, data) {
+  await Bun.write(path24, `${JSON.stringify(data, null, 2)}
 `);
 }
 function deepSet(obj, keyPath, value) {
@@ -103807,7 +104532,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 = join75(workdir, ".nax", "mono", dir, "config.json");
+    const pkgConfigPath = join76(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;
@@ -103861,13 +104586,13 @@ async function detectCommand(options) {
     if (rootDetected.confidence === "empty") {
       console.log(source_default.yellow("  root: skipped (empty detection)"));
     } else {
-      const rootConfigPath = join75(workdir, ".nax", "config.json");
+      const rootConfigPath = join76(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 ${join75(".nax", "config.json")}`));
+          console.log(source_default.green(`  root: ${status} \u2192 ${join76(".nax", "config.json")}`));
         }
       } catch (err) {
         console.error(source_default.red(`  root: write failed \u2014 ${err.message}`));
@@ -103880,13 +104605,13 @@ async function detectCommand(options) {
         console.log(source_default.dim(`  ${dir}: skipped (empty detection)`));
         continue;
       }
-      const pkgConfigPath = join75(workdir, ".nax", "mono", dir, "config.json");
+      const pkgConfigPath = join76(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 ${join75(".nax", "mono", dir, "config.json")}`));
+          console.log(source_default.green(`  ${dir}: ${status} \u2192 ${join76(".nax", "mono", dir, "config.json")}`));
         }
       } catch (err) {
         console.error(source_default.red(`  ${dir}: write failed \u2014 ${err.message}`));
@@ -103904,19 +104629,19 @@ async function detectCommand(options) {
 // src/commands/logs.ts
 init_common();
 import { existsSync as existsSync30 } from "fs";
-import { join as join78 } from "path";
+import { join as join79 } from "path";
 
 // src/commands/logs-formatter.ts
 init_source();
 init_formatter();
 import { readdirSync as readdirSync8 } from "fs";
-import { join as join77 } from "path";
+import { join as join78 } 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 join76 } from "path";
+import { join as join77 } from "path";
 var _logsReaderDeps = {
   getRunsDir
 };
@@ -103930,7 +104655,7 @@ async function resolveRunFileFromRegistry(runId) {
   }
   let matched = null;
   for (const entry of entries) {
-    const metaPath = join76(runsDir, entry, "meta.json");
+    const metaPath = join77(runsDir, entry, "meta.json");
     try {
       const meta3 = await Bun.file(metaPath).json();
       if (meta3.runId === runId || meta3.runId.startsWith(runId)) {
@@ -103952,14 +104677,14 @@ async function resolveRunFileFromRegistry(runId) {
     return null;
   }
   const specificFile = files.find((f) => f === `${matched.runId}.jsonl`);
-  return join76(matched.eventsDir, specificFile ?? files[0]);
+  return join77(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 join76(runsDir, files[0]);
+  return join77(runsDir, files[0]);
 }
 async function extractRunSummary(filePath) {
   const file3 = Bun.file(filePath);
@@ -104045,7 +104770,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 = join77(runsDir, file3);
+    const filePath = join78(runsDir, file3);
     const summary = await extractRunSummary(filePath);
     const timestamp = file3.replace(".jsonl", "");
     const stories = summary ? `${summary.passed}/${summary.total}` : "?/?";
@@ -104159,7 +104884,7 @@ async function logsCommand(options) {
     return;
   }
   const resolved = resolveProject2({ dir: options.dir });
-  const naxDir = join78(resolved.projectDir, ".nax");
+  const naxDir = join79(resolved.projectDir, ".nax");
   const configPath = resolved.configPath;
   const configFile = Bun.file(configPath);
   const config2 = await configFile.json();
@@ -104167,8 +104892,8 @@ async function logsCommand(options) {
   if (!featureName) {
     throw new Error("No feature specified in config.json");
   }
-  const featureDir = join78(naxDir, "features", featureName);
-  const runsDir = join78(featureDir, "runs");
+  const featureDir = join79(naxDir, "features", featureName);
+  const runsDir = join79(featureDir, "runs");
   if (!existsSync30(runsDir)) {
     throw new Error(`No runs directory found for feature: ${featureName}`);
   }
@@ -104194,7 +104919,7 @@ init_prd();
 init_precheck();
 init_common();
 import { existsSync as existsSync31 } from "fs";
-import { join as join79 } from "path";
+import { join as join80 } from "path";
 async function precheckCommand(options) {
   const resolved = resolveProject2({
     dir: options.dir,
@@ -104216,9 +104941,9 @@ async function precheckCommand(options) {
       process.exit(1);
     }
   }
-  const naxDir = join79(resolved.projectDir, ".nax");
-  const featureDir = join79(naxDir, "features", featureName);
-  const prdPath = join79(featureDir, "prd.json");
+  const naxDir = join80(resolved.projectDir, ".nax");
+  const featureDir = join80(naxDir, "features", featureName);
+  const prdPath = join80(featureDir, "prd.json");
   if (!existsSync31(featureDir)) {
     console.error(source_default.red(`Feature not found: ${featureName}`));
     process.exit(1);
@@ -104240,13 +104965,13 @@ async function precheckCommand(options) {
 // src/commands/replay.ts
 init_errors();
 import { existsSync as existsSync32 } from "fs";
-import { dirname as dirname12 } from "path";
+import { dirname as dirname13 } from "path";
 
 // src/replay/discovery.ts
 init_errors();
 init_paths3();
 import { readdir as readdir4 } from "fs/promises";
-import { join as join80 } from "path";
+import { join as join81 } from "path";
 var _discoveryDeps = {
   getRunsDir
 };
@@ -104260,7 +104985,7 @@ async function loadMetas(runsDir) {
   const metas = [];
   for (const entry of entries) {
     try {
-      const meta3 = await Bun.file(join80(runsDir, entry, "meta.json")).json();
+      const meta3 = await Bun.file(join81(runsDir, entry, "meta.json")).json();
       metas.push(meta3);
     } catch {}
   }
@@ -104277,7 +105002,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: join80(latest.eventsDir, `${latest.runId}.jsonl`) };
+    return { meta: latest, jsonlPath: join81(latest.eventsDir, `${latest.runId}.jsonl`) };
   }
   const matched = metas.filter((m) => matches(m, query));
   if (matched.length === 0) {
@@ -104294,7 +105019,7 @@ async function discoverRun(query, depsArg = _discoveryDeps) {
     });
   }
   const meta3 = matched[0];
-  return { meta: meta3, jsonlPath: join80(meta3.eventsDir, `${meta3.runId}.jsonl`) };
+  return { meta: meta3, jsonlPath: join81(meta3.eventsDir, `${meta3.runId}.jsonl`) };
 }
 
 // src/replay/json.ts
@@ -104525,10 +105250,10 @@ function renderReport(timeline, options = {}) {
 }
 
 // src/commands/replay.ts
-async function readJsonlLenient(path23) {
-  if (!existsSync32(path23))
+async function readJsonlLenient(path24) {
+  if (!existsSync32(path24))
     return [];
-  const content = await Bun.file(path23).text();
+  const content = await Bun.file(path24).text();
   const lines = content.split(`
 `);
   const entries = [];
@@ -104542,18 +105267,18 @@ async function readJsonlLenient(path23) {
   }
   return entries;
 }
-async function readJsonOrUndefined(path23) {
-  if (!existsSync32(path23))
+async function readJsonOrUndefined(path24) {
+  if (!existsSync32(path24))
     return;
   try {
-    return await Bun.file(path23).json();
+    return await Bun.file(path24).json();
   } catch {
     return;
   }
 }
 async function readMetricsFromProject(meta3) {
   const { loadRunMetrics: loadRunMetrics2 } = await Promise.resolve().then(() => (init_tracker(), exports_tracker));
-  const outputDir = dirname12(dirname12(dirname12(meta3.eventsDir)));
+  const outputDir = dirname13(dirname13(dirname13(meta3.eventsDir)));
   const all = await loadRunMetrics2(outputDir);
   return all.find((m) => m.runId === meta3.runId);
 }
@@ -104632,11 +105357,11 @@ init_errors();
 init_checkpoint();
 init_runtime();
 import { existsSync as existsSync37 } from "fs";
-import { basename as basename17, join as join94 } from "path";
+import { basename as basename17, join as join95 } from "path";
 async function defaultCheckpointExists(featureDir) {
   if (!featureDir || !existsSync37(featureDir))
     return false;
-  return existsSync37(join94(featureDir, "checkpoint.jsonl"));
+  return existsSync37(join95(featureDir, "checkpoint.jsonl"));
 }
 async function defaultLoadCheckpoints(featureDir) {
   return loadCheckpoints(featureDir);
@@ -104696,12 +105421,12 @@ function registerResumeCommand(program2) {
 `);
       process.exit(1);
     }
-    const featureDir = join94(naxDir, "features", cmdOpts.feature);
+    const featureDir = join95(naxDir, "features", cmdOpts.feature);
     const deps = {
       ..._resumeCmdDeps,
       runInvocation: async (feature, opts) => {
         const config2 = await loadConfig2(naxDir ?? undefined);
-        const prdPath = join94(opts.featureDir ?? "", "prd.json");
+        const prdPath = join95(opts.featureDir ?? "", "prd.json");
         if (!existsSync38(prdPath)) {
           process.stderr.write(`Feature "${feature}" not found or missing prd.json
 `);
@@ -104713,7 +105438,7 @@ function registerResumeCommand(program2) {
         applyResumeModeDeps2(opts.featureDir ?? "", "auto");
         const projectKey = config2.name?.trim() || basename17(cmdOpts.dir);
         const outputDir = projectOutputDir(projectKey, config2.outputDir);
-        const statusFilePath = join94(outputDir, "status.json");
+        const statusFilePath = join95(outputDir, "status.json");
         const result = await run2({
           prdPath,
           workdir: cmdOpts.dir,
@@ -104748,7 +105473,7 @@ function registerResumeCommand(program2) {
 init_source();
 init_paths3();
 import { readdir as readdir6 } from "fs/promises";
-import { join as join95 } from "path";
+import { join as join96 } from "path";
 var DEFAULT_LIMIT = 20;
 var _runsCmdDeps = {
   getRunsDir
@@ -104805,7 +105530,7 @@ async function runsCommand(options = {}) {
   }
   const rows = [];
   for (const entry of entries) {
-    const metaPath = join95(runsDir, entry, "meta.json");
+    const metaPath = join96(runsDir, entry, "meta.json");
     let meta3;
     try {
       meta3 = await Bun.file(metaPath).json();
@@ -104882,7 +105607,7 @@ async function runsCommand(options = {}) {
 
 // src/commands/unlock.ts
 init_source();
-import { join as join96 } from "path";
+import { join as join97 } from "path";
 function isProcessAlive2(pid) {
   try {
     process.kill(pid, 0);
@@ -104897,7 +105622,7 @@ function formatLockAge(ageMs) {
 }
 async function unlockCommand(options) {
   const workdir = options.dir ?? process.cwd();
-  const lockPath = join96(workdir, "nax.lock");
+  const lockPath = join97(workdir, "nax.lock");
   const lockFile = Bun.file(lockPath);
   const exists = await lockFile.exists();
   if (!exists) {
@@ -109842,8 +110567,8 @@ function Text({ color, backgroundColor, dimColor = false, bold = false, italic =
 }
 
 // node_modules/ink/build/components/ErrorOverview.js
-var cleanupPath = (path31) => {
-  return path31?.replace(`file://${cwd()}/`, "");
+var cleanupPath = (path32) => {
+  return path32?.replace(`file://${cwd()}/`, "");
 };
 var stackUtils = new import_stack_utils.default({
   cwd: cwd(),
@@ -110547,8 +111272,8 @@ class Ink {
     }
   }
   async waitUntilExit() {
-    this.exitPromise ||= new Promise((resolve18, reject2) => {
-      this.resolveExitPromise = resolve18;
+    this.exitPromise ||= new Promise((resolve19, reject2) => {
+      this.resolveExitPromise = resolve19;
       this.rejectExitPromise = reject2;
     });
     if (!this.beforeExitHandler) {
@@ -112802,7 +113527,7 @@ async function promptForConfirmation(question) {
   if (!process.stdin.isTTY) {
     return true;
   }
-  return new Promise((resolve18) => {
+  return new Promise((resolve19) => {
     process.stdout.write(source_default.bold(`${question} [Y/n] `));
     process.stdin.setRawMode(true);
     process.stdin.resume();
@@ -112815,9 +113540,9 @@ async function promptForConfirmation(question) {
       process.stdout.write(`
 `);
       if (answer === "n") {
-        resolve18(false);
+        resolve19(false);
       } else {
-        resolve18(true);
+        resolve19(true);
       }
     };
     process.stdin.on("data", handler);
@@ -112846,7 +113571,7 @@ Next: nax generate --package ${options.package}`));
     }
     return;
   }
-  const naxDir = join100(workdir, ".nax");
+  const naxDir = join101(workdir, ".nax");
   if (existsSync39(naxDir) && !options.force) {
     console.log(source_default.yellow("nax already initialized. Use --force to overwrite."));
     return;
@@ -112875,11 +113600,11 @@ Next: nax generate --package ${options.package}`));
       }
     }
   }
-  mkdirSync8(join100(naxDir, "features"), { recursive: true });
-  mkdirSync8(join100(naxDir, "hooks"), { recursive: true });
+  mkdirSync8(join101(naxDir, "features"), { recursive: true });
+  mkdirSync8(join101(naxDir, "hooks"), { recursive: true });
   const initConfig = options.name ? { ...DEFAULT_CONFIG, name: options.name } : DEFAULT_CONFIG;
-  await Bun.write(join100(naxDir, "config.json"), JSON.stringify(initConfig, null, 2));
-  await Bun.write(join100(naxDir, "hooks.json"), JSON.stringify({
+  await Bun.write(join101(naxDir, "config.json"), JSON.stringify(initConfig, null, 2));
+  await Bun.write(join101(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 },
@@ -112887,12 +113612,12 @@ Next: nax generate --package ${options.package}`));
       "on-error": { command: 'echo "nax error: $NAX_REASON"', enabled: false }
     }
   }, null, 2));
-  await Bun.write(join100(naxDir, ".gitignore"), `# nax temp files
+  await Bun.write(join101(naxDir, ".gitignore"), `# nax temp files
 *.tmp
 .paused.json
 .nax-verifier-verdict.json
 `);
-  await Bun.write(join100(naxDir, "context.md"), `# Project Context
+  await Bun.write(join101(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.
@@ -113076,7 +113801,7 @@ program2.command("run").description("Run the orchestration loop for a feature").
   const cliOverrides = {};
   const cliProfiles = options.profile ?? [];
   const profileOverride = naxDir ? await resolveRunProfileOverride({
-    prdPath: join100(naxDir, "features", options.feature, "prd.json"),
+    prdPath: join101(naxDir, "features", options.feature, "prd.json"),
     projectRoot: workdir,
     cliProfile: cliProfiles,
     envProfile: process.env.NAX_PROFILE
@@ -113089,8 +113814,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 = join100(naxDir, "features", options.feature);
-  const prdPath = join100(featureDir, "prd.json");
+  const featureDir = join101(naxDir, "features", options.feature);
+  const prdPath = join101(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}".`));
@@ -113112,10 +113837,10 @@ program2.command("run").description("Run the orchestration loop for a feature").
       }
     }
     try {
-      const planLogDir = join100(featureDir, "plan");
+      const planLogDir = join101(featureDir, "plan");
       mkdirSync8(planLogDir, { recursive: true });
       const planLogId = new Date().toISOString().replace(/:/g, "-").replace(/\..+/, "");
-      const planLogPath = join100(planLogDir, `${planLogId}.jsonl`);
+      const planLogPath = join101(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]"));
@@ -113161,10 +113886,10 @@ program2.command("run").description("Run the orchestration loop for a feature").
   resetLogger();
   const projectKey = config2.name?.trim() || basename19(workdir);
   const outputDir = projectOutputDir(projectKey, config2.outputDir);
-  const runsDir = join100(outputDir, "features", options.feature, "runs");
+  const runsDir = join101(outputDir, "features", options.feature, "runs");
   mkdirSync8(runsDir, { recursive: true });
   const runId = new Date().toISOString().replace(/:/g, "-").replace(/\..+/, "");
-  const logFilePath = join100(runsDir, `${runId}.jsonl`);
+  const logFilePath = join101(runsDir, `${runId}.jsonl`);
   const isTTY = process.stdout.isTTY ?? false;
   const headlessFlag = options.headless ?? false;
   const headlessEnv = process.env.NAX_HEADLESS === "1";
@@ -113190,7 +113915,7 @@ program2.command("run").description("Run the orchestration loop for a feature").
     }
     config2.execution.costLimit = maxCost;
   }
-  const globalNaxDir = join100(homedir3(), ".nax");
+  const globalNaxDir = join101(homedir3(), ".nax");
   const hooks = await loadHooksConfig(naxDir, globalNaxDir);
   const eventEmitter = new PipelineEventEmitter;
   const agentStreamEvents = useHeadless ? undefined : new AgentStreamEventBus;
@@ -113209,12 +113934,12 @@ program2.command("run").description("Run the orchestration loop for a feature").
       stories: initialStories,
       events: eventEmitter,
       agentStreamEvents,
-      queueFilePath: join100(workdir, ".queue.txt")
+      queueFilePath: join101(workdir, ".queue.txt")
     });
   } else {
     console.log(source_default.dim("   [Headless mode \u2014 pipe output]"));
   }
-  const statusFilePath = join100(outputDir, "status.json");
+  const statusFilePath = join101(outputDir, "status.json");
   let parallel;
   if (options.parallel !== undefined) {
     parallel = Number.parseInt(options.parallel, 10);
@@ -113277,7 +114002,7 @@ Scheduled run cancelled.`));
     agentStreamEvents,
     resumeMode: options.fresh === true || options.resume === false ? "fresh" : "auto"
   });
-  const latestSymlink = join100(runsDir, "latest.jsonl");
+  const latestSymlink = join101(runsDir, "latest.jsonl");
   try {
     if (existsSync39(latestSymlink)) {
       Bun.spawnSync(["rm", latestSymlink]);
@@ -113374,9 +114099,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 = join100(naxDir, "features", name);
+  const featureDir = join101(naxDir, "features", name);
   mkdirSync8(featureDir, { recursive: true });
-  await Bun.write(join100(featureDir, "spec.md"), `# Feature: ${name}
+  await Bun.write(join101(featureDir, "spec.md"), `# Feature: ${name}
 
 ## Overview
 
@@ -113409,7 +114134,7 @@ features.command("create <name>").description("Create a new feature").option("-d
 
 <!-- What this feature explicitly does NOT cover. -->
 `);
-  await Bun.write(join100(featureDir, "progress.txt"), `# Progress: ${name}
+  await Bun.write(join101(featureDir, "progress.txt"), `# Progress: ${name}
 
 Created: ${new Date().toISOString()}
 
@@ -113435,7 +114160,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 = join100(naxDir, "features");
+  const featuresDir = join101(naxDir, "features");
   if (!existsSync39(featuresDir)) {
     console.log(source_default.dim("No features yet."));
     return;
@@ -113450,7 +114175,7 @@ features.command("list").description("List all features").option("-d, --dir <pat
 Features:
 `));
   for (const name of entries) {
-    const prdPath = join100(featuresDir, name, "prd.json");
+    const prdPath = join101(featuresDir, name, "prd.json");
     if (existsSync39(prdPath)) {
       const prd = await loadPRD(prdPath);
       const c = countStories(prd);
@@ -113523,10 +114248,10 @@ Use: nax plan -f <feature> --from <spec>`));
     cliOverrides.profile = cliProfiles;
   }
   const config2 = await loadConfig(workdir, cliOverrides);
-  const featureLogDir = join100(naxDir, "features", options.feature, "plan");
+  const featureLogDir = join101(naxDir, "features", options.feature, "plan");
   mkdirSync8(featureLogDir, { recursive: true });
   const planLogId = new Date().toISOString().replace(/:/g, "-").replace(/\..+/, "");
-  const planLogPath = join100(featureLogDir, `${planLogId}.jsonl`);
+  const planLogPath = join101(featureLogDir, `${planLogId}.jsonl`);
   initLogger({ level: "info", filePath: planLogPath, useChalk: false, headless: true });
   console.log(source_default.dim(`   [Plan log: ${planLogPath}]`));
   try {
@@ -113633,8 +114358,8 @@ configProfileCmd.command("current").description("Show the currently active profi
 });
 configProfileCmd.command("create <name>").description("Create a new empty profile").option("-d, --dir <path>", "Project directory", process.cwd()).action(async (name, options) => {
   try {
-    const path31 = await profileCreateCommand(name, options.dir);
-    console.log(`Created profile at: ${path31}`);
+    const path32 = await profileCreateCommand(name, options.dir);
+    console.log(`Created profile at: ${path32}`);
   } catch (err) {
     console.error(source_default.red(`Error: ${err.message}`));
     process.exit(1);