@nathapp/nax 0.77.1 → 0.77.3

package/dist/nax.js

@@ -16865,7 +16865,10 @@ var init_schemas_execution = __esm(() => {
     maxFailureSummaryChars: exports_external.number().int().min(500).max(1e4).default(2000),
     abortOnIncreasingFailures: exports_external.boolean().default(true),
     consecutiveIncreasesToBail: exports_external.number().int().min(1).max(10).default(2),
+    abortOnNoProgress: exports_external.boolean().default(true),
+    consecutiveNoProgressToBail: exports_external.number().int().min(1).max(10).default(3),
     escalateOnExhaustion: exports_external.boolean().optional().default(true),
+    storyScopedFixBudget: exports_external.boolean().default(true),
     rethinkAtAttempt: exports_external.number().int().min(1).default(2),
     urgencyAtAttempt: exports_external.number().int().min(1).default(3)
   });
@@ -17531,7 +17534,10 @@ var init_schemas3 = __esm(() => {
         maxFailureSummaryChars: 2000,
         abortOnIncreasingFailures: true,
         consecutiveIncreasesToBail: 2,
+        abortOnNoProgress: true,
+        consecutiveNoProgressToBail: 3,
         escalateOnExhaustion: true,
+        storyScopedFixBudget: true,
         rethinkAtAttempt: 2,
         urgencyAtAttempt: 3
       },
@@ -17831,6 +17837,10 @@ var init_schemas3 = __esm(() => {
         defaultAgent: exports_external.string().nullable().default(null),
         model: exports_external.string().min(1, "model must be non-empty").nullable().default(null),
         narrative: exports_external.boolean().default(true),
+        prBody: exports_external.object({
+          template: exports_external.enum(["merge", "strict", "ignore"]).default("merge"),
+          sectionMap: exports_external.record(exports_external.string(), exports_external.string()).default({})
+        }).default({ template: "merge", sectionMap: {} }),
         reviewers: exports_external.object({
           spec: exports_external.string().nullable().default(null),
           quality: exports_external.string().nullable().default(null),
@@ -17850,6 +17860,7 @@ var init_schemas3 = __esm(() => {
         defaultAgent: null,
         model: null,
         narrative: true,
+        prBody: { template: "merge", sectionMap: {} },
         reviewers: { spec: null, quality: null, narrative: null },
         escalate: { telegram: true },
         notify: { mode: "escalation" },
@@ -17862,6 +17873,7 @@ var init_schemas3 = __esm(() => {
         defaultAgent: null,
         model: null,
         narrative: true,
+        prBody: { template: "merge", sectionMap: {} },
         reviewers: { spec: null, quality: null, narrative: null },
         escalate: { telegram: true },
         notify: { mode: "escalation" },
@@ -23592,7 +23604,7 @@ function parseFrontmatter(raw, filePath) {
   const doc2 = parsed ?? {};
   const unknownKeys = Object.keys(doc2).filter((key) => !KNOWN_FRONTMATTER_KEYS.has(key));
   if (unknownKeys.length > 0) {
-    throw new RulesFrontmatterError(`Canonical rule frontmatter declares unknown key(s): ${unknownKeys.join(", ")}. Only priority, paths, appliesTo, and stages are recognised.`, filePath);
+    throw new RulesFrontmatterError(`Canonical rule frontmatter declares unknown key(s): ${unknownKeys.join(", ")}. Only priority, paths, appliesTo, stages, and description are recognised.`, filePath);
   }
   const priorityRaw = doc2.priority;
   let priority = FRONTMATTER_PRIORITY_DEFAULT;
@@ -23645,12 +23657,29 @@ function parseFrontmatter(raw, filePath) {
       }
     }
   }
+  const descriptionRaw = doc2.description;
+  let description;
+  if (descriptionRaw !== undefined) {
+    if (typeof descriptionRaw !== "string") {
+      throw new RulesFrontmatterError("frontmatter.description must be a string", filePath);
+    }
+    if (descriptionRaw.includes(`
+`) || descriptionRaw.includes("\r")) {
+      throw new RulesFrontmatterError("frontmatter.description must be a single line", filePath);
+    }
+    const trimmed = descriptionRaw.trim();
+    if (!trimmed) {
+      throw new RulesFrontmatterError("frontmatter.description cannot be empty", filePath);
+    }
+    description = trimmed;
+  }
   return {
     content: effectiveContent.slice(close[0].length).trim(),
     priority,
     ...paths && { paths },
     ...appliesTo && { appliesTo },
     ...stages && { stages },
+    ...description && { description },
     warnings
   };
 }
@@ -23658,7 +23687,7 @@ var KNOWN_FRONTMATTER_KEYS, FRONTMATTER_PRIORITY_DEFAULT = 100, EXTRA_KNOWN_STAG
 var init_rules_frontmatter = __esm(() => {
   init_errors();
   init_stage_config();
-  KNOWN_FRONTMATTER_KEYS = new Set(["priority", "paths", "appliesTo", "stages"]);
+  KNOWN_FRONTMATTER_KEYS = new Set(["priority", "paths", "appliesTo", "stages", "description"]);
   EXTRA_KNOWN_STAGES = [
     "queue-check",
     "routing",
@@ -23821,6 +23850,7 @@ async function loadCanonicalRules(workdir, options = {}) {
       ...parsed.paths && { paths: parsed.paths },
       ...parsed.appliesTo && { appliesTo: parsed.appliesTo },
       ...parsed.stages && { stages: parsed.stages },
+      ...parsed.description && { description: parsed.description },
       ...parsed.warnings.length > 0 && { warnings: parsed.warnings }
     });
   }
@@ -26439,6 +26469,144 @@ function isInside(root, filePath) {
 }
 var init_realpath = () => {};
 
+// src/utils/porcelain.ts
+function parsePorcelainForNaxPaths(porcelain) {
+  const protectedPaths = [];
+  if (!porcelain)
+    return protectedPaths;
+  for (const rawLine of porcelain.split(`
+`)) {
+    if (!rawLine)
+      continue;
+    if (rawLine.length < 4)
+      continue;
+    const xStatus = rawLine[0];
+    const yStatus = rawLine[1];
+    if (xStatus === "?" && yStatus === "?")
+      continue;
+    const isDeleted = xStatus === "D" || yStatus === "D";
+    const isRename = xStatus === "R" || yStatus === "R";
+    if (!isDeleted && !isRename)
+      continue;
+    const staged = xStatus === "D" || xStatus === "R";
+    const pathField = rawLine.slice(3);
+    let targetPath;
+    if (isRename) {
+      const oldPath = splitRenameOldPath(pathField);
+      if (oldPath === null)
+        continue;
+      targetPath = oldPath;
+    } else {
+      targetPath = pathField;
+    }
+    targetPath = unquotePorcelainPath(targetPath);
+    if (!targetPath.split("/").includes(".nax"))
+      continue;
+    protectedPaths.push({ path: targetPath, staged });
+  }
+  return protectedPaths;
+}
+function unquotePorcelainPath(p) {
+  if (p.length < 2 || p[0] !== '"' || p[p.length - 1] !== '"')
+    return p;
+  const inner = p.slice(1, -1);
+  const bytes = [];
+  for (let i = 0;i < inner.length; i++) {
+    const c = inner[i];
+    if (c !== "\\" || i + 1 >= inner.length) {
+      bytes.push(c.charCodeAt(0));
+      continue;
+    }
+    const next = inner[i + 1];
+    if (next === '"' || next === "\\") {
+      bytes.push(next.charCodeAt(0));
+      i++;
+      continue;
+    }
+    if (next === "a") {
+      bytes.push(7);
+      i++;
+      continue;
+    }
+    if (next === "b") {
+      bytes.push(8);
+      i++;
+      continue;
+    }
+    if (next === "t") {
+      bytes.push(9);
+      i++;
+      continue;
+    }
+    if (next === "n") {
+      bytes.push(10);
+      i++;
+      continue;
+    }
+    if (next === "v") {
+      bytes.push(11);
+      i++;
+      continue;
+    }
+    if (next === "f") {
+      bytes.push(12);
+      i++;
+      continue;
+    }
+    if (next === "r") {
+      bytes.push(13);
+      i++;
+      continue;
+    }
+    if (next >= "0" && next <= "7") {
+      let j = i + 1;
+      let digits = "";
+      while (j < inner.length && digits.length < 3 && inner[j] >= "0" && inner[j] <= "7") {
+        digits += inner[j];
+        j++;
+      }
+      const byte = Number.parseInt(digits, 8);
+      if (!Number.isNaN(byte)) {
+        bytes.push(byte);
+        i = j - 1;
+        continue;
+      }
+    }
+    if (next === "x") {
+      const slice = inner.slice(i + 2, i + 4);
+      if (slice.length === 2 && /^[0-9a-fA-F]{2}$/.test(slice)) {
+        bytes.push(Number.parseInt(slice, 16));
+        i += 3;
+        continue;
+      }
+    }
+    bytes.push(c.charCodeAt(0));
+  }
+  return new TextDecoder("utf-8").decode(new Uint8Array(bytes));
+}
+function splitRenameOldPath(pathField) {
+  let start = 0;
+  if (pathField.startsWith('"')) {
+    let i = 1;
+    while (i < pathField.length) {
+      const c = pathField[i];
+      if (c === "\\" && i + 1 < pathField.length) {
+        i += 2;
+        continue;
+      }
+      if (c === '"') {
+        start = i + 1;
+        break;
+      }
+      i++;
+    }
+  }
+  const arrowIdx = pathField.indexOf(" -> ", start);
+  if (arrowIdx < 0)
+    return null;
+  return pathField.slice(0, arrowIdx);
+}
+
 // src/utils/git.ts
 async function getGitRoot(workdir) {
   try {
@@ -26583,6 +26751,32 @@ async function autoCommitIfDirty(workdir, stage, role, storyId, blockedWorktrees
       dirtyFiles: statusOutput.trim().split(`
 `).length
     });
+    const naxPaths = parsePorcelainForNaxPaths(statusOutput);
+    for (const { path: protectedPath, staged } of naxPaths) {
+      logger?.error(stage, "Restoring deleted .nax/ path before auto-commit", {
+        storyId,
+        role,
+        path: protectedPath,
+        staged
+      });
+      const checkoutArgs = staged ? ["git", "checkout", "HEAD", "--", protectedPath] : ["git", "checkout", "--", protectedPath];
+      const checkoutProc = _gitDeps.spawn(checkoutArgs, {
+        cwd: realGitRoot,
+        stdout: "pipe",
+        stderr: "pipe"
+      });
+      const checkoutExit = await checkoutProc.exited;
+      if (checkoutExit !== 0) {
+        const stderr = await new Response(checkoutProc.stderr).text();
+        logger?.error(stage, "Failed to restore .nax/ path before auto-commit", {
+          storyId,
+          role,
+          path: protectedPath,
+          exitCode: checkoutExit,
+          stderr: stderr.trim()
+        });
+      }
+    }
     const addProc = _gitDeps.spawn(["git", "add", "-A"], { cwd: realGitRoot, stdout: "pipe", stderr: "pipe" });
     await addProc.exited;
     const commitProc = _gitDeps.spawn(["git", "commit", "-m", `chore(${storyId}): auto-commit after ${role} session`], {
@@ -33409,6 +33603,20 @@ Include the story ID when known \u2014 \`feat(<story-id>): <description>\`.
 When the story is ambiguous, pick an interpretation, proceed, and document the choice in the commit body under \`Assumptions:\`. Do not invent requirements; do not silently choose when the story is genuinely under-specified \u2014 note it.`;
 }
 
+// src/prompts/sections/nax-artifacts.ts
+function buildNaxArtifactsSection(role, _variant, _isolation) {
+  return `# .nax/ artifact immutability
+
+Files under \`.nax/\` are nax's own artifacts (acceptance scaffolds, plan state, generated acceptance
+tests). They must NEVER be moved, renamed, or deleted \u2014 \`.nax/\` is a tool-managed directory and
+modifying it breaks the orchestrator.
+
+- A test under \`.nax/\` is NOT a reason to skip writing source-tree tests. \`.nax/\` is generated
+  scaffolding, not real coverage of the package's code.
+- A source-tree test is NOT a reason to remove a test under \`.nax/\`. The two serve different
+  purposes and must coexist.`;
+}
+
 // src/prompts/sections/test-quality.ts
 function buildTestQualitySection(role, variant, storyId) {
   const authors = AUTHORING_ROLES.has(role) || role === "implementer" && variant === "lite";
@@ -33597,6 +33805,9 @@ class TddPromptBuilder {
     const guardrails = buildBehavioralGuardrailsSection(this.role, guardrailLevel, guardrailVariant, guardrailIsolation);
     if (guardrails)
       acc.add(this.s("guardrails", guardrails));
+    const naxArtifacts = buildNaxArtifactsSection(this.role, guardrailVariant, guardrailIsolation);
+    if (naxArtifacts)
+      acc.add(this.s("nax-artifacts", naxArtifacts));
     const testQuality = buildTestQualitySection(this.role, this.options.variant, this.story_?.id);
     if (testQuality)
       acc.add(this.s("test-quality", testQuality));
@@ -43501,12 +43712,23 @@ var init_mutation_check = __esm(() => {
         candidates: 0,
         checked: false
       };
-      const record2 = (result) => {
+      const logger = getLogger();
+      const record2 = (result, skipReason) => {
         if (ctx.storyId) {
           ctx.runtime?.mutationSummaries?.set(ctx.storyId, { storyId: ctx.storyId, ...result });
         }
+        if (result.checked) {
+          logger.info("mutation-check", "Mutation spot-check outcomes", {
+            storyId: input.storyId,
+            killed: result.outcomes.killed,
+            survived: result.outcomes.survived,
+            errored: result.outcomes.errored,
+            candidates: result.candidates,
+            ...skipReason ? { skipReason } : {},
+            ...result.revertFailed ? { revertFailed: true } : {}
+          });
+        }
       };
-      const logger = getLogger();
       if (!cfg?.enabled) {
         if (await mayHaveJournal([input.workdir, input.repoRoot])) {
           await sweepLeftoverMutants(await deps.getGitRoot(input.workdir) ?? input.workdir, input.storyId);
@@ -43544,7 +43766,7 @@ var init_mutation_check = __esm(() => {
         logger.warn("mutation-check", "Failed to obtain changed-line ranges \u2014 skipping mutation spot-check", {
           storyId: input.storyId
         });
-        record2({ ...emptyOutput, checked: true });
+        record2({ ...emptyOutput, checked: true }, "changed-line-ranges-unavailable");
         return { success: true, ...emptyOutput, checked: true };
       }
       const survivors = [];
@@ -43779,8 +44001,8 @@ var init_cycle_iteration_log = __esm(() => {
 });
 
 // src/findings/cycle-retirement.ts
-function createDeclineLedger() {
-  const declinedByStrategy = new Map;
+function createDeclineLedger(backing) {
+  const declinedByStrategy = backing ?? new Map;
   const hasDeclined = (strategyName, finding) => declinedByStrategy.get(strategyName)?.has(findingKey(finding)) === true;
   const isRetiredFor = (strategy, findings) => {
     const claimed = findings.filter((f) => strategy.appliesTo(f));
@@ -43872,13 +44094,14 @@ async function runFixCycle(cycle, ctx, cycleName, _deps = {}) {
   const storyId = ctx.storyId;
   const packageDir = ctx.packageDir;
   let totalCostUsd = 0;
-  const declines = createDeclineLedger();
+  const declines = createDeclineLedger(_deps.declineBacking);
   let unresolvedDetail;
   const finish = (result) => unresolvedDetail !== undefined && result.unresolvedDetail === undefined ? { ...result, unresolvedDetail } : result;
   for (;; ) {
     if (cycle.findings.length === 0 && cycle.verdict === undefined) {
       return { iterations: cycle.iterations, finalFindings: [], exitReason: "resolved", costUsd: totalCostUsd };
     }
+    const history = cycle.priorIterations ? [...cycle.priorIterations, ...cycle.iterations] : cycle.iterations;
     const selectable = cycle.strategies.filter((s) => !declines.isRetiredFor(s, cycle.findings));
     const active = selectActiveStrategies(selectable, cycle.findings, cycle.verdict);
     if (active.length === 0) {
@@ -43900,9 +44123,9 @@ async function runFixCycle(cycle, ctx, cycleName, _deps = {}) {
         costUsd: totalCostUsd
       });
     }
-    const uncappedActive = active.filter((s) => countStrategyAttempts(cycle.iterations, s.name) < s.maxAttempts);
+    const uncappedActive = active.filter((s) => countStrategyAttempts(history, s.name) < s.maxAttempts);
     if (uncappedActive.length === 0) {
-      const exhaustedStrategy = active.find((s) => countStrategyAttempts(cycle.iterations, s.name) >= s.maxAttempts);
+      const exhaustedStrategy = active.find((s) => countStrategyAttempts(history, s.name) >= s.maxAttempts);
       logger?.info("findings.cycle", "cycle exited \u2014 all active strategies exhausted", {
         storyId,
         packageDir,
@@ -43918,7 +44141,7 @@ async function runFixCycle(cycle, ctx, cycleName, _deps = {}) {
         costUsd: totalCostUsd
       });
     }
-    const totalAttempts = countTotalAttempts(cycle.iterations);
+    const totalAttempts = countTotalAttempts(history);
     if (totalAttempts >= cycle.config.maxAttemptsTotal) {
       logger?.info("findings.cycle", "cycle exited \u2014 total attempt cap reached", {
         storyId,
@@ -43936,7 +44159,7 @@ async function runFixCycle(cycle, ctx, cycleName, _deps = {}) {
       });
     }
     for (const strategy of uncappedActive) {
-      const bailReason = strategy.bailWhen?.(cycle.iterations) ?? null;
+      const bailReason = strategy.bailWhen?.(history) ?? null;
       if (bailReason !== null) {
         logger?.info("findings.cycle", "cycle exited \u2014 bail predicate fired", {
           storyId,
@@ -44024,7 +44247,7 @@ async function runFixCycle(cycle, ctx, cycleName, _deps = {}) {
       });
     }
     const allExhausted = group.every((s) => {
-      const prior = countStrategyAttempts(cycle.iterations, s.name);
+      const prior = countStrategyAttempts(history, s.name);
       const current = fixesApplied.filter((fa) => fa.strategyName === s.name).length;
       return prior + current >= s.maxAttempts;
     });
@@ -44192,6 +44415,55 @@ var init_cycle = __esm(() => {
   };
 });
 
+// src/findings/bail-marker.ts
+function markNaxBailWrapper(predicate) {
+  Object.assign(predicate, { [NAX_BAIL_WRAPPER]: true });
+  return predicate;
+}
+function isNaxBailWrapper(predicate) {
+  if (!predicate)
+    return false;
+  return predicate[NAX_BAIL_WRAPPER] === true;
+}
+var NAX_BAIL_WRAPPER = "__naxBailWrapper";
+
+// src/findings/story-fix-history.ts
+function createStoryFixHistory() {
+  return new Map;
+}
+function storyFixKey(storyId, tier) {
+  return `${storyId}::${tier ?? "default"}`;
+}
+function getStoryFixState(store, key) {
+  let existing = store.get(key);
+  if (!existing) {
+    existing = { iterations: [], declines: new Map };
+    store.set(key, existing);
+  }
+  return existing;
+}
+function appendStoryFixIterations(store, key, iterations) {
+  const existing = store.get(key);
+  if (existing) {
+    store.set(key, {
+      iterations: [...existing.iterations, ...iterations],
+      declines: existing.declines
+    });
+  } else {
+    store.set(key, {
+      iterations: [...iterations],
+      declines: new Map
+    });
+  }
+}
+function mergeStoryFixDeclines(store, key, declines) {
+  const existing = store.get(key);
+  store.set(key, {
+    iterations: existing?.iterations ?? [],
+    declines: new Map([...declines].map(([name, keys]) => [name, new Set(keys)]))
+  });
+}
+
 // src/findings/index.ts
 var init_findings = __esm(() => {
   init_types6();
@@ -44199,6 +44471,7 @@ var init_findings = __esm(() => {
   init_path_utils();
   init_cycle();
   init_cycle_iteration_log();
+  init_cycle_retirement();
 });
 
 // src/review/review-iteration-store.ts
@@ -44685,7 +44958,7 @@ var package_default;
 var init_package = __esm(() => {
   package_default = {
     name: "@nathapp/nax",
-    version: "0.77.1",
+    version: "0.77.3",
     description: "AI Coding Agent Orchestrator \u2014 loops until done",
     type: "module",
     bin: {
@@ -44749,7 +45022,7 @@ var init_package = __esm(() => {
       "@biomejs/biome": "^1.9.4",
       "@types/bun": "^1.3.8",
       "react-devtools-core": "^7.0.1",
-      typescript: "^5.7.3"
+      typescript: "^7.0.2"
     },
     license: "MIT",
     author: "William Khoo",
@@ -44789,8 +45062,8 @@ var init_version = __esm(() => {
   NAX_VERSION = package_default.version;
   NAX_COMMIT = (() => {
     try {
-      if (/^[0-9a-f]{6,10}$/.test("a50be624"))
-        return "a50be624";
+      if (/^[0-9a-f]{6,10}$/.test("e42ce962"))
+        return "e42ce962";
     } catch {}
     try {
       const result = Bun.spawnSync(["git", "rev-parse", "--short", "HEAD"], {
@@ -46848,6 +47121,8 @@ evidence that an acceptance criterion is already tested, and you may NOT emit UN
 The only valid response to a missing-test finding is to
 author a real test under the package's resolved test path.
 
+${buildNaxArtifactsSection("implementer")}
+
 ## Test-file edit exceptions
 
 The "do not modify test files" rule has ${countWord} narrow escape valves. Each requires a
@@ -51912,6 +52187,7 @@ function createRuntime(config2, workdir, opts) {
   const adversarialIterations = new Map;
   const semanticIterations = new Map;
   const rectificationOscillations = new Map;
+  const storyFixHistory = createStoryFixHistory();
   const mutationSummaries = new Map;
   const dirtyWorktrees = new Set;
   let closed = false;
@@ -51938,6 +52214,7 @@ function createRuntime(config2, workdir, opts) {
     adversarialIterations,
     semanticIterations,
     rectificationOscillations,
+    storyFixHistory,
     mutationSummaries,
     dirtyWorktrees,
     get signal() {
@@ -51985,6 +52262,7 @@ var init_runtime = __esm(() => {
   init_config();
   init_errors();
   init_pid_registry();
+  init_findings();
   init_logger2();
   init_review_audit();
   init_session();
@@ -59101,6 +59379,7 @@ __export(exports_acceptance2, {
   acceptanceStage: () => acceptanceStage,
   _acceptanceStageDeps: () => _acceptanceStageDeps
 });
+import path12 from "path";
 function areAllStoriesComplete(ctx) {
   const counts = countStories(ctx.prd);
   const totalComplete = counts.passed + counts.failed + counts.skipped;
@@ -59145,18 +59424,42 @@ var init_acceptance3 = __esm(() => {
           packageDir: ctx.workdir
         }
       ];
+      const storiesByPackageDir = new Map;
+      for (const s of ctx.prd.userStories) {
+        if (s.id.startsWith("US-FIX-") || s.status === "decomposed")
+          continue;
+        const wd = s.workdir ?? "";
+        const pkgDir = wd ? path12.join(ctx.workdir, wd) : ctx.workdir;
+        storiesByPackageDir.set(pkgDir, (storiesByPackageDir.get(pkgDir) ?? 0) + 1);
+      }
       const allFailedACs = [];
       const allFindings = [];
       const failedPackages = [];
+      const missingTargets = [];
       const allOutputParts = [];
       let anyError = false;
       let errorExitCode = 0;
       let hardeningPromoted = 0;
-      for (const { testPath, packageDir, testFramework, commandOverride } of testGroups) {
+      for (const { testPath, packageDir, testFramework, commandOverride, storyCount, acceptanceEnabled } of testGroups) {
         const testFile = Bun.file(testPath);
         const exists = await testFile.exists();
         if (!exists) {
-          logger.warn("acceptance", "Acceptance test file not found \u2014 skipping", { storyId: ctx.story.id, testPath });
+          const resolvedStoryCount = storyCount ?? storiesByPackageDir.get(packageDir) ?? 0;
+          const resolvedAcceptanceEnabled = acceptanceEnabled ?? true;
+          if (resolvedStoryCount > 0 && resolvedAcceptanceEnabled) {
+            logger.warn("acceptance", "Required acceptance test file missing", {
+              storyId: ctx.story.id,
+              testPath,
+              packageDir
+            });
+            missingTargets.push(packageDir);
+          } else {
+            logger.warn("acceptance", "Acceptance test file not found \u2014 skipping", {
+              storyId: ctx.story.id,
+              testPath,
+              packageDir
+            });
+          }
           continue;
         }
         const resolvedFramework = testFramework ?? ctx.config.project?.testFramework;
@@ -59233,6 +59536,29 @@ ${stderr}`;
       const combinedOutput = allOutputParts.join(`
 `);
       const durationMs = Date.now() - startTime;
+      if (missingTargets.length > 0) {
+        ctx.acceptanceFailures = {
+          failedACs: allFailedACs,
+          findings: allFindings,
+          testOutput: combinedOutput,
+          failedPackages,
+          missingTargets
+        };
+        logger.info("acceptance", "verdict", {
+          storyId: ctx.story.id,
+          packageDir: ctx.workdir,
+          passed: false,
+          failedACs: allFailedACs,
+          retries: ctx.acceptanceRetries ?? 0,
+          hardeningPromoted,
+          durationMs,
+          missingTargets
+        });
+        return {
+          action: "fail",
+          reason: `Required acceptance test files are missing for packages: ${missingTargets.join(", ")}`
+        };
+      }
       if (allFailedACs.length === 0) {
         logger.info("acceptance", "All acceptance tests passed", { storyId: ctx.story.id });
         const hardeningEnabled = ctx.config.acceptance?.hardening?.enabled !== false;
@@ -59380,7 +59706,7 @@ __export(exports_acceptance_setup, {
   acceptanceSetupStage: () => acceptanceSetupStage,
   _acceptanceSetupDeps: () => _acceptanceSetupDeps
 });
-import path12 from "path";
+import path13 from "path";
 function computeACFingerprint(criteria) {
   const sorted = [...criteria].sort().join(`
 `);
@@ -59391,7 +59717,7 @@ function computeACFingerprint(criteria) {
 async function runAcceptanceSetup(ctx, featureDir, phaseStartTime) {
   const language = ctx.config.project?.language;
   const testPathConfig = ctx.config.acceptance.testPath;
-  const metaPath = path12.join(featureDir, "acceptance-meta.json");
+  const metaPath = path13.join(featureDir, "acceptance-meta.json");
   const allCriteria = ctx.prd.userStories.filter((s) => !s.id.startsWith("US-FIX-") && s.status !== "decomposed").flatMap((s) => s.acceptanceCriteria);
   const featureName = ctx.prd.feature ?? ctx.prd.featureName;
   const groups = await groupStoriesByPackage(ctx.prd, ctx.workdir, featureName, testPathConfig, language);
@@ -59518,7 +59844,7 @@ async function runAcceptanceSetup(ctx, featureDir, phaseStartTime) {
         testable: c.testable,
         storyId: c.storyId
       })), null, 2);
-      await _acceptanceSetupDeps.writeFile(path12.join(featureDir, "acceptance-refined.json"), refinedJsonContent);
+      await _acceptanceSetupDeps.writeFile(path13.join(featureDir, "acceptance-refined.json"), refinedJsonContent);
     }
     const fingerprint2 = computeACFingerprint(allCriteria);
     await _acceptanceSetupDeps.writeMeta(metaPath, {
@@ -59532,7 +59858,7 @@ async function runAcceptanceSetup(ctx, featureDir, phaseStartTime) {
   }
   const acceptanceTestPaths = [];
   for (const g of groups) {
-    const relativeWorkdir = path12.relative(ctx.projectDir, g.packageDir);
+    const relativeWorkdir = path13.relative(ctx.projectDir, g.packageDir);
     let groupConfig = ctx.config;
     if (relativeWorkdir && relativeWorkdir !== ".") {
       try {
@@ -59545,7 +59871,9 @@ async function runAcceptanceSetup(ctx, featureDir, phaseStartTime) {
       testPath: g.testPath,
       packageDir: g.packageDir,
       testFramework: groupConfig.project?.testFramework,
-      commandOverride: groupConfig.acceptance.command
+      commandOverride: groupConfig.acceptance.command,
+      storyCount: g.stories.length,
+      acceptanceEnabled: groupConfig.acceptance.enabled
     });
   }
   ctx.acceptanceTestPaths = acceptanceTestPaths;
@@ -59662,7 +59990,7 @@ var init_acceptance_setup = __esm(() => {
     },
     autoCommitIfDirty,
     loadGroupConfig: async (projectDir, relativeWorkdir) => {
-      return loadConfigForWorkdir(path12.join(projectDir, ".nax", "config.json"), relativeWorkdir || undefined);
+      return loadConfigForWorkdir(path13.join(projectDir, ".nax", "config.json"), relativeWorkdir || undefined);
     },
     runTest: async (_testPath, _workdir, _cmd) => {
       const cmd = _cmd;
@@ -60299,7 +60627,7 @@ var init_story_context = __esm(() => {
 
 // src/execution/lock.ts
 import { unlink as unlink2 } from "fs/promises";
-import path13 from "path";
+import path14 from "path";
 function getSafeLogger3() {
   try {
     return getLogger();
@@ -60316,7 +60644,7 @@ function isProcessAlive(pid) {
   }
 }
 async function acquireLock(workdir) {
-  const lockPath = path13.join(workdir, "nax.lock");
+  const lockPath = path14.join(workdir, "nax.lock");
   const lockFile = Bun.file(lockPath);
   try {
     const exists = await lockFile.exists();
@@ -60368,7 +60696,7 @@ async function acquireLock(workdir) {
   }
 }
 async function releaseLock(workdir) {
-  const lockPath = path13.join(workdir, "nax.lock");
+  const lockPath = path14.join(workdir, "nax.lock");
   try {
     await unlink2(lockPath);
   } catch (error48) {
@@ -61274,6 +61602,45 @@ function countOscillationOutcomes(iterations) {
   return count;
 }
 
+// src/execution/story-orchestrator/no-progress-bail.ts
+function madeNoProgress(iteration) {
+  if (iteration.findingsBefore.length === 0)
+    return false;
+  const after = new Set(iteration.findingsAfter.map(findingKey));
+  return iteration.findingsBefore.every((finding) => after.has(findingKey(finding)));
+}
+function withNoProgressBail(strategies, enabled, consecutiveNoProgress) {
+  if (!enabled)
+    return strategies;
+  const threshold = Math.max(1, consecutiveNoProgress);
+  return strategies.map((strategy) => {
+    const innerBail = strategy.bailWhen;
+    const isUserBail = innerBail !== undefined && !isNaxBailWrapper(innerBail);
+    return {
+      ...strategy,
+      bailWhen: markNaxBailWrapper((iterations) => {
+        if (isUserBail) {
+          const userReason = innerBail(iterations);
+          if (userReason !== null)
+            return userReason;
+        }
+        if (iterations.length >= threshold) {
+          const trailing = iterations.slice(-threshold);
+          if (trailing.every(madeNoProgress)) {
+            return `no finding resolved for ${threshold} consecutive iteration(s); ${trailing.at(-1)?.findingsBefore.length ?? 0} finding(s) persisted`;
+          }
+        }
+        if (!isUserBail && innerBail)
+          return innerBail(iterations);
+        return null;
+      })
+    };
+  });
+}
+var init_no_progress_bail = __esm(() => {
+  init_findings();
+});
+
 // src/execution/checkpoint/resume-plan.ts
 function buildResumePlan(cp, current) {
   if (!cp) {
@@ -61806,7 +62173,7 @@ function withIncreasingFailuresBail(strategies, enabled, consecutiveIncreases) {
   const threshold = Math.max(1, consecutiveIncreases);
   return strategies.map((strategy) => ({
     ...strategy,
-    bailWhen: (iterations) => {
+    bailWhen: markNaxBailWrapper((iterations) => {
       const userReason = strategy.bailWhen?.(iterations) ?? null;
       if (userReason !== null)
         return userReason;
@@ -61820,7 +62187,7 @@ function withIncreasingFailuresBail(strategies, enabled, consecutiveIncreases) {
         return `failure count increased for ${threshold} consecutive iteration(s): ${first.findingsBefore.length} -> ${last.findingsAfter.length}`;
       }
       return null;
-    }
+    })
   }));
 }
 var _storyOrchestratorDeps, ALL_FINDING_SEVERITIES;
@@ -61986,6 +62353,12 @@ async function runRectification(ctx, state, phaseCosts, phaseOutputs, overrides)
   if (!ctx.storyId) {
     return {};
   }
+  const storyFixBudgetEnabled = !nbfPath && ctx.runtime.configLoader.current().execution?.rectification?.storyScopedFixBudget === true;
+  const store = ctx.runtime.storyFixHistory;
+  const fixKey = storyFixBudgetEnabled ? storyFixKey(ctx.storyId, ctx.phaseTelemetry?.tier) : undefined;
+  const fixState = fixKey !== undefined && store ? getStoryFixState(store, fixKey) : undefined;
+  const priorIterationCount = fixState?.iterations.length ?? 0;
+  const declineSnapshot = fixState ? new Map([...fixState.declines].map(([name, keys]) => [name, new Set(keys)])) : undefined;
   const fixOpPhaseOutputs = {};
   const wrappedCallOp = async (cycleCtx, op, input) => {
     const slot = { op, input };
@@ -61994,7 +62367,8 @@ async function runRectification(ctx, state, phaseCosts, phaseOutputs, overrides)
   const cycle = {
     findings: [...initialFindings],
     iterations: [],
-    strategies: withIncreasingFailuresBail(overrides?.strategies ?? rectification2.strategies, rectification2.abortOnIncreasingFailures, rectification2.consecutiveIncreasesToBail ?? 1),
+    priorIterations: fixState?.iterations,
+    strategies: withNoProgressBail(withIncreasingFailuresBail(overrides?.strategies ?? rectification2.strategies, rectification2.abortOnIncreasingFailures, rectification2.consecutiveIncreasesToBail ?? 1), rectification2.abortOnNoProgress ?? true, rectification2.consecutiveNoProgressToBail ?? 3),
     config: { maxAttemptsTotal: overrides?.maxAttempts ?? rectification2.maxAttempts, validatorRetries: 1 },
     validate: async (_validateCtx, opts) => {
       if (ctx.runtime.signal?.aborted)
@@ -62055,15 +62429,22 @@ async function runRectification(ctx, state, phaseCosts, phaseOutputs, overrides)
       return { findings: validated, shortCircuited };
     }
   };
-  const cycleResult = await _storyOrchestratorDeps.runFixCycle(cycle, ctx, "story-orchestrator-rectification", { callOp: wrappedCallOp });
+  const cycleResult = await _storyOrchestratorDeps.runFixCycle(cycle, ctx, "story-orchestrator-rectification", { callOp: wrappedCallOp, declineBacking: declineSnapshot });
+  if (fixKey !== undefined && store && cycleResult.iterations.length > 0) {
+    appendStoryFixIterations(store, fixKey, cycleResult.iterations);
+  }
+  if (fixKey !== undefined && store && declineSnapshot) {
+    mergeStoryFixDeclines(store, fixKey, declineSnapshot);
+  }
   const oscillationCount = countOscillationOutcomes(cycleResult.iterations);
   if (oscillationCount > 0) {
     recordOscillations(ctx.runtime.rectificationOscillations, ctx.storyId, oscillationCount);
   }
+  const reportedExitReason = cycleResult.exitReason === "validate-short-circuit" && priorIterationCount > 0 ? "max-attempts-per-strategy" : cycleResult.exitReason;
   phaseOutputs.rectification = {
     success: cycleResult.exitReason === "resolved",
     iterationCount: cycleResult.iterations.length,
-    exitReason: cycleResult.exitReason,
+    exitReason: reportedExitReason,
     finalFindingsCount: cycleResult.finalFindings.length
   };
   const rectLogger = getSafeLogger();
@@ -62072,7 +62453,7 @@ async function runRectification(ctx, state, phaseCosts, phaseOutputs, overrides)
     initialFindingsCount: initialFindings.length,
     iterationCount: cycleResult.iterations.length,
     finalFindingsCount: cycleResult.finalFindings.length,
-    exitReason: cycleResult.exitReason,
+    exitReason: reportedExitReason,
     costUsd: cycleResult.costUsd
   };
   if (cycleResult.exitReason === "resolved") {
@@ -62098,8 +62479,10 @@ async function runRectification(ctx, state, phaseCosts, phaseOutputs, overrides)
   return {};
 }
 var init_rectification = __esm(() => {
+  init_findings();
   init_logger2();
   init_nbf_flake_triage();
+  init_no_progress_bail();
   init_phase_eval();
   init_phase_eval();
   init_run_phase();
@@ -62453,6 +62836,7 @@ var init_story_orchestrator = __esm(() => {
   init_phase_eval();
   init_rectification();
   init_nbf_flake_triage();
+  init_no_progress_bail();
   init_run_phase();
   init_review_decision();
   init_types9();
@@ -62873,7 +63257,9 @@ async function assemblePlanInputsFromCtx(ctx) {
     maxAttempts: ctx.config.execution.rectification.maxAttemptsTotal,
     strategies: [],
     abortOnIncreasingFailures: ctx.config.execution.rectification.abortOnIncreasingFailures,
-    consecutiveIncreasesToBail: ctx.config.execution.rectification.consecutiveIncreasesToBail
+    consecutiveIncreasesToBail: ctx.config.execution.rectification.consecutiveIncreasesToBail,
+    abortOnNoProgress: ctx.config.execution.rectification.abortOnNoProgress,
+    consecutiveNoProgressToBail: ctx.config.execution.rectification.consecutiveNoProgressToBail
   } : undefined;
   const mutationCheckInput = ctx.config.execution?.mutationCheck?.enabled === true ? {
     story,
@@ -63834,7 +64220,7 @@ function parseQueueFile(content) {
 var init_queue = () => {};
 
 // src/execution/queue-handler.ts
-import path14 from "path";
+import path15 from "path";
 function getSafeLogger4() {
   try {
     return getLogger();
@@ -63843,8 +64229,8 @@ function getSafeLogger4() {
   }
 }
 async function readQueueFile(workdir) {
-  const queuePath = path14.join(workdir, ".queue.txt");
-  const processingPath = path14.join(workdir, ".queue.txt.processing");
+  const queuePath = path15.join(workdir, ".queue.txt");
+  const processingPath = path15.join(workdir, ".queue.txt.processing");
   const logger = getSafeLogger4();
   try {
     const file3 = Bun.file(queuePath);
@@ -63869,7 +64255,7 @@ async function readQueueFile(workdir) {
   }
 }
 async function clearQueueFile(workdir) {
-  const processingPath = path14.join(workdir, ".queue.txt.processing");
+  const processingPath = path15.join(workdir, ".queue.txt.processing");
   const logger = getSafeLogger4();
   try {
     const file3 = Bun.file(processingPath);
@@ -63889,7 +64275,7 @@ var init_queue_handler = __esm(() => {
 });
 
 // src/pipeline/stages/queue-check.ts
-import path15 from "path";
+import path16 from "path";
 var queueCheckStage;
 var init_queue_check = __esm(() => {
   init_config();
@@ -63943,10 +64329,10 @@ var init_queue_check = __esm(() => {
         }
         if (cmd.type === "INJECT") {
           try {
-            if (path15.isAbsolute(cmd.storyFile)) {
+            if (path16.isAbsolute(cmd.storyFile)) {
               throw new NaxError(`INJECT storyFile must be a relative path within the workspace: ${cmd.storyFile}`, "INJECT_PATH_ABSOLUTE", { stage: "queue-check", storyId: ctx.story?.id ?? "unknown", storyFile: cmd.storyFile });
             }
-            const storyFilePath = validateFilePath(path15.join(ctx.workdir, cmd.storyFile), ctx.workdir);
+            const storyFilePath = validateFilePath(path16.join(ctx.workdir, cmd.storyFile), ctx.workdir);
             const raw = await Bun.file(storyFilePath).json();
             const existingIds = new Set(ctx.prd.userStories.map((s) => s.id));
             const story = validateInjectedStory(raw, existingIds);
@@ -64760,11 +65146,11 @@ __export(exports_init_context, {
   generateContextTemplate: () => generateContextTemplate
 });
 import { basename as basename12, join as join56 } from "path";
-async function bunFileExists(path16) {
-  return Bun.file(path16).exists();
+async function bunFileExists(path17) {
+  return Bun.file(path17).exists();
 }
-async function bunMkdirp(path16) {
-  const proc = Bun.spawn(["mkdir", "-p", path16]);
+async function bunMkdirp(path17) {
+  const proc = Bun.spawn(["mkdir", "-p", path17]);
   await proc.exited;
 }
 async function findFiles(dir, maxFiles = 200) {
@@ -64830,8 +65216,8 @@ async function detectEntryPoints(projectRoot) {
   const candidates = ["src/index.ts", "src/main.ts", "main.go", "src/lib.rs"];
   const found = [];
   for (const candidate of candidates) {
-    const path16 = join56(projectRoot, candidate);
-    if (await bunFileExists(path16)) {
+    const path17 = join56(projectRoot, candidate);
+    if (await bunFileExists(path17)) {
       found.push(candidate);
     }
   }
@@ -64841,8 +65227,8 @@ async function detectConfigFiles(projectRoot) {
   const candidates = ["tsconfig.json", "biome.json", "turbo.json", ".env.example"];
   const found = [];
   for (const candidate of candidates) {
-    const path16 = join56(projectRoot, candidate);
-    if (await bunFileExists(path16)) {
+    const path17 = join56(projectRoot, candidate);
+    if (await bunFileExists(path17)) {
       found.push(candidate);
     }
   }
@@ -65584,10 +65970,10 @@ var init_setup_analyze = __esm(() => {
   init_workspace();
   CANONICAL_SCRIPTS = ["build", "test", "lint", "type-check", "lint:fix"];
   _analyzeRepoDeps = {
-    fileExists: async (path16) => Bun.file(path16).exists(),
-    readJson: async (path16) => {
+    fileExists: async (path17) => Bun.file(path17).exists(),
+    readJson: async (path17) => {
       try {
-        const f = Bun.file(path16);
+        const f = Bun.file(path17);
         if (!await f.exists())
           return null;
         return JSON.parse(await f.text());
@@ -65642,9 +66028,9 @@ async function fillScripts(workdir, analysis) {
 var TYPE_CHECK_KEY = "type-check", TYPE_CHECK_SCRIPT = "tsc --noEmit -p tsconfig.json", TYPE_CHECK_TURBO_PASSTHROUGH = "turbo run type-check", _fillScriptsDeps;
 var init_setup_fill = __esm(() => {
   _fillScriptsDeps = {
-    readJson: async (path16) => {
+    readJson: async (path17) => {
       try {
-        const f = Bun.file(path16);
+        const f = Bun.file(path17);
         if (!await f.exists())
           return null;
         return JSON.parse(await f.text());
@@ -65652,8 +66038,8 @@ var init_setup_fill = __esm(() => {
         return null;
       }
     },
-    writeFile: async (path16, content) => {
-      await Bun.write(path16, content);
+    writeFile: async (path17, content) => {
+      await Bun.write(path17, content);
     }
   };
 });
@@ -65712,9 +66098,9 @@ async function writeSetupConfig(workdir, config2, monoConfigs, _opts, deps = _wr
 var _writeSetupDeps;
 var init_setup_write = __esm(() => {
   _writeSetupDeps = {
-    writeFile: (path16, content) => Bun.write(path16, content).then(() => {}),
-    mkdir: async (path16) => {
-      const proc = Bun.spawn(["mkdir", "-p", path16]);
+    writeFile: (path17, content) => Bun.write(path17, content).then(() => {}),
+    mkdir: async (path17) => {
+      const proc = Bun.spawn(["mkdir", "-p", path17]);
       await proc.exited;
     }
   };
@@ -65798,7 +66184,7 @@ var init_setup = __esm(() => {
     },
     generateSetupPlan: (ctx, analysis) => generateSetupPlan(ctx, analysis),
     runGate: (workdir, config2) => runSetupGate(workdir, config2),
-    fileExists: (path16) => Bun.file(path16).exists(),
+    fileExists: (path17) => Bun.file(path17).exists(),
     writeSetupConfig: (workdir, config2, monoConfigs, opts) => writeSetupConfig(workdir, config2, monoConfigs, opts),
     stdout: (msg) => {
       process.stdout.write(`${msg}
@@ -65854,6 +66240,130 @@ var init_forge = __esm(() => {
   URL_REGEX = /https?:\/\/\S+/;
 });
 
+// flows/nax-finish/pr-template-merge.ts
+function normalizeHeading(heading) {
+  return heading.toLowerCase().replace(/[^a-z0-9\s]/g, " ").replace(/\s+/g, " ").trim();
+}
+function cleanTemplateText(text) {
+  return text.replace(HTML_COMMENT_RE, "").split(`
+`).filter((line) => !DANGLING_ISSUE_RE.test(line) && !UNCHECKED_BOX_RE.test(line)).map((line) => line.trimEnd()).join(`
+`).trim();
+}
+function parseTemplate(rawText) {
+  const text = rawText.replace(/\r\n/g, `
+`);
+  const frontmatterMatch = FRONTMATTER_RE.exec(text);
+  const frontmatter = frontmatterMatch ? frontmatterMatch[0].trimEnd() : "";
+  const rest = frontmatterMatch ? text.slice(frontmatterMatch[0].length) : text;
+  const preambleLines = [];
+  const sections2 = [];
+  let current = null;
+  for (const line of rest.split(`
+`)) {
+    const heading = HEADING_RE.exec(line);
+    if (heading) {
+      if (current)
+        sections2.push({ heading: current.heading, body: current.lines.join(`
+`) });
+      current = { heading: heading[1], lines: [] };
+      continue;
+    }
+    if (current)
+      current.lines.push(line);
+    else
+      preambleLines.push(line);
+  }
+  if (current)
+    sections2.push({ heading: current.heading, body: current.lines.join(`
+`) });
+  return { frontmatter, preamble: preambleLines.join(`
+`), sections: sections2 };
+}
+function renderSection2(heading, body) {
+  if (heading.length === 0)
+    return body;
+  return body.length === 0 ? `## ${heading}` : `## ${heading}
+
+${body}`;
+}
+function renderSections(sections2) {
+  return sections2.filter((s) => s.body.trim().length > 0).map((s) => renderSection2(s.heading, s.body.trim())).join(`
+
+`).trim();
+}
+function mergeTemplate(template, sections2, opts = {}) {
+  const mode = opts.mode ?? "merge";
+  if (mode === "ignore" || !template || template.trim().length === 0)
+    return renderSections(sections2);
+  const parsed = parseTemplate(template);
+  if (parsed.sections.length === 0)
+    return renderSections(sections2);
+  const aliases = { ...DEFAULT_SECTION_ALIASES };
+  for (const [heading, key] of Object.entries(opts.sectionMap ?? {}))
+    aliases[normalizeHeading(heading)] = key;
+  const fillable = sections2.filter((s) => s.heading.length > 0 && s.body.trim().length > 0);
+  const consumed = new Set;
+  const parts = [];
+  if (parsed.frontmatter.length > 0)
+    parts.push(parsed.frontmatter);
+  const preamble = cleanTemplateText(parsed.preamble);
+  if (preamble.length > 0)
+    parts.push(preamble);
+  for (const templateSection of parsed.sections) {
+    const key = aliases[normalizeHeading(templateSection.heading)];
+    const match = key ? fillable.find((s) => s.key === key && !consumed.has(s.key)) : undefined;
+    if (match) {
+      consumed.add(match.key);
+      parts.push(renderSection2(templateSection.heading, match.body.trim()));
+    } else if (mode === "strict") {
+      parts.push(renderSection2(templateSection.heading, ""));
+    }
+  }
+  for (const section of sections2) {
+    if (consumed.has(section.key) || section.body.trim().length === 0)
+      continue;
+    parts.push(renderSection2(section.heading, section.body.trim()));
+  }
+  return parts.join(`
+
+`).trim();
+}
+var DEFAULT_SECTION_ALIASES, HEADING_RE, FRONTMATTER_RE, HTML_COMMENT_RE, DANGLING_ISSUE_RE, UNCHECKED_BOX_RE;
+var init_pr_template_merge = __esm(() => {
+  DEFAULT_SECTION_ALIASES = {
+    what: "narrative",
+    "what changed": "narrative",
+    "whats changed": "narrative",
+    summary: "narrative",
+    description: "narrative",
+    overview: "narrative",
+    changes: "narrative",
+    "what does this do": "narrative",
+    "what does this mr do and why": "narrative",
+    "what does this pr do": "narrative",
+    how: "stories",
+    implementation: "stories",
+    "implementation details": "stories",
+    "changes made": "stories",
+    approach: "stories",
+    design: "stories",
+    testing: "verification",
+    tests: "verification",
+    "test plan": "verification",
+    verification: "verification",
+    qa: "verification",
+    validation: "verification",
+    "how to test": "verification",
+    "how has this been tested": "verification",
+    "how to set up and validate locally": "verification"
+  };
+  HEADING_RE = /^##[ \t]+(.+?)[ \t]*$/;
+  FRONTMATTER_RE = /^---[ \t]*\r?\n[\s\S]*?\r?\n---[ \t]*(?:\r?\n|$)/;
+  HTML_COMMENT_RE = /<!--[\s\S]*?-->/g;
+  DANGLING_ISSUE_RE = /^[ \t]*(?:closes?|fixe?s?|resolves?)[ \t]*:?[ \t]*#[ \t]*(?:\([^)]*\))?[ \t]*$/i;
+  UNCHECKED_BOX_RE = /^[ \t]*[-*+][ \t]+\[[ \t]\]/;
+});
+
 // src/plugins/builtin/auto-pr/pr-body.ts
 function buildTitle(ctx) {
   return `feat: ${ctx.feature}`;
@@ -65871,7 +66381,6 @@ function buildSummaryLines(ctx) {
   const failed = `${storySummary.failed} failed`;
   const skipped = `${storySummary.skipped} skipped`;
   return [
-    "## Run summary",
     `- Feature: ${ctx.feature}`,
     `- Stories: ${passed} / ${failed} / ${skipped}`,
     `- Duration: ${formatDuration3(ctx.totalDurationMs)}`,
@@ -65895,26 +66404,30 @@ function buildStoryTable(stories) {
   lines.push("");
   return lines;
 }
-function buildBody2(ctx, template) {
-  const blocks = [];
-  blocks.push("> Auto-opened by nax \u2014 review pending. Run nax-finish before merge.");
-  blocks.push("");
-  blocks.push(...buildSummaryLines(ctx));
-  blocks.push(...buildStoryTable(ctx.stories));
-  if (template !== null) {
-    blocks.push("---");
-    blocks.push(template);
-  }
-  return blocks.join(`
-`);
+function buildBody2(ctx, template, opts = {}) {
+  const sections2 = [
+    {
+      key: "stories",
+      heading: "Run summary",
+      body: [...buildSummaryLines(ctx), ...buildStoryTable(ctx.stories)].join(`
+`).trim()
+    }
+  ];
+  const merged = mergeTemplate(template, sections2, opts);
+  return merged.length > 0 ? `${REVIEW_PENDING_BANNER}
+
+${merged}` : REVIEW_PENDING_BANNER;
 }
-var SECONDS_PER_MINUTE = 60, MS_PER_SECOND = 1000;
+var SECONDS_PER_MINUTE = 60, MS_PER_SECOND = 1000, REVIEW_PENDING_BANNER = "> Auto-opened by nax \u2014 review pending. Run nax-finish before merge.";
+var init_pr_body = __esm(() => {
+  init_pr_template_merge();
+});
 
 // src/plugins/builtin/auto-pr/template.ts
-import * as path16 from "path";
+import * as path17 from "path";
 async function firstExisting(workdir, deps, paths) {
   for (const relPath of paths) {
-    const content = await deps.readText(path16.join(workdir, relPath));
+    const content = await deps.readText(path17.join(workdir, relPath));
     if (content !== null) {
       return content;
     }
@@ -65941,7 +66454,7 @@ var init_template = __esm(() => {
 });
 
 // src/plugins/builtin/auto-pr/index.ts
-import * as path17 from "path";
+import * as path18 from "path";
 async function defaultRun(cmd, opts) {
   const proc = Bun.spawn(cmd, { cwd: opts.cwd, stdout: "pipe", stderr: "pipe" });
   const [exitCode, stdout, stderr] = await Promise.all([
@@ -65951,8 +66464,8 @@ async function defaultRun(cmd, opts) {
   ]);
   return { exitCode, stdout, stderr };
 }
-async function defaultReadText(path18) {
-  const file3 = Bun.file(path18);
+async function defaultReadText(path19) {
+  const file3 = Bun.file(path19);
   if (!await file3.exists())
     return null;
   return file3.text();
@@ -65982,8 +66495,8 @@ function getStorySummary(context) {
 function relativePrdPath(workdir, prdPath) {
   if (!prdPath)
     return prdPath;
-  const rel = path17.relative(workdir, prdPath);
-  return rel && !rel.startsWith("..") && !path17.isAbsolute(rel) ? rel : prdPath;
+  const rel = path18.relative(workdir, prdPath);
+  return rel && !rel.startsWith("..") && !path18.isAbsolute(rel) ? rel : prdPath;
 }
 function toPrBodyContext(context) {
   const summary = getStorySummary(context);
@@ -66002,6 +66515,7 @@ function toPrBodyContext(context) {
 var PLUGIN_NAME = "nax-auto-pr", PLUGIN_VERSION = "0.1.0", GIT_REMOTE_CMD, _autoPrDeps, autoPrAction, autoPrPlugin;
 var init_auto_pr = __esm(() => {
   init_forge();
+  init_pr_body();
   init_template();
   GIT_REMOTE_CMD = ["git", "remote", "get-url", "origin"];
   _autoPrDeps = {
@@ -66213,7 +66727,7 @@ var init_auto_route = __esm(() => {
 });
 
 // src/plugins/builtin/curator/collect.ts
-import * as path18 from "path";
+import * as path19 from "path";
 function now() {
   return new Date().toISOString();
 }
@@ -66263,7 +66777,7 @@ function tokenCount(story) {
 }
 async function collectFromMetrics(context) {
   const observations = [];
-  const metricsPath = path18.join(context.outputDir, "metrics.json");
+  const metricsPath = path19.join(context.outputDir, "metrics.json");
   try {
     const data = await readJsonFile(metricsPath);
     const runs = Array.isArray(data) ? data : [data];
@@ -66332,11 +66846,11 @@ function findingMessage(finding) {
 }
 async function collectFromReviewAudit(context) {
   const observations = [];
-  const auditDir = path18.join(context.outputDir, "review-audit");
+  const auditDir = path19.join(context.outputDir, "review-audit");
   try {
     const glob = new Bun.Glob("**/*.json");
     for await (const file3 of glob.scan({ cwd: auditDir, absolute: false })) {
-      const fullPath = path18.join(auditDir, file3);
+      const fullPath = path19.join(auditDir, file3);
       try {
         const audit = asRecord3(await readJsonFile(fullPath));
         if (!audit)
@@ -66382,12 +66896,12 @@ async function collectFromReviewAudit(context) {
 }
 async function collectFromContextManifests(context) {
   const observations = [];
-  const featuresDir = path18.join(context.workdir, ".nax", "features");
+  const featuresDir = path19.join(context.workdir, ".nax", "features");
   let skippedManifests = 0;
   try {
     const glob = new Bun.Glob("*/stories/*/context-manifest-*.json");
     for await (const file3 of glob.scan({ cwd: featuresDir, absolute: false })) {
-      const fullPath = path18.join(featuresDir, file3);
+      const fullPath = path19.join(featuresDir, file3);
       try {
         const parts = file3.split("/");
         const featureId = parts[0] ?? context.feature;
@@ -66991,10 +67505,10 @@ async function* streamJsonlLines(file3) {
 
 // src/plugins/builtin/curator/rollup.ts
 import { appendFile as appendFile3, mkdir as mkdir9, writeFile } from "fs/promises";
-import * as path19 from "path";
+import * as path20 from "path";
 async function appendToRollup(observations, rollupPath) {
   try {
-    const dir = path19.dirname(rollupPath);
+    const dir = path20.dirname(rollupPath);
     await mkdir9(dir, { recursive: true });
     if (observations.length === 0) {
       const f = Bun.file(rollupPath);
@@ -67078,7 +67592,7 @@ var init_rollup = __esm(() => {
 
 // src/plugins/builtin/curator/index.ts
 import { mkdir as mkdir10 } from "fs/promises";
-import * as path20 from "path";
+import * as path21 from "path";
 function getCuratorEnabled(context) {
   const cfg = context.config;
   if (!cfg)
@@ -67152,7 +67666,7 @@ var init_curator = __esm(() => {
         const observations = await collectObservations(curatorContext);
         if (context.outputDir) {
           const { observationsPath, rollupPath } = resolveCuratorOutputs(curatorContext);
-          const runDir = path20.dirname(observationsPath);
+          const runDir = path21.dirname(observationsPath);
           await mkdir10(runDir, { recursive: true });
           await Bun.write(observationsPath, observations.map((o) => JSON.stringify(o)).join(`
 `) + (observations.length > 0 ? `
@@ -67171,7 +67685,7 @@ var init_curator = __esm(() => {
           }
           const proposals = runHeuristics(window2.observations.length > 0 ? window2.observations : observations, thresholds);
           const markdown = renderProposals(proposals, context.runId, observations.length);
-          const proposalsMdPath = path20.join(runDir, "curator-proposals.md");
+          const proposalsMdPath = path21.join(runDir, "curator-proposals.md");
           await Bun.write(proposalsMdPath, markdown);
         }
         return {
@@ -67221,6 +67735,10 @@ function getFinishAutoFlowConfig(ctx) {
     defaultAgent: resolveFlowAgent(ctx.config, autoFlow.defaultAgent),
     model: autoFlow.model ?? null,
     narrative: autoFlow.narrative !== false,
+    prBody: {
+      template: autoFlow.prBody?.template ?? defaults.prBody.template,
+      sectionMap: autoFlow.prBody?.sectionMap ?? defaults.prBody.sectionMap
+    },
     reviewers: {
       spec: autoFlow.reviewers?.spec ?? null,
       quality: autoFlow.reviewers?.quality ?? null,
@@ -67252,6 +67770,7 @@ var init_config2 = __esm(() => {
     flowPath: "flows/nax-finish/nax-finish.flow.ts",
     model: null,
     narrative: true,
+    prBody: { template: "merge", sectionMap: {} },
     reviewers: { spec: null, quality: null, narrative: null },
     escalate: { telegram: true },
     notify: { mode: "escalation" },
@@ -67321,7 +67840,7 @@ var init_telegram2 = __esm(() => {
 });
 
 // src/plugins/builtin/nax-finish/index.ts
-import * as path21 from "path";
+import * as path22 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;
@@ -67347,11 +67866,11 @@ async function defaultRun2(cmd, opts) {
   }
 }
 function finishAuditDir(ctx) {
-  const root = ctx.outputDir ?? path21.join(ctx.workdir, ".nax");
-  return path21.join(root, "finish-audit", ctx.feature);
+  const root = ctx.outputDir ?? path22.join(ctx.workdir, ".nax");
+  return path22.join(root, "finish-audit", ctx.feature);
 }
 function finishResultPath(ctx, runId) {
-  return path21.join(finishAuditDir(ctx), `${runId}.result.json`);
+  return path22.join(finishAuditDir(ctx), `${runId}.result.json`);
 }
 async function defaultReadResult(resultPath) {
   const f = Bun.file(resultPath);
@@ -67368,17 +67887,17 @@ function isFeatureBranch(b) {
   return b !== "main" && b !== "master" && b.length > 0;
 }
 async function resolveFlowPath(workdir, flowPath, deps = _naxFinishDeps) {
-  if (path21.isAbsolute(flowPath)) {
+  if (path22.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));
+    dir = path22.dirname(dir);
+    if (await deps.exists(path22.join(dir, "package.json")))
+      candidates.push(path22.resolve(dir, flowPath));
   }
-  candidates.push(path21.resolve(workdir, flowPath));
+  candidates.push(path22.resolve(workdir, flowPath));
   for (const candidate of candidates) {
     if (await deps.exists(candidate))
       return candidate;
@@ -67401,7 +67920,14 @@ function buildFlowArgv(flowPath, inputJson, opts = {}) {
   ];
 }
 function buildFlowEnv(cfg) {
-  const env2 = { ...process.env };
+  const {
+    NAX_FINISH_SPEC_PROFILE: _spec,
+    NAX_FINISH_QUALITY_PROFILE: _quality,
+    NAX_FINISH_NARRATIVE_PROFILE: _narrative,
+    NAX_FINISH_NARRATIVE: _narrativeSwitch,
+    ...rest
+  } = process.env;
+  const env2 = { ...rest };
   if (cfg.reviewers.spec)
     env2.NAX_FINISH_SPEC_PROFILE = cfg.reviewers.spec;
   if (cfg.reviewers.quality)
@@ -67449,7 +67975,8 @@ async function executeFinishFlow(options) {
     auditDir: finishAuditDir(ctx),
     runId: ctx.runId,
     escalateTelegram,
-    timeouts: { acceptanceMs: cfg.timeouts.acceptanceMs, gateMs: cfg.timeouts.gateMs }
+    timeouts: { acceptanceMs: cfg.timeouts.acceptanceMs, gateMs: cfg.timeouts.gateMs },
+    prBody: { template: cfg.prBody.template, sectionMap: cfg.prBody.sectionMap }
   };
   const cmd = buildFlowArgv(flowPath, JSON.stringify(input), {
     defaultAgent: cfg.defaultAgent,
@@ -68939,14 +69466,14 @@ var init_validator = __esm(() => {
 
 // src/plugins/loader.ts
 import * as fs from "fs/promises";
-import * as path22 from "path";
+import * as path23 from "path";
 function getSafeLogger6() {
   return getSafeLogger();
 }
 function extractPluginName(pluginPath) {
-  const basename14 = path22.basename(pluginPath);
+  const basename14 = path23.basename(pluginPath);
   if (basename14 === "index.ts" || basename14 === "index.js" || basename14 === "index.mjs") {
-    return path22.basename(path22.dirname(pluginPath));
+    return path23.basename(path23.dirname(pluginPath));
   }
   return basename14.replace(/\.(ts|js|mjs)$/, "");
 }
@@ -69094,7 +69621,7 @@ async function discoverPlugins(dir, isTestFileFn) {
   try {
     const entries = await fs.readdir(dir, { withFileTypes: true });
     for (const entry of entries) {
-      const fullPath = path22.join(dir, entry.name);
+      const fullPath = path23.join(dir, entry.name);
       if (entry.isFile()) {
         if (isPluginFile(entry.name, isTestFileFn)) {
           discovered.push({ path: fullPath });
@@ -69102,7 +69629,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 = path22.join(fullPath, indexFile);
+          const indexPath = path23.join(fullPath, indexFile);
           try {
             await fs.access(indexPath);
             discovered.push({ path: indexPath });
@@ -69127,13 +69654,13 @@ function isPluginFile(filename, isTestFileFn) {
   return !FALLBACK_TEST_FILE_RE.test(filename);
 }
 function resolveModulePath(modulePath, projectRoot) {
-  if (path22.isAbsolute(modulePath) || !modulePath.startsWith("./") && !modulePath.startsWith("../")) {
+  if (path23.isAbsolute(modulePath) || !modulePath.startsWith("./") && !modulePath.startsWith("../")) {
     return modulePath;
   }
   if (projectRoot) {
-    return path22.resolve(projectRoot, modulePath);
+    return path23.resolve(projectRoot, modulePath);
   }
-  return path22.resolve(modulePath);
+  return path23.resolve(modulePath);
 }
 async function loadAndValidatePlugin(initialModulePath, config2, allowedRoots = [], originalPath) {
   let attemptedPath = initialModulePath;
@@ -70161,7 +70688,7 @@ var init_fix_diagnosis = __esm(() => {
 });
 
 // src/execution/lifecycle/acceptance-helpers.ts
-import path24 from "path";
+import path25 from "path";
 function isStubTestFile(content) {
   return isStubTestContent(content);
 }
@@ -70180,7 +70707,7 @@ function isTestLevelFailure(failedACs, totalACs, semanticVerdicts) {
 async function loadSpecContent(featureDir) {
   if (!featureDir)
     return "";
-  const specPath = path24.join(featureDir, "spec.md");
+  const specPath = path25.join(featureDir, "spec.md");
   const specFile = Bun.file(specPath);
   return await specFile.exists() ? await specFile.text() : "";
 }
@@ -70200,13 +70727,26 @@ async function loadAcceptanceTestContent2(featureDir, testPaths, configuredTestP
   }
   if (!configuredTestPath)
     return [];
-  const resolvedPath = path24.join(featureDir, configuredTestPath);
+  const resolvedPath = path25.join(featureDir, configuredTestPath);
   const testFile = Bun.file(resolvedPath);
   const content = await testFile.exists() ? await testFile.text() : "";
   return [{ content, path: resolvedPath }];
 }
-function buildResult(success2, prd, totalCost2, iterations, storiesCompleted, prdDirty, failedACs, retries) {
-  return { success: success2, prd, totalCost: totalCost2, iterations, storiesCompleted, prdDirty, failedACs, retries };
+function buildResult(success2, prd, totalCost2, iterations, storiesCompleted, prdDirty, failedACs, retries, skippedPackages) {
+  return { success: success2, prd, totalCost: totalCost2, iterations, storiesCompleted, prdDirty, failedACs, retries, skippedPackages };
+}
+function buildFailureResult(prd, totalCost2, iterations, storiesCompleted, failedACs, retries, skippedPackages) {
+  return {
+    success: false,
+    prd,
+    totalCost: totalCost2,
+    iterations,
+    storiesCompleted,
+    prdDirty: false,
+    failedACs,
+    retries,
+    skippedPackages
+  };
 }
 async function regenerateAcceptanceTest(testPath, acceptanceContext) {
   const logger = getSafeLogger();
@@ -70217,7 +70757,7 @@ async function regenerateAcceptanceTest(testPath, acceptanceContext) {
   const { unlink: unlink3 } = await import("fs/promises");
   await unlink3(testPath);
   if (acceptanceContext.featureDir) {
-    const metaPath = path24.join(acceptanceContext.featureDir, "acceptance-meta.json");
+    const metaPath = path25.join(acceptanceContext.featureDir, "acceptance-meta.json");
     try {
       await unlink3(metaPath);
     } catch {}
@@ -70231,7 +70771,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 ? path24.join(acceptanceContext.projectDir, acceptanceContext.story.workdir) : undefined;
+      const packageDir = acceptanceContext.story.workdir && acceptanceContext.projectDir ? path25.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;
@@ -70240,7 +70780,7 @@ async function regenerateAcceptanceTest(testPath, acceptanceContext) {
       for (const file3 of changedFiles) {
         if (totalBytes >= MAX_BYTES)
           break;
-        const filePath = path24.join(workdir, file3);
+        const filePath = path25.join(workdir, file3);
         try {
           const fileContent = await _regenerateDeps.readFile(filePath);
           const remaining = MAX_BYTES - totalBytes;
@@ -70460,6 +71000,15 @@ async function runAcceptanceTestsOnce(ctx, prd, packageFilter) {
   if (result.action !== "fail")
     return { passed: true, failedACs: [], testOutput: "" };
   const failures = acceptanceContext.acceptanceFailures;
+  if (failures?.missingTargets && failures.missingTargets.length > 0) {
+    return {
+      passed: false,
+      failedACs: [],
+      testOutput: failures.testOutput,
+      failedPackages: failures.failedPackages,
+      missingTargets: failures.missingTargets
+    };
+  }
   if (!failures || failures.failedACs.length === 0)
     return { passed: true, failedACs: [], testOutput: "" };
   return {
@@ -70557,10 +71106,11 @@ async function runAcceptanceLoop(ctx) {
       return buildResult(false, prd, totalCost2, iterations, storiesCompleted, prdDirty);
     }
     const failures = acceptanceContext.acceptanceFailures;
+    const skippedPackages = acceptanceResult.skippedPackages ?? failures?.missingTargets;
     if (!failures || failures.failedACs.length === 0) {
       logger?.error("acceptance", "Acceptance tests failed but no specific failures detected");
       await fireHook(ctx.hooks, "on-pause", hookCtx(ctx.feature, { reason: "Acceptance tests failed (no failures detected)", cost: totalCost2 }), ctx.workdir);
-      return buildResult(false, prd, totalCost2, iterations, storiesCompleted, prdDirty);
+      return buildFailureResult(prd, totalCost2, iterations, storiesCompleted, undefined, undefined, skippedPackages);
     }
     acceptanceRetries++;
     logger?.warn("acceptance", `Acceptance retry ${acceptanceRetries}/${maxRetries}`, {
@@ -70573,7 +71123,7 @@ async function runAcceptanceLoop(ctx) {
         reason: `Acceptance validation failed after ${maxRetries} retries: ${failures.failedACs.join(", ")}`,
         cost: totalCost2
       }), ctx.workdir);
-      return buildResult(false, prd, totalCost2, iterations, storiesCompleted, prdDirty, failures.failedACs, acceptanceRetries);
+      return buildFailureResult(prd, totalCost2, iterations, storiesCompleted, failures.failedACs, acceptanceRetries, skippedPackages);
     }
     if (ctx.featureDir) {
       const existingStubPath = await findExistingAcceptanceTestPath({
@@ -70588,7 +71138,7 @@ async function runAcceptanceLoop(ctx) {
             storyId: firstStory?.id,
             stubRegenCount
           });
-          return buildResult(false, prd, totalCost2, iterations, storiesCompleted, prdDirty, failures.failedACs, acceptanceRetries);
+          return buildFailureResult(prd, totalCost2, iterations, storiesCompleted, failures.failedACs, acceptanceRetries, skippedPackages);
         }
         stubRegenCount++;
         logger?.warn("acceptance", "Stub test detected \u2014 full regen", {
@@ -70604,7 +71154,7 @@ async function runAcceptanceLoop(ctx) {
     const totalACs = prd.userStories.filter((s) => !s.id.startsWith("US-FIX-")).flatMap((s) => s.acceptanceCriteria).length;
     if (!ctx.runtime) {
       logger?.error("acceptance", "Runtime not found for diagnosis", { storyId: firstStory?.id });
-      return buildResult(false, prd, totalCost2, iterations, storiesCompleted, prdDirty, failures.failedACs, acceptanceRetries);
+      return buildFailureResult(prd, totalCost2, iterations, storiesCompleted, failures.failedACs, acceptanceRetries, skippedPackages);
     }
     const failedPkgs = failures.failedPackages && failures.failedPackages.length > 0 ? failures.failedPackages : [{ testPath: "", packageDir: ctx.workdir, output: failures.testOutput, failedACs: failures.failedACs }];
     const strategy = ctx.config.acceptance.fix?.strategy ?? "diagnose-first";
@@ -70647,7 +71197,7 @@ async function runAcceptanceLoop(ctx) {
     const finalCheck = await runAcceptanceTestsOnce(attemptCtx, prd);
     const success2 = finalCheck.passed && remainingFindings.length === 0;
     const failureMessages = !success2 ? finalCheck.failedACs.length > 0 ? finalCheck.failedACs : remainingFindings.length > 0 ? remainingFindings.map((f) => f.message) : ["acceptance validation failed (unknown cause)"] : undefined;
-    return buildResult(success2, prd, totalCost2, iterations, storiesCompleted, prdDirty, failureMessages, acceptanceRetries + totalInternalIterations);
+    return buildResult(success2, prd, totalCost2, iterations, storiesCompleted, prdDirty, failureMessages, acceptanceRetries + totalInternalIterations, finalCheck.missingTargets);
   }
   return buildResult(false, prd, totalCost2, iterations, storiesCompleted, prdDirty);
 }
@@ -70724,9 +71274,9 @@ var init_scratch_purge = __esm(() => {
         return [];
       }
     },
-    fileExists: (path25) => Bun.file(path25).exists(),
-    readFile: (path25) => Bun.file(path25).text(),
-    remove: (path25) => rm(path25, { recursive: true, force: true }),
+    fileExists: (path26) => Bun.file(path26).exists(),
+    readFile: (path26) => Bun.file(path26).text(),
+    remove: (path26) => rm(path26, { recursive: true, force: true }),
     move: async (src, dest) => {
       await mkdir12(dirname15(dest), { recursive: true });
       await rename(src, dest);
@@ -71616,7 +72166,7 @@ var init_headless_formatter = __esm(() => {
 });
 
 // src/execution/runner-completion.ts
-import path25 from "path";
+import path26 from "path";
 async function runCompletionPhase(options) {
   const logger = getSafeLogger();
   logger?.debug("execution", "Completion phase started", {
@@ -71637,11 +72187,11 @@ async function runCompletionPhase(options) {
       const acceptanceStartTime = Date.now();
       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 = path25.relative(options.workdir, g.packageDir);
+        const relativeWorkdir = path26.relative(options.workdir, g.packageDir);
         let groupConfig = options.config;
         if (relativeWorkdir && relativeWorkdir !== ".") {
           try {
-            groupConfig = await _runnerCompletionDeps.loadConfigForWorkdir(path25.join(options.workdir, ".nax", "config.json"), relativeWorkdir);
+            groupConfig = await _runnerCompletionDeps.loadConfigForWorkdir(path26.join(options.workdir, ".nax", "config.json"), relativeWorkdir);
           } catch (error48) {
             logger?.warn("execution", "Falling back to root config for package acceptance settings", {
               packageDir: g.packageDir,
@@ -71654,7 +72204,9 @@ async function runCompletionPhase(options) {
           testPath: g.testPath,
           packageDir: g.packageDir,
           testFramework: groupConfig.project?.testFramework,
-          commandOverride: groupConfig.acceptance.command
+          commandOverride: groupConfig.acceptance.command,
+          storyCount: g.stories.length,
+          acceptanceEnabled: groupConfig.acceptance.enabled
         };
       })) : undefined;
       let acceptanceResult;
@@ -71679,7 +72231,8 @@ async function runCompletionPhase(options) {
           sessionManager: options.sessionManager,
           runtime: options.runtime,
           abortSignal: options.abortSignal,
-          acceptanceTestPaths
+          acceptanceTestPaths,
+          skippedPackages: postRunStatus?.acceptance?.skippedPackages
         });
       } catch (err) {
         pipelineEventBus.emit({
@@ -71693,7 +72246,11 @@ async function runCompletionPhase(options) {
       const lastRunAt = new Date().toISOString();
       const acceptanceDurationMs = Date.now() - acceptanceStartTime;
       if (acceptanceResult.success) {
-        options.statusWriter.setPostRunPhase("acceptance", { status: "passed", lastRunAt });
+        options.statusWriter.setPostRunPhase("acceptance", {
+          status: "passed",
+          lastRunAt,
+          skippedPackages: undefined
+        });
         pipelineEventBus.emit({
           type: "postrun:phase:completed",
           phase: "acceptance",
@@ -71707,12 +72264,14 @@ async function runCompletionPhase(options) {
         });
       } else {
         acceptancePassed = false;
-        options.statusWriter.setPostRunPhase("acceptance", {
+        const failureUpdate = {
           status: "failed",
           failedACs: acceptanceResult.failedACs ?? [],
           retries: acceptanceResult.retries ?? 0,
-          lastRunAt
-        });
+          lastRunAt,
+          skippedPackages: acceptanceResult.skippedPackages && acceptanceResult.skippedPackages.length > 0 ? acceptanceResult.skippedPackages : undefined
+        };
+        options.statusWriter.setPostRunPhase("acceptance", failureUpdate);
         pipelineEventBus.emit({
           type: "postrun:phase:completed",
           phase: "acceptance",
@@ -71913,7 +72472,7 @@ function precomputeBatchPlan(stories, maxBatchSize = DEFAULT_MAX_BATCH_SIZE2) {
 var DEFAULT_MAX_BATCH_SIZE2 = 4;
 
 // src/execution/ensure-package-dirs.ts
-import path26 from "path";
+import path27 from "path";
 async function ensureStoryPackageDirs(prd, workdir, deps = _ensurePackageDirsDeps) {
   const logger = getSafeLogger();
   const relToStoryId = new Map;
@@ -71926,8 +72485,8 @@ async function ensureStoryPackageDirs(prd, workdir, deps = _ensurePackageDirsDep
   }
   const created = [];
   for (const [rel, storyId] of relToStoryId) {
-    const abs = path26.resolve(workdir, rel);
-    const rootWithSep = workdir.endsWith(path26.sep) ? workdir : workdir + path26.sep;
+    const abs = path27.resolve(workdir, rel);
+    const rootWithSep = workdir.endsWith(path27.sep) ? workdir : workdir + path27.sep;
     if (abs !== workdir && !abs.startsWith(rootWithSep)) {
       logger?.warn("execution", "Skipping story workdir outside repo root", {
         storyId,
@@ -72961,9 +73520,9 @@ var _quoteIntegrityDeps, CONTEXT_LINES = 3;
 var init_quote_integrity = __esm(() => {
   init_logger2();
   _quoteIntegrityDeps = {
-    readFile: async (path27) => {
+    readFile: async (path28) => {
       try {
-        return await Bun.file(path27).text();
+        return await Bun.file(path28).text();
       } catch {
         return null;
       }
@@ -73252,7 +73811,7 @@ var exports_merge_conflict_rectify = {};
 __export(exports_merge_conflict_rectify, {
   rectifyConflictedStory: () => rectifyConflictedStory
 });
-import path27 from "path";
+import path28 from "path";
 async function closeStaleAcpSession(worktreePath, sessionName) {
   const logger = getSafeLogger();
   try {
@@ -73279,7 +73838,7 @@ async function rectifyConflictedStory(options) {
       await worktreeManager.remove(workdir, storyId);
     } catch {}
     await worktreeManager.create(workdir, storyId);
-    const worktreePath = path27.join(workdir, ".nax-wt", storyId);
+    const worktreePath = path28.join(workdir, ".nax-wt", storyId);
     const { formatSessionName: formatSessionName2 } = await Promise.resolve().then(() => (init_naming(), exports_naming));
     const staleSessionName = formatSessionName2({
       workdir: worktreePath,
@@ -73979,7 +74538,7 @@ __export(exports_parallel_batch, {
   runParallelBatch: () => runParallelBatch,
   _parallelBatchDeps: () => _parallelBatchDeps
 });
-import path28 from "path";
+import path29 from "path";
 async function runParallelBatch(options) {
   const { stories, ctx, prd } = options;
   const { workdir, config: config2, maxConcurrency, pipelineContext, eventEmitter, agentGetFn, hooks, pluginRegistry } = ctx;
@@ -73998,9 +74557,9 @@ async function runParallelBatch(options) {
       });
       throw error48;
     }
-    worktreePaths.set(story.id, path28.join(workdir, ".nax-wt", story.id));
+    worktreePaths.set(story.id, path29.join(workdir, ".nax-wt", story.id));
   }
-  const rootConfigPath = path28.join(workdir, ".nax", "config.json");
+  const rootConfigPath = path29.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) => {
@@ -74847,7 +75406,7 @@ import { resolve as resolve21 } from "path";
 function countProgress(prd) {
   const stories = prd.userStories;
   const passed = stories.filter((s) => s.status === "passed").length;
-  const failed = stories.filter((s) => s.status === "failed").length;
+  const failed = stories.filter((s) => s.status === "failed" || s.status === "regression-failed").length;
   const paused = stories.filter((s) => s.status === "paused").length;
   const blocked = stories.filter((s) => s.status === "blocked").length;
   const total = stories.length;
@@ -75054,7 +75613,7 @@ __export(exports_migrate, {
 });
 import { existsSync as existsSync36 } from "fs";
 import { mkdir as mkdir16, readdir as readdir5, rename as rename3 } from "fs/promises";
-import path29 from "path";
+import path30 from "path";
 async function detectGeneratedContent(naxDir) {
   if (!existsSync36(naxDir))
     return [];
@@ -75067,17 +75626,17 @@ async function detectGeneratedContent(naxDir) {
   }
   for (const entry of entries) {
     if (GENERATED_NAMES.has(entry)) {
-      candidates.push({ name: entry, srcPath: path29.join(naxDir, entry) });
+      candidates.push({ name: entry, srcPath: path30.join(naxDir, entry) });
     }
   }
-  const featuresDir = path29.join(naxDir, "features");
+  const featuresDir = path30.join(naxDir, "features");
   if (existsSync36(featuresDir)) {
     let featureDirs = [];
     try {
       featureDirs = await readdir5(featuresDir);
     } catch {}
     for (const fid of featureDirs) {
-      const featureDir = path29.join(featuresDir, fid);
+      const featureDir = path30.join(featuresDir, fid);
       let subEntries = [];
       try {
         subEntries = await readdir5(featureDir);
@@ -75087,12 +75646,12 @@ async function detectGeneratedContent(naxDir) {
       for (const sub of subEntries) {
         if (GENERATED_FEATURE_SUBNAMES.has(sub)) {
           candidates.push({
-            name: path29.join("features", fid, sub),
-            srcPath: path29.join(featureDir, sub)
+            name: path30.join("features", fid, sub),
+            srcPath: path30.join(featureDir, sub)
           });
         }
         if (sub === "stories") {
-          const storiesDir = path29.join(featureDir, "stories");
+          const storiesDir = path30.join(featureDir, "stories");
           let storyDirs = [];
           try {
             storyDirs = await readdir5(storiesDir);
@@ -75100,7 +75659,7 @@ async function detectGeneratedContent(naxDir) {
             continue;
           }
           for (const sid of storyDirs) {
-            const storyDir = path29.join(storiesDir, sid);
+            const storyDir = path30.join(storiesDir, sid);
             let storyEntries = [];
             try {
               storyEntries = await readdir5(storyDir);
@@ -75110,8 +75669,8 @@ async function detectGeneratedContent(naxDir) {
             for (const se of storyEntries) {
               if (se.startsWith("context-manifest-") && se.endsWith(".json")) {
                 candidates.push({
-                  name: path29.join("features", fid, "stories", sid, se),
-                  srcPath: path29.join(storyDir, se)
+                  name: path30.join("features", fid, "stories", sid, se),
+                  srcPath: path30.join(storyDir, se)
                 });
               }
             }
@@ -75132,15 +75691,15 @@ async function migrateCommand(options) {
         name: options.reclaim
       });
     }
-    const src = path29.join(globalConfigDir(), options.reclaim);
+    const src = path30.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 = path29.join(globalConfigDir(), "_archive");
-    const archiveDest = path29.join(archiveBase, `${options.reclaim}-${Date.now()}`);
+    const archiveBase = path30.join(globalConfigDir(), "_archive");
+    const archiveDest = path30.join(archiveBase, `${options.reclaim}-${Date.now()}`);
     await mkdir16(archiveBase, { recursive: true });
     await rename3(src, archiveDest);
     logger.info("migrate", `Reclaimed: archived to ${archiveDest}`, { storyId: "_migrate" });
@@ -75177,8 +75736,8 @@ async function migrateCommand(options) {
     logger.info("migrate", `Merged: identity for "${options.merge}" updated`, { storyId: "_migrate" });
     return;
   }
-  const naxDir = path29.join(options.workdir, ".nax");
-  const configPath = path29.join(naxDir, "config.json");
+  const naxDir = path30.join(options.workdir, ".nax");
+  const configPath = path30.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",
@@ -75194,7 +75753,7 @@ async function migrateCommand(options) {
       cause: e
     });
   }
-  const projectKey = config2.name?.trim() || path29.basename(options.workdir);
+  const projectKey = config2.name?.trim() || path30.basename(options.workdir);
   const destBase = projectOutputDir(projectKey, config2.outputDir);
   const candidates = await detectGeneratedContent(naxDir);
   if (candidates.length === 0) {
@@ -75203,7 +75762,7 @@ async function migrateCommand(options) {
   }
   if (options.dryRun) {
     for (const c of candidates) {
-      logger.info("migrate", `[dry-run] Would move: ${c.srcPath} -> ${path29.join(destBase, c.name)}`, {
+      logger.info("migrate", `[dry-run] Would move: ${c.srcPath} -> ${path30.join(destBase, c.name)}`, {
         storyId: "_migrate"
       });
     }
@@ -75212,8 +75771,8 @@ async function migrateCommand(options) {
   await mkdir16(destBase, { recursive: true });
   let moved = 0;
   for (const candidate of candidates) {
-    const dest = path29.join(destBase, candidate.name);
-    await mkdir16(path29.dirname(dest), { recursive: true });
+    const dest = path30.join(destBase, candidate.name);
+    await mkdir16(path30.dirname(dest), { recursive: true });
     if (existsSync36(dest)) {
       throw new NaxError(`Migration conflict: destination already exists.
   Source:      ${candidate.srcPath}
@@ -75243,7 +75802,7 @@ async function migrateCommand(options) {
     moved++;
     logger.info("migrate", `Moved: ${candidate.name}`, { storyId: "_migrate" });
   }
-  await Bun.write(path29.join(destBase, ".migrated-from"), JSON.stringify({ from: options.workdir, migratedAt: new Date().toISOString() }, null, 2));
+  await Bun.write(path30.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
@@ -75360,7 +75919,7 @@ __export(exports_precheck_runner, {
   runPrecheckValidation: () => runPrecheckValidation
 });
 import { mkdirSync as mkdirSync7 } from "fs";
-import path30 from "path";
+import path31 from "path";
 async function runPrecheckValidation(ctx) {
   const logger = getSafeLogger();
   if (process.env.NAX_PRECHECK !== "1") {
@@ -75375,7 +75934,7 @@ async function runPrecheckValidation(ctx) {
     silent: true
   });
   if (ctx.logFilePath) {
-    mkdirSync7(path30.dirname(ctx.logFilePath), { recursive: true });
+    mkdirSync7(path31.dirname(ctx.logFilePath), { recursive: true });
     const precheckLog = {
       type: "precheck",
       timestamp: new Date().toISOString(),
@@ -75688,7 +76247,7 @@ __export(exports_run_setup, {
   setupRun: () => setupRun,
   _runSetupDeps: () => _runSetupDeps
 });
-import path31 from "path";
+import path32 from "path";
 function warnProfileMismatch(prd, config2, logger) {
   const profiles = config2.routing?.agents?.profiles ?? [];
   const profileIds = new Set(profiles.map((p) => p.id));
@@ -75809,7 +76368,7 @@ async function setupRun(options) {
   statusWriter.setPrd(prd);
   {
     const { detectGeneratedContent: detectGeneratedContent2, migrateCommand: migrateCommand2 } = await Promise.resolve().then(() => (init_migrate(), exports_migrate));
-    const naxDir = path31.join(workdir, ".nax");
+    const naxDir = path32.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", {
@@ -75836,7 +76395,7 @@ async function setupRun(options) {
         remoteUrl = new TextDecoder().decode(gitResult.stdout).trim() || null;
       }
     } catch {}
-    const projectKey = config2.name?.trim() || path31.basename(workdir);
+    const projectKey = config2.name?.trim() || path32.basename(workdir);
     await claimProjectIdentity2(projectKey, workdir, remoteUrl).catch((err) => {
       if (err instanceof NaxError && err.code === "RUN_NAME_COLLISION") {
         throw err;
@@ -75891,8 +76450,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 = path31.join(globalConfigDir(), "plugins");
-    const projectPluginsDir = path31.join(workdir, ".nax", "plugins");
+    const globalPluginsDir = path32.join(globalConfigDir(), "plugins");
+    const projectPluginsDir = path32.join(workdir, ".nax", "plugins");
     const configPlugins = config2.plugins || [];
     const resolvedPatterns = await resolveTestFilePatterns(config2, workdir);
     const isTestFileFn = (filename) => resolvedPatterns.regex.some((re) => re.test(filename));
@@ -76417,6 +76976,7 @@ var init_lifecycle = __esm(() => {
 var exports_execution = {};
 __export(exports_execution, {
   writeExitSummary: () => writeExitSummary,
+  withNoProgressBail: () => withNoProgressBail,
   withIncreasingFailuresBail: () => withIncreasingFailuresBail,
   toReviewDecisionPayload: () => toReviewDecisionPayload,
   synthesizeBackfillMetric: () => synthesizeBackfillMetric,
@@ -76496,6 +77056,7 @@ __export(exports_execution, {
   _pidRegistryDeps: () => _pidRegistryDeps,
   _newPackageSetupDeps: () => _newPackageSetupDeps,
   StoryOrchestratorBuilder: () => StoryOrchestratorBuilder,
+  StatusWriter: () => StatusWriter,
   STRICT_VERDICT_PHASE_NAMES: () => STRICT_VERDICT_PHASE_NAMES,
   PidRegistry: () => PidRegistry,
   PHASE_KIND_TO_STATE_KEY: () => PHASE_KIND_TO_STATE_KEY,
@@ -76511,6 +77072,7 @@ var init_execution2 = __esm(() => {
   init_iteration_runner();
   init_escalation();
   init_queue_handler();
+  init_status_writer();
   init_ensure_package_dirs();
   init_new_package_setup();
   init_helpers();
@@ -77813,11 +78375,11 @@ var require_react_reconciler_development = __commonJS((exports, module) => {
         fiber = fiber.next, id--;
       return fiber;
     }
-    function copyWithSetImpl(obj, path32, index, value) {
-      if (index >= path32.length)
+    function copyWithSetImpl(obj, path33, index, value) {
+      if (index >= path33.length)
         return value;
-      var key = path32[index], updated = isArrayImpl(obj) ? obj.slice() : assign2({}, obj);
-      updated[key] = copyWithSetImpl(obj[key], path32, index + 1, value);
+      var key = path33[index], updated = isArrayImpl(obj) ? obj.slice() : assign2({}, obj);
+      updated[key] = copyWithSetImpl(obj[key], path33, index + 1, value);
       return updated;
     }
     function copyWithRename(obj, oldPath, newPath) {
@@ -77837,11 +78399,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, path32, index) {
-      var key = path32[index], updated = isArrayImpl(obj) ? obj.slice() : assign2({}, obj);
-      if (index + 1 === path32.length)
+    function copyWithDeleteImpl(obj, path33, index) {
+      var key = path33[index], updated = isArrayImpl(obj) ? obj.slice() : assign2({}, obj);
+      if (index + 1 === path33.length)
         return isArrayImpl(updated) ? updated.splice(key, 1) : delete updated[key], updated;
-      updated[key] = copyWithDeleteImpl(obj[key], path32, index + 1);
+      updated[key] = copyWithDeleteImpl(obj[key], path33, index + 1);
       return updated;
     }
     function shouldSuspendImpl() {
@@ -87864,29 +88426,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, path32, value) {
+    overrideHookState = function(fiber, id, path33, value) {
       id = findHook(fiber, id);
-      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));
+      id !== null && (path33 = copyWithSetImpl(id.memoizedState, path33, 0, value), id.memoizedState = path33, id.baseState = path33, fiber.memoizedProps = assign2({}, fiber.memoizedProps), path33 = enqueueConcurrentRenderForLane(fiber, 2), path33 !== null && scheduleUpdateOnFiber(path33, fiber, 2));
     };
-    overrideHookStateDeletePath = function(fiber, id, path32) {
+    overrideHookStateDeletePath = function(fiber, id, path33) {
       id = findHook(fiber, id);
-      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));
+      id !== null && (path33 = copyWithDeleteImpl(id.memoizedState, path33, 0), id.memoizedState = path33, id.baseState = path33, fiber.memoizedProps = assign2({}, fiber.memoizedProps), path33 = enqueueConcurrentRenderForLane(fiber, 2), path33 !== null && scheduleUpdateOnFiber(path33, 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, path32, value) {
-      fiber.pendingProps = copyWithSetImpl(fiber.memoizedProps, path32, 0, value);
+    overrideProps = function(fiber, path33, value) {
+      fiber.pendingProps = copyWithSetImpl(fiber.memoizedProps, path33, 0, value);
       fiber.alternate && (fiber.alternate.pendingProps = fiber.pendingProps);
-      path32 = enqueueConcurrentRenderForLane(fiber, 2);
-      path32 !== null && scheduleUpdateOnFiber(path32, fiber, 2);
+      path33 = enqueueConcurrentRenderForLane(fiber, 2);
+      path33 !== null && scheduleUpdateOnFiber(path33, fiber, 2);
     };
-    overridePropsDeletePath = function(fiber, path32) {
-      fiber.pendingProps = copyWithDeleteImpl(fiber.memoizedProps, path32, 0);
+    overridePropsDeletePath = function(fiber, path33) {
+      fiber.pendingProps = copyWithDeleteImpl(fiber.memoizedProps, path33, 0);
       fiber.alternate && (fiber.alternate.pendingProps = fiber.pendingProps);
-      path32 = enqueueConcurrentRenderForLane(fiber, 2);
-      path32 !== null && scheduleUpdateOnFiber(path32, fiber, 2);
+      path33 = enqueueConcurrentRenderForLane(fiber, 2);
+      path33 !== null && scheduleUpdateOnFiber(path33, fiber, 2);
     };
     overridePropsRenamePath = function(fiber, oldPath, newPath) {
       fiber.pendingProps = copyWithRename(fiber.memoizedProps, oldPath, newPath);
@@ -91941,8 +92503,8 @@ In order to be iterable, non-array objects must have a [Symbol.iterator]() metho
           }
           return false;
         }
-        function utils_getInObject(object2, path32) {
-          return path32.reduce(function(reduced, attr2) {
+        function utils_getInObject(object2, path33) {
+          return path33.reduce(function(reduced, attr2) {
             if (reduced) {
               if (utils_hasOwnProperty.call(reduced, attr2)) {
                 return reduced[attr2];
@@ -91954,11 +92516,11 @@ In order to be iterable, non-array objects must have a [Symbol.iterator]() metho
             return null;
           }, object2);
         }
-        function deletePathInObject(object2, path32) {
-          var length = path32.length;
-          var last2 = path32[length - 1];
+        function deletePathInObject(object2, path33) {
+          var length = path33.length;
+          var last2 = path33[length - 1];
           if (object2 != null) {
-            var parent = utils_getInObject(object2, path32.slice(0, length - 1));
+            var parent = utils_getInObject(object2, path33.slice(0, length - 1));
             if (parent) {
               if (src_isArray(parent)) {
                 parent.splice(last2, 1);
@@ -91984,11 +92546,11 @@ In order to be iterable, non-array objects must have a [Symbol.iterator]() metho
             }
           }
         }
-        function utils_setInObject(object2, path32, value) {
-          var length = path32.length;
-          var last2 = path32[length - 1];
+        function utils_setInObject(object2, path33, value) {
+          var length = path33.length;
+          var last2 = path33[length - 1];
           if (object2 != null) {
-            var parent = utils_getInObject(object2, path32.slice(0, length - 1));
+            var parent = utils_getInObject(object2, path33.slice(0, length - 1));
             if (parent) {
               parent[last2] = value;
             }
@@ -92519,8 +93081,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, path32) {
-          cleaned.push(path32);
+        function createDehydrated(type, inspectable, data, cleaned, path33) {
+          cleaned.push(path33);
           var dehydrated = {
             inspectable,
             type,
@@ -92538,13 +93100,13 @@ In order to be iterable, non-array objects must have a [Symbol.iterator]() metho
           }
           return dehydrated;
         }
-        function dehydrate(data, cleaned, unserializable, path32, isPathAllowed) {
+        function dehydrate(data, cleaned, unserializable, path33, 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(path32);
+              cleaned.push(path33);
               return {
                 inspectable: false,
                 preview_short: formatDataForPreview(data, false),
@@ -92553,7 +93115,7 @@ In order to be iterable, non-array objects must have a [Symbol.iterator]() metho
                 type
               };
             case "function":
-              cleaned.push(path32);
+              cleaned.push(path33);
               return {
                 inspectable: false,
                 preview_short: formatDataForPreview(data, false),
@@ -92562,14 +93124,14 @@ In order to be iterable, non-array objects must have a [Symbol.iterator]() metho
                 type
               };
             case "string":
-              isPathAllowedCheck = isPathAllowed(path32);
+              isPathAllowedCheck = isPathAllowed(path33);
               if (isPathAllowedCheck) {
                 return data;
               } else {
                 return data.length <= 500 ? data : data.slice(0, 500) + "...";
               }
             case "bigint":
-              cleaned.push(path32);
+              cleaned.push(path33);
               return {
                 inspectable: false,
                 preview_short: formatDataForPreview(data, false),
@@ -92578,7 +93140,7 @@ In order to be iterable, non-array objects must have a [Symbol.iterator]() metho
                 type
               };
             case "symbol":
-              cleaned.push(path32);
+              cleaned.push(path33);
               return {
                 inspectable: false,
                 preview_short: formatDataForPreview(data, false),
@@ -92587,9 +93149,9 @@ In order to be iterable, non-array objects must have a [Symbol.iterator]() metho
                 type
               };
             case "react_element": {
-              isPathAllowedCheck = isPathAllowed(path32);
+              isPathAllowedCheck = isPathAllowed(path33);
               if (level >= LEVEL_THRESHOLD && !isPathAllowedCheck) {
-                cleaned.push(path32);
+                cleaned.push(path33);
                 return {
                   inspectable: true,
                   preview_short: formatDataForPreview(data, false),
@@ -92606,19 +93168,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, path32.concat(["key"]), isPathAllowed, isPathAllowedCheck ? 1 : level + 1);
+              unserializableValue.key = dehydrate(data.key, cleaned, unserializable, path33.concat(["key"]), isPathAllowed, isPathAllowedCheck ? 1 : level + 1);
               if (data.$$typeof === REACT_LEGACY_ELEMENT_TYPE) {
-                unserializableValue.ref = dehydrate(data.ref, cleaned, unserializable, path32.concat(["ref"]), isPathAllowed, isPathAllowedCheck ? 1 : level + 1);
+                unserializableValue.ref = dehydrate(data.ref, cleaned, unserializable, path33.concat(["ref"]), isPathAllowed, isPathAllowedCheck ? 1 : level + 1);
               }
-              unserializableValue.props = dehydrate(data.props, cleaned, unserializable, path32.concat(["props"]), isPathAllowed, isPathAllowedCheck ? 1 : level + 1);
-              unserializable.push(path32);
+              unserializableValue.props = dehydrate(data.props, cleaned, unserializable, path33.concat(["props"]), isPathAllowed, isPathAllowedCheck ? 1 : level + 1);
+              unserializable.push(path33);
               return unserializableValue;
             }
             case "react_lazy": {
-              isPathAllowedCheck = isPathAllowed(path32);
+              isPathAllowedCheck = isPathAllowed(path33);
               var payload = data._payload;
               if (level >= LEVEL_THRESHOLD && !isPathAllowedCheck) {
-                cleaned.push(path32);
+                cleaned.push(path33);
                 var inspectable = payload !== null && hydration_typeof(payload) === "object" && (payload._status === 1 || payload._status === 2 || payload.status === "fulfilled" || payload.status === "rejected");
                 return {
                   inspectable,
@@ -92635,13 +93197,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, path32.concat(["_payload"]), isPathAllowed, isPathAllowedCheck ? 1 : level + 1);
-              unserializable.push(path32);
+              _unserializableValue._payload = dehydrate(payload, cleaned, unserializable, path33.concat(["_payload"]), isPathAllowed, isPathAllowedCheck ? 1 : level + 1);
+              unserializable.push(path33);
               return _unserializableValue;
             }
             case "array_buffer":
             case "data_view":
-              cleaned.push(path32);
+              cleaned.push(path33);
               return {
                 inspectable: false,
                 preview_short: formatDataForPreview(data, false),
@@ -92651,21 +93213,21 @@ In order to be iterable, non-array objects must have a [Symbol.iterator]() metho
                 type
               };
             case "array":
-              isPathAllowedCheck = isPathAllowed(path32);
+              isPathAllowedCheck = isPathAllowed(path33);
               if (level >= LEVEL_THRESHOLD && !isPathAllowedCheck) {
-                return createDehydrated(type, true, data, cleaned, path32);
+                return createDehydrated(type, true, data, cleaned, path33);
               }
               var arr = [];
               for (var i = 0;i < data.length; i++) {
-                arr[i] = dehydrateKey(data, i, cleaned, unserializable, path32.concat([i]), isPathAllowed, isPathAllowedCheck ? 1 : level + 1);
+                arr[i] = dehydrateKey(data, i, cleaned, unserializable, path33.concat([i]), isPathAllowed, isPathAllowedCheck ? 1 : level + 1);
               }
               return arr;
             case "html_all_collection":
             case "typed_array":
             case "iterator":
-              isPathAllowedCheck = isPathAllowed(path32);
+              isPathAllowedCheck = isPathAllowed(path33);
               if (level >= LEVEL_THRESHOLD && !isPathAllowedCheck) {
-                return createDehydrated(type, true, data, cleaned, path32);
+                return createDehydrated(type, true, data, cleaned, path33);
               } else {
                 var _unserializableValue2 = {
                   unserializable: true,
@@ -92677,13 +93239,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, path32.concat([i2]), isPathAllowed, isPathAllowedCheck ? 1 : level + 1);
+                  return _unserializableValue2[i2] = dehydrate(item, cleaned, unserializable, path33.concat([i2]), isPathAllowed, isPathAllowedCheck ? 1 : level + 1);
                 });
-                unserializable.push(path32);
+                unserializable.push(path33);
                 return _unserializableValue2;
               }
             case "opaque_iterator":
-              cleaned.push(path32);
+              cleaned.push(path33);
               return {
                 inspectable: false,
                 preview_short: formatDataForPreview(data, false),
@@ -92692,7 +93254,7 @@ In order to be iterable, non-array objects must have a [Symbol.iterator]() metho
                 type
               };
             case "date":
-              cleaned.push(path32);
+              cleaned.push(path33);
               return {
                 inspectable: false,
                 preview_short: formatDataForPreview(data, false),
@@ -92701,7 +93263,7 @@ In order to be iterable, non-array objects must have a [Symbol.iterator]() metho
                 type
               };
             case "regexp":
-              cleaned.push(path32);
+              cleaned.push(path33);
               return {
                 inspectable: false,
                 preview_short: formatDataForPreview(data, false),
@@ -92710,9 +93272,9 @@ In order to be iterable, non-array objects must have a [Symbol.iterator]() metho
                 type
               };
             case "thenable":
-              isPathAllowedCheck = isPathAllowed(path32);
+              isPathAllowedCheck = isPathAllowed(path33);
               if (level >= LEVEL_THRESHOLD && !isPathAllowedCheck) {
-                cleaned.push(path32);
+                cleaned.push(path33);
                 return {
                   inspectable: data.status === "fulfilled" || data.status === "rejected",
                   preview_short: formatDataForPreview(data, false),
@@ -92733,8 +93295,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, path32.concat(["value"]), isPathAllowed, isPathAllowedCheck ? 1 : level + 1);
-                  unserializable.push(path32);
+                  _unserializableValue3.value = dehydrate(data.value, cleaned, unserializable, path33.concat(["value"]), isPathAllowed, isPathAllowedCheck ? 1 : level + 1);
+                  unserializable.push(path33);
                   return _unserializableValue3;
                 }
                 case "rejected": {
@@ -92745,12 +93307,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, path32.concat(["reason"]), isPathAllowed, isPathAllowedCheck ? 1 : level + 1);
-                  unserializable.push(path32);
+                  _unserializableValue4.reason = dehydrate(data.reason, cleaned, unserializable, path33.concat(["reason"]), isPathAllowed, isPathAllowedCheck ? 1 : level + 1);
+                  unserializable.push(path33);
                   return _unserializableValue4;
                 }
                 default:
-                  cleaned.push(path32);
+                  cleaned.push(path33);
                   return {
                     inspectable: false,
                     preview_short: formatDataForPreview(data, false),
@@ -92760,21 +93322,21 @@ In order to be iterable, non-array objects must have a [Symbol.iterator]() metho
                   };
               }
             case "object":
-              isPathAllowedCheck = isPathAllowed(path32);
+              isPathAllowedCheck = isPathAllowed(path33);
               if (level >= LEVEL_THRESHOLD && !isPathAllowedCheck) {
-                return createDehydrated(type, true, data, cleaned, path32);
+                return createDehydrated(type, true, data, cleaned, path33);
               } else {
                 var object2 = {};
                 getAllEnumerableKeys(data).forEach(function(key) {
                   var name = key.toString();
-                  object2[name] = dehydrateKey(data, key, cleaned, unserializable, path32.concat([name]), isPathAllowed, isPathAllowedCheck ? 1 : level + 1);
+                  object2[name] = dehydrateKey(data, key, cleaned, unserializable, path33.concat([name]), isPathAllowed, isPathAllowedCheck ? 1 : level + 1);
                 });
                 return object2;
               }
             case "class_instance": {
-              isPathAllowedCheck = isPathAllowed(path32);
+              isPathAllowedCheck = isPathAllowed(path33);
               if (level >= LEVEL_THRESHOLD && !isPathAllowedCheck) {
-                return createDehydrated(type, true, data, cleaned, path32);
+                return createDehydrated(type, true, data, cleaned, path33);
               }
               var value = {
                 unserializable: true,
@@ -92786,15 +93348,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, path32.concat([keyAsString]), isPathAllowed, isPathAllowedCheck ? 1 : level + 1);
+                value[keyAsString] = dehydrate(data[key], cleaned, unserializable, path33.concat([keyAsString]), isPathAllowed, isPathAllowedCheck ? 1 : level + 1);
               });
-              unserializable.push(path32);
+              unserializable.push(path33);
               return value;
             }
             case "error": {
-              isPathAllowedCheck = isPathAllowed(path32);
+              isPathAllowedCheck = isPathAllowed(path33);
               if (level >= LEVEL_THRESHOLD && !isPathAllowedCheck) {
-                return createDehydrated(type, true, data, cleaned, path32);
+                return createDehydrated(type, true, data, cleaned, path33);
               }
               var _value = {
                 unserializable: true,
@@ -92804,22 +93366,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, path32.concat(["message"]), isPathAllowed, isPathAllowedCheck ? 1 : level + 1);
-              _value.stack = dehydrate(data.stack, cleaned, unserializable, path32.concat(["stack"]), isPathAllowed, isPathAllowedCheck ? 1 : level + 1);
+              _value.message = dehydrate(data.message, cleaned, unserializable, path33.concat(["message"]), isPathAllowed, isPathAllowedCheck ? 1 : level + 1);
+              _value.stack = dehydrate(data.stack, cleaned, unserializable, path33.concat(["stack"]), isPathAllowed, isPathAllowedCheck ? 1 : level + 1);
               if ("cause" in data) {
-                _value.cause = dehydrate(data.cause, cleaned, unserializable, path32.concat(["cause"]), isPathAllowed, isPathAllowedCheck ? 1 : level + 1);
+                _value.cause = dehydrate(data.cause, cleaned, unserializable, path33.concat(["cause"]), isPathAllowed, isPathAllowedCheck ? 1 : level + 1);
               }
               getAllEnumerableKeys(data).forEach(function(key) {
                 var keyAsString = key.toString();
-                _value[keyAsString] = dehydrate(data[key], cleaned, unserializable, path32.concat([keyAsString]), isPathAllowed, isPathAllowedCheck ? 1 : level + 1);
+                _value[keyAsString] = dehydrate(data[key], cleaned, unserializable, path33.concat([keyAsString]), isPathAllowed, isPathAllowedCheck ? 1 : level + 1);
               });
-              unserializable.push(path32);
+              unserializable.push(path33);
               return _value;
             }
             case "infinity":
             case "nan":
             case "undefined":
-              cleaned.push(path32);
+              cleaned.push(path33);
               return {
                 type
               };
@@ -92827,10 +93389,10 @@ In order to be iterable, non-array objects must have a [Symbol.iterator]() metho
               return data;
           }
         }
-        function dehydrateKey(parent, key, cleaned, unserializable, path32, isPathAllowed) {
+        function dehydrateKey(parent, key, cleaned, unserializable, path33, isPathAllowed) {
           var level = arguments.length > 6 && arguments[6] !== undefined ? arguments[6] : 0;
           try {
-            return dehydrate(parent[key], cleaned, unserializable, path32, isPathAllowed, level);
+            return dehydrate(parent[key], cleaned, unserializable, path33, isPathAllowed, level);
           } catch (error48) {
             var preview = "";
             if (hydration_typeof(error48) === "object" && error48 !== null && typeof error48.stack === "string") {
@@ -92838,7 +93400,7 @@ In order to be iterable, non-array objects must have a [Symbol.iterator]() metho
             } else if (typeof error48 === "string") {
               preview = error48;
             }
-            cleaned.push(path32);
+            cleaned.push(path33);
             return {
               inspectable: false,
               preview_short: "[Exception]",
@@ -92848,8 +93410,8 @@ In order to be iterable, non-array objects must have a [Symbol.iterator]() metho
             };
           }
         }
-        function fillInPath(object2, data, path32, value) {
-          var target = getInObject(object2, path32);
+        function fillInPath(object2, data, path33, value) {
+          var target = getInObject(object2, path33);
           if (target != null) {
             if (!target[meta3.unserializable]) {
               delete target[meta3.inspectable];
@@ -92864,9 +93426,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 === path32.length;
-            for (var i = 0;i < path32.length; i++) {
-              if (path32[i] !== unserializablePath[i]) {
+            var isMatch2 = unserializablePath.length === path33.length;
+            for (var i = 0;i < path33.length; i++) {
+              if (path33[i] !== unserializablePath[i]) {
                 isMatch2 = false;
                 break;
               }
@@ -92875,13 +93437,13 @@ In order to be iterable, non-array objects must have a [Symbol.iterator]() metho
               upgradeUnserializable(value, value);
             }
           }
-          setInObject(object2, path32, value);
+          setInObject(object2, path33, value);
         }
         function hydrate(object2, cleaned, unserializable) {
-          cleaned.forEach(function(path32) {
-            var length = path32.length;
-            var last2 = path32[length - 1];
-            var parent = getInObject(object2, path32.slice(0, length - 1));
+          cleaned.forEach(function(path33) {
+            var length = path33.length;
+            var last2 = path33[length - 1];
+            var parent = getInObject(object2, path33.slice(0, length - 1));
             if (!parent || !parent.hasOwnProperty(last2)) {
               return;
             }
@@ -92907,10 +93469,10 @@ In order to be iterable, non-array objects must have a [Symbol.iterator]() metho
               parent[last2] = replaced;
             }
           });
-          unserializable.forEach(function(path32) {
-            var length = path32.length;
-            var last2 = path32[length - 1];
-            var parent = getInObject(object2, path32.slice(0, length - 1));
+          unserializable.forEach(function(path33) {
+            var length = path33.length;
+            var last2 = path33[length - 1];
+            var parent = getInObject(object2, path33.slice(0, length - 1));
             if (!parent || !parent.hasOwnProperty(last2)) {
               return;
             }
@@ -93031,11 +93593,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 path32 = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : [];
+          var path33 = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : [];
           if (data !== null) {
             var cleanedPaths = [];
             var unserializablePaths = [];
-            var cleanedData = dehydrate(data, cleanedPaths, unserializablePaths, path32, isPathAllowed);
+            var cleanedData = dehydrate(data, cleanedPaths, unserializablePaths, path33, isPathAllowed);
             return {
               data: cleanedData,
               cleaned: cleanedPaths,
@@ -93045,18 +93607,18 @@ In order to be iterable, non-array objects must have a [Symbol.iterator]() metho
             return null;
           }
         }
-        function copyWithDelete(obj, path32) {
+        function copyWithDelete(obj, path33) {
           var index = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : 0;
-          var key = path32[index];
+          var key = path33[index];
           var updated = shared_isArray(obj) ? obj.slice() : utils_objectSpread({}, obj);
-          if (index + 1 === path32.length) {
+          if (index + 1 === path33.length) {
             if (shared_isArray(updated)) {
               updated.splice(key, 1);
             } else {
               delete updated[key];
             }
           } else {
-            updated[key] = copyWithDelete(obj[key], path32, index + 1);
+            updated[key] = copyWithDelete(obj[key], path33, index + 1);
           }
           return updated;
         }
@@ -93077,14 +93639,14 @@ In order to be iterable, non-array objects must have a [Symbol.iterator]() metho
           }
           return updated;
         }
-        function copyWithSet(obj, path32, value) {
+        function copyWithSet(obj, path33, value) {
           var index = arguments.length > 3 && arguments[3] !== undefined ? arguments[3] : 0;
-          if (index >= path32.length) {
+          if (index >= path33.length) {
             return value;
           }
-          var key = path32[index];
+          var key = path33[index];
           var updated = shared_isArray(obj) ? obj.slice() : utils_objectSpread({}, obj);
-          updated[key] = copyWithSet(obj[key], path32, value, index + 1);
+          updated[key] = copyWithSet(obj[key], path33, value, index + 1);
           return updated;
         }
         function getEffectDurations(root) {
@@ -94412,12 +94974,12 @@ In order to be iterable, non-array objects must have a [Symbol.iterator]() metho
               }
             });
             bridge_defineProperty(_this, "overrideValueAtPath", function(_ref) {
-              var { id, path: path32, rendererID, type, value } = _ref;
+              var { id, path: path33, rendererID, type, value } = _ref;
               switch (type) {
                 case "context":
                   _this.send("overrideContext", {
                     id,
-                    path: path32,
+                    path: path33,
                     rendererID,
                     wasForwarded: true,
                     value
@@ -94426,7 +94988,7 @@ In order to be iterable, non-array objects must have a [Symbol.iterator]() metho
                 case "hooks":
                   _this.send("overrideHookState", {
                     id,
-                    path: path32,
+                    path: path33,
                     rendererID,
                     wasForwarded: true,
                     value
@@ -94435,7 +94997,7 @@ In order to be iterable, non-array objects must have a [Symbol.iterator]() metho
                 case "props":
                   _this.send("overrideProps", {
                     id,
-                    path: path32,
+                    path: path33,
                     rendererID,
                     wasForwarded: true,
                     value
@@ -94444,7 +95006,7 @@ In order to be iterable, non-array objects must have a [Symbol.iterator]() metho
                 case "state":
                   _this.send("overrideState", {
                     id,
-                    path: path32,
+                    path: path33,
                     rendererID,
                     wasForwarded: true,
                     value
@@ -94778,12 +95340,12 @@ In order to be iterable, non-array objects must have a [Symbol.iterator]() metho
               }
             });
             agent_defineProperty(_this, "copyElementPath", function(_ref5) {
-              var { id, path: path32, rendererID } = _ref5;
+              var { id, path: path33, 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, path32);
+                var value = renderer.getSerializedElementValueByPath(id, path33);
                 if (value != null) {
                   _this._bridge.send("saveToClipboard", value);
                 } else {
@@ -94792,12 +95354,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: path32, rendererID, type } = _ref6;
+              var { hookID, id, path: path33, 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, path32);
+                renderer.deletePath(type, id, hookID, path33);
               }
             });
             agent_defineProperty(_this, "getBackendVersion", function() {
@@ -94834,12 +95396,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: path32, rendererID, requestID } = _ref9;
+              var { forceFullData, id, path: path33, 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, path32, forceFullData));
+                _this._bridge.send("inspectedElement", renderer.inspectElement(requestID, id, path33, forceFullData));
                 if (_this._persistedSelectionMatch === null || _this._persistedSelectionMatch.id !== id) {
                   _this._persistedSelection = null;
                   _this._persistedSelectionMatch = null;
@@ -94873,15 +95435,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 path32 = null;
+                var path33 = null;
                 if (suspendedByPathIndex !== null && rendererPath !== null) {
                   var suspendedByPathRendererIndex = suspendedByPathIndex - suspendedByOffset;
                   var rendererHasRequestedSuspendedByPath = renderer.getElementAttributeByPath(id, ["suspendedBy", suspendedByPathRendererIndex]) !== undefined;
                   if (rendererHasRequestedSuspendedByPath) {
-                    path32 = ["suspendedBy", suspendedByPathRendererIndex].concat(rendererPath);
+                    path33 = ["suspendedBy", suspendedByPathRendererIndex].concat(rendererPath);
                   }
                 }
-                var inspectedRootsPayload = renderer.inspectElement(requestID, id, path32, forceFullData);
+                var inspectedRootsPayload = renderer.inspectElement(requestID, id, path33, forceFullData);
                 switch (inspectedRootsPayload.type) {
                   case "hydrated-path":
                     inspectedRootsPayload.path[1] += suspendedByOffset;
@@ -94975,20 +95537,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: path32, rendererID, type, value } = _ref15;
+              var { hookID, id, path: path33, 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, path32, value);
+                renderer.overrideValueAtPath(type, id, hookID, path33, value);
               }
             });
             agent_defineProperty(_this, "overrideContext", function(_ref16) {
-              var { id, path: path32, rendererID, wasForwarded, value } = _ref16;
+              var { id, path: path33, rendererID, wasForwarded, value } = _ref16;
               if (!wasForwarded) {
                 _this.overrideValueAtPath({
                   id,
-                  path: path32,
+                  path: path33,
                   rendererID,
                   type: "context",
                   value
@@ -94996,11 +95558,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: path32, rendererID, wasForwarded, value } = _ref17;
+              var { id, hookID, path: path33, rendererID, wasForwarded, value } = _ref17;
               if (!wasForwarded) {
                 _this.overrideValueAtPath({
                   id,
-                  path: path32,
+                  path: path33,
                   rendererID,
                   type: "hooks",
                   value
@@ -95008,11 +95570,11 @@ In order to be iterable, non-array objects must have a [Symbol.iterator]() metho
               }
             });
             agent_defineProperty(_this, "overrideProps", function(_ref18) {
-              var { id, path: path32, rendererID, wasForwarded, value } = _ref18;
+              var { id, path: path33, rendererID, wasForwarded, value } = _ref18;
               if (!wasForwarded) {
                 _this.overrideValueAtPath({
                   id,
-                  path: path32,
+                  path: path33,
                   rendererID,
                   type: "props",
                   value
@@ -95020,11 +95582,11 @@ In order to be iterable, non-array objects must have a [Symbol.iterator]() metho
               }
             });
             agent_defineProperty(_this, "overrideState", function(_ref19) {
-              var { id, path: path32, rendererID, wasForwarded, value } = _ref19;
+              var { id, path: path33, rendererID, wasForwarded, value } = _ref19;
               if (!wasForwarded) {
                 _this.overrideValueAtPath({
                   id,
-                  path: path32,
+                  path: path33,
                   rendererID,
                   type: "state",
                   value
@@ -95091,12 +95653,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: path32, rendererID } = _ref23;
+              var { count, id, path: path33, 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, path32, count);
+                renderer.storeAsGlobal(id, path33, count);
               }
             });
             agent_defineProperty(_this, "updateHookSettings", function(settings) {
@@ -95113,12 +95675,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 path32 = renderer.getPathForElement(_this._lastSelectedElementID);
-                  if (path32 !== null) {
-                    renderer.setTrackedPath(path32);
+                  var path33 = renderer.getPathForElement(_this._lastSelectedElementID);
+                  if (path33 !== null) {
+                    renderer.setTrackedPath(path33);
                     _this._persistedSelection = {
                       rendererID,
-                      path: path32
+                      path: path33
                     };
                   }
                 }
@@ -95193,11 +95755,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 path32 = renderer != null ? renderer.getPathForElement(id) : null;
-              if (path32 !== null) {
+              var path33 = renderer != null ? renderer.getPathForElement(id) : null;
+              if (path33 !== null) {
                 storage_sessionStorageSetItem(SESSION_STORAGE_LAST_SELECTION_KEY, JSON.stringify({
                   rendererID,
-                  path: path32
+                  path: path33
                 }));
               } else {
                 storage_sessionStorageRemoveItem(SESSION_STORAGE_LAST_SELECTION_KEY);
@@ -95920,7 +96482,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, path32) {
+            inspectElement: function inspectElement(requestID, id, path33) {
               return {
                 id,
                 responseID: requestID,
@@ -101190,9 +101752,9 @@ In order to be iterable, non-array objects must have a [Symbol.iterator]() metho
             }
             return null;
           }
-          function getElementAttributeByPath(id, path32) {
+          function getElementAttributeByPath(id, path33) {
             if (isMostRecentlyInspectedElement(id)) {
-              return utils_getInObject(mostRecentlyInspectedElement, path32);
+              return utils_getInObject(mostRecentlyInspectedElement, path33);
             }
             return;
           }
@@ -101895,9 +102457,9 @@ In order to be iterable, non-array objects must have a [Symbol.iterator]() metho
           function isMostRecentlyInspectedElementCurrent(id) {
             return isMostRecentlyInspectedElement(id) && !hasElementUpdatedSinceLastInspected;
           }
-          function mergeInspectedPaths(path32) {
+          function mergeInspectedPaths(path33) {
             var current = currentlyInspectedPaths;
-            path32.forEach(function(key) {
+            path33.forEach(function(key) {
               if (!current[key]) {
                 current[key] = {};
               }
@@ -101905,21 +102467,21 @@ In order to be iterable, non-array objects must have a [Symbol.iterator]() metho
             });
           }
           function createIsPathAllowed(key, secondaryCategory) {
-            return function isPathAllowed(path32) {
+            return function isPathAllowed(path33) {
               switch (secondaryCategory) {
                 case "hooks":
-                  if (path32.length === 1) {
+                  if (path33.length === 1) {
                     return true;
                   }
-                  if (path32[path32.length - 2] === "hookSource" && path32[path32.length - 1] === "fileName") {
+                  if (path33[path33.length - 2] === "hookSource" && path33[path33.length - 1] === "fileName") {
                     return true;
                   }
-                  if (path32[path32.length - 1] === "subHooks" || path32[path32.length - 2] === "subHooks") {
+                  if (path33[path33.length - 1] === "subHooks" || path33[path33.length - 2] === "subHooks") {
                     return true;
                   }
                   break;
                 case "suspendedBy":
-                  if (path32.length < 5) {
+                  if (path33.length < 5) {
                     return true;
                   }
                   break;
@@ -101930,8 +102492,8 @@ In order to be iterable, non-array objects must have a [Symbol.iterator]() metho
               if (!current) {
                 return false;
               }
-              for (var i = 0;i < path32.length; i++) {
-                current = current[path32[i]];
+              for (var i = 0;i < path33.length; i++) {
+                current = current[path33[i]];
                 if (!current) {
                   return false;
                 }
@@ -101985,38 +102547,38 @@ In order to be iterable, non-array objects must have a [Symbol.iterator]() metho
                 break;
             }
           }
-          function storeAsGlobal(id, path32, count) {
+          function storeAsGlobal(id, path33, count) {
             if (isMostRecentlyInspectedElement(id)) {
-              var value = utils_getInObject(mostRecentlyInspectedElement, path32);
+              var value = utils_getInObject(mostRecentlyInspectedElement, path33);
               var key = "$reactTemp".concat(count);
               window[key] = value;
               console.log(key);
               console.log(value);
             }
           }
-          function getSerializedElementValueByPath(id, path32) {
+          function getSerializedElementValueByPath(id, path33) {
             if (isMostRecentlyInspectedElement(id)) {
-              var valueToCopy = utils_getInObject(mostRecentlyInspectedElement, path32);
+              var valueToCopy = utils_getInObject(mostRecentlyInspectedElement, path33);
               return serializeToString(valueToCopy);
             }
           }
-          function inspectElement(requestID, id, path32, forceFullData) {
-            if (path32 !== null) {
-              mergeInspectedPaths(path32);
+          function inspectElement(requestID, id, path33, forceFullData) {
+            if (path33 !== null) {
+              mergeInspectedPaths(path33);
             }
             if (isMostRecentlyInspectedElement(id) && !forceFullData) {
               if (!hasElementUpdatedSinceLastInspected) {
-                if (path32 !== null) {
+                if (path33 !== null) {
                   var secondaryCategory = null;
-                  if (path32[0] === "hooks" || path32[0] === "suspendedBy") {
-                    secondaryCategory = path32[0];
+                  if (path33[0] === "hooks" || path33[0] === "suspendedBy") {
+                    secondaryCategory = path33[0];
                   }
                   return {
                     id,
                     responseID: requestID,
                     type: "hydrated-path",
-                    path: path32,
-                    value: cleanForBridge(utils_getInObject(mostRecentlyInspectedElement, path32), createIsPathAllowed(null, secondaryCategory), path32)
+                    path: path33,
+                    value: cleanForBridge(utils_getInObject(mostRecentlyInspectedElement, path33), createIsPathAllowed(null, secondaryCategory), path33)
                   };
                 } else {
                   return {
@@ -102212,7 +102774,7 @@ The error thrown in the component is:
               console.groupEnd();
             }
           }
-          function deletePath(type, id, hookID, path32) {
+          function deletePath(type, id, hookID, path33) {
             var devtoolsInstance = idToDevToolsInstanceMap.get(id);
             if (devtoolsInstance === undefined) {
               console.warn('Could not find DevToolsInstance with id "'.concat(id, '"'));
@@ -102226,11 +102788,11 @@ The error thrown in the component is:
               var instance2 = fiber.stateNode;
               switch (type) {
                 case "context":
-                  path32 = path32.slice(1);
+                  path33 = path33.slice(1);
                   switch (fiber.tag) {
                     case ClassComponent:
-                      if (path32.length === 0) {} else {
-                        deletePathInObject(instance2.context, path32);
+                      if (path33.length === 0) {} else {
+                        deletePathInObject(instance2.context, path33);
                       }
                       instance2.forceUpdate();
                       break;
@@ -102240,21 +102802,21 @@ The error thrown in the component is:
                   break;
                 case "hooks":
                   if (typeof overrideHookStateDeletePath === "function") {
-                    overrideHookStateDeletePath(fiber, hookID, path32);
+                    overrideHookStateDeletePath(fiber, hookID, path33);
                   }
                   break;
                 case "props":
                   if (instance2 === null) {
                     if (typeof overridePropsDeletePath === "function") {
-                      overridePropsDeletePath(fiber, path32);
+                      overridePropsDeletePath(fiber, path33);
                     }
                   } else {
-                    fiber.pendingProps = copyWithDelete(instance2.props, path32);
+                    fiber.pendingProps = copyWithDelete(instance2.props, path33);
                     instance2.forceUpdate();
                   }
                   break;
                 case "state":
-                  deletePathInObject(instance2.state, path32);
+                  deletePathInObject(instance2.state, path33);
                   instance2.forceUpdate();
                   break;
               }
@@ -102309,7 +102871,7 @@ The error thrown in the component is:
               }
             }
           }
-          function overrideValueAtPath(type, id, hookID, path32, value) {
+          function overrideValueAtPath(type, id, hookID, path33, value) {
             var devtoolsInstance = idToDevToolsInstanceMap.get(id);
             if (devtoolsInstance === undefined) {
               console.warn('Could not find DevToolsInstance with id "'.concat(id, '"'));
@@ -102323,13 +102885,13 @@ The error thrown in the component is:
               var instance2 = fiber.stateNode;
               switch (type) {
                 case "context":
-                  path32 = path32.slice(1);
+                  path33 = path33.slice(1);
                   switch (fiber.tag) {
                     case ClassComponent:
-                      if (path32.length === 0) {
+                      if (path33.length === 0) {
                         instance2.context = value;
                       } else {
-                        utils_setInObject(instance2.context, path32, value);
+                        utils_setInObject(instance2.context, path33, value);
                       }
                       instance2.forceUpdate();
                       break;
@@ -102339,18 +102901,18 @@ The error thrown in the component is:
                   break;
                 case "hooks":
                   if (typeof overrideHookState === "function") {
-                    overrideHookState(fiber, hookID, path32, value);
+                    overrideHookState(fiber, hookID, path33, value);
                   }
                   break;
                 case "props":
                   switch (fiber.tag) {
                     case ClassComponent:
-                      fiber.pendingProps = copyWithSet(instance2.props, path32, value);
+                      fiber.pendingProps = copyWithSet(instance2.props, path33, value);
                       instance2.forceUpdate();
                       break;
                     default:
                       if (typeof overrideProps === "function") {
-                        overrideProps(fiber, path32, value);
+                        overrideProps(fiber, path33, value);
                       }
                       break;
                   }
@@ -102358,7 +102920,7 @@ The error thrown in the component is:
                 case "state":
                   switch (fiber.tag) {
                     case ClassComponent:
-                      utils_setInObject(instance2.state, path32, value);
+                      utils_setInObject(instance2.state, path33, value);
                       instance2.forceUpdate();
                       break;
                   }
@@ -102644,14 +103206,14 @@ The error thrown in the component is:
           var trackedPathMatchInstance = null;
           var trackedPathMatchDepth = -1;
           var mightBeOnTrackedPath = false;
-          function setTrackedPath(path32) {
-            if (path32 === null) {
+          function setTrackedPath(path33) {
+            if (path33 === null) {
               trackedPathMatchFiber = null;
               trackedPathMatchInstance = null;
               trackedPathMatchDepth = -1;
               mightBeOnTrackedPath = false;
             }
-            trackedPath = path32;
+            trackedPath = path33;
           }
           function updateTrackedPathStateBeforeMount(fiber, fiberInstance) {
             if (trackedPath === null || !mightBeOnTrackedPath) {
@@ -103415,9 +103977,9 @@ The error thrown in the component is:
           }
           var currentlyInspectedElementID = null;
           var currentlyInspectedPaths = {};
-          function mergeInspectedPaths(path32) {
+          function mergeInspectedPaths(path33) {
             var current = currentlyInspectedPaths;
-            path32.forEach(function(key) {
+            path33.forEach(function(key) {
               if (!current[key]) {
                 current[key] = {};
               }
@@ -103425,13 +103987,13 @@ The error thrown in the component is:
             });
           }
           function createIsPathAllowed(key) {
-            return function isPathAllowed(path32) {
+            return function isPathAllowed(path33) {
               var current = currentlyInspectedPaths[key];
               if (!current) {
                 return false;
               }
-              for (var i = 0;i < path32.length; i++) {
-                current = current[path32[i]];
+              for (var i = 0;i < path33.length; i++) {
+                current = current[path33[i]];
                 if (!current) {
                   return false;
                 }
@@ -103481,24 +104043,24 @@ The error thrown in the component is:
                 break;
             }
           }
-          function storeAsGlobal(id, path32, count) {
+          function storeAsGlobal(id, path33, count) {
             var inspectedElement = inspectElementRaw(id);
             if (inspectedElement !== null) {
-              var value = utils_getInObject(inspectedElement, path32);
+              var value = utils_getInObject(inspectedElement, path33);
               var key = "$reactTemp".concat(count);
               window[key] = value;
               console.log(key);
               console.log(value);
             }
           }
-          function getSerializedElementValueByPath(id, path32) {
+          function getSerializedElementValueByPath(id, path33) {
             var inspectedElement = inspectElementRaw(id);
             if (inspectedElement !== null) {
-              var valueToCopy = utils_getInObject(inspectedElement, path32);
+              var valueToCopy = utils_getInObject(inspectedElement, path33);
               return serializeToString(valueToCopy);
             }
           }
-          function inspectElement(requestID, id, path32, forceFullData) {
+          function inspectElement(requestID, id, path33, forceFullData) {
             if (forceFullData || currentlyInspectedElementID !== id) {
               currentlyInspectedElementID = id;
               currentlyInspectedPaths = {};
@@ -103511,8 +104073,8 @@ The error thrown in the component is:
                 type: "not-found"
               };
             }
-            if (path32 !== null) {
-              mergeInspectedPaths(path32);
+            if (path33 !== null) {
+              mergeInspectedPaths(path33);
             }
             updateSelectedElement(id);
             inspectedElement.context = cleanForBridge(inspectedElement.context, createIsPathAllowed("context"));
@@ -103715,10 +104277,10 @@ The error thrown in the component is:
               console.groupEnd();
             }
           }
-          function getElementAttributeByPath(id, path32) {
+          function getElementAttributeByPath(id, path33) {
             var inspectedElement = inspectElementRaw(id);
             if (inspectedElement !== null) {
-              return utils_getInObject(inspectedElement, path32);
+              return utils_getInObject(inspectedElement, path33);
             }
             return;
           }
@@ -103735,14 +104297,14 @@ The error thrown in the component is:
             }
             return element.type;
           }
-          function deletePath(type, id, hookID, path32) {
+          function deletePath(type, id, hookID, path33) {
             var internalInstance = idToInternalInstanceMap.get(id);
             if (internalInstance != null) {
               var publicInstance = internalInstance._instance;
               if (publicInstance != null) {
                 switch (type) {
                   case "context":
-                    deletePathInObject(publicInstance.context, path32);
+                    deletePathInObject(publicInstance.context, path33);
                     forceUpdate(publicInstance);
                     break;
                   case "hooks":
@@ -103750,12 +104312,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, path32)
+                      props: copyWithDelete(element.props, path33)
                     });
                     forceUpdate(publicInstance);
                     break;
                   case "state":
-                    deletePathInObject(publicInstance.state, path32);
+                    deletePathInObject(publicInstance.state, path33);
                     forceUpdate(publicInstance);
                     break;
                 }
@@ -103789,14 +104351,14 @@ The error thrown in the component is:
               }
             }
           }
-          function overrideValueAtPath(type, id, hookID, path32, value) {
+          function overrideValueAtPath(type, id, hookID, path33, value) {
             var internalInstance = idToInternalInstanceMap.get(id);
             if (internalInstance != null) {
               var publicInstance = internalInstance._instance;
               if (publicInstance != null) {
                 switch (type) {
                   case "context":
-                    utils_setInObject(publicInstance.context, path32, value);
+                    utils_setInObject(publicInstance.context, path33, value);
                     forceUpdate(publicInstance);
                     break;
                   case "hooks":
@@ -103804,12 +104366,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, path32, value)
+                      props: copyWithSet(element.props, path33, value)
                     });
                     forceUpdate(publicInstance);
                     break;
                   case "state":
-                    utils_setInObject(publicInstance.state, path32, value);
+                    utils_setInObject(publicInstance.state, path33, value);
                     forceUpdate(publicInstance);
                     break;
                 }
@@ -103850,7 +104412,7 @@ The error thrown in the component is:
             return [];
           }
           function setTraceUpdatesEnabled(enabled) {}
-          function setTrackedPath(path32) {}
+          function setTrackedPath(path33) {}
           function getOwnersList(id) {
             return null;
           }
@@ -107309,10 +107871,10 @@ init_setup_write();
 // src/cli/plugins.ts
 init_paths();
 init_loader4();
-import * as path23 from "path";
+import * as path24 from "path";
 async function pluginsListCommand(config2, workdir, overrideGlobalPluginsDir) {
-  const globalPluginsDir = overrideGlobalPluginsDir ?? path23.join(globalConfigDir(), "plugins");
-  const projectPluginsDir = path23.join(workdir, ".nax", "plugins");
+  const globalPluginsDir = overrideGlobalPluginsDir ?? path24.join(globalConfigDir(), "plugins");
+  const projectPluginsDir = path24.join(workdir, ".nax", "plugins");
   const configPlugins = config2.plugins || [];
   const registry3 = await loadPlugins(globalPluginsDir, projectPluginsDir, configPlugins, workdir, config2.disabledPlugins);
   const plugins = registry3.plugins;
@@ -107362,10 +107924,10 @@ function formatSource(type, sourcePath) {
     return `built-in (${sourcePath})`;
   }
   if (type === "global") {
-    return `global (${path23.basename(sourcePath)})`;
+    return `global (${path24.basename(sourcePath)})`;
   }
   if (type === "project") {
-    return `project (${path23.basename(sourcePath)})`;
+    return `project (${path24.basename(sourcePath)})`;
   }
   return `config (${sourcePath})`;
 }
@@ -107607,6 +108169,8 @@ var FIELD_DESCRIPTIONS = {
   "execution.rectification.maxFailureSummaryChars": "Max characters in failure summary",
   "execution.rectification.abortOnIncreasingFailures": "Abort if failure count increases",
   "execution.rectification.consecutiveIncreasesToBail": "Consecutive regressing iterations required before abortOnIncreasingFailures bails (default: 2; 1 = legacy behaviour)",
+  "execution.rectification.abortOnNoProgress": "Abort rectification when no progress is made for several consecutive iterations (default: true)",
+  "execution.rectification.consecutiveNoProgressToBail": "Consecutive no-progress iterations required before abortOnNoProgress bails (default: 3; one higher than the count bail's 2 because the no-progress predicate fires on a wider shape)",
   "execution.rectification.escalateOnExhaustion": "Enable model tier escalation when attempts are exhausted with remaining failures",
   "execution.rectification.rethinkAtAttempt": "Attempt number at which 'rethink your approach' language is injected into the prompt (default: 2)",
   "execution.rectification.urgencyAtAttempt": "Attempt number at which 'final chance before escalation' urgency is added (default: 3)",
@@ -107759,10 +108323,10 @@ function deepDiffConfigs(global2, project, currentPath = []) {
   for (const key of Object.keys(project)) {
     const projectValue = project[key];
     const globalValue = global2[key];
-    const path24 = [...currentPath, key];
-    const pathStr = path24.join(".");
+    const path25 = [...currentPath, key];
+    const pathStr = path25.join(".");
     if (projectValue !== null && typeof projectValue === "object" && !Array.isArray(projectValue) && globalValue !== null && typeof globalValue === "object" && !Array.isArray(globalValue)) {
-      const nestedDiffs = deepDiffConfigs(globalValue, projectValue, path24);
+      const nestedDiffs = deepDiffConfigs(globalValue, projectValue, path25);
       diffs.push(...nestedDiffs);
     } else {
       if (!deepEqual(projectValue, globalValue)) {
@@ -107805,11 +108369,11 @@ init_defaults();
 init_loader();
 import { existsSync as existsSync25 } from "fs";
 import { join as join71 } from "path";
-async function loadConfigFile(path24) {
-  if (!existsSync25(path24))
+async function loadConfigFile(path25) {
+  if (!existsSync25(path25))
     return null;
   try {
-    return await Bun.file(path24).json();
+    return await Bun.file(path25).json();
   } catch {
     return null;
   }
@@ -107856,10 +108420,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 path24 = diff2.path.padEnd(40);
+      const path25 = diff2.path.padEnd(40);
       const projectVal = formatValueForTable(diff2.projectValue);
       const globalVal = formatValueForTable(diff2.globalValue);
-      console.log(`${path24}${projectVal.padEnd(20)}${globalVal}`);
+      console.log(`${path25}${projectVal.padEnd(20)}${globalVal}`);
       const description = FIELD_DESCRIPTIONS[diff2.path];
       if (description) {
         console.log(`${"".padEnd(40)}\u21B3 ${description}`);
@@ -107892,26 +108456,26 @@ function determineConfigSources() {
     project: projectPath && fileExists(projectPath) ? projectPath : null
   };
 }
-function fileExists(path24) {
-  return existsSync26(path24);
+function fileExists(path25) {
+  return existsSync26(path25);
 }
-function displayConfigWithDescriptions(obj, path24, sources, indent = 0) {
+function displayConfigWithDescriptions(obj, path25, sources, indent = 0) {
   const indentStr = "  ".repeat(indent);
-  const pathStr = path24.join(".");
+  const pathStr = path25.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 = path24[path24.length - 1] || "";
+    const key = path25[path25.length - 1] || "";
     console.log(`${indentStr}${key}: ${value}`);
     console.log();
     return;
   }
   const entries = Object.entries(obj);
   const objAsRecord = obj;
-  const isPromptsSection = path24.join(".") === "prompts";
+  const isPromptsSection = path25.join(".") === "prompts";
   if (isPromptsSection && !objAsRecord.overrides) {
     const description = FIELD_DESCRIPTIONS["prompts.overrides"];
     if (description) {
@@ -107934,7 +108498,7 @@ function displayConfigWithDescriptions(obj, path24, sources, indent = 0) {
   }
   for (let i = 0;i < entries.length; i++) {
     const [key, value] = entries[i];
-    const currentPath = [...path24, key];
+    const currentPath = [...path25, key];
     const currentPathStr = currentPath.join(".");
     const description = FIELD_DESCRIPTIONS[currentPathStr];
     if (description) {
@@ -108372,11 +108936,11 @@ async function rulesLintCommand(options, deps = _rulesLintDeps) {
 }
 // src/cli/rules.ts
 var _rulesCLIDeps = {
-  readFile: async (path24) => Bun.file(path24).text(),
-  writeFile: async (path24, content) => {
-    await Bun.write(path24, content);
+  readFile: async (path25) => Bun.file(path25).text(),
+  writeFile: async (path25, content) => {
+    await Bun.write(path25, content);
   },
-  fileExists: async (path24) => Bun.file(path24).exists(),
+  fileExists: async (path25) => Bun.file(path25).exists(),
   globInDir: (dir) => {
     try {
       return [...new Bun.Glob("*.md").scanSync({ cwd: dir })].sort().map((f) => join75(dir, f));
@@ -108384,8 +108948,8 @@ var _rulesCLIDeps = {
       return [];
     }
   },
-  mkdir: async (path24) => {
-    await mkdir11(path24, { recursive: true });
+  mkdir: async (path25) => {
+    await mkdir11(path25, { recursive: true });
   },
   globCanonicalRuleFiles: (workdir) => _rulesLintDeps.globCanonicalRuleFiles(workdir),
   globHasMatch: (pattern, cwd) => _rulesLintDeps.globHasMatch(pattern, cwd),
@@ -108411,22 +108975,35 @@ var AGENT_RULE_DIRS = {
   claude: ".claude/rules"
 };
 var SUPPORTED_AGENTS = [...Object.keys(AGENT_RULE_DIRS), ...Object.keys(AGENT_SHIM_FILES)].sort();
+function packageGlobToFileGlob(pattern) {
+  const base = pattern.replace(/\/+$/, "").replace(/\/+\*{1,2}$/, "").replace(/\/+$/, "");
+  if (base === "" || base === "**")
+    return "**";
+  return `${base}/**`;
+}
 function claudeFrontmatter(rule) {
-  if (rule.paths?.length) {
-    _rulesCLIDeps.getLogger().warn("rules-export", "Dropping package scope \u2014 Claude has no equivalent", {
+  const fileGlobs = rule.appliesTo ?? [];
+  const packageGlobs = rule.paths ?? [];
+  if (fileGlobs.length > 0 && packageGlobs.length > 0) {
+    _rulesCLIDeps.getLogger().warn("rules-export", "Dropping package scope \u2014 Claude cannot express both scopes", {
       rule: rule.path ?? rule.fileName,
-      droppedPaths: rule.paths
+      description: rule.description,
+      droppedPaths: packageGlobs,
+      keptAppliesTo: fileGlobs
     });
   }
-  const globs = rule.appliesTo ?? [];
-  if (globs.length === 0)
+  const globs = fileGlobs.length > 0 ? fileGlobs : [...new Set(packageGlobs.map(packageGlobToFileGlob))];
+  const description = rule.description;
+  if (globs.length === 0 && description === undefined)
     return "";
-  const lines = globs.map((g) => `  - ${JSON.stringify(g)}`).join(`
-`);
+  const descLine = description !== undefined ? `description: ${JSON.stringify(description)}
+` : "";
+  const globLines = globs.length > 0 ? `paths:
+${globs.map((g) => `  - ${JSON.stringify(g)}`).join(`
+`)}
+` : "";
   return `---
-paths:
-${lines}
----
+${descLine}${globLines}---
 `;
 }
 async function exportRuleDirectory(input) {
@@ -108645,8 +109222,8 @@ async function resolveRunProfileOverride(opts) {
     return cliChain;
   if (opts.envProfile)
     return;
-  const readJson = opts._readJson ?? (async (path24) => {
-    const file3 = Bun.file(path24);
+  const readJson = opts._readJson ?? (async (path25) => {
+    const file3 = Bun.file(path25);
     if (!await file3.exists())
       return;
     return file3.json();
@@ -109049,14 +109626,14 @@ function resolveEffective(detected, configPatterns) {
     return "detected";
   return "none";
 }
-async function loadRawConfig(path24) {
-  const f = Bun.file(path24);
+async function loadRawConfig(path25) {
+  const f = Bun.file(path25);
   if (!await f.exists())
     return {};
   return JSON.parse(await f.text());
 }
-async function writeRawConfig(path24, data) {
-  await Bun.write(path24, `${JSON.stringify(data, null, 2)}
+async function writeRawConfig(path25, data) {
+  await Bun.write(path25, `${JSON.stringify(data, null, 2)}
 `);
 }
 function deepSet(obj, keyPath, value) {
@@ -109844,10 +110421,10 @@ function renderReport(timeline, options = {}) {
 }
 
 // src/commands/replay.ts
-async function readJsonlLenient(path24) {
-  if (!existsSync32(path24))
+async function readJsonlLenient(path25) {
+  if (!existsSync32(path25))
     return [];
-  const content = await Bun.file(path24).text();
+  const content = await Bun.file(path25).text();
   const lines = content.split(`
 `);
   const entries = [];
@@ -109861,11 +110438,11 @@ async function readJsonlLenient(path24) {
   }
   return entries;
 }
-async function readJsonOrUndefined(path24) {
-  if (!existsSync32(path24))
+async function readJsonOrUndefined(path25) {
+  if (!existsSync32(path25))
     return;
   try {
-    return await Bun.file(path24).json();
+    return await Bun.file(path25).json();
   } catch {
     return;
   }
@@ -115161,8 +115738,8 @@ function Text({ color, backgroundColor, dimColor = false, bold = false, italic =
 }
 
 // node_modules/ink/build/components/ErrorOverview.js
-var cleanupPath = (path32) => {
-  return path32?.replace(`file://${cwd()}/`, "");
+var cleanupPath = (path33) => {
+  return path33?.replace(`file://${cwd()}/`, "");
 };
 var stackUtils = new import_stack_utils.default({
   cwd: cwd(),
@@ -118966,8 +119543,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 path32 = await profileCreateCommand(name, options.dir);
-    console.log(`Created profile at: ${path32}`);
+    const path33 = await profileCreateCommand(name, options.dir);
+    console.log(`Created profile at: ${path33}`);
   } catch (err) {
     console.error(source_default.red(`Error: ${err.message}`));
     process.exit(1);
@@ -119267,6 +119844,7 @@ rules.command("export").description("Export canonical rules for an agent (claude
     process.exit(1);
     return;
   }
+  initLogger({ level: "info", useChalk: true });
   try {
     await rulesExportCommand({
       dir: workdir,