@event4u/agent-config 14.7.0 → 14.8.0

package/dist/mcp/server.mjs

@@ -8642,14 +8642,14 @@ var require_parser = __commonJS({
             case "scalar":
             case "single-quoted-scalar":
             case "double-quoted-scalar": {
-              const fs83 = this.flowScalar(this.type);
+              const fs84 = this.flowScalar(this.type);
               if (atNextItem || it.value) {
-                map.items.push({ start, key: fs83, sep: [] });
+                map.items.push({ start, key: fs84, sep: [] });
                 this.onKeyLine = true;
               } else if (it.sep) {
-                this.stack.push(fs83);
+                this.stack.push(fs84);
               } else {
-                Object.assign(it, { key: fs83, sep: [] });
+                Object.assign(it, { key: fs84, sep: [] });
                 this.onKeyLine = true;
               }
               return;
@@ -8777,13 +8777,13 @@ var require_parser = __commonJS({
             case "scalar":
             case "single-quoted-scalar":
             case "double-quoted-scalar": {
-              const fs83 = this.flowScalar(this.type);
+              const fs84 = this.flowScalar(this.type);
               if (!it || it.value)
-                fc.items.push({ start: [], key: fs83, sep: [] });
+                fc.items.push({ start: [], key: fs84, sep: [] });
               else if (it.sep)
-                this.stack.push(fs83);
+                this.stack.push(fs84);
               else
-                Object.assign(it, { key: fs83, sep: [] });
+                Object.assign(it, { key: fs84, sep: [] });
               return;
             }
             case "flow-map-end":
@@ -18807,6 +18807,99 @@ var init_archival_sweep = __esm({
   }
 });
 
+// src/agent-src/scripts/dashboard_mode.ts
+import { spawnSync as spawnSync5 } from "node:child_process";
+import * as fs22 from "node:fs";
+function isTrackedInGit(abs, repo_root) {
+  const r = spawnSync5("git", ["ls-files", "--error-unmatch", "--", abs], {
+    cwd: repo_root,
+    encoding: "utf-8",
+    timeout: 1e4
+  });
+  return r.status === 0;
+}
+function evaluateDashboardState(inp) {
+  const { mode, present, trackedInGit, current, rel } = inp;
+  const regen = inp.regen ?? REGEN;
+  const noun = inp.noun ?? "dashboard";
+  if (mode === "untracked" && trackedInGit) {
+    return {
+      stale: true,
+      error: `\u274C  ${rel} is still tracked by git, but this repository runs \`--untracked-mode\`. Untrack it, keeping the working-tree file:
+      git rm --cached ${rel}
+`,
+      ok: null
+    };
+  }
+  if (!present) {
+    if (mode === "tracked") {
+      return {
+        stale: true,
+        error: `\u274C  ${rel} is missing. ` + regen.replace("to regenerate", "to generate it") + ` If this repository deliberately does not commit the ${noun}, pass \`--untracked-mode\`.
+`,
+        ok: null
+      };
+    }
+    return {
+      stale: false,
+      error: null,
+      ok: `\u2705  ${rel} is not committed here (--untracked-mode) and no stale copy is on disk.
+`
+    };
+  }
+  if (!current) {
+    return { stale: true, error: `\u274C  ${rel} is stale. ${regen}
+`, ok: null };
+  }
+  return { stale: false, error: null, ok: `\u2705  ${rel} is up to date.
+` };
+}
+function evaluateDashboardOnDisk(opts) {
+  const present = fs22.existsSync(opts.target);
+  return evaluateDashboardState({
+    mode: opts.mode,
+    present,
+    trackedInGit: opts.mode === "untracked" && isTrackedInGit(opts.target, opts.repo_root),
+    current: present && fs22.readFileSync(opts.target, { encoding: "utf-8" }) === opts.rendered,
+    rel: opts.rel,
+    ...opts.regen === void 0 ? {} : { regen: opts.regen },
+    ...opts.noun === void 0 ? {} : { noun: opts.noun }
+  });
+}
+function reportCheckVerdict(inp) {
+  const { verdict, dashboardOnly } = inp;
+  const complete = dashboardOnly ? [] : inp.complete;
+  const pending = dashboardOnly ? [] : inp.pending;
+  let err = verdict.error ?? "";
+  if (complete.length) {
+    err += "\u274C  Completed roadmaps are still in `agents/roadmaps/` \u2014 move them to `agents/roadmaps/archive/` (per the `roadmap-progress-sync` rule):\n";
+    for (const r of complete) err += `      - ${r.rel}  (${r.done}/${r.total_active} done)
+`;
+  }
+  if (pending.length) {
+    err += "\u274C  Iron Law 3 \u2014 roadmaps with unresolved `[~]` deferred items must NOT auto-archive. Resolve via `roadmap-management \xA7 4b` (spawn follow-up, restore, or cancel):\n";
+    for (const r of pending) {
+      err += `      - ${r.rel}  (${r.done}/${r.total_active} done \xB7 ${r.deferred} deferred)
+`;
+    }
+  }
+  if (!dashboardOnly && inp.gatedCount > 0) inp.warnMergeGated();
+  const rc = verdict.stale || complete.length > 0 || pending.length > 0 ? 1 : 0;
+  return { rc, stdout: rc === 0 ? verdict.ok ?? "" : "", stderr: err };
+}
+function parseModeToken(tok) {
+  if (tok === "--tracked-mode") return "tracked";
+  if (tok === "--untracked-mode") return "untracked";
+  return null;
+}
+var REGEN;
+var init_dashboard_mode = __esm({
+  "src/agent-src/scripts/dashboard_mode.ts"() {
+    "use strict";
+    REGEN = "Run `./scripts-run src/agent-src/scripts/update_roadmap_progress` to regenerate (or `task roadmap-progress` in Taskfile projects).";
+  }
+});
+
 // src/agent-src/scripts/update_roadmap_progress.ts
 var update_roadmap_progress_exports = {};
 __export(update_roadmap_progress_exports, {
@@ -18836,8 +18929,8 @@ __export(update_roadmap_progress_exports, {
   unarchived_complete: () => unarchived_complete
 });
 import { createRequire as createRequire4 } from "node:module";
-import { spawnSync as spawnSync5 } from "node:child_process";
-import * as fs22 from "node:fs";
+import { spawnSync as spawnSync6 } from "node:child_process";
+import * as fs23 from "node:fs";
 import * as path22 from "node:path";
 import { fileURLToPath as fileURLToPath17, pathToFileURL as pathToFileURL9 } from "node:url";
 function _pyRound4(x) {
@@ -19080,7 +19173,7 @@ function blocker_needs_user(owner) {
   return /\buser\b/i.test(owner);
 }
 function parse_roadmap(p, roadmap_root) {
-  const text = fs22.readFileSync(p, { encoding: "utf-8" });
+  const text = fs23.readFileSync(p, { encoding: "utf-8" });
   const phase_matches = [];
   PHASE_RE.lastIndex = 0;
   let pm;
@@ -19134,7 +19227,7 @@ function _rglobMdSorted3(root) {
   const walk = (dir) => {
     let entries;
     try {
-      entries = fs22.readdirSync(dir, { withFileTypes: true });
+      entries = fs23.readdirSync(dir, { withFileTypes: true });
     } catch {
       return;
     }
@@ -19155,14 +19248,14 @@ function _rglobMdSorted3(root) {
 }
 function _isDir8(p) {
   try {
-    return fs22.statSync(p).isDirectory();
+    return fs23.statSync(p).isDirectory();
   } catch {
     return false;
   }
 }
 function _isFile8(p) {
   try {
-    return fs22.statSync(p).isFile();
+    return fs23.statSync(p).isFile();
   } catch {
     return false;
   }
@@ -19173,7 +19266,7 @@ function collect(roadmap_root) {
     if (!_isFile8(p) || !is_roadmap_candidate(p)) {
       continue;
     }
-    const text = fs22.readFileSync(p, { encoding: "utf-8" });
+    const text = fs23.readFileSync(p, { encoding: "utf-8" });
     if (is_draft(parse_frontmatter2(text))) {
       continue;
     }
@@ -19188,7 +19281,7 @@ function collect_parked(roadmap_root) {
   const dir = path22.join(roadmap_root, "later");
   let names;
   try {
-    names = fs22.readdirSync(dir).sort();
+    names = fs23.readdirSync(dir).sort();
   } catch {
     return [];
   }
@@ -19200,7 +19293,7 @@ function collect_parked(roadmap_root) {
     }
     let text;
     try {
-      text = fs22.readFileSync(full, { encoding: "utf-8" });
+      text = fs23.readFileSync(full, { encoding: "utf-8" });
     } catch {
       continue;
     }
@@ -19260,7 +19353,7 @@ function pending_iron_law_3(roadmaps) {
 }
 function collect_bundles(repo_root) {
   const reg = path22.join(repo_root, "agents", "tickets", "_registry.yml");
-  if (!fs22.existsSync(reg)) {
+  if (!fs23.existsSync(reg)) {
     return [];
   }
   let YAML9;
@@ -19271,7 +19364,7 @@ function collect_bundles(repo_root) {
   }
   let data;
   try {
-    data = YAML9.parse(fs22.readFileSync(reg, { encoding: "utf-8" }), { version: "1.1" }) ?? {};
+    data = YAML9.parse(fs23.readFileSync(reg, { encoding: "utf-8" }), { version: "1.1" }) ?? {};
   } catch {
     return [];
   }
@@ -19285,7 +19378,7 @@ function collect_bundles(repo_root) {
     let n = 0;
     if (_isDir8(bdir)) {
       try {
-        n = fs22.readdirSync(bdir).filter((f) => f.startsWith("T-") && f.endsWith(".md")).length;
+        n = fs23.readdirSync(bdir).filter((f) => f.startsWith("T-") && f.endsWith(".md")).length;
       } catch {
         n = 0;
       }
@@ -19319,7 +19412,7 @@ function render(roadmaps, bundles, roadmap_root) {
     // `.augment/scripts/...` that a script-less / non-Augment consumer does
     // not have. `task roadmap-progress` covers Taskfile projects; the bare
     // script name covers the rest.
-    "> Auto-generated \u2014 do not edit. Regenerate with `task roadmap-progress` or by running the `update_roadmap_progress` script for your install; rewritten on every roadmap create / execute / completion change (timestamp lives in git history).\n>\n" + header_meta
+    "> Auto-generated \u2014 do not edit. Regenerate with `task roadmap-progress` or by running the `update_roadmap_progress` script for your install; rewritten on every roadmap create / execute / completion change. A repository that does not commit this file has no git history for it \u2014 regenerate to see the current state.\n>\n" + header_meta
   );
   lines.push("## Overall\n");
   lines.push(`**${total_done} / ${total_active} steps done \xB7 ${overall_pct}%**
@@ -19476,12 +19569,15 @@ _${resolvedCount} blocker${resolvedCount !== 1 ? "s" : ""} resolved._`
   return lines.join("\n") + "\n";
 }
 function _usage() {
-  return `usage: ${_PROG5} [-h] [--check] [--archive | --no-archive] [--repo-root REPO_ROOT]
+  return `usage: ${_PROG5} [-h] [--check] [--tracked-mode | --untracked-mode]
+       [--archive | --no-archive] [--repo-root REPO_ROOT] [--dashboard-only]
 `;
 }
 function _parseArgs5(argv) {
   let check = false;
+  let mode = "tracked";
   let archive = false;
+  let dashboard_only = false;
   let repo_root = process.cwd();
   const emitError = (msg) => {
     process.stderr.write(_usage());
@@ -19498,6 +19594,12 @@ function _parseArgs5(argv) {
     } else if (tok === "--check") {
       check = true;
       i += 1;
+    } else if (parseModeToken(tok) !== null) {
+      mode = parseModeToken(tok);
+      i += 1;
+    } else if (tok === "--dashboard-only") {
+      dashboard_only = true;
+      i += 1;
     } else if (tok === "--archive") {
       archive = true;
       i += 1;
@@ -19521,11 +19623,14 @@ function _parseArgs5(argv) {
   if (check && archive) {
     emitError("argument --archive: not allowed with --check");
   }
-  return { check, archive, repo_root };
+  if (dashboard_only && !check) {
+    emitError("argument --dashboard-only: only meaningful with --check");
+  }
+  return { check, mode, archive, repo_root, dashboard_only };
 }
 function _fallback_git_toplevel(repo_root) {
   try {
-    const r = spawnSync5("git", ["rev-parse", "--show-toplevel"], {
+    const r = spawnSync6("git", ["rev-parse", "--show-toplevel"], {
       cwd: repo_root,
       encoding: "utf-8",
       timeout: 1e4
@@ -19570,11 +19675,9 @@ function main9(argv) {
   }
   const roadmaps = collect(roadmap_root);
   const new_text = render(roadmaps, collect_bundles(repo_root), roadmap_root);
-  const current = fs22.existsSync(target) ? fs22.readFileSync(target, { encoding: "utf-8" }) : "";
   const complete = unarchived_complete(roadmaps);
   const pending = pending_iron_law_3(roadmaps);
   const gated = merge_gated_pending(roadmaps);
-  const _relToRepo = (p) => _relPosix(repo_root, p);
   const _warn_merge_gated = () => {
     process.stderr.write(
       "\u23F3  Merge-gated roadmaps (every open item gated on a PR) \u2014 flip + archive the moment the gating PR merges (`roadmap-progress-sync` Iron Law 1):\n"
@@ -19588,46 +19691,22 @@ function main9(argv) {
     }
   };
   if (args.check) {
-    const stale = current !== new_text;
-    if (stale) {
-      process.stderr.write(
-        `\u274C  ${_relToRepo(target)} is stale. Run \`node node_modules/.bin/tsx .augment/scripts/update_roadmap_progress.ts\` to regenerate (or \`task roadmap-progress\` in Taskfile projects).
-`
-      );
-    }
-    if (complete.length) {
-      process.stderr.write(
-        "\u274C  Completed roadmaps are still in `agents/roadmaps/` \u2014 move them to `agents/roadmaps/archive/` (per the `roadmap-progress-sync` rule):\n"
-      );
-      for (const r of complete) {
-        process.stderr.write(`      - ${r.rel}  (${r.done}/${r.total_active} done)
-`);
-      }
-    }
-    if (pending.length) {
-      process.stderr.write(
-        "\u274C  Iron Law 3 \u2014 roadmaps with unresolved `[~]` deferred items must NOT auto-archive. Resolve via `roadmap-management \xA7 4b` (spawn follow-up, restore, or cancel):\n"
-      );
-      for (const r of pending) {
-        process.stderr.write(
-          `      - ${r.rel}  (${r.done}/${r.total_active} done \xB7 ${r.deferred} deferred)
-`
-        );
-      }
-    }
-    if (gated.length) {
-      _warn_merge_gated();
-    }
-    if (stale || complete.length || pending.length) {
-      return 1;
-    }
-    process.stdout.write(`\u2705  ${_relToRepo(target)} is up to date.
-`);
-    return 0;
+    const rel = _relPosix(repo_root, target);
+    const r = reportCheckVerdict({
+      verdict: evaluateDashboardOnDisk({ mode: args.mode, target, repo_root, rendered: new_text, rel }),
+      complete,
+      pending,
+      dashboardOnly: args.dashboard_only,
+      warnMergeGated: _warn_merge_gated,
+      gatedCount: gated.length
+    });
+    if (r.stderr) process.stderr.write(r.stderr);
+    if (r.stdout) process.stdout.write(r.stdout);
+    return r.rc;
   }
-  fs22.writeFileSync(target, new_text, { encoding: "utf-8" });
+  fs23.writeFileSync(target, new_text, { encoding: "utf-8" });
   process.stdout.write(
-    `\u2705  Wrote ${_relToRepo(target)} \xB7 ${roadmaps.length} roadmap(s) \xB7 ${roadmaps.reduce((s, r) => s + r.done, 0)}/${roadmaps.reduce((s, r) => s + r.total_active, 0)} steps done.
+    `\u2705  Wrote ${_relPosix(repo_root, target)} \xB7 ${roadmaps.length} roadmap(s) \xB7 ${roadmaps.reduce((s, r) => s + r.done, 0)}/${roadmaps.reduce((s, r) => s + r.total_active, 0)} steps done.
 `
   );
   if (sweep_out) {
@@ -19665,8 +19744,8 @@ function _isCliEntry9() {
     return true;
   }
   try {
-    const here = fs22.realpathSync(fileURLToPath17(import.meta.url));
-    const argv = fs22.realpathSync(path22.resolve(process.argv[1]));
+    const here = fs23.realpathSync(fileURLToPath17(import.meta.url));
+    const argv = fs23.realpathSync(path22.resolve(process.argv[1]));
     return here === argv;
   } catch {
     return false;
@@ -19677,6 +19756,7 @@ var init_update_roadmap_progress = __esm({
   "src/agent-src/scripts/update_roadmap_progress.ts"() {
     "use strict";
     init_archival_sweep();
+    init_dashboard_mode();
     _HERE6 = fileURLToPath17(import.meta.url);
     _require3 = createRequire4(import.meta.url);
     CHECKBOX_RE = /^[ \t\n\r\f\v]*[-*][ \t\n\r\f\v]+\[([ xX~\-])\][ \t\n\r\f\v]/gm;
@@ -19835,13 +19915,13 @@ __export(archive_completed_roadmaps_exports, {
   archive_completed: () => archive_completed,
   main: () => main10
 });
-import { spawnSync as spawnSync6 } from "node:child_process";
-import * as fs23 from "node:fs";
+import { spawnSync as spawnSync7 } from "node:child_process";
+import * as fs24 from "node:fs";
 import * as path23 from "node:path";
 import process9 from "node:process";
 import { fileURLToPath as fileURLToPath18, pathToFileURL as pathToFileURL10 } from "node:url";
 function _run(cmd, cwd) {
-  const res = spawnSync6(cmd[0], cmd.slice(1), { cwd, encoding: "utf-8" });
+  const res = spawnSync7(cmd[0], cmd.slice(1), { cwd, encoding: "utf-8" });
   if (res.error) {
     return { returncode: -1, stdout: res.stdout ?? "", stderr: String(res.error.message ?? "") };
   }
@@ -19907,7 +19987,7 @@ function _inbound_ref_rewrite(root, old_rel, new_rel, dry_run, tracked = true) {
     const fp = path23.join(root, rel);
     let text;
     try {
-      text = fs23.readFileSync(fp, { encoding: "utf-8" });
+      text = fs24.readFileSync(fp, { encoding: "utf-8" });
     } catch {
       continue;
     }
@@ -19915,7 +19995,7 @@ function _inbound_ref_rewrite(root, old_rel, new_rel, dry_run, tracked = true) {
       continue;
     }
     if (!dry_run) {
-      fs23.writeFileSync(fp, _replaceAll(text, old_rel, new_rel), { encoding: "utf-8" });
+      fs24.writeFileSync(fp, _replaceAll(text, old_rel, new_rel), { encoding: "utf-8" });
     }
     changed.push(rel);
   }
@@ -19929,13 +20009,13 @@ function _git_mv(root, src_rel, dst_rel, dry_run) {
   if (dry_run) {
     return { ok: true, tracked: true };
   }
-  fs23.mkdirSync(path23.dirname(dst), { recursive: true });
+  fs24.mkdirSync(path23.dirname(dst), { recursive: true });
   const cp = _run(["git", "mv", src_rel, dst_rel], root);
   if (cp.returncode === 0) {
     return { ok: true, tracked: true };
   }
   try {
-    fs23.renameSync(path23.join(root, src_rel), dst);
+    fs24.renameSync(path23.join(root, src_rel), dst);
     return { ok: true, tracked: false };
   } catch {
     return { ok: false, tracked: false };
@@ -19947,7 +20027,7 @@ function _fs_grep_files(root, needle) {
   const walk = (dirAbs) => {
     let entries;
     try {
-      entries = fs23.readdirSync(dirAbs, { withFileTypes: true });
+      entries = fs24.readdirSync(dirAbs, { withFileTypes: true });
     } catch {
       return;
     }
@@ -19961,7 +20041,7 @@ function _fs_grep_files(root, needle) {
       } else if (e.isFile() && /\.(md|json|ya?ml|ts|js|txt)$/.test(e.name)) {
         let text;
         try {
-          text = fs23.readFileSync(abs, { encoding: "utf-8" });
+          text = fs24.readFileSync(abs, { encoding: "utf-8" });
         } catch {
           continue;
         }
@@ -20023,14 +20103,14 @@ function archive_completed(root, opts) {
 }
 function _isDir9(p) {
   try {
-    return fs23.statSync(p).isDirectory();
+    return fs24.statSync(p).isDirectory();
   } catch {
     return false;
   }
 }
 function _isFile9(p) {
   try {
-    return fs23.statSync(p).isFile();
+    return fs24.statSync(p).isFile();
   } catch {
     return false;
   }
@@ -20041,10 +20121,6 @@ function _regen_dashboard(root, dry_run) {
   }
   const script = path23.join(path23.dirname(_HERE7), "update_roadmap_progress.ts");
   _runTwin(root, script);
-  const dash = path23.join(root, "agents", "roadmaps-progress.md");
-  if (_isFile9(dash)) {
-    _run(["git", "add", "--", "agents/roadmaps-progress.md"], root);
-  }
 }
 function _regen_archive_index(root, dry_run) {
   if (dry_run) {
@@ -20066,8 +20142,8 @@ function _runTwin(root, script) {
   let dir = path23.dirname(_HERE7);
   for (; ; ) {
     const candidate = path23.join(dir, "node_modules", ".bin", binName);
-    if (fs23.existsSync(candidate)) {
-      spawnSync6(candidate, [script], { cwd: root, encoding: "utf-8" });
+    if (fs24.existsSync(candidate)) {
+      spawnSync7(candidate, [script], { cwd: root, encoding: "utf-8" });
       return;
     }
     const parent = path23.dirname(dir);
@@ -20076,7 +20152,7 @@ function _runTwin(root, script) {
     }
     dir = parent;
   }
-  spawnSync6("npx", ["tsx", script], { cwd: root, encoding: "utf-8" });
+  spawnSync7("npx", ["tsx", script], { cwd: root, encoding: "utf-8" });
 }
 function _usage2() {
   return `usage: ${_PROG6} [-h] [--all] [--base BASE] [--dry-run] [--repo-root REPO_ROOT]
@@ -20162,8 +20238,8 @@ function _isCliEntry10() {
     return true;
   }
   try {
-    const here = fs23.realpathSync(fileURLToPath18(import.meta.url));
-    const argv = fs23.realpathSync(path23.resolve(process9.argv[1]));
+    const here = fs24.realpathSync(fileURLToPath18(import.meta.url));
+    const argv = fs24.realpathSync(path23.resolve(process9.argv[1]));
     return here === argv;
   } catch {
     return false;
@@ -20211,20 +20287,20 @@ __export(generate_capabilities_index_exports, {
   build: () => build,
   main: () => main11
 });
-import * as fs24 from "node:fs";
+import * as fs25 from "node:fs";
 import * as path24 from "node:path";
 import process10 from "node:process";
 import { fileURLToPath as fileURLToPath19, pathToFileURL as pathToFileURL11 } from "node:url";
 function _isFile10(p) {
   try {
-    return fs24.statSync(p).isFile();
+    return fs25.statSync(p).isFile();
   } catch {
     return false;
   }
 }
 function _exists4(p) {
   try {
-    fs24.statSync(p);
+    fs25.statSync(p);
     return true;
   } catch {
     return false;
@@ -20260,7 +20336,7 @@ function _coverage_band(count) {
 function _load_packs() {
   let raw;
   try {
-    raw = (0, import_yaml4.parse)(fs24.readFileSync(PACKS_YML, "utf-8"), { version: "1.1" });
+    raw = (0, import_yaml4.parse)(fs25.readFileSync(PACKS_YML, "utf-8"), { version: "1.1" });
   } catch {
     raw = null;
   }
@@ -20284,7 +20360,7 @@ function _sortedPosix(items) {
 function _globSkillMds() {
   let entries;
   try {
-    entries = fs24.readdirSync(SKILLS_DIR, { withFileTypes: true });
+    entries = fs25.readdirSync(SKILLS_DIR, { withFileTypes: true });
   } catch {
     return [];
   }
@@ -20293,7 +20369,7 @@ function _globSkillMds() {
     const dir = path24.join(SKILLS_DIR, ent.name);
     const isDir4 = ent.isDirectory() || ent.isSymbolicLink() && (() => {
       try {
-        return fs24.statSync(dir).isDirectory();
+        return fs25.statSync(dir).isDirectory();
       } catch {
         return false;
       }
@@ -20317,7 +20393,7 @@ function _nameOr(v, fallback) {
 function _skill_packs() {
   const byPack = {};
   for (const skillMd of _globSkillMds()) {
-    const [fm] = parse_frontmatter(fs24.readFileSync(skillMd, "utf-8"));
+    const [fm] = parse_frontmatter(fs25.readFileSync(skillMd, "utf-8"));
     if (!fm || !_pyTruthy(fm)) {
       continue;
     }
@@ -20339,7 +20415,7 @@ function _skill_packs() {
 function _command_packs() {
   const byPack = {};
   for (const cmdMd of iter_commands()) {
-    const [fm] = parse_frontmatter(fs24.readFileSync(cmdMd, "utf-8"));
+    const [fm] = parse_frontmatter(fs25.readFileSync(cmdMd, "utf-8"));
     if (!fm || !_pyTruthy(fm)) {
       continue;
     }
@@ -20550,7 +20626,7 @@ function main11(argv = null) {
     return 1;
   }
   if (args.check) {
-    const onDisk = _exists4(OUT) ? fs24.readFileSync(OUT, "utf-8") : "";
+    const onDisk = _exists4(OUT) ? fs25.readFileSync(OUT, "utf-8") : "";
     if (onDisk !== content) {
       process10.stderr.write(
         "\u274C  CAPABILITIES.yaml is stale \u2014 run `./scripts-run src/scripts/generate_capabilities_index`\n"
@@ -20563,7 +20639,7 @@ function main11(argv = null) {
     );
     return 0;
   }
-  fs24.writeFileSync(OUT, content, "utf-8");
+  fs25.writeFileSync(OUT, content, "utf-8");
   process10.stdout.write(
     `\u2705  Wrote CAPABILITIES.yaml \u2014 ${_kib(size)} KB, ${_msFmt(elapsed)}ms \xB7 ${_load_packs().length} areas.
 `
@@ -20579,8 +20655,8 @@ function _isCliEntry11() {
     return true;
   }
   try {
-    const here = fs24.realpathSync(fileURLToPath19(import.meta.url));
-    const argv = fs24.realpathSync(path24.resolve(process10.argv[1]));
+    const here = fs25.realpathSync(fileURLToPath19(import.meta.url));
+    const argv = fs25.realpathSync(path24.resolve(process10.argv[1]));
     return here === argv;
   } catch {
     return false;
@@ -20609,7 +20685,7 @@ var init_generate_capabilities_index = __esm({
 });
 
 // src/scripts/_lib/claude_plugin.ts
-import * as fs25 from "node:fs";
+import * as fs26 from "node:fs";
 import * as os4 from "node:os";
 import * as path25 from "node:path";
 import process11 from "node:process";
@@ -20621,7 +20697,7 @@ function _plugin_id_recorded(plugin_id) {
   const p = path25.join(claude_config_dir(), "plugins", "installed_plugins.json");
   let data;
   try {
-    data = JSON.parse(fs25.readFileSync(p, "utf-8"));
+    data = JSON.parse(fs26.readFileSync(p, "utf-8"));
   } catch {
     return false;
   }
@@ -20639,7 +20715,7 @@ function _plugin_marketplaces(plugin_id) {
   const p = path25.join(claude_config_dir(), "plugins", "installed_plugins.json");
   let data;
   try {
-    data = JSON.parse(fs25.readFileSync(p, "utf-8"));
+    data = JSON.parse(fs26.readFileSync(p, "utf-8"));
   } catch {
     return [];
   }
@@ -20653,7 +20729,7 @@ function _marketplace_source_repo(marketplace) {
   const p = path25.join(claude_config_dir(), "plugins", "known_marketplaces.json");
   let data;
   try {
-    data = JSON.parse(fs25.readFileSync(p, "utf-8"));
+    data = JSON.parse(fs26.readFileSync(p, "utf-8"));
   } catch {
     return null;
   }
@@ -20687,7 +20763,7 @@ function claude_plugin_snapshot_version() {
   );
   let data;
   try {
-    data = JSON.parse(fs25.readFileSync(p, "utf-8"));
+    data = JSON.parse(fs26.readFileSync(p, "utf-8"));
   } catch {
     return null;
   }
@@ -20724,7 +20800,7 @@ import {
   fsyncSync,
   mkdirSync as mkdirSync8,
   openSync,
-  readFileSync as readFileSync21,
+  readFileSync as readFileSync22,
   renameSync as renameSync4,
   unlinkSync as unlinkSync2,
   writeSync
@@ -20761,7 +20837,7 @@ function atomicWriteFile(target, data, options = {}) {
 function atomicAppendLine(target, line) {
   let existing = "";
   try {
-    existing = readFileSync21(target, "utf8");
+    existing = readFileSync22(target, "utf8");
   } catch {
     existing = "";
   }
@@ -20779,12 +20855,12 @@ var init_atomic = __esm({
 });
 
 // src/scripts/_lib/claude_settings_hooks.ts
-import * as fs26 from "node:fs";
+import * as fs27 from "node:fs";
 function _yaml_parse(text) {
   return YAML3.parse(text);
 }
 function build_claude_hook_matrix(manifest_path2) {
-  const raw = fs26.readFileSync(manifest_path2, "utf8");
+  const raw = fs27.readFileSync(manifest_path2, "utf8");
   const manifest = _yaml_parse(raw) ?? {};
   const hook_spec = manifest["schema_version"] ?? 1;
   const platforms = manifest["platforms"] ?? {};
@@ -20816,12 +20892,12 @@ var init_claude_settings_hooks = __esm({
 });
 
 // src/scripts/_lib/cli_wrapper.ts
-import fs27 from "node:fs";
+import fs28 from "node:fs";
 import path26 from "node:path";
 import { fileURLToPath as fileURLToPath20 } from "node:url";
 function _is_file2(p) {
   try {
-    return fs27.statSync(p).isFile();
+    return fs28.statSync(p).isFile();
   } catch {
     return false;
   }
@@ -20832,8 +20908,8 @@ function _target(project_root) {
 function install_cli_wrapper(project_root) {
   if (!_is_file2(_TEMPLATE)) return null;
   const target = _target(project_root);
-  fs27.copyFileSync(_TEMPLATE, target);
-  fs27.chmodSync(target, 493);
+  fs28.copyFileSync(_TEMPLATE, target);
+  fs28.chmodSync(target, 493);
   return target;
 }
 var _PACKAGE_ROOT2, _TEMPLATE;
@@ -20876,7 +20952,7 @@ __export(sync_gitignore_exports, {
   template_entries: () => template_entries,
   unified_diff: () => unified_diff
 });
-import * as fs28 from "node:fs";
+import * as fs29 from "node:fs";
 import * as path27 from "node:path";
 import process12 from "node:process";
 import { fileURLToPath as fileURLToPath21, pathToFileURL as pathToFileURL12 } from "node:url";
@@ -20889,7 +20965,7 @@ function _is_entry(ln) {
 }
 function _isFile11(p) {
   try {
-    return fs28.statSync(p).isFile();
+    return fs29.statSync(p).isFile();
   } catch {
     return false;
   }
@@ -20904,7 +20980,7 @@ function load_template(p) {
   if (!_isFile11(p)) {
     throw new TemplateNotFoundError(p);
   }
-  const text = fs28.readFileSync(p, "utf-8");
+  const text = fs29.readFileSync(p, "utf-8");
   return _splitlines4(text).map(_strip4);
 }
 function find_block(lines) {
@@ -21241,7 +21317,7 @@ function main12(argv) {
   let existing_text;
   let existing_lines;
   if (_isFile11(target)) {
-    existing_text = fs28.readFileSync(target, "utf-8");
+    existing_text = fs29.readFileSync(target, "utf-8");
     existing_lines = _splitlines4(existing_text).map(_strip4);
   } else {
     existing_text = "";
@@ -21280,8 +21356,8 @@ function main12(argv) {
     }
     return 0;
   }
-  fs28.mkdirSync(path27.dirname(path27.resolve(target)), { recursive: true });
-  fs28.writeFileSync(target, new_text, "utf-8");
+  fs29.mkdirSync(path27.dirname(path27.resolve(target)), { recursive: true });
+  fs29.writeFileSync(target, new_text, "utf-8");
   if (!args.quiet) {
     const action = args.replace ? "replaced" : "updated";
     process12.stdout.write(
@@ -21306,8 +21382,8 @@ function _isCliEntry12() {
     return true;
   }
   try {
-    const here = fs28.realpathSync(fileURLToPath21(import.meta.url));
-    const argv = fs28.realpathSync(path27.resolve(process12.argv[1]));
+    const here = fs29.realpathSync(fileURLToPath21(import.meta.url));
+    const argv = fs29.realpathSync(path27.resolve(process12.argv[1]));
     return here === argv;
   } catch {
     return false;
@@ -21376,7 +21452,7 @@ __export(sync_gitattributes_exports, {
   sync_block: () => sync_block2,
   template_entries: () => template_entries2
 });
-import * as fs29 from "node:fs";
+import * as fs30 from "node:fs";
 import * as path28 from "node:path";
 import process13 from "node:process";
 import { fileURLToPath as fileURLToPath22, pathToFileURL as pathToFileURL13 } from "node:url";
@@ -21389,7 +21465,7 @@ function _is_entry2(ln) {
 }
 function _isFile12(p) {
   try {
-    return fs29.statSync(p).isFile();
+    return fs30.statSync(p).isFile();
   } catch {
     return false;
   }
@@ -21404,7 +21480,7 @@ function load_template2(p) {
   if (!_isFile12(p)) {
     throw new TemplateNotFoundError2(p);
   }
-  const text = fs29.readFileSync(p, "utf-8");
+  const text = fs30.readFileSync(p, "utf-8");
   return _splitlines5(text).map(_strip5);
 }
 function find_block2(lines) {
@@ -21526,7 +21602,7 @@ function main13(argv) {
   let existing_text;
   let existing_lines;
   if (_isFile12(target)) {
-    existing_text = fs29.readFileSync(target, "utf-8");
+    existing_text = fs30.readFileSync(target, "utf-8");
     existing_lines = _splitlines5(existing_text).map(_strip5);
   } else {
     existing_text = "";
@@ -21552,8 +21628,8 @@ function main13(argv) {
     }
     return 1;
   }
-  fs29.mkdirSync(path28.dirname(path28.resolve(target)), { recursive: true });
-  fs29.writeFileSync(target, new_text, "utf-8");
+  fs30.mkdirSync(path28.dirname(path28.resolve(target)), { recursive: true });
+  fs30.writeFileSync(target, new_text, "utf-8");
   if (!args.quiet) {
     process13.stdout.write(
       `\u2705  ${target}: updated block (${added.length} entr${added.length === 1 ? "y" : "ies"} added)
@@ -21571,8 +21647,8 @@ function _isCliEntry13() {
     return true;
   }
   try {
-    const here = fs29.realpathSync(fileURLToPath22(import.meta.url));
-    const argv = fs29.realpathSync(path28.resolve(process13.argv[1]));
+    const here = fs30.realpathSync(fileURLToPath22(import.meta.url));
+    const argv = fs30.realpathSync(path28.resolve(process13.argv[1]));
     return here === argv;
   } catch {
     return false;
@@ -21608,7 +21684,7 @@ var init_sync_gitattributes = __esm({
 });
 
 // src/scripts/_lib/package_root.ts
-import * as fs30 from "node:fs";
+import * as fs31 from "node:fs";
 import * as path29 from "node:path";
 import { fileURLToPath as fileURLToPath23 } from "node:url";
 function resolvePackageRoot(fromUrlOrPath, legacyHops = 3) {
@@ -21617,9 +21693,9 @@ function resolvePackageRoot(fromUrlOrPath, legacyHops = 3) {
   let dir = startDir;
   for (let i = 0; i < MAX_ASCENT; i++) {
     const manifest = path29.join(dir, "package.json");
-    if (fs30.existsSync(manifest)) {
+    if (fs31.existsSync(manifest)) {
       try {
-        const parsed = JSON.parse(fs30.readFileSync(manifest, "utf8"));
+        const parsed = JSON.parse(fs31.readFileSync(manifest, "utf8"));
         if (parsed.name === PACKAGE_NAME) {
           return dir;
         }
@@ -21644,9 +21720,9 @@ var init_package_root = __esm({
 });
 
 // src/scripts/_cli/cmd_refresh.ts
-import * as fs31 from "node:fs";
+import * as fs32 from "node:fs";
 import * as path30 from "node:path";
-import { spawnSync as spawnSync7 } from "node:child_process";
+import { spawnSync as spawnSync8 } from "node:child_process";
 import process14 from "node:process";
 import { fileURLToPath as fileURLToPath24, pathToFileURL as pathToFileURL14 } from "node:url";
 function _print2(out, line = "") {
@@ -21654,31 +21730,31 @@ function _print2(out, line = "") {
 }
 function _isFile13(p) {
   try {
-    return fs31.statSync(p).isFile();
+    return fs32.statSync(p).isFile();
   } catch {
     return false;
   }
 }
 function _isDir10(p) {
   try {
-    return fs31.statSync(p).isDirectory();
+    return fs32.statSync(p).isDirectory();
   } catch {
     return false;
   }
 }
 function _exists5(p) {
   try {
-    fs31.statSync(p);
+    fs32.statSync(p);
     return true;
   } catch {
     return false;
   }
 }
 function _readText(p) {
-  return fs31.readFileSync(p, { encoding: "utf-8" });
+  return fs32.readFileSync(p, { encoding: "utf-8" });
 }
 function _writeText(p, text) {
-  fs31.writeFileSync(p, text, { encoding: "utf-8" });
+  fs32.writeFileSync(p, text, { encoding: "utf-8" });
 }
 function _remove_legacy_consumer_bridge_marker(project_root, env = null) {
   const env_map = env ?? process14.env;
@@ -21687,14 +21763,14 @@ function _remove_legacy_consumer_bridge_marker(project_root, env = null) {
   const target = path30.join(project_root, CONSUMER_BRIDGE_MARKER_RELPATH);
   if (!_isFile13(target)) return null;
   try {
-    fs31.rmSync(target);
+    fs32.rmSync(target);
   } catch {
     return null;
   }
   return target;
 }
 function _default_runner(cmd) {
-  const r = spawnSync7(cmd[0], cmd.slice(1), { stdio: "inherit" });
+  const r = spawnSync8(cmd[0], cmd.slice(1), { stdio: "inherit" });
   if (r.error) {
     _stderr.write(`agent-config refresh: cannot run ${cmd[0]}: ${osErrorStr(r.error)}
 `);
@@ -21746,7 +21822,7 @@ function _glob_packages_uncondensed(project_root) {
   const packages = path30.join(project_root, "packages");
   let entries;
   try {
-    entries = fs31.readdirSync(packages);
+    entries = fs32.readdirSync(packages);
   } catch {
     return [];
   }
@@ -21772,7 +21848,7 @@ function _refresh_project(project_root, out, err) {
     _print2(out, `\u2705  removed legacy bridge marker: ${removed}`);
   }
   const overrides = path30.join(project_root, "agents", "overrides");
-  fs31.mkdirSync(overrides, { recursive: true });
+  fs32.mkdirSync(overrides, { recursive: true });
   const keep = path30.join(overrides, "README.md");
   if (!_exists5(keep)) {
     _writeText(
@@ -21912,8 +21988,8 @@ function _isCliEntry14() {
     return true;
   }
   try {
-    const here = fs31.realpathSync(fileURLToPath24(import.meta.url));
-    const argv = fs31.realpathSync(path30.resolve(process14.argv[1]));
+    const here = fs32.realpathSync(fileURLToPath24(import.meta.url));
+    const argv = fs32.realpathSync(path30.resolve(process14.argv[1]));
     return here === argv;
   } catch {
     return false;
@@ -21965,7 +22041,7 @@ var init_install_layout = __esm({
 });
 
 // src/scripts/_lib/installed_lock.ts
-import * as fs32 from "node:fs";
+import * as fs33 from "node:fs";
 import * as os5 from "node:os";
 import * as path31 from "node:path";
 function _default_lockfile() {
@@ -21996,7 +22072,7 @@ function read_lockfile(path81) {
   const target = path81 ?? lockfile_path();
   let text;
   try {
-    text = fs32.readFileSync(target, { encoding: "utf-8" });
+    text = fs33.readFileSync(target, { encoding: "utf-8" });
   } catch {
     return null;
   }
@@ -22073,7 +22149,7 @@ var init_installed_lock = __esm({
 });
 
 // src/scripts/_lib/fs_atomic.ts
-import fs33 from "node:fs";
+import fs34 from "node:fs";
 import path32 from "node:path";
 import { randomBytes as randomBytes2 } from "node:crypto";
 function _normalize_encoding(encoding) {
@@ -22092,7 +22168,7 @@ function write_atomic(p, data, options = {}) {
   const encoding = options.encoding ?? "utf-8";
   const target = path32.normalize(p);
   const parent = path32.dirname(target);
-  fs33.mkdirSync(parent, { recursive: true });
+  fs34.mkdirSync(parent, { recursive: true });
   let payload;
   if (typeof data === "string") {
     payload = Buffer.from(data, _normalize_encoding(encoding));
@@ -22111,7 +22187,7 @@ function write_atomic(p, data, options = {}) {
       `.${path32.basename(target)}.tmp.${randomBytes2(6).toString("hex")}`
     );
     try {
-      fd = fs33.openSync(tmp_path, "wx", 384);
+      fd = fs34.openSync(tmp_path, "wx", 384);
       break;
     } catch (err) {
       if (err.code === "EEXIST") continue;
@@ -22125,24 +22201,24 @@ function write_atomic(p, data, options = {}) {
   try {
     let offset = 0;
     while (offset < payload.length) {
-      offset += fs33.writeSync(fd, payload, offset, payload.length - offset);
+      offset += fs34.writeSync(fd, payload, offset, payload.length - offset);
     }
     try {
-      fs33.fsyncSync(fd);
+      fs34.fsyncSync(fd);
     } catch {
     }
-    fs33.closeSync(fd);
+    fs34.closeSync(fd);
     closed = true;
-    fs33.renameSync(tmp_path, target);
+    fs34.renameSync(tmp_path, target);
   } catch (err) {
     if (!closed) {
       try {
-        fs33.closeSync(fd);
+        fs34.closeSync(fd);
       } catch {
       }
     }
     try {
-      fs33.unlinkSync(tmp_path);
+      fs34.unlinkSync(tmp_path);
     } catch {
     }
     throw err;
@@ -22153,17 +22229,17 @@ function write_atomic(p, data, options = {}) {
 function _fsync_dir(directory) {
   let dir_fd;
   try {
-    dir_fd = fs33.openSync(directory, fs33.constants.O_RDONLY);
+    dir_fd = fs34.openSync(directory, fs34.constants.O_RDONLY);
   } catch {
     return;
   }
   try {
     try {
-      fs33.fsyncSync(dir_fd);
+      fs34.fsyncSync(dir_fd);
     } catch {
     }
   } finally {
-    fs33.closeSync(dir_fd);
+    fs34.closeSync(dir_fd);
   }
 }
 var init_fs_atomic = __esm({
@@ -22190,7 +22266,7 @@ __export(installed_tools_exports, {
   upsert_tool: () => upsert_tool,
   write_manifest: () => write_manifest
 });
-import * as fs34 from "node:fs";
+import * as fs35 from "node:fs";
 import * as os6 from "node:os";
 import * as fsPath from "node:path";
 function expanduser3(p) {
@@ -22221,7 +22297,7 @@ function read_manifest(path81) {
   return _normalise_v2_shape(data);
 }
 function require_read_text(path81) {
-  return fs34.readFileSync(path81, { encoding: "utf-8" });
+  return fs35.readFileSync(path81, { encoding: "utf-8" });
 }
 function _normalise_v2_shape(data) {
   if (data["tools"] === void 0 || data["tools"] === null) {
@@ -22534,7 +22610,7 @@ __export(global_deploy_inventory_exports, {
   save_inventory: () => save_inventory
 });
 import { randomBytes as randomBytes3 } from "node:crypto";
-import * as fs35 from "node:fs";
+import * as fs36 from "node:fs";
 import * as os7 from "node:os";
 import * as path33 from "node:path";
 function expanduser4(p) {
@@ -22548,14 +22624,14 @@ function expanduser4(p) {
 }
 function resolve_path(p) {
   try {
-    return fs35.realpathSync(p);
+    return fs36.realpathSync(p);
   } catch {
     const abs = path33.resolve(p);
     const parts = abs.split(path33.sep);
     for (let i = parts.length; i > 0; i -= 1) {
       const prefix = parts.slice(0, i).join(path33.sep) || path33.sep;
       try {
-        const real = fs35.realpathSync(prefix);
+        const real = fs36.realpathSync(prefix);
         const rest = parts.slice(i);
         return rest.length > 0 ? path33.join(real, ...rest) : real;
       } catch {
@@ -22567,7 +22643,7 @@ function resolve_path(p) {
 }
 function path_exists(p) {
   try {
-    fs35.statSync(p);
+    fs36.statSync(p);
     return true;
   } catch {
     return false;
@@ -22585,7 +22661,7 @@ function load_inventory(p) {
   const target = p ?? inventory_path();
   let data;
   try {
-    data = JSON.parse(fs35.readFileSync(target, { encoding: "utf-8" }));
+    data = JSON.parse(fs36.readFileSync(target, { encoding: "utf-8" }));
   } catch {
     return { schema_version: SCHEMA_VERSION5, tools: {} };
   }
@@ -22596,7 +22672,7 @@ function load_inventory(p) {
 }
 function save_inventory(data, p) {
   const target = p ?? inventory_path();
-  fs35.mkdirSync(path33.dirname(target), { recursive: true });
+  fs36.mkdirSync(path33.dirname(target), { recursive: true });
   const payload = json_dumps_sorted(data, 2) + "\n";
   const parent = path33.dirname(target);
   let fd = null;
@@ -22604,7 +22680,7 @@ function save_inventory(data, p) {
   for (let attempt = 0; attempt < 32; attempt += 1) {
     tmp_name = path33.join(parent, `${path33.basename(target)}.${randomBytes3(6).toString("hex")}`);
     try {
-      fd = fs35.openSync(tmp_name, "wx", 384);
+      fd = fs36.openSync(tmp_name, "wx", 384);
       break;
     } catch (err) {
       if (err.code === "EEXIST") {
@@ -22617,16 +22693,16 @@ function save_inventory(data, p) {
     throw new Error("save_inventory: could not create a unique temp file");
   }
   try {
-    fs35.writeFileSync(fd, payload, { encoding: "utf-8" });
-    fs35.closeSync(fd);
-    fs35.renameSync(tmp_name, target);
+    fs36.writeFileSync(fd, payload, { encoding: "utf-8" });
+    fs36.closeSync(fd);
+    fs36.renameSync(tmp_name, target);
   } catch (err) {
     try {
-      fs35.closeSync(fd);
+      fs36.closeSync(fd);
     } catch {
     }
     try {
-      fs35.unlinkSync(tmp_name);
+      fs36.unlinkSync(tmp_name);
     } catch {
     }
     throw err;
@@ -22685,7 +22761,7 @@ function expected_deploy_files(src, dest_rel, file_filter = null) {
   const out = /* @__PURE__ */ new Set();
   let src_stat;
   try {
-    src_stat = fs35.statSync(src);
+    src_stat = fs36.statSync(src);
   } catch {
     return out;
   }
@@ -22697,23 +22773,23 @@ function expected_deploy_files(src, dest_rel, file_filter = null) {
     return out;
   }
   const _walk = (node, prefix) => {
-    const entries = fs35.readdirSync(node).sort((a, b) => a < b ? -1 : a > b ? 1 : 0);
+    const entries = fs36.readdirSync(node).sort((a, b) => a < b ? -1 : a > b ? 1 : 0);
     for (const name of entries) {
       const entry = path33.join(node, name);
       const rel = join_rel(prefix, name);
-      const lst = fs35.lstatSync(entry);
+      const lst = fs36.lstatSync(entry);
       if (lst.isDirectory() && !lst.isSymbolicLink()) {
         _walk(entry, rel);
         continue;
       }
       let resolved_is_dir = false;
       try {
-        resolved_is_dir = fs35.statSync(entry).isDirectory();
+        resolved_is_dir = fs36.statSync(entry).isDirectory();
       } catch {
         resolved_is_dir = false;
       }
       if (resolved_is_dir) {
-        _walk(fs35.realpathSync(entry), rel);
+        _walk(fs36.realpathSync(entry), rel);
         continue;
       }
       if (file_filter !== null && !file_filter(entry)) {
@@ -22765,7 +22841,7 @@ function reap_stale(tool_id, anchor, current_files, inventory, dry_run = false)
     }
     let lst = null;
     try {
-      lst = fs35.lstatSync(target);
+      lst = fs36.lstatSync(target);
     } catch {
       lst = null;
     }
@@ -22779,7 +22855,7 @@ function reap_stale(tool_id, anchor, current_files, inventory, dry_run = false)
       continue;
     }
     try {
-      fs35.unlinkSync(target);
+      fs36.unlinkSync(target);
     } catch {
       continue;
     }
@@ -22798,7 +22874,7 @@ function reap_tagged_orphans(anchor, dest_subs, current_files, package_tag, dry_
     const root = dest_sub ? path33.join(anchor_resolved, dest_sub) : anchor_resolved;
     let root_stat;
     try {
-      root_stat = fs35.statSync(root);
+      root_stat = fs36.statSync(root);
     } catch {
       continue;
     }
@@ -22808,7 +22884,7 @@ function reap_tagged_orphans(anchor, dest_subs, current_files, package_tag, dry_
     for (const md of rglob_md(root)) {
       let md_lst;
       try {
-        md_lst = fs35.lstatSync(md);
+        md_lst = fs36.lstatSync(md);
       } catch {
         continue;
       }
@@ -22826,7 +22902,7 @@ function reap_tagged_orphans(anchor, dest_subs, current_files, package_tag, dry_
       }
       let head;
       try {
-        head = fs35.readFileSync(md, { encoding: "utf-8" });
+        head = fs36.readFileSync(md, { encoding: "utf-8" });
       } catch {
         continue;
       }
@@ -22844,7 +22920,7 @@ function reap_tagged_orphans(anchor, dest_subs, current_files, package_tag, dry_
         continue;
       }
       try {
-        fs35.unlinkSync(md);
+        fs36.unlinkSync(md);
       } catch {
         continue;
       }
@@ -22875,7 +22951,7 @@ function prune_empty_dirs(prune_candidates, anchor_resolved) {
     let node = start;
     while (node !== anchor_resolved && is_ancestor(anchor_resolved, node)) {
       try {
-        fs35.rmdirSync(node);
+        fs36.rmdirSync(node);
       } catch {
         break;
       }
@@ -22905,7 +22981,7 @@ function rglob_md(root) {
   const walk = (dir) => {
     let names;
     try {
-      names = fs35.readdirSync(dir).sort((a, b) => a < b ? -1 : a > b ? 1 : 0);
+      names = fs36.readdirSync(dir).sort((a, b) => a < b ? -1 : a > b ? 1 : 0);
     } catch {
       return;
     }
@@ -22913,7 +22989,7 @@ function rglob_md(root) {
       const full = path33.join(dir, name);
       let lst;
       try {
-        lst = fs35.lstatSync(full);
+        lst = fs36.lstatSync(full);
       } catch {
         continue;
       }
@@ -22964,10 +23040,10 @@ var init_global_deploy_inventory = __esm({
 });
 
 // src/scripts/_lib/duplicate_scope_census.ts
-import * as fs36 from "node:fs";
+import * as fs37 from "node:fs";
 import * as path34 from "node:path";
 function censusDuplicateScope(userRulesDir, projectRulesDir) {
-  if (!fs36.existsSync(userRulesDir) || !fs36.existsSync(projectRulesDir)) {
+  if (!fs37.existsSync(userRulesDir) || !fs37.existsSync(projectRulesDir)) {
     return {
       evaluable: false,
       reason: `one or both rule directories are missing (user: ${userRulesDir}, project: ${projectRulesDir})`,
@@ -22975,15 +23051,15 @@ function censusDuplicateScope(userRulesDir, projectRulesDir) {
       duplicate_chars: 0
     };
   }
-  const userFiles = new Set(fs36.readdirSync(userRulesDir).filter((f) => f.endsWith(".md")));
-  const projectFiles = fs36.readdirSync(projectRulesDir).filter((f) => f.endsWith(".md"));
+  const userFiles = new Set(fs37.readdirSync(userRulesDir).filter((f) => f.endsWith(".md")));
+  const projectFiles = fs37.readdirSync(projectRulesDir).filter((f) => f.endsWith(".md"));
   const shared = [];
   let duplicateChars = 0;
   for (const f of projectFiles) {
     if (!userFiles.has(f)) continue;
     shared.push(f);
-    const a = fs36.statSync(path34.join(userRulesDir, f)).size;
-    const b = fs36.statSync(path34.join(projectRulesDir, f)).size;
+    const a = fs37.statSync(path34.join(userRulesDir, f)).size;
+    const b = fs37.statSync(path34.join(projectRulesDir, f)).size;
     duplicateChars += Math.min(a, b);
   }
   shared.sort();
@@ -23930,7 +24006,7 @@ var init_agent_user_profile = __esm({
 });
 
 // src/scripts/_lib/carrier_divergence.ts
-import * as fs37 from "node:fs";
+import * as fs38 from "node:fs";
 import * as path38 from "node:path";
 function stripOwnershipKeys(text) {
   return text.split("\n").filter((line) => !OWNERSHIP_KEYS.some((k) => line.startsWith(`${k}:`))).join("\n");
@@ -23980,14 +24056,14 @@ function censusRuleDir(dir) {
   let chars = 0;
   let entries;
   try {
-    entries = fs37.readdirSync(dir);
+    entries = fs38.readdirSync(dir);
   } catch {
     return { files: 0, chars: 0 };
   }
   for (const name of entries) {
     if (!name.endsWith(".md")) continue;
     try {
-      chars += fs37.statSync(path38.join(dir, name)).size;
+      chars += fs38.statSync(path38.join(dir, name)).size;
       files += 1;
     } catch {
     }
@@ -24003,7 +24079,7 @@ var init_carrier_divergence = __esm({
 });
 
 // src/scripts/_lib/cc_transcript.ts
-import * as fs38 from "node:fs";
+import * as fs39 from "node:fs";
 import * as path39 from "node:path";
 import { homedir as homedir7 } from "node:os";
 function projectStoreSlug(cwd) {
@@ -24051,7 +24127,7 @@ function parseLine(line) {
 function listTranscriptFiles(opts = {}) {
   const root = opts.root ?? DEFAULT_PROJECTS_ROOT;
   const base = opts.projectDir ? path39.isAbsolute(opts.projectDir) ? opts.projectDir : path39.join(root, opts.projectDir) : root;
-  if (!fs38.existsSync(base)) return [];
+  if (!fs39.existsSync(base)) return [];
   const cutoffMs = opts.maxAgeDays !== void 0 ? (opts.now ?? /* @__PURE__ */ new Date()).getTime() - opts.maxAgeDays * 24 * 60 * 60 * 1e3 : null;
   const out = [];
   const stack = [base];
@@ -24059,7 +24135,7 @@ function listTranscriptFiles(opts = {}) {
     const dir = stack.pop();
     let entries;
     try {
-      entries = fs38.readdirSync(dir, { withFileTypes: true });
+      entries = fs39.readdirSync(dir, { withFileTypes: true });
     } catch {
       continue;
     }
@@ -24073,7 +24149,7 @@ function listTranscriptFiles(opts = {}) {
       if (cutoffMs !== null) {
         let mtimeMs;
         try {
-          mtimeMs = fs38.statSync(full).mtimeMs;
+          mtimeMs = fs39.statSync(full).mtimeMs;
         } catch {
           continue;
         }
@@ -24092,7 +24168,7 @@ function scanTranscripts(opts = {}) {
   for (const file of files) {
     let text;
     try {
-      text = fs38.readFileSync(file, "utf-8");
+      text = fs39.readFileSync(file, "utf-8");
     } catch {
       continue;
     }
@@ -24232,7 +24308,7 @@ __export(pricing_exports, {
   prices_file_for: () => prices_file_for,
   reprice_with_cache: () => reprice_with_cache
 });
-import * as fs39 from "node:fs";
+import * as fs40 from "node:fs";
 import * as path40 from "node:path";
 import { fileURLToPath as fileURLToPath25 } from "node:url";
 function prices_file_for(repo_root) {
@@ -24354,16 +24430,16 @@ function is_stale(table, now) {
   return last < last_monday_utc(now);
 }
 function load_prices(p = PRICES_FILE) {
-  if (!fs39.existsSync(p)) {
+  if (!fs40.existsSync(p)) {
     bootstrap_from_defaults(p);
   }
-  return _parse2(fs39.readFileSync(p, "utf-8"));
+  return _parse2(fs40.readFileSync(p, "utf-8"));
 }
 function bootstrap_from_defaults(p = PRICES_FILE) {
-  fs39.mkdirSync(path40.dirname(p), { recursive: true });
+  fs40.mkdirSync(path40.dirname(p), { recursive: true });
   const rows = as_rows();
   const body = _render_markdown(LAST_UPDATED, "shipped-default", rows);
-  fs39.writeFileSync(p, body, "utf-8");
+  fs40.writeFileSync(p, body, "utf-8");
 }
 function _fmt62f(x) {
   const s = x.toFixed(2);
@@ -24497,7 +24573,7 @@ var init_pricing = __esm({
 
 // src/scripts/cache_realization_report.ts
 import { execFileSync } from "node:child_process";
-import * as fs40 from "node:fs";
+import * as fs41 from "node:fs";
 import { homedir as homedir8 } from "node:os";
 import * as path41 from "node:path";
 import { fileURLToPath as fileURLToPath26, pathToFileURL as pathToFileURL15 } from "node:url";
@@ -24599,14 +24675,14 @@ function computeDuplicateScope(userRulesDir, projectRulesDir, subagentWriteVolum
 }
 function findDebateRoundFiles(councilRoot) {
   const base = path41.join(councilRoot, "agents", "runtime", "council", "responses");
-  if (!fs40.existsSync(base)) return [];
+  if (!fs41.existsSync(base)) return [];
   const out = [];
   const stack = [base];
   while (stack.length > 0) {
     const dir = stack.pop();
     let entries;
     try {
-      entries = fs40.readdirSync(dir, { withFileTypes: true });
+      entries = fs41.readdirSync(dir, { withFileTypes: true });
     } catch {
       continue;
     }
@@ -24655,7 +24731,7 @@ function computeCouncilMispricing(councilRoot) {
     for (const f of groupFiles) {
       let data;
       try {
-        data = JSON.parse(fs40.readFileSync(f, "utf-8"));
+        data = JSON.parse(fs41.readFileSync(f, "utf-8"));
       } catch {
         continue;
       }
@@ -24723,8 +24799,8 @@ function computeWorktreeFragmentation(projectsRoot, worktreePaths, maxAgeDays) {
   }
   const established = worktreePaths[0];
   const encodedEstablished = encodeProjectPath(established);
-  const worktreeDirs = worktreePaths.slice(1).map(encodeProjectPath).filter((d) => fs40.existsSync(path41.join(projectsRoot, d)));
-  if (!fs40.existsSync(path41.join(projectsRoot, encodedEstablished)) || worktreeDirs.length === 0) {
+  const worktreeDirs = worktreePaths.slice(1).map(encodeProjectPath).filter((d) => fs41.existsSync(path41.join(projectsRoot, d)));
+  if (!fs41.existsSync(path41.join(projectsRoot, encodedEstablished)) || worktreeDirs.length === 0) {
     return {
       status: "pending",
       reason: "no transcript directory found for both an established and a fresh-worktree checkout of this repo"
@@ -25004,7 +25080,7 @@ __export(preamble_byte_census_exports, {
   renderText: () => renderText2,
   topRulesByCost: () => topRulesByCost
 });
-import * as fs41 from "node:fs";
+import * as fs42 from "node:fs";
 import { homedir as homedir9 } from "node:os";
 import * as path42 from "node:path";
 import { fileURLToPath as fileURLToPath27, pathToFileURL as pathToFileURL16 } from "node:url";
@@ -25013,19 +25089,19 @@ function tokensFromChars(chars) {
 }
 function readCharsIfExists(p) {
   try {
-    return fs41.statSync(p).size;
+    return fs42.statSync(p).size;
   } catch {
     return 0;
   }
 }
 function topRulesByCost(dir, limit = 10) {
-  if (!fs41.existsSync(dir)) return [];
+  if (!fs42.existsSync(dir)) return [];
   const entries = [];
-  for (const name of fs41.readdirSync(dir)) {
+  for (const name of fs42.readdirSync(dir)) {
     if (!name.endsWith(".md")) continue;
     let chars;
     try {
-      chars = fs41.statSync(path42.join(dir, name)).size;
+      chars = fs42.statSync(path42.join(dir, name)).size;
     } catch {
       continue;
     }
@@ -25037,7 +25113,7 @@ function topRulesByCost(dir, limit = 10) {
 function parseClaudeMdImports(claudeMdPath) {
   let text;
   try {
-    text = fs41.readFileSync(claudeMdPath, "utf-8");
+    text = fs42.readFileSync(claudeMdPath, "utf-8");
   } catch {
     return [];
   }
@@ -25059,11 +25135,11 @@ function censusClaudeMdHierarchy(repoRoot, userHome) {
   const userClaudeMd = path42.join(userHome, ".claude", "CLAUDE.md");
   return {
     project_claude_md_chars: readCharsIfExists(projectClaudeMd),
-    project_claude_md_present: fs41.existsSync(projectClaudeMd),
+    project_claude_md_present: fs42.existsSync(projectClaudeMd),
     project_claude_local_md_chars: readCharsIfExists(projectClaudeLocalMd),
-    project_claude_local_md_present: fs41.existsSync(projectClaudeLocalMd),
+    project_claude_local_md_present: fs42.existsSync(projectClaudeLocalMd),
     user_claude_md_chars: readCharsIfExists(userClaudeMd),
-    user_claude_md_present: fs41.existsSync(userClaudeMd),
+    user_claude_md_present: fs42.existsSync(userClaudeMd),
     user_imports: parseClaudeMdImports(userClaudeMd)
   };
 }
@@ -25085,15 +25161,15 @@ function parseFrontmatter(text) {
   }
 }
 function censusSkillsCatalog(skillsDir) {
-  if (!fs41.existsSync(skillsDir)) return { skills: 0, chars: 0 };
+  if (!fs42.existsSync(skillsDir)) return { skills: 0, chars: 0 };
   let skills = 0;
   let chars = 0;
-  for (const entry of fs41.readdirSync(skillsDir, { withFileTypes: true })) {
+  for (const entry of fs42.readdirSync(skillsDir, { withFileTypes: true })) {
     if (!entry.isDirectory()) continue;
     const skillMd = path42.join(skillsDir, entry.name, "SKILL.md");
     let text;
     try {
-      text = fs41.readFileSync(skillMd, "utf-8");
+      text = fs42.readFileSync(skillMd, "utf-8");
     } catch {
       continue;
     }
@@ -25363,7 +25439,7 @@ __export(dispatch_economy_report_exports, {
   readAuditOrchestrations: () => readAuditOrchestrations,
   renderText: () => renderText3
 });
-import * as fs42 from "node:fs";
+import * as fs43 from "node:fs";
 import * as path43 from "node:path";
 import { fileURLToPath as fileURLToPath28, pathToFileURL as pathToFileURL17 } from "node:url";
 function median2(values) {
@@ -25410,19 +25486,19 @@ function isFiniteNonNegInt(v) {
   return typeof v === "number" && Number.isInteger(v) && v >= 0;
 }
 function readAuditOrchestrations(auditDir, opts = {}) {
-  if (!fs42.existsSync(auditDir)) return [];
+  if (!fs43.existsSync(auditDir)) return [];
   const out = [];
   const cutoffMs = opts.maxAgeDays !== void 0 ? (opts.now ?? /* @__PURE__ */ new Date()).getTime() - opts.maxAgeDays * 24 * 60 * 60 * 1e3 : null;
   let entries;
   try {
-    entries = fs42.readdirSync(auditDir).filter((f) => f.endsWith(".jsonl")).sort();
+    entries = fs43.readdirSync(auditDir).filter((f) => f.endsWith(".jsonl")).sort();
   } catch {
     return [];
   }
   if (cutoffMs !== null) {
     entries = entries.filter((f) => {
       try {
-        return fs42.statSync(path43.join(auditDir, f)).mtimeMs >= cutoffMs;
+        return fs43.statSync(path43.join(auditDir, f)).mtimeMs >= cutoffMs;
       } catch {
         return false;
       }
@@ -25431,7 +25507,7 @@ function readAuditOrchestrations(auditDir, opts = {}) {
   for (const f of entries) {
     let text;
     try {
-      text = fs42.readFileSync(path43.join(auditDir, f), "utf8");
+      text = fs43.readFileSync(path43.join(auditDir, f), "utf8");
     } catch {
       continue;
     }
@@ -25453,7 +25529,7 @@ function readAuditOrchestrations(auditDir, opts = {}) {
   return out;
 }
 function buildReport3(opts) {
-  const registrationRaw = fs42.readFileSync(REGISTRATION_FILE, "utf8");
+  const registrationRaw = fs43.readFileSync(REGISTRATION_FILE, "utf8");
   const registration = JSON.parse(registrationRaw);
   const scanOpts = {
     root: opts.root,
@@ -25617,7 +25693,7 @@ function _isCliEntry15() {
   const argvUrl = pathToFileURL17(path43.resolve(process.argv[1])).href;
   if (import.meta.url === argvUrl) return true;
   try {
-    return fs42.realpathSync(fileURLToPath28(import.meta.url)) === fs42.realpathSync(path43.resolve(process.argv[1]));
+    return fs43.realpathSync(fileURLToPath28(import.meta.url)) === fs43.realpathSync(path43.resolve(process.argv[1]));
   } catch {
     return false;
   }
@@ -25637,11 +25713,11 @@ var init_dispatch_economy_report = __esm({
 });
 
 // src/scripts/_lib/git_common_dir.ts
-import fs43 from "node:fs";
+import fs44 from "node:fs";
 import path44 from "node:path";
 function realpath_or_self(p) {
   try {
-    return fs43.realpathSync(p);
+    return fs44.realpathSync(p);
   } catch {
     return p;
   }
@@ -25649,18 +25725,18 @@ function realpath_or_self(p) {
 function git_common_dir(project_root) {
   const dot_git = path44.join(project_root, ".git");
   try {
-    const st = fs43.statSync(dot_git);
+    const st = fs44.statSync(dot_git);
     if (st.isDirectory()) {
       return realpath_or_self(dot_git);
     }
-    const m = fs43.readFileSync(dot_git, "utf-8").match(/^gitdir:\s*(.+)\s*$/m);
+    const m = fs44.readFileSync(dot_git, "utf-8").match(/^gitdir:\s*(.+)\s*$/m);
     if (m === null) {
       return null;
     }
     const gitdir = path44.resolve(project_root, m[1].trim());
     const commondir_file = path44.join(gitdir, "commondir");
-    if (fs43.existsSync(commondir_file)) {
-      const common = path44.resolve(gitdir, fs43.readFileSync(commondir_file, "utf-8").trim());
+    if (fs44.existsSync(commondir_file)) {
+      const common = path44.resolve(gitdir, fs44.readFileSync(commondir_file, "utf-8").trim());
       return realpath_or_self(common);
     }
     return realpath_or_self(gitdir);
@@ -25850,7 +25926,7 @@ var init_py_json = __esm({
 });
 
 // src/scripts/ai_council/cli_call_budget.ts
-import * as fs44 from "node:fs";
+import * as fs45 from "node:fs";
 import * as path45 from "node:path";
 function attributionPath(target) {
   return `${target}${CLI_CALLS_ATTRIBUTION_SUFFIX}`;
@@ -25876,14 +25952,14 @@ function resolveCliCallCaps(raw, validProviders) {
   return out;
 }
 function writeStateAtomically(target, payload) {
-  fs44.mkdirSync(path45.dirname(target), { recursive: true });
+  fs45.mkdirSync(path45.dirname(target), { recursive: true });
   const tmp = `${target}.${process.pid}.${_monotonicish()}.tmp`;
   try {
-    fs44.writeFileSync(tmp, payload, { encoding: "utf-8" });
-    fs44.renameSync(tmp, target);
+    fs45.writeFileSync(tmp, payload, { encoding: "utf-8" });
+    fs45.renameSync(tmp, target);
   } catch (exc) {
     try {
-      fs44.unlinkSync(tmp);
+      fs45.unlinkSync(tmp);
     } catch {
     }
     throw exc;
@@ -25896,14 +25972,14 @@ function withStateLock(target, fn) {
   const started = _monotonicish();
   while (_monotonicish() - started < waitMs) {
     try {
-      fs44.mkdirSync(path45.dirname(lockPath), { recursive: true });
-      fs44.closeSync(fs44.openSync(lockPath, "wx"));
+      fs45.mkdirSync(path45.dirname(lockPath), { recursive: true });
+      fs45.closeSync(fs45.openSync(lockPath, "wx"));
       held = true;
       break;
     } catch {
       try {
-        if (_monotonicish() - fs44.statSync(lockPath).mtimeMs > waitMs) {
-          fs44.unlinkSync(lockPath);
+        if (_monotonicish() - fs45.statSync(lockPath).mtimeMs > waitMs) {
+          fs45.unlinkSync(lockPath);
           continue;
         }
       } catch {
@@ -25916,7 +25992,7 @@ function withStateLock(target, fn) {
   } finally {
     if (held) {
       try {
-        fs44.unlinkSync(lockPath);
+        fs45.unlinkSync(lockPath);
       } catch {
       }
     }
@@ -25924,12 +26000,12 @@ function withStateLock(target, fn) {
 }
 function readAttribution(target, todayIso) {
   const p = attributionPath(target);
-  if (!fs44.existsSync(p)) {
+  if (!fs45.existsSync(p)) {
     return {};
   }
   let data;
   try {
-    data = JSON.parse(fs44.readFileSync(p, { encoding: "utf-8" }));
+    data = JSON.parse(fs45.readFileSync(p, { encoding: "utf-8" }));
   } catch {
     return {};
   }
@@ -26081,7 +26157,7 @@ var init_quorum = __esm({
 
 // src/scripts/ai_council/events_log.ts
 import * as crypto4 from "node:crypto";
-import * as fs45 from "node:fs";
+import * as fs46 from "node:fs";
 import * as path46 from "node:path";
 import { fileURLToPath as fileURLToPath29 } from "node:url";
 function _hash_original_ask(originalAsk) {
@@ -26177,9 +26253,9 @@ function appendEvent(event, opts = {}) {
     }
   }
   const target = opts.logPath != null ? opts.logPath : _DEFAULT_LOG_PATH;
-  fs45.mkdirSync(path46.dirname(target), { recursive: true });
+  fs46.mkdirSync(path46.dirname(target), { recursive: true });
   const line = _pyJsonDumpsCompact(record);
-  fs45.appendFileSync(target, line + "\n", { encoding: "utf-8" });
+  fs46.appendFileSync(target, line + "\n", { encoding: "utf-8" });
   return true;
 }
 function appendQuorumEvent(input, opts = {}) {
@@ -26425,8 +26501,8 @@ __export(clients_exports, {
   record_cli_call: () => record_cli_call,
   reset_cli_call_counts: () => reset_cli_call_counts
 });
-import { spawnSync as spawnSync8 } from "node:child_process";
-import * as fs46 from "node:fs";
+import { spawnSync as spawnSync9 } from "node:child_process";
+import * as fs47 from "node:fs";
 import * as os8 from "node:os";
 import * as path47 from "node:path";
 function _subagentModelCeiling(cwd = process.cwd()) {
@@ -26486,13 +26562,13 @@ function _setMonotonicSource(fn) {
   return prev;
 }
 function _loadKey(p, prefix, installScript) {
-  if (!fs46.existsSync(p)) {
+  if (!fs47.existsSync(p)) {
     throw new KeyGateError(
       `Key not found at ${p}.
     Install it with: bash ${installScript}`
     );
   }
-  const st = fs46.statSync(p);
+  const st = fs47.statSync(p);
   const mode = st.mode & 511;
   if (mode !== 384) {
     throw new KeyGateError(
@@ -26500,7 +26576,7 @@ function _loadKey(p, prefix, installScript) {
     Fix:  chmod 600 ${p}`
     );
   }
-  const key = fs46.readFileSync(p, { encoding: "utf-8" }).trim();
+  const key = fs47.readFileSync(p, { encoding: "utf-8" }).trim();
   if (!key) {
     throw new KeyGateError(`${p} is empty.`);
   }
@@ -26540,7 +26616,7 @@ function _curlJsonPost(url, extraHeaders, body) {
   }
   args.push("--connect-timeout", "30", "--max-time", "290");
   args.push("-w", "\n%{http_code}", "--data-binary", "@-");
-  const r = spawnSync8("curl", args, {
+  const r = spawnSync9("curl", args, {
     input: JSON.stringify(body),
     encoding: "utf8",
     maxBuffer: 64 * 1024 * 1024,
@@ -26573,12 +26649,12 @@ function _today_utc_iso() {
 }
 function load_cli_call_counts(p = null) {
   const target = p !== null ? p : _cliCallsStatePath();
-  if (!fs46.existsSync(target)) {
+  if (!fs47.existsSync(target)) {
     return {};
   }
   let data;
   try {
-    data = JSON.parse(fs46.readFileSync(target, { encoding: "utf-8" }));
+    data = JSON.parse(fs47.readFileSync(target, { encoding: "utf-8" }));
   } catch {
     return {};
   }
@@ -26850,7 +26926,7 @@ function _which(name) {
 }
 function _isExecutable(p) {
   try {
-    const st = fs46.statSync(p);
+    const st = fs47.statSync(p);
     if (!st.isFile()) {
       return false;
     }
@@ -26877,7 +26953,7 @@ function _defaultStdin() {
   function ensure() {
     if (buffer === null) {
       try {
-        buffer = fs46.readFileSync(0, { encoding: "utf-8" });
+        buffer = fs47.readFileSync(0, { encoding: "utf-8" });
       } catch {
         buffer = "";
       }
@@ -27573,7 +27649,7 @@ ${user_prompt}`;
         if (stdinPayload !== null) {
           spawnOpts.input = stdinPayload;
         }
-        const r = spawnSync8(argv0, cmd.slice(1), spawnOpts);
+        const r = spawnSync9(argv0, cmd.slice(1), spawnOpts);
         if (r.error) {
           const err = r.error;
           if (r.signal === "SIGTERM" || err.code === "ETIMEDOUT") {
@@ -28418,7 +28494,7 @@ __export(config_exports, {
   resolve_cli_call_caps: () => resolve_cli_call_caps,
   resolve_config_path: () => resolve_config_path
 });
-import * as fs47 from "node:fs";
+import * as fs48 from "node:fs";
 import * as os9 from "node:os";
 import * as path48 from "node:path";
 function _pyReprStr(s) {
@@ -28620,14 +28696,14 @@ function resolve_config_path(project_root, options = {}) {
   });
 }
 function load_council_config(p) {
-  if (!fs47.existsSync(p)) {
+  if (!fs48.existsSync(p)) {
     throw new CouncilConfigError(
       `Council config not found at ${p}. Create it per docs/contracts/ai-council-config.md.`
     );
   }
   let raw;
   try {
-    const text = fs47.readFileSync(p, "utf-8");
+    const text = fs48.readFileSync(p, "utf-8");
     const parsed = (0, import_yaml5.parse)(text, { version: "1.1" });
     raw = parsed === null || parsed === void 0 ? {} : parsed;
   } catch (exc) {
@@ -29651,16 +29727,16 @@ function resolve_api_key(ref, scope = "api_key_ref") {
     }
     resolved = found;
   }
-  if (!fs47.existsSync(resolved)) {
+  if (!fs48.existsSync(resolved)) {
     throw new CouncilConfigError(`${scope}: key file does not exist at ${resolved}.`);
   }
-  const mode = fs47.statSync(resolved).mode & 4095;
+  const mode = fs48.statSync(resolved).mode & 4095;
   if (mode !== 384) {
     throw new CouncilConfigError(
       `${scope}: unsafe permissions on ${resolved}: got ${_pyOct(mode)}, expected 0o600. Fix:  chmod 600 ${resolved}`
     );
   }
-  const value = fs47.readFileSync(resolved, "utf-8").trim();
+  const value = fs48.readFileSync(resolved, "utf-8").trim();
   if (value === "") {
     throw new CouncilConfigError(`${scope}: key file at ${resolved} is empty.`);
   }
@@ -29780,7 +29856,7 @@ var init_config = __esm({
 });
 
 // src/install/toolDetection.ts
-import { existsSync as existsSync23 } from "node:fs";
+import { existsSync as existsSync24 } from "node:fs";
 import { homedir as homedir11 } from "node:os";
 import { delimiter as delimiter2, join as join44 } from "node:path";
 function knownToolIds() {
@@ -29803,7 +29879,7 @@ function resolveBinaryPath(name, pathEnv) {
     if (dir.length === 0) continue;
     for (const candidate of [name, `${name}.exe`, `${name}.cmd`]) {
       const full = join44(dir, candidate);
-      if (existsSync23(full)) return full;
+      if (existsSync24(full)) return full;
     }
   }
   return null;
@@ -29813,10 +29889,10 @@ function binOnPath(name, pathEnv) {
 }
 function isToolInstalled(signal, home, pathEnv) {
   for (const rel of signal.homePaths ?? []) {
-    if (existsSync23(join44(home, rel))) return true;
+    if (existsSync24(join44(home, rel))) return true;
   }
   for (const abs of signal.absPaths ?? []) {
-    if (existsSync23(abs)) return true;
+    if (existsSync24(abs)) return true;
   }
   for (const bin of signal.bins ?? []) {
     if (binOnPath(bin, pathEnv)) return true;
@@ -29884,8 +29960,8 @@ var init_agentSwitchDetection = __esm({
 });
 
 // src/scripts/_lib/environment_detector.ts
-import { spawnSync as spawnSync9 } from "node:child_process";
-import * as fs48 from "node:fs";
+import { spawnSync as spawnSync10 } from "node:child_process";
+import * as fs49 from "node:fs";
 import * as os10 from "node:os";
 import * as path49 from "node:path";
 function knownProviders() {
@@ -29912,7 +29988,7 @@ function homeOf(env) {
 function defaultProbeKeychain(service) {
   if (process.platform !== "darwin") return false;
   try {
-    const res = spawnSync9("security", ["find-generic-password", "-s", service], {
+    const res = spawnSync10("security", ["find-generic-password", "-s", service], {
       timeout: VERSION_PROBE_TIMEOUT_MS,
       encoding: "utf-8",
       windowsHide: true,
@@ -29926,7 +30002,7 @@ function defaultProbeKeychain(service) {
 }
 function defaultProbeVersion(binary) {
   try {
-    const res = spawnSync9(binary, ["--version"], {
+    const res = spawnSync10(binary, ["--version"], {
       timeout: VERSION_PROBE_TIMEOUT_MS,
       encoding: "utf-8",
       windowsHide: true,
@@ -29941,14 +30017,14 @@ ${res.stderr ?? ""}`;
 }
 function isFile2(p) {
   try {
-    return fs48.statSync(p).isFile();
+    return fs49.statSync(p).isFile();
   } catch {
     return false;
   }
 }
 function exists2(p) {
   try {
-    return fs48.existsSync(p);
+    return fs49.existsSync(p);
   } catch {
     return false;
   }
@@ -29956,7 +30032,7 @@ function exists2(p) {
 function classifyCodexAuth(authPath) {
   let data;
   try {
-    data = JSON.parse(fs48.readFileSync(authPath, "utf-8"));
+    data = JSON.parse(fs49.readFileSync(authPath, "utf-8"));
   } catch {
     return "cli-api-key";
   }
@@ -30696,7 +30772,7 @@ var init_detection_report = __esm({
 
 // src/scripts/hooks/state_io.ts
 import { createHash as createHash6 } from "node:crypto";
-import fs49 from "node:fs";
+import fs50 from "node:fs";
 import path51 from "node:path";
 function is_replay_mode() {
   return (process.env[REPLAY_ENV_VAR2] ?? "").trim() === "1";
@@ -30800,7 +30876,7 @@ function atomic_write_json(target, payload, options = {}) {
   const indent = options.indent ?? 2;
   const targetPath = path51.resolve(target);
   const state_dir = path51.dirname(targetPath);
-  fs49.mkdirSync(state_dir, { recursive: true });
+  fs50.mkdirSync(state_dir, { recursive: true });
   const body = _py_json_dumps(payload, indent) + "\n";
   _atomic_write_text2(targetPath, body);
 }
@@ -30810,7 +30886,7 @@ function atomic_write_text(target, text) {
   }
   const targetPath = path51.resolve(target);
   const state_dir = path51.dirname(targetPath);
-  fs49.mkdirSync(state_dir, { recursive: true });
+  fs50.mkdirSync(state_dir, { recursive: true });
   _atomic_write_text2(targetPath, text);
 }
 function _sleep(ms) {
@@ -30819,11 +30895,11 @@ function _sleep(ms) {
 }
 function _acquire_lock(lock_path, options = {}) {
   const blocking = options.blocking ?? true;
-  const fd = fs49.openSync(lock_path, "a", 420);
+  const fd = fs50.openSync(lock_path, "a", 420);
   const held = lock_path + ".held";
   const give_up = () => {
     try {
-      fs49.closeSync(fd);
+      fs50.closeSync(fd);
     } catch {
     }
     return null;
@@ -30831,8 +30907,8 @@ function _acquire_lock(lock_path, options = {}) {
   const start = Date.now();
   for (; ; ) {
     try {
-      const heldFd = fs49.openSync(held, "wx", 420);
-      fs49.closeSync(heldFd);
+      const heldFd = fs50.openSync(held, "wx", 420);
+      fs50.closeSync(heldFd);
       return fd;
     } catch (err) {
       if (err.code !== "EEXIST") {
@@ -30840,13 +30916,13 @@ function _acquire_lock(lock_path, options = {}) {
       }
       let age_ms;
       try {
-        age_ms = Date.now() - fs49.statSync(held).mtimeMs;
+        age_ms = Date.now() - fs50.statSync(held).mtimeMs;
       } catch {
         continue;
       }
       if (age_ms >= LOCK_STALE_MS) {
         try {
-          fs49.rmSync(held, { force: true });
+          fs50.rmSync(held, { force: true });
         } catch {
         }
         continue;
@@ -30863,18 +30939,18 @@ function _acquire_lock(lock_path, options = {}) {
 }
 function _release_lock(fd, lock_path) {
   try {
-    fs49.closeSync(fd);
+    fs50.closeSync(fd);
   } catch {
   }
   try {
-    fs49.rmSync(lock_path + ".held", { force: true });
+    fs50.rmSync(lock_path + ".held", { force: true });
   } catch {
   }
 }
 function _publish_text_locked(target, text) {
   const tmp = target + `.tmp.${process.pid}`;
-  fs49.writeFileSync(tmp, text, { encoding: "utf-8" });
-  fs49.renameSync(tmp, target);
+  fs50.writeFileSync(tmp, text, { encoding: "utf-8" });
+  fs50.renameSync(tmp, target);
 }
 function _atomic_write_text2(target, text) {
   const lock_path = _lock_path(path51.dirname(target));
@@ -30896,27 +30972,27 @@ function session_state_file(dir, session_id) {
   const digest = createHash6("sha256").update(session_id, "utf8").digest("hex").slice(0, 32);
   return path51.join(dir, `${digest}.json`);
 }
-function restore_claimed_state(tomb, live, link = fs49.linkSync) {
+function restore_claimed_state(tomb, live, link = fs50.linkSync) {
   try {
     link(tomb, live);
   } catch (err) {
     const code = err.code;
     if (code !== "EEXIST" && code !== "ENOENT") {
       if (!NO_HARD_LINK_CODES.has(code ?? "")) throw err;
-      if (!fs49.existsSync(live)) {
-        fs49.renameSync(tomb, live);
+      if (!fs50.existsSync(live)) {
+        fs50.renameSync(tomb, live);
         return;
       }
     }
   }
-  fs49.rmSync(tomb, { force: true });
+  fs50.rmSync(tomb, { force: true });
 }
-function prune_stale_session_states(dir, now_ms, retention_days, mtime_of = (target) => fs49.statSync(target).mtimeMs) {
+function prune_stale_session_states(dir, now_ms, retention_days, mtime_of = (target) => fs50.statSync(target).mtimeMs) {
   if (is_replay_mode()) return 0;
   const cutoff = now_ms - retention_days * 24 * 60 * 60 * 1e3;
   let entries;
   try {
-    entries = fs49.readdirSync(dir);
+    entries = fs50.readdirSync(dir);
   } catch {
     return 0;
   }
@@ -30933,7 +31009,7 @@ function prune_stale_session_states(dir, now_ms, retention_days, mtime_of = (tar
         restore_claimed_state(tomb, live);
         continue;
       }
-      fs49.rmSync(tomb, { force: true });
+      fs50.rmSync(tomb, { force: true });
       removed += 1;
     } catch {
     }
@@ -30945,15 +31021,15 @@ function prune_stale_session_states(dir, now_ms, retention_days, mtime_of = (tar
       if (mtime_of(full) >= cutoff) continue;
       claim += 1;
       const tomb = `${full}.${process.pid}.${claim}.tomb`;
-      fs49.renameSync(full, tomb);
+      fs50.renameSync(full, tomb);
       if (mtime_of(tomb) >= cutoff) {
         restore_claimed_state(tomb, full);
         continue;
       }
-      fs49.rmSync(tomb, { force: true });
+      fs50.rmSync(tomb, { force: true });
       for (const suffix of [".lock", ".lock.held"]) {
         try {
-          fs49.rmSync(`${full}${suffix}`, { force: true });
+          fs50.rmSync(`${full}${suffix}`, { force: true });
         } catch {
         }
       }
@@ -30966,8 +31042,8 @@ function prune_stale_session_states(dir, now_ms, retention_days, mtime_of = (tar
 function prune_legacy_state_file(target) {
   if (is_replay_mode()) return;
   try {
-    if (fs49.statSync(target).isFile()) {
-      fs49.rmSync(target, { force: true });
+    if (fs50.statSync(target).isFile()) {
+      fs50.rmSync(target, { force: true });
     }
   } catch {
   }
@@ -30981,7 +31057,7 @@ function update_json_under_lock(target, mutate, options = {}) {
   const targetPath = path51.resolve(target);
   const state_dir = path51.dirname(targetPath);
   try {
-    fs49.mkdirSync(state_dir, { recursive: true });
+    fs50.mkdirSync(state_dir, { recursive: true });
   } catch {
     return "failed";
   }
@@ -30996,7 +31072,7 @@ function update_json_under_lock(target, mutate, options = {}) {
   try {
     let loaded = {};
     try {
-      const raw = fs49.readFileSync(targetPath, "utf-8");
+      const raw = fs50.readFileSync(targetPath, "utf-8");
       const decoded = JSON.parse(raw);
       if (typeof decoded === "object" && decoded !== null && !Array.isArray(decoded)) {
         loaded = decoded;
@@ -31048,13 +31124,13 @@ var init_config2 = __esm({
 
 // src/scripts/ai_team/review_gate.ts
 import * as crypto5 from "node:crypto";
-import * as fs50 from "node:fs";
+import * as fs51 from "node:fs";
 import * as os11 from "node:os";
 import * as path52 from "node:path";
 function _workspace_state_segment(workspace_root) {
   let canonical = workspace_root;
   try {
-    canonical = fs50.realpathSync.native(workspace_root);
+    canonical = fs51.realpathSync.native(workspace_root);
   } catch {
     canonical = workspace_root;
   }
@@ -31080,7 +31156,7 @@ function upstream_gate_enabled(workspace_root) {
   for (const dir of upstream_state_dir_candidates(workspace_root)) {
     let parsed;
     try {
-      parsed = JSON.parse(fs50.readFileSync(path52.join(dir, "state.json"), "utf-8"));
+      parsed = JSON.parse(fs51.readFileSync(path52.join(dir, "state.json"), "utf-8"));
     } catch {
       continue;
     }
@@ -31148,7 +31224,7 @@ var init_surface_tiers = __esm({
 });
 
 // src/scripts/_lib/scoped_projection.ts
-import * as fs51 from "node:fs";
+import * as fs52 from "node:fs";
 import { createRequire as createRequire5 } from "node:module";
 import * as path53 from "node:path";
 function isPlainObject3(v) {
@@ -31169,7 +31245,7 @@ function yamlSafeLoad(text) {
 }
 function load_packs_registry(package_root) {
   const vocab_path = path53.join(package_root, PACKS_YML_REL);
-  const data = yamlSafeLoad(fs51.readFileSync(vocab_path, "utf-8"));
+  const data = yamlSafeLoad(fs52.readFileSync(vocab_path, "utf-8"));
   if (!Array.isArray(data)) {
     throw new Error(`packs.yml did not parse to a list: ${vocab_path}`);
   }
@@ -31247,7 +31323,7 @@ var init_scoped_projection = __esm({
 });
 
 // src/install/ruleInScope.ts
-import * as fs52 from "node:fs";
+import * as fs53 from "node:fs";
 function parseYaml4(text) {
   try {
     const data = YAML5.parse(text, { version: "1.1" });
@@ -31285,7 +31361,7 @@ function rule_in_scope(source_path, scope, pack_scope = null, role_scope = null)
   if (scope === null && pack_scope === null && role_scope === null) {
     return true;
   }
-  const [meta] = parseFrontmatter2(fs52.readFileSync(source_path, "utf-8"));
+  const [meta] = parseFrontmatter2(fs53.readFileSync(source_path, "utf-8"));
   if (meta["type"] === "always" || meta["alwaysApply"] === true) {
     return true;
   }
@@ -31310,7 +31386,7 @@ var init_ruleInScope = __esm({
 });
 
 // src/install/rule_scope.ts
-import * as fs53 from "node:fs";
+import * as fs54 from "node:fs";
 import * as path54 from "node:path";
 function _list(value) {
   if (Array.isArray(value) && value.length > 0) {
@@ -31352,7 +31428,7 @@ function ruleFileArrives(sourcePath, scope) {
 function excludedRuleBasenames(rulesDir, scope) {
   let entries;
   try {
-    entries = fs53.readdirSync(rulesDir).sort();
+    entries = fs54.readdirSync(rulesDir).sort();
   } catch {
     return [];
   }
@@ -31363,7 +31439,7 @@ function excludedRuleBasenames(rulesDir, scope) {
     }
     const full = path54.join(rulesDir, name);
     try {
-      if (!fs53.statSync(full).isFile()) {
+      if (!fs54.statSync(full).isFile()) {
         continue;
       }
     } catch {
@@ -31456,7 +31532,7 @@ __export(cmd_doctor_exports, {
   shutilWhich: () => shutilWhich
 });
 import * as crypto6 from "node:crypto";
-import * as fs54 from "node:fs";
+import * as fs55 from "node:fs";
 import * as os12 from "node:os";
 import * as path55 from "node:path";
 import process15 from "node:process";
@@ -31470,7 +31546,7 @@ function expanduser5(p) {
 }
 function pathExists(p) {
   try {
-    fs54.statSync(p);
+    fs55.statSync(p);
     return true;
   } catch {
     return false;
@@ -31478,27 +31554,27 @@ function pathExists(p) {
 }
 function isFile3(p) {
   try {
-    return fs54.statSync(p).isFile();
+    return fs55.statSync(p).isFile();
   } catch {
     return false;
   }
 }
 function isDir2(p) {
   try {
-    return fs54.statSync(p).isDirectory();
+    return fs55.statSync(p).isDirectory();
   } catch {
     return false;
   }
 }
 function resolvePath(p) {
   try {
-    return fs54.realpathSync(path55.resolve(p));
+    return fs55.realpathSync(path55.resolve(p));
   } catch {
     return path55.resolve(p);
   }
 }
 function readText2(p) {
-  return fs54.readFileSync(p, "utf-8");
+  return fs55.readFileSync(p, "utf-8");
 }
 function _jsonStrAscii3(s) {
   let out = '"';
@@ -31713,7 +31789,7 @@ function _resolve_path(project_root, raw) {
 }
 function _sha256(p) {
   try {
-    const data = fs54.readFileSync(p);
+    const data = fs55.readFileSync(p);
     return crypto6.createHash("sha256").update(data).digest("hex");
   } catch {
     return null;
@@ -31849,7 +31925,7 @@ function rglob2(root) {
   const walk = (dir) => {
     let entries;
     try {
-      entries = fs54.readdirSync(dir, { withFileTypes: true });
+      entries = fs55.readdirSync(dir, { withFileTypes: true });
     } catch {
       return;
     }
@@ -32137,10 +32213,10 @@ function shutilWhich(name) {
 }
 function isExecutableFile(p) {
   try {
-    const st = fs54.statSync(p);
+    const st = fs55.statSync(p);
     if (!st.isFile()) return false;
     if (process15.platform === "win32") return true;
-    fs54.accessSync(p, fs54.constants.X_OK);
+    fs55.accessSync(p, fs55.constants.X_OK);
     return true;
   } catch {
     return false;
@@ -32251,8 +32327,8 @@ function _check_claude_command_wrappers() {
       remedy: ""
     };
   }
-  const flat_probe = fs54.existsSync(path55.join(commands_dir, "commit.md"));
-  const wrapper_probe = fs54.existsSync(path55.join(anchor, "skills", "commit", "SKILL.md"));
+  const flat_probe = fs55.existsSync(path55.join(commands_dir, "commit.md"));
+  const wrapper_probe = fs55.existsSync(path55.join(anchor, "skills", "commit", "SKILL.md"));
   if (wrapper_probe) {
     return {
       id: "claude-command-wrappers",
@@ -32343,7 +32419,7 @@ function _check_surface_state() {
 }
 function pathExistsAny(p) {
   try {
-    fs54.statSync(p);
+    fs55.statSync(p);
     return true;
   } catch {
     return false;
@@ -32365,7 +32441,7 @@ function _check_hook_wiring() {
     const matrix = build_claude_hook_matrix(
       path55.join(_package_root(), "src", "scripts", "hook_manifest.yaml")
     );
-    const settings = pathExists(settings_path) ? JSON.parse(fs54.readFileSync(settings_path, "utf8")) : {};
+    const settings = pathExists(settings_path) ? JSON.parse(fs55.readFileSync(settings_path, "utf8")) : {};
     const hooks = (settings["hooks"] ?? {}) || {};
     missing = Object.keys(matrix).filter((ev) => {
       const groups = hooks[ev];
@@ -32600,7 +32676,7 @@ function _check_rule_scope_drift(project_root) {
     }
     let count = 0;
     try {
-      for (const name of fs54.readdirSync(cand)) {
+      for (const name of fs55.readdirSync(cand)) {
         if (name.endsWith(".md") && isFile3(path55.join(cand, name))) {
           count += 1;
         }
@@ -32862,7 +32938,7 @@ function _check_tier_usage_readiness(project_root) {
   };
 }
 function readText0(p) {
-  return fs54.readFileSync(p, "utf-8");
+  return fs55.readFileSync(p, "utf-8");
 }
 function osErrorStr2(exc) {
   if (exc && typeof exc === "object" && "message" in exc) {
@@ -33034,7 +33110,7 @@ function _epoch_seconds(value) {
 function _codex_auth_expiry(auth_path) {
   let data;
   try {
-    data = JSON.parse(fs54.readFileSync(auth_path, "utf-8"));
+    data = JSON.parse(fs55.readFileSync(auth_path, "utf-8"));
   } catch {
     return null;
   }
@@ -33877,7 +33953,7 @@ function _run_repair(opts) {
     };
     if (exists3) {
       try {
-        fs54.unlinkSync(state_pth);
+        fs55.unlinkSync(state_pth);
       } catch (exc) {
         payload["action"] = "error";
         payload["error"] = osErrorStr2(exc);
@@ -33990,8 +34066,8 @@ function _isCliEntry16() {
     return true;
   }
   try {
-    const here = fs54.realpathSync(fileURLToPath30(import.meta.url));
-    const argv = fs54.realpathSync(path55.resolve(process15.argv[1]));
+    const here = fs55.realpathSync(fileURLToPath30(import.meta.url));
+    const argv = fs55.realpathSync(path55.resolve(process15.argv[1]));
     return here === argv;
   } catch {
     return false;
@@ -34152,12 +34228,12 @@ var init_cmd_doctor = __esm({
 });
 
 // src/install/txlog.ts
-import { createReadStream, createWriteStream, existsSync as existsSync26, readFileSync as readFileSync43, renameSync as renameSync8, statSync as statSync33, unlinkSync as unlinkSync7 } from "node:fs";
+import { createReadStream, createWriteStream, existsSync as existsSync27, readFileSync as readFileSync44, renameSync as renameSync8, statSync as statSync33, unlinkSync as unlinkSync7 } from "node:fs";
 function readRecentEntries(logPath) {
-  if (!existsSync26(logPath)) {
+  if (!existsSync27(logPath)) {
     return [];
   }
-  const raw = readFileSync43(logPath, "utf8");
+  const raw = readFileSync44(logPath, "utf8");
   const lines = raw.split("\n").filter((l) => l.length > 0);
   const tail = lines.slice(-RECOVERY_DEPTH_CAP);
   const out = [];
@@ -34192,7 +34268,7 @@ var init_txlog = __esm({
 });
 
 // src/install/detect.ts
-import { existsSync as existsSync27, readFileSync as readFileSync44, readdirSync as readdirSync28, statSync as statSync34 } from "node:fs";
+import { existsSync as existsSync28, readFileSync as readFileSync45, readdirSync as readdirSync28, statSync as statSync34 } from "node:fs";
 import { join as join50, resolve as resolve30 } from "node:path";
 function detectToolPresence(root) {
   return {
@@ -34200,8 +34276,8 @@ function detectToolPresence(root) {
     claude: isDir3(join50(root, ".claude")),
     cursor: isDir3(join50(root, ".cursor")),
     cline: isDir3(join50(root, ".clinerules")),
-    windsurf: isDir3(join50(root, ".windsurf")) || existsSync27(join50(root, ".windsurfrules")),
-    agentsMd: existsSync27(join50(root, "AGENTS.md"))
+    windsurf: isDir3(join50(root, ".windsurf")) || existsSync28(join50(root, ".windsurfrules")),
+    agentsMd: existsSync28(join50(root, "AGENTS.md"))
   };
 }
 function isDir3(path81) {
@@ -34314,7 +34390,7 @@ var init_prompt_shape = __esm({
 });
 
 // src/scripts/language_mirror_hook.ts
-import fs55 from "node:fs";
+import fs56 from "node:fs";
 import path56 from "node:path";
 import { fileURLToPath as fileURLToPath31, pathToFileURL as pathToFileURL19 } from "node:url";
 function hasStableSessionId(session_id) {
@@ -34413,7 +34489,7 @@ This pin exists because the trigger is not observable from the transcript alone:
 }
 function _loadState(target) {
   try {
-    const raw = fs55.readFileSync(target, "utf8");
+    const raw = fs56.readFileSync(target, "utf8");
     const decoded = JSON.parse(raw);
     return _isObject3(decoded) ? decoded : {};
   } catch {
@@ -34469,8 +34545,8 @@ function _sessionId(envelope) {
 function _migrateLegacyMarker(consumer_root) {
   const legacy = path56.join(consumer_root, PIN_LOST_DIR);
   try {
-    if (fs55.statSync(legacy).isFile()) {
-      fs55.rmSync(legacy, { force: true });
+    if (fs56.statSync(legacy).isFile()) {
+      fs56.rmSync(legacy, { force: true });
     }
   } catch {
   }
@@ -34485,7 +34561,7 @@ function _setPinLost(consumer_root, session_id) {
 }
 function _pinLost(consumer_root, session_id) {
   try {
-    return fs55.existsSync(path56.join(consumer_root, pinLostMarker(session_id)));
+    return fs56.existsSync(path56.join(consumer_root, pinLostMarker(session_id)));
   } catch {
     return false;
   }
@@ -34493,7 +34569,7 @@ function _pinLost(consumer_root, session_id) {
 function _clearPinLost(consumer_root, session_id) {
   if (is_replay_mode()) return;
   try {
-    fs55.rmSync(path56.join(consumer_root, pinLostMarker(session_id)), { force: true });
+    fs56.rmSync(path56.join(consumer_root, pinLostMarker(session_id)), { force: true });
   } catch {
   }
 }
@@ -34532,7 +34608,7 @@ function _reEmitAfterCompaction(consumer_root, session_id, write_json = atomic_w
 function _pruneLegacyState(consumer_root) {
   prune_legacy_state_file(path56.join(consumer_root, STATE_FILE));
 }
-function _pruneStaleSessions(consumer_root, now_ms, mtimeOf = (target) => fs55.statSync(target).mtimeMs) {
+function _pruneStaleSessions(consumer_root, now_ms, mtimeOf = (target) => fs56.statSync(target).mtimeMs) {
   return prune_stale_session_states(
     path56.join(consumer_root, STATE_DIR),
     now_ms,
@@ -34545,20 +34621,20 @@ function _withToolWriteLock(consumer_root, session_id, when_busy, body, now_ms =
   let fd;
   const acquire = () => {
     try {
-      fs55.mkdirSync(path56.dirname(lock), { recursive: true });
-      return fs55.openSync(lock, "wx");
+      fs56.mkdirSync(path56.dirname(lock), { recursive: true });
+      return fs56.openSync(lock, "wx");
     } catch (err) {
       if (err.code !== "EEXIST") return null;
       let age;
       try {
-        age = now_ms - fs55.statSync(lock).mtimeMs;
+        age = now_ms - fs56.statSync(lock).mtimeMs;
       } catch {
         return null;
       }
       if (age < LOCK_STALE_MS2) return null;
       try {
-        fs55.rmSync(lock, { force: true });
-        return fs55.openSync(lock, "wx");
+        fs56.rmSync(lock, { force: true });
+        return fs56.openSync(lock, "wx");
       } catch {
         return null;
       }
@@ -34571,11 +34647,11 @@ function _withToolWriteLock(consumer_root, session_id, when_busy, body, now_ms =
     return body();
   } finally {
     try {
-      fs55.closeSync(fd);
+      fs56.closeSync(fd);
     } catch {
     }
     try {
-      fs55.rmSync(lock, { force: true });
+      fs56.rmSync(lock, { force: true });
     } catch {
     }
   }
@@ -34743,8 +34819,8 @@ function _isCliEntry17() {
     return true;
   }
   try {
-    const here = fs55.realpathSync(fileURLToPath31(import.meta.url));
-    const argv = fs55.realpathSync(path56.resolve(process.argv[1]));
+    const here = fs56.realpathSync(fileURLToPath31(import.meta.url));
+    const argv = fs56.realpathSync(path56.resolve(process.argv[1]));
     return here === argv;
   } catch {
     return false;
@@ -34780,7 +34856,7 @@ var init_language_mirror_hook = __esm({
 });
 
 // src/scripts/git_authorization_hook.ts
-import fs56 from "node:fs";
+import fs57 from "node:fs";
 import path57 from "node:path";
 import { fileURLToPath as fileURLToPath32, pathToFileURL as pathToFileURL20 } from "node:url";
 function sessionSlug(session_id) {
@@ -34870,12 +34946,12 @@ function takePending(consumer_root, session_id, now) {
   const file = path57.join(consumer_root, pendingFileFor(session_id));
   let raw;
   try {
-    raw = fs56.readFileSync(file, "utf8");
+    raw = fs57.readFileSync(file, "utf8");
   } catch {
     return null;
   }
   try {
-    fs56.rmSync(file, { force: true });
+    fs57.rmSync(file, { force: true });
   } catch {
   }
   try {
@@ -34970,8 +35046,8 @@ function _isCliEntry18() {
     return true;
   }
   try {
-    const here = fs56.realpathSync(fileURLToPath32(import.meta.url));
-    const argv = fs56.realpathSync(path57.resolve(process.argv[1]));
+    const here = fs57.realpathSync(fileURLToPath32(import.meta.url));
+    const argv = fs57.realpathSync(path57.resolve(process.argv[1]));
     return here === argv;
   } catch {
     return false;
@@ -35038,7 +35114,7 @@ var init_git_authorization_hook = __esm({
 });
 
 // src/scripts/hooks/block_unauthorized_git.ts
-import fs57 from "node:fs";
+import fs58 from "node:fs";
 import path58 from "node:path";
 import { fileURLToPath as fileURLToPath33, pathToFileURL as pathToFileURL21 } from "node:url";
 function _isObject5(v) {
@@ -35242,7 +35318,7 @@ function _loadLedger(consumer_root, session_id, now) {
 }
 function _readLedgerFile(file, session_id, now) {
   try {
-    const raw = fs57.readFileSync(file, "utf8");
+    const raw = fs58.readFileSync(file, "utf8");
     const decoded = JSON.parse(raw);
     if (_isObject5(decoded) && Array.isArray(decoded["authorized"])) {
       const ledgerSession = typeof decoded["session_id"] === "string" ? decoded["session_id"] : "";
@@ -35348,8 +35424,8 @@ function _isCliEntry19() {
     return true;
   }
   try {
-    const here = fs57.realpathSync(fileURLToPath33(import.meta.url));
-    const argv = fs57.realpathSync(path58.resolve(process.argv[1]));
+    const here = fs58.realpathSync(fileURLToPath33(import.meta.url));
+    const argv = fs58.realpathSync(path58.resolve(process.argv[1]));
     return here === argv;
   } catch {
     return false;
@@ -35414,7 +35490,7 @@ var init_block_unauthorized_git = __esm({
       "execute_shell",
       "RunShellCommand"
     ]);
-    LEDGER_MAX_AGE_MS = 6 * 60 * 60 * 1e3;
+    LEDGER_MAX_AGE_MS = 30 * 60 * 1e3;
     if (_isCliEntry19()) {
       process.exit(main21());
     }
@@ -35422,7 +35498,7 @@ var init_block_unauthorized_git = __esm({
 });
 
 // src/scripts/before_complete_hook.ts
-import fs58 from "node:fs";
+import fs59 from "node:fs";
 import path59 from "node:path";
 import { fileURLToPath as fileURLToPath34, pathToFileURL as pathToFileURL22 } from "node:url";
 function statePathFor2(session_id) {
@@ -35695,8 +35771,8 @@ function _isCliEntry20() {
     return true;
   }
   try {
-    const here = fs58.realpathSync(fileURLToPath34(import.meta.url));
-    const argv = fs58.realpathSync(path59.resolve(process.argv[1]));
+    const here = fs59.realpathSync(fileURLToPath34(import.meta.url));
+    const argv = fs59.realpathSync(path59.resolve(process.argv[1]));
     return here === argv;
   } catch {
     return false;
@@ -35856,9 +35932,9 @@ var init_envelope = __esm({
 });
 
 // src/scripts/hooks/end_review_nudge_hook.ts
-import { spawnSync as spawnSync10 } from "node:child_process";
+import { spawnSync as spawnSync11 } from "node:child_process";
 import * as crypto7 from "node:crypto";
-import * as fs59 from "node:fs";
+import * as fs60 from "node:fs";
 import * as os13 from "node:os";
 import * as path60 from "node:path";
 import { fileURLToPath as fileURLToPath35, pathToFileURL as pathToFileURL23 } from "node:url";
@@ -35867,13 +35943,13 @@ function isSafeTranscriptPath(rawPath, opts = {}) {
   const homeDir = opts.homeDir ?? os13.homedir();
   const maxBytes = opts.maxBytes ?? TRANSCRIPT_SCAN_MAX_BYTES;
   try {
-    const realHome = fs59.realpathSync(homeDir);
-    const realPath = fs59.realpathSync(rawPath);
+    const realHome = fs60.realpathSync(homeDir);
+    const realPath = fs60.realpathSync(rawPath);
     const relative16 = path60.relative(realHome, realPath);
     if (relative16 === "" || relative16.startsWith("..") || path60.isAbsolute(relative16)) {
       return false;
     }
-    const { size } = fs59.statSync(realPath);
+    const { size } = fs60.statSync(realPath);
     return size <= maxBytes;
   } catch {
     return false;
@@ -35902,7 +35978,7 @@ function nonDocMutatedLines(rows) {
 }
 function gitNumstatRows(cwd) {
   try {
-    const r = spawnSync10("git", ["diff", "--numstat", "HEAD"], {
+    const r = spawnSync11("git", ["diff", "--numstat", "HEAD"], {
       cwd,
       encoding: "utf8",
       maxBuffer: 16 * 1024 * 1024
@@ -35915,7 +35991,7 @@ function gitNumstatRows(cwd) {
 }
 function untrackedNonDocFiles(cwd) {
   try {
-    const r = spawnSync10("git", ["ls-files", "--others", "--exclude-standard"], {
+    const r = spawnSync11("git", ["ls-files", "--others", "--exclude-standard"], {
       cwd,
       encoding: "utf8",
       maxBuffer: 16 * 1024 * 1024
@@ -35929,12 +36005,12 @@ function untrackedNonDocFiles(cwd) {
 function untrackedFileLineCount(cwd, relPath) {
   try {
     const abs = path60.resolve(cwd, relPath);
-    const size = fs59.statSync(abs).size;
+    const size = fs60.statSync(abs).size;
     if (size === 0) return 0;
     if (size > UNTRACKED_FILE_READ_CAP_BYTES) {
       return MUTATION_LINE_THRESHOLD + 1;
     }
-    const buf = fs59.readFileSync(abs);
+    const buf = fs60.readFileSync(abs);
     if (buf.length === 0) return 0;
     const probe = buf.subarray(0, Math.min(buf.length, BINARY_PROBE_BYTES));
     if (probe.includes(0)) return 0;
@@ -36021,9 +36097,9 @@ function appendReviewSkippedTelemetry(workspaceRoot, diffLines, mutationMeasure)
   if (errors.length || line === null) return;
   try {
     const dir = path60.join(workspaceRoot, "agents", "runtime", "state", "audit");
-    fs59.mkdirSync(dir, { recursive: true });
+    fs60.mkdirSync(dir, { recursive: true });
     const file = path60.join(dir, `${ts.slice(0, 7)}.jsonl`);
-    fs59.appendFileSync(file, `${JSON.stringify(line)}
+    fs60.appendFileSync(file, `${JSON.stringify(line)}
 `, "utf8");
   } catch {
   }
@@ -36041,7 +36117,7 @@ function deriveSessionKey(envelope, payload) {
 }
 function hasFiredThisSession(workspaceRoot, sessionKey) {
   try {
-    return fs59.existsSync(sessionStateFile(workspaceRoot, sessionKey));
+    return fs60.existsSync(sessionStateFile(workspaceRoot, sessionKey));
   } catch {
     return false;
   }
@@ -36084,7 +36160,7 @@ function main23() {
   let reviewerRan = false;
   if (transcriptPath && isSafeTranscriptPath(transcriptPath)) {
     try {
-      reviewerRan = scanTranscriptForReviewer(fs59.readFileSync(transcriptPath, "utf-8"));
+      reviewerRan = scanTranscriptForReviewer(fs60.readFileSync(transcriptPath, "utf-8"));
     } catch {
       reviewerRan = false;
     }
@@ -36119,8 +36195,8 @@ function _isCliEntry21() {
     return true;
   }
   try {
-    const here = fs59.realpathSync(fileURLToPath35(import.meta.url));
-    const argv = fs59.realpathSync(path60.resolve(process.argv[1]));
+    const here = fs60.realpathSync(fileURLToPath35(import.meta.url));
+    const argv = fs60.realpathSync(path60.resolve(process.argv[1]));
     return here === argv;
   } catch {
     return false;
@@ -36287,7 +36363,7 @@ var init_subagent_response = __esm({
 
 // src/scripts/hooks/subagent_ledger_hook.ts
 import * as crypto8 from "node:crypto";
-import * as fs60 from "node:fs";
+import * as fs61 from "node:fs";
 import * as path61 from "node:path";
 import { fileURLToPath as fileURLToPath36, pathToFileURL as pathToFileURL24 } from "node:url";
 function isObject2(v) {
@@ -36400,7 +36476,7 @@ function readOpenRecords(root) {
   const out = /* @__PURE__ */ new Map();
   let names;
   try {
-    names = fs60.readdirSync(openDir(root));
+    names = fs61.readdirSync(openDir(root));
   } catch {
     return out;
   }
@@ -36408,7 +36484,7 @@ function readOpenRecords(root) {
     if (!name.endsWith(".json")) continue;
     const expectedRef = name.slice(0, -".json".length);
     try {
-      const raw = fs60.readFileSync(path61.join(openDir(root), name), "utf8");
+      const raw = fs61.readFileSync(path61.join(openDir(root), name), "utf8");
       const rec = _asOpenRecord(JSON.parse(raw), expectedRef);
       if (rec) out.set(rec.ref, rec);
     } catch {
@@ -36428,8 +36504,8 @@ function ledgerFileFor2(root, ts) {
 function appendLedgerLine(root, ts, line) {
   if (is_replay_mode()) return;
   const file = ledgerFileFor2(root, ts);
-  fs60.mkdirSync(path61.dirname(file), { recursive: true });
-  fs60.appendFileSync(file, `${JSON.stringify(line)}
+  fs61.mkdirSync(path61.dirname(file), { recursive: true });
+  fs61.appendFileSync(file, `${JSON.stringify(line)}
 `, "utf8");
 }
 function armsExceeded(elapsedMs) {
@@ -36437,7 +36513,7 @@ function armsExceeded(elapsedMs) {
   return WALL_CLOCK_ARMS_MS.filter((a) => elapsedMs >= a.ms).map((a) => a.label);
 }
 function openRecordStats(root, nowMs = Date.now()) {
-  const ledgerPresent = fs60.existsSync(path61.join(root, LEDGER_DIR));
+  const ledgerPresent = fs61.existsSync(path61.join(root, LEDGER_DIR));
   const open = readOpenRecords(root);
   let maxDepth = 0;
   let counted = 0;
@@ -36465,13 +36541,13 @@ function writeOpenRecord(root, rec) {
 function removeOpenRecord(root, ref) {
   if (is_replay_mode()) return;
   try {
-    fs60.unlinkSync(openFile(root, ref));
+    fs61.unlinkSync(openFile(root, ref));
   } catch {
   }
 }
 function countOpen(root) {
   try {
-    return fs60.readdirSync(openDir(root)).filter((n) => n.endsWith(".json")).length;
+    return fs61.readdirSync(openDir(root)).filter((n) => n.endsWith(".json")).length;
   } catch {
     return 0;
   }
@@ -36637,7 +36713,7 @@ function _isCliEntry22() {
   const argvUrl = pathToFileURL24(path61.resolve(process.argv[1])).href;
   if (import.meta.url === argvUrl) return true;
   try {
-    return fs60.realpathSync(fileURLToPath36(import.meta.url)) === fs60.realpathSync(path61.resolve(process.argv[1]));
+    return fs61.realpathSync(fileURLToPath36(import.meta.url)) === fs61.realpathSync(path61.resolve(process.argv[1]));
   } catch {
     return false;
   }
@@ -36776,7 +36852,7 @@ var init_turn_end_refusals = __esm({
 });
 
 // src/scripts/hooks/turn_end_gate_hook.ts
-import * as fs61 from "node:fs";
+import * as fs62 from "node:fs";
 import * as path63 from "node:path";
 import { fileURLToPath as fileURLToPath37, pathToFileURL as pathToFileURL25 } from "node:url";
 function stripFencedBlocks(text) {
@@ -36835,7 +36911,7 @@ function detectPromissory(reply) {
 function readCiSettled(workspaceRoot, session_id) {
   if (!hasStableSessionId(session_id)) return { seen: false, settled: false };
   try {
-    const raw = fs61.readFileSync(path63.join(workspaceRoot, statePathFor2(session_id)), "utf-8");
+    const raw = fs62.readFileSync(path63.join(workspaceRoot, statePathFor2(session_id)), "utf-8");
     const decoded = JSON.parse(raw);
     if (!owns_session_state(decoded, session_id)) return { seen: false, settled: false };
     if (typeof decoded === "object" && decoded !== null && !Array.isArray(decoded)) {
@@ -36869,7 +36945,7 @@ function detectCompletionClaim(reply, ci) {
 function readLanguagePin(workspaceRoot, session_id) {
   if (!hasStableSessionId(session_id)) return "und";
   try {
-    const raw = fs61.readFileSync(
+    const raw = fs62.readFileSync(
       path63.join(workspaceRoot, statePathFor(session_id)),
       "utf-8"
     );
@@ -36924,7 +37000,7 @@ function sessionStateFile2(workspaceRoot, sessionKey) {
 }
 function alreadyRefusedTurn(workspaceRoot, sessionKey, turnOrdinal) {
   try {
-    const raw = fs61.readFileSync(sessionStateFile2(workspaceRoot, sessionKey), "utf-8");
+    const raw = fs62.readFileSync(sessionStateFile2(workspaceRoot, sessionKey), "utf-8");
     const decoded = JSON.parse(raw);
     if (typeof decoded === "object" && decoded !== null && !Array.isArray(decoded)) {
       return decoded["refused_turn"] === turnOrdinal;
@@ -36938,7 +37014,7 @@ function markRefusedTurn(workspaceRoot, sessionKey, turnOrdinal, detectors) {
   const file = sessionStateFile2(workspaceRoot, sessionKey);
   let prev = null;
   try {
-    prev = parseRecord(fs61.readFileSync(file, "utf-8"));
+    prev = parseRecord(fs62.readFileSync(file, "utf-8"));
   } catch {
   }
   let version;
@@ -36965,10 +37041,10 @@ function readTranscriptTail(transcriptPath, opts = {}) {
   if (!transcriptPath || !isSafeTranscriptPath(transcriptPath, opts)) return empty;
   let lines;
   try {
-    if (opts.maxBytes !== void 0 && fs61.statSync(transcriptPath).size > opts.maxBytes) {
+    if (opts.maxBytes !== void 0 && fs62.statSync(transcriptPath).size > opts.maxBytes) {
       return empty;
     }
-    lines = fs61.readFileSync(transcriptPath, "utf-8").split("\n");
+    lines = fs62.readFileSync(transcriptPath, "utf-8").split("\n");
   } catch {
     return empty;
   }
@@ -37123,8 +37199,8 @@ function _isCliEntry23() {
     return true;
   }
   try {
-    const here = fs61.realpathSync(fileURLToPath37(import.meta.url));
-    const argv = fs61.realpathSync(path63.resolve(process.argv[1]));
+    const here = fs62.realpathSync(fileURLToPath37(import.meta.url));
+    const argv = fs62.realpathSync(path63.resolve(process.argv[1]));
     return here === argv;
   } catch {
     return false;
@@ -37204,7 +37280,7 @@ var init_turn_end_gate_hook = __esm({
 
 // src/scripts/hooks/evidence_independence.ts
 import crypto10 from "node:crypto";
-import fs62 from "node:fs";
+import fs63 from "node:fs";
 import path64 from "node:path";
 import { fileURLToPath as fileURLToPath38, pathToFileURL as pathToFileURL26 } from "node:url";
 function _isObject7(v) {
@@ -37243,7 +37319,7 @@ function extractDispatch(envelope) {
 }
 function _ledgerStamp(consumer_root) {
   try {
-    const raw = fs62.readFileSync(
+    const raw = fs63.readFileSync(
       path64.join(consumer_root, "agents", "state", "git-authorization.json"),
       "utf8"
     );
@@ -37255,7 +37331,7 @@ function _ledgerStamp(consumer_root) {
 }
 function _load2(target) {
   try {
-    const decoded = JSON.parse(fs62.readFileSync(target, "utf8"));
+    const decoded = JSON.parse(fs63.readFileSync(target, "utf8"));
     if (_isObject7(decoded) && Array.isArray(decoded["evaluations"])) {
       return decoded;
     }
@@ -37368,8 +37444,8 @@ function _isCliEntry24() {
     return true;
   }
   try {
-    const here = fs62.realpathSync(fileURLToPath38(import.meta.url));
-    const argv = fs62.realpathSync(path64.resolve(process.argv[1]));
+    const here = fs63.realpathSync(fileURLToPath38(import.meta.url));
+    const argv = fs63.realpathSync(path64.resolve(process.argv[1]));
     return here === argv;
   } catch {
     return false;
@@ -37771,7 +37847,7 @@ var init_subagent_routing = __esm({
 });
 
 // src/scripts/hooks/delegation_nudge_hook.ts
-import fs63 from "node:fs";
+import fs64 from "node:fs";
 import path65 from "node:path";
 import { fileURLToPath as fileURLToPath39, pathToFileURL as pathToFileURL27 } from "node:url";
 function _isObject8(v) {
@@ -37976,8 +38052,8 @@ function _isCliEntry25() {
     return true;
   }
   try {
-    const here = fs63.realpathSync(fileURLToPath39(import.meta.url));
-    const argv = fs63.realpathSync(path65.resolve(process.argv[1]));
+    const here = fs64.realpathSync(fileURLToPath39(import.meta.url));
+    const argv = fs64.realpathSync(path65.resolve(process.argv[1]));
     return here === argv;
   } catch {
     return false;
@@ -38012,7 +38088,7 @@ var init_delegation_nudge_hook = __esm({
 
 // src/scripts/conformance_scan.ts
 import { createHash as createHash12 } from "node:crypto";
-import fs64 from "node:fs";
+import fs65 from "node:fs";
 import os14 from "node:os";
 import path66 from "node:path";
 import { fileURLToPath as fileURLToPath40, pathToFileURL as pathToFileURL28 } from "node:url";
@@ -38352,13 +38428,13 @@ function measureDelivered(projectRulesDir, globalRulesDir) {
   return {
     project: {
       dir: projectRulesDir,
-      present: fs64.existsSync(projectRulesDir),
+      present: fs65.existsSync(projectRulesDir),
       files: p.files,
       tokens: _tokens(p.chars)
     },
     global: {
       dir: globalRulesDir,
-      present: fs64.existsSync(globalRulesDir),
+      present: fs65.existsSync(globalRulesDir),
       files: g.files,
       tokens: _tokens(g.chars)
     },
@@ -38369,10 +38445,10 @@ function storeKey(store) {
   return createHash12("sha256").update(path66.resolve(store)).digest("hex").slice(0, 12);
 }
 function scanStore(store, limit) {
-  const files = fs64.readdirSync(store).filter((f) => f.endsWith(".jsonl")).map((f) => ({ f, m: fs64.statSync(path66.join(store, f)).mtimeMs })).sort((a, b) => b.m - a.m).slice(0, limit).map((x) => x.f);
+  const files = fs65.readdirSync(store).filter((f) => f.endsWith(".jsonl")).map((f) => ({ f, m: fs65.statSync(path66.join(store, f)).mtimeMs })).sort((a, b) => b.m - a.m).slice(0, limit).map((x) => x.f);
   const per_session = [];
   for (const f of files) {
-    const lines = fs64.readFileSync(path66.join(store, f), "utf8").split("\n");
+    const lines = fs65.readFileSync(path66.join(store, f), "utf8").split("\n");
     const r = scanSession(f.replace(/\.jsonl$/, "").slice(0, 8), lines);
     if (r.assistant_turns > 0) {
       per_session.push(r);
@@ -38433,8 +38509,8 @@ function scanStore(store, limit) {
   };
 }
 function recordRate(file, scanned_at, rate) {
-  fs64.mkdirSync(path66.dirname(file), { recursive: true });
-  fs64.appendFileSync(file, `${JSON.stringify({ measured_at: scanned_at, ...rate })}
+  fs65.mkdirSync(path66.dirname(file), { recursive: true });
+  fs65.appendFileSync(file, `${JSON.stringify({ measured_at: scanned_at, ...rate })}
 `, "utf8");
 }
 function render2(report2) {
@@ -38565,14 +38641,14 @@ function main28(argv) {
     return 2;
   }
   const resolved = store ?? defaultStore(process.cwd());
-  if (!fs64.existsSync(resolved)) {
+  if (!fs65.existsSync(resolved)) {
     process.stderr.write(`conformance:behavior: no transcript store at ${resolved}
 `);
     return 1;
   }
   const report2 = scanStore(resolved, Number.isFinite(limit) && limit > 0 ? limit : 30);
   if (out) {
-    fs64.writeFileSync(out, `${JSON.stringify(report2, null, 2)}
+    fs65.writeFileSync(out, `${JSON.stringify(report2, null, 2)}
 `, "utf8");
   }
   if (record) {
@@ -38580,7 +38656,7 @@ function main28(argv) {
   }
   if (why !== null) {
     const id = why;
-    fs64.writeSync(
+    fs65.writeSync(
       1,
       json ? `${JSON.stringify(
         {
@@ -38600,7 +38676,7 @@ function main28(argv) {
     );
     return 0;
   }
-  fs64.writeSync(1, json ? `${JSON.stringify(report2, null, 2)}
+  fs65.writeSync(1, json ? `${JSON.stringify(report2, null, 2)}
 ` : `${render2(report2)}
 `);
   return 0;
@@ -38617,8 +38693,8 @@ function _isCliEntry26() {
     return true;
   }
   try {
-    const here = fs64.realpathSync(fileURLToPath40(import.meta.url));
-    const argv = fs64.realpathSync(path66.resolve(process.argv[1]));
+    const here = fs65.realpathSync(fileURLToPath40(import.meta.url));
+    const argv = fs65.realpathSync(path66.resolve(process.argv[1]));
     return here === argv;
   } catch {
     return false;
@@ -38680,14 +38756,14 @@ var init_conformance_scan = __esm({
 });
 
 // src/scripts/report_carrier_divergence.ts
-import * as fs65 from "node:fs";
+import * as fs66 from "node:fs";
 import * as os15 from "node:os";
 import * as path67 from "node:path";
 import process17 from "node:process";
 import { fileURLToPath as fileURLToPath41, pathToFileURL as pathToFileURL29 } from "node:url";
 function _listRules(dir) {
   try {
-    return fs65.readdirSync(dir).filter((f) => f.endsWith(".md")).sort();
+    return fs66.readdirSync(dir).filter((f) => f.endsWith(".md")).sort();
   } catch {
     return [];
   }
@@ -38695,7 +38771,7 @@ function _listRules(dir) {
 function _ruleType(file) {
   let text;
   try {
-    text = fs65.readFileSync(file, "utf-8");
+    text = fs66.readFileSync(file, "utf-8");
   } catch {
     return "";
   }
@@ -38706,8 +38782,8 @@ function compareCarriers(projectDir, globalDir, sourceDir) {
   const out = {
     projectDir,
     globalDir,
-    globalPresent: fs65.existsSync(globalDir),
-    projectPresent: fs65.existsSync(projectDir),
+    globalPresent: fs66.existsSync(globalDir),
+    projectPresent: fs66.existsSync(projectDir),
     shared: 0,
     identical: [],
     provenanceOnly: [],
@@ -38740,8 +38816,8 @@ function compareCarriers(projectDir, globalDir, sourceDir) {
     let projectCopy;
     let globalCopy;
     try {
-      projectCopy = fs65.readFileSync(path67.join(projectDir, rule));
-      globalCopy = fs65.readFileSync(path67.join(globalDir, rule));
+      projectCopy = fs66.readFileSync(path67.join(projectDir, rule));
+      globalCopy = fs66.readFileSync(path67.join(globalDir, rule));
       verdict = comparePair(projectCopy, globalCopy);
     } catch {
       out.shared -= 1;
@@ -38928,7 +39004,7 @@ function _isCliEntry27() {
   if (process17.argv[1] === void 0) return false;
   if (import.meta.url === pathToFileURL29(path67.resolve(process17.argv[1])).href) return true;
   try {
-    return fs65.realpathSync(_HERE18) === fs65.realpathSync(path67.resolve(process17.argv[1]));
+    return fs66.realpathSync(_HERE18) === fs66.realpathSync(path67.resolve(process17.argv[1]));
   } catch {
     return false;
   }
@@ -38950,25 +39026,25 @@ var init_report_carrier_divergence = __esm({
 });
 
 // src/scripts/report_skill_activation.ts
-import * as fs66 from "node:fs";
+import * as fs67 from "node:fs";
 import * as os16 from "node:os";
 import * as path68 from "node:path";
 import { fileURLToPath as fileURLToPath42, pathToFileURL as pathToFileURL30 } from "node:url";
 function censusSkills(root) {
   const out = { total: 0, withTriggerKey: [], withDeterministicObligation: [] };
-  if (!fs66.existsSync(root)) {
+  if (!fs67.existsSync(root)) {
     return out;
   }
-  for (const entry of fs66.readdirSync(root, { withFileTypes: true }).sort((a, b) => a.name.localeCompare(b.name))) {
+  for (const entry of fs67.readdirSync(root, { withFileTypes: true }).sort((a, b) => a.name.localeCompare(b.name))) {
     if (!entry.isDirectory()) {
       continue;
     }
     const file = path68.join(root, entry.name, "SKILL.md");
-    if (!fs66.existsSync(file)) {
+    if (!fs67.existsSync(file)) {
       continue;
     }
     out.total += 1;
-    const text = fs66.readFileSync(file, "utf8");
+    const text = fs67.readFileSync(file, "utf8");
     const fmEnd = text.startsWith("---") ? text.indexOf("\n---", 3) : -1;
     const fm = fmEnd === -1 ? "" : text.slice(0, fmEnd);
     if (TRIGGER_KEYS.some((k) => new RegExp(`^${k}`, "m").test(fm))) {
@@ -38986,13 +39062,13 @@ function defaultStore2(cwd) {
 }
 function measureUsage(store, limit) {
   const rep = { store, sessions: 0, assistantTurns: 0, invocations: 0, bySkill: {} };
-  if (!fs66.existsSync(store)) {
+  if (!fs67.existsSync(store)) {
     return rep;
   }
-  const files = fs66.readdirSync(store).filter((f) => f.endsWith(".jsonl")).map((f) => path68.join(store, f)).sort((a, b) => fs66.statSync(b).mtimeMs - fs66.statSync(a).mtimeMs).slice(0, limit);
+  const files = fs67.readdirSync(store).filter((f) => f.endsWith(".jsonl")).map((f) => path68.join(store, f)).sort((a, b) => fs67.statSync(b).mtimeMs - fs67.statSync(a).mtimeMs).slice(0, limit);
   rep.sessions = files.length;
   for (const file of files) {
-    for (const line of fs66.readFileSync(file, "utf8").split("\n")) {
+    for (const line of fs67.readFileSync(file, "utf8").split("\n")) {
       if (!line.trim()) {
         continue;
       }
@@ -39126,7 +39202,7 @@ var init_report_skill_activation = __esm({
 });
 
 // src/scripts/report_skill_obligation_violations.ts
-import * as fs67 from "node:fs";
+import * as fs68 from "node:fs";
 import * as os17 from "node:os";
 import * as path69 from "node:path";
 import process18 from "node:process";
@@ -39163,7 +39239,7 @@ function extractObligations(repoRoot) {
   for (const skill of census.withDeterministicObligation) {
     let text;
     try {
-      text = fs67.readFileSync(path69.join(skillsRoot, skill, "SKILL.md"), "utf-8");
+      text = fs68.readFileSync(path69.join(skillsRoot, skill, "SKILL.md"), "utf-8");
     } catch {
       continue;
     }
@@ -39278,13 +39354,13 @@ function scanStore2(repoRoot, store, limit) {
   };
   let files;
   try {
-    files = fs67.readdirSync(store).filter((f) => f.endsWith(".jsonl")).map((f) => ({ p: path69.join(store, f), m: fs67.statSync(path69.join(store, f)).mtimeMs })).sort((a, b) => b.m - a.m).slice(0, limit).map((x) => x.p);
+    files = fs68.readdirSync(store).filter((f) => f.endsWith(".jsonl")).map((f) => ({ p: path69.join(store, f), m: fs68.statSync(path69.join(store, f)).mtimeMs })).sort((a, b) => b.m - a.m).slice(0, limit).map((x) => x.p);
   } catch {
     return report2;
   }
   report2.sessions = files.length;
   for (const file of files) {
-    const lines = fs67.readFileSync(file, "utf-8").split("\n");
+    const lines = fs68.readFileSync(file, "utf-8").split("\n");
     const id = path69.basename(file).replace(/\.jsonl$/, "").slice(0, 8);
     const entries = _parseSession(lines);
     if (loadedSkillsFrom(entries).size > 0) report2.sessionsWithASkill += 1;
@@ -39412,7 +39488,7 @@ function _isCliEntry28() {
   if (process18.argv[1] === void 0) return false;
   if (import.meta.url === pathToFileURL31(path69.resolve(process18.argv[1])).href) return true;
   try {
-    return fs67.realpathSync(_HERE20) === fs67.realpathSync(path69.resolve(process18.argv[1]));
+    return fs68.realpathSync(_HERE20) === fs68.realpathSync(path69.resolve(process18.argv[1]));
   } catch {
     return false;
   }
@@ -39466,7 +39542,7 @@ var init_report_skill_obligation_violations = __esm({
 });
 
 // src/scripts/report_conformance_funnel.ts
-import * as fs68 from "node:fs";
+import * as fs69 from "node:fs";
 import * as os18 from "node:os";
 import * as path70 from "node:path";
 import process19 from "node:process";
@@ -39483,7 +39559,7 @@ function buildFunnel(opts = {}) {
     divergence: compareCarriers(projectRulesDir, globalRulesDir, sourceDir),
     skills: censusSkills(path70.join(repoRoot, SKILLS_ROOT)),
     usage: measureUsage(store, limit),
-    storePresent: fs68.existsSync(store),
+    storePresent: fs69.existsSync(store),
     sk2: scanStore2(repoRoot, store, limit)
   };
 }
@@ -39658,7 +39734,7 @@ function _isCliEntry29() {
   if (process19.argv[1] === void 0) return false;
   if (import.meta.url === pathToFileURL32(path70.resolve(process19.argv[1])).href) return true;
   try {
-    return fs68.realpathSync(_HERE21) === fs68.realpathSync(path70.resolve(process19.argv[1]));
+    return fs69.realpathSync(_HERE21) === fs69.realpathSync(path70.resolve(process19.argv[1]));
   } catch {
     return false;
   }
@@ -39699,11 +39775,11 @@ __export(cmd_conformance_exports, {
   routeTargetPaths: () => routeTargetPaths,
   runConformanceChecks: () => runConformanceChecks
 });
-import * as fs69 from "node:fs";
+import * as fs70 from "node:fs";
 import * as os19 from "node:os";
 import * as path71 from "node:path";
 import process20 from "node:process";
-import { spawnSync as spawnSync11 } from "node:child_process";
+import { spawnSync as spawnSync12 } from "node:child_process";
 import { fileURLToPath as fileURLToPath45, pathToFileURL as pathToFileURL33 } from "node:url";
 function print2(s = "") {
   process20.stdout.write(`${s}
@@ -39728,7 +39804,7 @@ function installLogPath() {
   return path71.join(os19.homedir(), ".event4u", "agent-config", "install-log.jsonl");
 }
 function _check_txlog_clean(logPath = installLogPath()) {
-  if (!fs69.existsSync(logPath)) {
+  if (!fs70.existsSync(logPath)) {
     return {
       id: "txlog-clean",
       status: "ok",
@@ -39766,7 +39842,7 @@ function routeTargetPaths(target) {
 }
 function _check_router_pointers(packageRoot = PACKAGE_ROOT2) {
   const routerPath = path71.join(packageRoot, "dist", "router.json");
-  if (!fs69.existsSync(routerPath)) {
+  if (!fs70.existsSync(routerPath)) {
     return {
       id: "router-pointers",
       status: "fail",
@@ -39776,7 +39852,7 @@ function _check_router_pointers(packageRoot = PACKAGE_ROOT2) {
   }
   let router;
   try {
-    router = JSON.parse(fs69.readFileSync(routerPath, "utf8"));
+    router = JSON.parse(fs70.readFileSync(routerPath, "utf8"));
   } catch (exc) {
     return {
       id: "router-pointers",
@@ -39791,7 +39867,7 @@ function _check_router_pointers(packageRoot = PACKAGE_ROOT2) {
   let targets = 0;
   for (const kernelId of router["kernel"] ?? []) {
     ids += 1;
-    if (!fs69.existsSync(path71.join(rulesDir, `${kernelId}.md`))) {
+    if (!fs70.existsSync(path71.join(rulesDir, `${kernelId}.md`))) {
       broken.push(`kernel:${kernelId} \u2192 rules/${kernelId}.md missing`);
     }
   }
@@ -39799,7 +39875,7 @@ function _check_router_pointers(packageRoot = PACKAGE_ROOT2) {
     for (const entry of router[tier] ?? []) {
       const ruleId = String(entry["id"] ?? "");
       ids += 1;
-      if (!fs69.existsSync(path71.join(rulesDir, `${ruleId}.md`))) {
+      if (!fs70.existsSync(path71.join(rulesDir, `${ruleId}.md`))) {
         broken.push(`${tier}:${ruleId} \u2192 rules/${ruleId}.md missing`);
       }
       for (const target of entry["routes_to"] ?? []) {
@@ -39809,7 +39885,7 @@ function _check_router_pointers(packageRoot = PACKAGE_ROOT2) {
           broken.push(`${ruleId} \u2192 unparseable routes_to ${JSON.stringify(target)}`);
           continue;
         }
-        if (!candidates.some((rel) => fs69.existsSync(path71.join(packageRoot, rel)))) {
+        if (!candidates.some((rel) => fs70.existsSync(path71.join(packageRoot, rel)))) {
           broken.push(`${ruleId} \u2192 ${target} (${candidates[0]} missing)`);
         }
       }
@@ -39843,7 +39919,7 @@ function detectSmokePlatform(projectRoot) {
 function dispatcherRunner(packageRoot) {
   const localTsx = path71.join(packageRoot, "node_modules", ".bin", "tsx");
   const script = path71.join(packageRoot, "src", "scripts", "hooks", "dispatch_hook.ts");
-  if (fs69.existsSync(localTsx)) {
+  if (fs70.existsSync(localTsx)) {
     return [localTsx, script];
   }
   return ["npx", "tsx", script];
@@ -39860,7 +39936,7 @@ function _check_hook_dispatcher(projectRoot, packageRoot = PACKAGE_ROOT2, opts =
       ...event === "stop" ? { stop_reason: "conformance-smoke" } : { source: "startup" }
     });
     const argv = [...runner, "--platform", platform, "--event", event];
-    const proc = spawnSync11(argv[0], argv.slice(1), {
+    const proc = spawnSync12(argv[0], argv.slice(1), {
       input: payload,
       cwd: projectRoot,
       encoding: "utf8",
@@ -39894,11 +39970,11 @@ function _check_hook_dispatcher(projectRoot, packageRoot = PACKAGE_ROOT2, opts =
 }
 function readSettingsMode(projectRoot) {
   const settingsPath = path71.join(projectRoot, ".agent-settings.yml");
-  if (!fs69.existsSync(settingsPath)) {
+  if (!fs70.existsSync(settingsPath)) {
     return "eager-all";
   }
   try {
-    const parsed = YAML7.parse(fs69.readFileSync(settingsPath, "utf8"));
+    const parsed = YAML7.parse(fs70.readFileSync(settingsPath, "utf8"));
     const lean = parsed?.["lean_projection"] ?? null;
     const mode = lean?.["mode"];
     return typeof mode === "string" && mode.length > 0 ? mode : "eager-all";
@@ -39909,7 +39985,7 @@ function readSettingsMode(projectRoot) {
 function kernelIdsFromRouter(packageRoot) {
   try {
     const router = JSON.parse(
-      fs69.readFileSync(path71.join(packageRoot, "dist", "router.json"), "utf8")
+      fs70.readFileSync(path71.join(packageRoot, "dist", "router.json"), "utf8")
     );
     return new Set((router["kernel"] ?? []).map(String));
   } catch {
@@ -39927,7 +40003,7 @@ function _check_lean_projection(projectRoot, packageRoot = PACKAGE_ROOT2, projec
     };
   }
   const rulesDir = projectedRulesDir ?? path71.join(projectRoot, ".augment", "rules");
-  if (!fs69.existsSync(rulesDir)) {
+  if (!fs70.existsSync(rulesDir)) {
     return {
       id: "lean-projection",
       status: "skipped",
@@ -39936,7 +40012,7 @@ function _check_lean_projection(projectRoot, packageRoot = PACKAGE_ROOT2, projec
     };
   }
   const kernel = kernelIdsFromRouter(packageRoot);
-  const files = fs69.readdirSync(rulesDir).filter((f) => f.endsWith(".md") && f !== "INDEX.md").sort();
+  const files = fs70.readdirSync(rulesDir).filter((f) => f.endsWith(".md") && f !== "INDEX.md").sort();
   const nonKernel = files.filter((f) => !kernel.has(f.replace(/\.md$/, "")));
   if (nonKernel.length === 0) {
     return {
@@ -39950,7 +40026,7 @@ function _check_lean_projection(projectRoot, packageRoot = PACKAGE_ROOT2, projec
   for (const f of nonKernel) {
     let text = "";
     try {
-      text = fs69.readFileSync(path71.join(rulesDir, f), "utf8");
+      text = fs70.readFileSync(path71.join(rulesDir, f), "utf8");
     } catch {
       continue;
     }
@@ -39982,7 +40058,7 @@ function _check_host_manifest(projectRoot) {
   const detected = Object.entries(detectToolPresence(projectRoot)).filter(([, v]) => v === true).map(([k]) => k);
   const detectedNote = detected.length > 0 ? `detected surfaces: ${detected.join(", ")}` : "no surfaces detected";
   const settingsPath = path71.join(projectRoot, ".agent-settings.yml");
-  if (!fs69.existsSync(settingsPath)) {
+  if (!fs70.existsSync(settingsPath)) {
     return {
       id: "host-manifest",
       status: "ok",
@@ -39992,7 +40068,7 @@ function _check_host_manifest(projectRoot) {
   }
   let parsed = null;
   try {
-    parsed = YAML7.parse(fs69.readFileSync(settingsPath, "utf8"));
+    parsed = YAML7.parse(fs70.readFileSync(settingsPath, "utf8"));
   } catch (exc) {
     return {
       id: "host-manifest",
@@ -40170,8 +40246,8 @@ function _isCliEntry30() {
     return true;
   }
   try {
-    const here = fs69.realpathSync(fileURLToPath45(import.meta.url));
-    const argv = fs69.realpathSync(path71.resolve(process20.argv[1]));
+    const here = fs70.realpathSync(fileURLToPath45(import.meta.url));
+    const argv = fs70.realpathSync(path71.resolve(process20.argv[1]));
     return here === argv;
   } catch {
     return false;
@@ -40238,7 +40314,7 @@ __export(settings_exports, {
   read_tier_usage_settings: () => read_tier_usage_settings
 });
 import { createRequire as createRequire6 } from "node:module";
-import * as fs70 from "node:fs";
+import * as fs71 from "node:fs";
 function _isPlainObject8(v) {
   return typeof v === "object" && v !== null && !Array.isArray(v) && !(v instanceof Date);
 }
@@ -40275,7 +40351,7 @@ function _coerce_path(value, def) {
 }
 function _isFile14(p) {
   try {
-    return fs70.statSync(p).isFile();
+    return fs71.statSync(p).isFile();
   } catch {
     return false;
   }
@@ -40286,7 +40362,7 @@ function _read_telemetry_section(p, key) {
   }
   let raw = {};
   try {
-    raw = YAML8.parse(fs70.readFileSync(p, "utf-8"), { version: "1.1" });
+    raw = YAML8.parse(fs71.readFileSync(p, "utf-8"), { version: "1.1" });
     if (raw === null || raw === void 0) {
       raw = {};
     }
@@ -40930,7 +41006,7 @@ __export(aggregator_exports, {
   aggregate: () => aggregate2,
   rank_artefacts: () => rank_artefacts
 });
-import * as fs71 from "node:fs";
+import * as fs72 from "node:fs";
 function _key(kind, artId) {
   return `${kind}\0${artId}`;
 }
@@ -40967,7 +41043,7 @@ function* _iter_events(log_path) {
   if (!_isFile15(log_path)) {
     return;
   }
-  const text = fs71.readFileSync(log_path, "utf-8");
+  const text = fs72.readFileSync(log_path, "utf-8");
   const lines = _pyFileLines(text);
   let lineNo = 0;
   for (const line of lines) {
@@ -41001,7 +41077,7 @@ function _pyFileLines(text) {
 }
 function _isFile15(p) {
   try {
-    return fs71.statSync(p).isFile();
+    return fs72.statSync(p).isFile();
   } catch {
     return false;
   }
@@ -41515,7 +41591,7 @@ var init_report_renderer = __esm({
 });
 
 // src/scripts/ai_council/bundler.ts
-import * as fs72 from "node:fs";
+import * as fs73 from "node:fs";
 function _context(mode, text, manifest = [], excluded = []) {
   return { mode, text, manifest, excluded };
 }
@@ -41573,10 +41649,10 @@ function bundle_prompt(text) {
   return _context("prompt", _enforceSize(redacted, "prompt"), ["<inline prompt>"]);
 }
 function bundle_roadmap(p) {
-  if (!fs72.existsSync(p)) {
+  if (!fs73.existsSync(p)) {
     throw new FileNotFoundError2(`Roadmap not found: ${p}`);
   }
-  const raw = fs72.readFileSync(p, { encoding: "utf-8" });
+  const raw = fs73.readFileSync(p, { encoding: "utf-8" });
   const redacted = redact(raw);
   return _context(
     "roadmap",
@@ -42187,7 +42263,7 @@ not. Cite the peer-reviewer label and the targeted response label
 });
 
 // src/scripts/ai_council/advisors.ts
-import * as fs73 from "node:fs";
+import * as fs74 from "node:fs";
 import * as path72 from "node:path";
 function _split_frontmatter2(raw) {
   const match = _FRONTMATTER_RE2.exec(raw);
@@ -42220,8 +42296,8 @@ function resolve_persona_text(persona_path, repo_root) {
     path72.join(repo_root, ".agent-src.uncondensed", persona_path)
   ];
   for (const candidate of candidates) {
-    if (fs73.existsSync(candidate)) {
-      const raw = fs73.readFileSync(candidate, "utf-8");
+    if (fs74.existsSync(candidate)) {
+      const raw = fs74.readFileSync(candidate, "utf-8");
       const [meta, body] = _split_frontmatter2(raw);
       return [body.trim(), meta];
     }
@@ -42794,7 +42870,7 @@ var init_qualification = __esm({
 });
 
 // src/scripts/ai_council/probe_store.ts
-import fs74 from "node:fs";
+import fs75 from "node:fs";
 import path73 from "node:path";
 function probeStorePath(root) {
   return path73.join(root, PROBE_STORE_RELPATH);
@@ -42802,7 +42878,7 @@ function probeStorePath(root) {
 function readProbeStore(root) {
   let raw;
   try {
-    raw = fs74.readFileSync(probeStorePath(root), "utf8");
+    raw = fs75.readFileSync(probeStorePath(root), "utf8");
   } catch {
     return EMPTY;
   }
@@ -42852,8 +42928,8 @@ function recordProbes(root, entries) {
       members[e.name] = { at: e.at, outcome: e.outcome };
     }
     const target = probeStorePath(root);
-    fs74.mkdirSync(path73.dirname(target), { recursive: true });
-    fs74.writeFileSync(target, `${JSON.stringify({ schema: 1, members }, null, 2)}
+    fs75.mkdirSync(path73.dirname(target), { recursive: true });
+    fs75.writeFileSync(target, `${JSON.stringify({ schema: 1, members }, null, 2)}
 `, "utf8");
   } catch {
   }
@@ -43221,7 +43297,7 @@ __export(low_impact_corpus_exports, {
   load_validated_phrases: () => load_validated_phrases,
   parse_corpus_strict: () => parse_corpus_strict
 });
-import * as fs75 from "node:fs";
+import * as fs76 from "node:fs";
 function _entry(phrase, normalised, section, line_no, trailing_metadata = "") {
   return { phrase, normalised, section, line_no, trailing_metadata };
 }
@@ -43394,10 +43470,10 @@ function _checkHeadingDrift(text, title) {
 }
 function parse_corpus_strict(corpusPath) {
   const p = corpusPath;
-  if (!fs75.existsSync(p)) {
+  if (!fs76.existsSync(p)) {
     return new CorpusParseResult();
   }
-  const text = fs75.readFileSync(p, { encoding: "utf-8" });
+  const text = fs76.readFileSync(p, { encoding: "utf-8" });
   const allTitles = _SECTION_KEYS.map((k) => _SECTION_TITLES[k]);
   const resultSections = {
     validated: [],
@@ -43460,10 +43536,10 @@ function load_anti_example_phrases(corpusPath) {
 }
 function load_corpus_lock(yamlPath) {
   const p = yamlPath;
-  if (!fs75.existsSync(p)) {
+  if (!fs76.existsSync(p)) {
     return new CorpusParseResult();
   }
-  const parsed = (0, import_yaml7.parse)(fs75.readFileSync(p, { encoding: "utf-8" }), { version: "1.1" });
+  const parsed = (0, import_yaml7.parse)(fs76.readFileSync(p, { encoding: "utf-8" }), { version: "1.1" });
   const doc = parsed === null || parsed === void 0 ? {} : parsed;
   const schemaVersion = doc["schema_version"];
   if (schemaVersion !== 1) {
@@ -43525,7 +43601,7 @@ function _deriveLockPath(corpusPath) {
 }
 function _loadSectionFromLock(corpusPath, section) {
   const lockPath = _deriveLockPath(corpusPath);
-  if (!fs75.existsSync(lockPath)) {
+  if (!fs76.existsSync(lockPath)) {
     return null;
   }
   try {
@@ -43537,10 +43613,10 @@ function _loadSectionFromLock(corpusPath, section) {
 }
 function _loadSectionLenient(corpusPath, section) {
   const p = corpusPath;
-  if (!fs75.existsSync(p)) {
+  if (!fs76.existsSync(p)) {
     return [];
   }
-  const text = fs75.readFileSync(p, { encoding: "utf-8" });
+  const text = fs76.readFileSync(p, { encoding: "utf-8" });
   const allTitles = _SECTION_KEYS.map((k) => _SECTION_TITLES[k]);
   const bounds = _sectionBounds(text, _SECTION_TITLES[section], allTitles);
   if (bounds === null) {
@@ -44320,7 +44396,7 @@ var init_necessity = __esm({
 });
 
 // src/scripts/ai_council/budget_guard.ts
-import * as fs76 from "node:fs";
+import * as fs77 from "node:fs";
 import * as path74 from "node:path";
 function _resolveLedgerPath(p) {
   if (p !== null) {
@@ -44338,16 +44414,16 @@ function _nowUtcMs() {
 function _ensureLedgerDir(p) {
   const parent = path74.dirname(p);
   try {
-    fs76.mkdirSync(parent, { recursive: true });
+    fs77.mkdirSync(parent, { recursive: true });
     let mode;
     try {
-      mode = fs76.statSync(parent).mode & 511;
+      mode = fs77.statSync(parent).mode & 511;
     } catch {
       mode = 448;
     }
     if (mode !== 448) {
       try {
-        fs76.chmodSync(parent, 448);
+        fs77.chmodSync(parent, 448);
       } catch {
       }
     }
@@ -44359,18 +44435,18 @@ function _ensureLedgerDir(p) {
   }
 }
 function _ensureLedgerFileMode(p) {
-  if (!fs76.existsSync(p)) {
+  if (!fs77.existsSync(p)) {
     return;
   }
   let current;
   try {
-    current = fs76.statSync(p).mode & 511;
+    current = fs77.statSync(p).mode & 511;
   } catch {
     return;
   }
   if (current !== 384) {
     try {
-      fs76.chmodSync(p, 384);
+      fs77.chmodSync(p, 384);
     } catch {
     }
   }
@@ -44522,11 +44598,11 @@ function pyNumToStr(n) {
 }
 function read_entries2(p = null) {
   const resolved = _resolveLedgerPath(p);
-  if (!fs76.existsSync(resolved)) {
+  if (!fs77.existsSync(resolved)) {
     return [];
   }
   const out = [];
-  const text = fs76.readFileSync(resolved, "utf-8");
+  const text = fs77.readFileSync(resolved, "utf-8");
   for (const rawLine of text.split(/\r\n|\r|\n/u)) {
     const line = rawLine.trim();
     if (line === "") {
@@ -44629,7 +44705,7 @@ function record_spend(usd, provider, model, options = {}) {
   )}
 `;
   try {
-    fs76.appendFileSync(p, entry, { encoding: "utf-8" });
+    fs77.appendFileSync(p, entry, { encoding: "utf-8" });
   } catch (exc) {
     process.stderr.write(`[council:budget_guard] write failed: ${_errStr(exc)}
 `);
@@ -44752,8 +44828,8 @@ function aggregate_scores(findings, scores) {
     by_id.get(s.finding_id).push(s);
   }
   const out = /* @__PURE__ */ new Map();
-  for (const [fid, fs83] of by_id) {
-    if (fs83.length === 0) {
+  for (const [fid, fs84] of by_id) {
+    if (fs84.length === 0) {
       out.set(
         fid,
         new ConsensusMetadata({
@@ -44769,13 +44845,13 @@ function aggregate_scores(findings, scores) {
       );
       continue;
     }
-    const mean2 = fs83.reduce((acc, s) => acc + s.score, 0) / fs83.length;
-    const agree_rate = fs83.filter((s) => s.agree).length / fs83.length;
+    const mean2 = fs84.reduce((acc, s) => acc + s.score, 0) / fs84.length;
+    const agree_rate = fs84.filter((s) => s.agree).length / fs84.length;
     const strength = mean2 / 10 * agree_rate;
-    const dissent = fs83.filter((s) => !s.agree).length;
-    const concur = fs83.filter((s) => s.agree).length;
-    const scorers = fs83.map((s) => s.scorer);
-    const dissent_reasons = fs83.filter((s) => !s.agree).map((s) => [s.scorer, s.reason]);
+    const dissent = fs84.filter((s) => !s.agree).length;
+    const concur = fs84.filter((s) => s.agree).length;
+    const scorers = fs84.map((s) => s.scorer);
+    const dissent_reasons = fs84.filter((s) => !s.agree).map((s) => [s.scorer, s.reason]);
     const mean_rounded = pyRound(mean2, 2);
     out.set(
       fid,
@@ -46923,18 +46999,18 @@ __export(project_context_exports, {
   REPO_PURPOSE_MAX_CHARS: () => REPO_PURPOSE_MAX_CHARS,
   detect_project_context: () => detect_project_context
 });
-import * as fs77 from "node:fs";
+import * as fs78 from "node:fs";
 import * as path75 from "node:path";
 function _isPlainObject11(v) {
   return typeof v === "object" && v !== null && !Array.isArray(v);
 }
 function _read_json(p) {
-  if (!fs77.existsSync(p)) {
+  if (!fs78.existsSync(p)) {
     return null;
   }
   let raw;
   try {
-    raw = fs77.readFileSync(p, "utf-8");
+    raw = fs78.readFileSync(p, "utf-8");
   } catch {
     return null;
   }
@@ -47025,12 +47101,12 @@ function _splitlines10(text) {
   return parts;
 }
 function _purpose_from_readme(p) {
-  if (!fs77.existsSync(p)) {
+  if (!fs78.existsSync(p)) {
     return null;
   }
   let text;
   try {
-    text = fs77.readFileSync(p, "utf-8");
+    text = fs78.readFileSync(p, "utf-8");
   } catch {
     return null;
   }
@@ -47390,7 +47466,7 @@ __export(shadow_dispatch_exports, {
   slo_banner: () => slo_banner,
   slo_status: () => slo_status
 });
-import * as fs78 from "node:fs";
+import * as fs79 from "node:fs";
 import { createHash as createHash14 } from "node:crypto";
 function should_shadow(sampleRate, opts = {}) {
   const rate = Math.max(0, Math.min(1, sampleRate));
@@ -47428,7 +47504,7 @@ function record_shadow_decision(logPath, opts) {
     escalated,
     escalation_reason: escalationReason
   };
-  fs78.mkdirSync(_dirname2(logPath), { recursive: true });
+  fs79.mkdirSync(_dirname2(logPath), { recursive: true });
   const row = _pyJsonDumps2({
     timestamp: decision.timestamp,
     query_hash: decision.query_hash,
@@ -47438,7 +47514,7 @@ function record_shadow_decision(logPath, opts) {
     escalated: decision.escalated,
     escalation_reason: decision.escalation_reason
   }) + "\n";
-  fs78.appendFileSync(logPath, row, { encoding: "utf-8" });
+  fs79.appendFileSync(logPath, row, { encoding: "utf-8" });
   return decision;
 }
 function _isoNowSeconds() {
@@ -47447,10 +47523,10 @@ function _isoNowSeconds() {
   return `${pad(d.getUTCFullYear(), 4)}-${pad(d.getUTCMonth() + 1)}-${pad(d.getUTCDate())}T${pad(d.getUTCHours())}:${pad(d.getUTCMinutes())}:${pad(d.getUTCSeconds())}+00:00`;
 }
 function* _iterLog(logPath) {
-  if (!fs78.existsSync(logPath)) {
+  if (!fs79.existsSync(logPath)) {
     return;
   }
-  const content = fs78.readFileSync(logPath, { encoding: "utf-8" });
+  const content = fs79.readFileSync(logPath, { encoding: "utf-8" });
   for (const rawLine of _splitlines11(content)) {
     const line = _strip7(rawLine);
     if (!line) {
@@ -48377,7 +48453,7 @@ __export(council_cli_exports, {
   load_settings: () => load_settings,
   main: () => main34
 });
-import * as fs79 from "node:fs";
+import * as fs80 from "node:fs";
 import * as path76 from "node:path";
 import { fileURLToPath as fileURLToPath46, pathToFileURL as pathToFileURL34 } from "node:url";
 function _pyFixed6(x, ndigits) {
@@ -48587,7 +48663,7 @@ function _stderr2(s) {
 function load_settings(p = SETTINGS_FILE2, opts = {}) {
   const ai_council_path = opts.ai_council_path ?? AI_COUNCIL_FILE;
   const settings = load_agent_settings({ project_path: p });
-  if (fs79.existsSync(ai_council_path)) {
+  if (fs80.existsSync(ai_council_path)) {
     const cfg = load_council_config(ai_council_path);
     settings["ai_council"] = synthesizeAiCouncilBlock(cfg);
   }
@@ -48955,7 +49031,7 @@ function build_question(opts) {
   let ctx;
   let artefact;
   if (input_mode === "prompt") {
-    const text = fs79.readFileSync(input_path, "utf-8");
+    const text = fs80.readFileSync(input_path, "utf-8");
     ctx = bundle_prompt(text);
     artefact = String(input_path);
   } else if (input_mode === "roadmap") {
@@ -49099,8 +49175,8 @@ function _maybe_write_decision_replay(opts) {
     })
   );
   const target = path76.join(path76.dirname(opts.out_path), "decision-replay.md");
-  fs79.mkdirSync(path76.dirname(target), { recursive: true });
-  fs79.writeFileSync(target, replay, { encoding: "utf-8" });
+  fs80.mkdirSync(path76.dirname(target), { recursive: true });
+  fs80.writeFileSync(target, replay, { encoding: "utf-8" });
   return target;
 }
 function _peer_review_active(ai_cfg, args) {
@@ -49805,7 +49881,7 @@ function cmd_status(args, opts = {}) {
   const env = opts.env ?? process.env;
   const override = env[COUNCIL_CONFIG_ENV];
   const path_ = resolve_config_path(REPO_ROOT11, { env });
-  const exists3 = fs79.existsSync(String(path_));
+  const exists3 = fs80.existsSync(String(path_));
   const provenance = override ? `${COUNCIL_CONFIG_ENV} override` : "user-global";
   let cfg = null;
   let parse_error = null;
@@ -50261,8 +50337,8 @@ function cmd_run(args, opts = {}) {
     kind: "responses",
     subcommand: "run"
   });
-  fs79.mkdirSync(path76.dirname(_resolveTarget(out_path)), { recursive: true });
-  fs79.writeFileSync(_resolveTarget(out_path), _jsonDumpsIndent2(payload) + "\n", { encoding: "utf-8" });
+  fs80.mkdirSync(path76.dirname(_resolveTarget(out_path)), { recursive: true });
+  fs80.writeFileSync(_resolveTarget(out_path), _jsonDumpsIndent2(payload) + "\n", { encoding: "utf-8" });
   _stdout2(
     `
 council:run \xB7 wrote ${out_path} (estimated $${_pyFixed6(estimated_total, 4)} / actual $${_pyFixed6(actual_total, 4)})
@@ -50287,7 +50363,7 @@ function _debate_round_filename(round_number) {
   return `debate-round-${round_number}.json`;
 }
 function _write_debate_round(out_dir, round_number, responses, opts) {
-  fs79.mkdirSync(_resolveTarget(out_dir), { recursive: true });
+  fs80.mkdirSync(_resolveTarget(out_dir), { recursive: true });
   let actual_total = 0;
   for (const r of responses) {
     if (r.error) {
@@ -50312,14 +50388,14 @@ function _write_debate_round(out_dir, round_number, responses, opts) {
     responses: _serialise_responses(responses)
   };
   const out_path = path76.join(_resolveTarget(out_dir), _debate_round_filename(round_number));
-  fs79.writeFileSync(out_path, _jsonDumpsIndent2(payload) + "\n", { encoding: "utf-8" });
+  fs80.writeFileSync(out_path, _jsonDumpsIndent2(payload) + "\n", { encoding: "utf-8" });
   return out_path;
 }
 function _load_debate_seed(p, expected_members) {
-  if (!fs79.existsSync(p)) {
+  if (!fs80.existsSync(p)) {
     throw new FileNotFoundError3(`--continue-as-debate path not found: ${p}`);
   }
-  const payload = JSON.parse(fs79.readFileSync(p, "utf-8"));
+  const payload = JSON.parse(fs80.readFileSync(p, "utf-8"));
   const source_members = (payload["members"] || []).slice();
   const expected_labels = expected_members.map((m) => `${m.name}/${m.model}`);
   if (!_listEq(source_members, expected_labels)) {
@@ -50365,7 +50441,7 @@ function _readStdinLine() {
   try {
     const buf = Buffer.alloc(4096);
     const fd = 0;
-    const n = fs79.readSync(fd, buf, 0, buf.length, null);
+    const n = fs80.readSync(fd, buf, 0, buf.length, null);
     return buf.toString("utf-8", 0, n).split("\n")[0]?.trim().toLowerCase() ?? "";
   } catch {
     return "";
@@ -50599,7 +50675,7 @@ council:debate \xB7 ${all_rounds.length} round(s) complete \xB7 actual $${_pyFix
   return errors_last.length > 0 && errors_last.length === last.length ? 1 : 0;
 }
 function cmd_render(args) {
-  const payload = JSON.parse(fs79.readFileSync(args.responses, "utf-8"));
+  const payload = JSON.parse(fs80.readFileSync(args.responses, "utf-8"));
   const items = payload["responses"] || [];
   const explicit = _getattr3(args, "prompt_mode", null);
   const mode = explicit || payload["prompt_mode"] || payload["mode"];
@@ -50628,8 +50704,8 @@ function cmd_render(args) {
       kind: "sessions",
       subcommand: "render"
     });
-    fs79.mkdirSync(path76.dirname(_resolveTarget(out_path)), { recursive: true });
-    fs79.writeFileSync(_resolveTarget(out_path), body + "\n", { encoding: "utf-8" });
+    fs80.mkdirSync(path76.dirname(_resolveTarget(out_path)), { recursive: true });
+    fs80.writeFileSync(_resolveTarget(out_path), body + "\n", { encoding: "utf-8" });
     _stdout2(`council:render \xB7 wrote ${out_path}
 `);
     return 0;
@@ -50641,14 +50717,14 @@ function _cmd_replay_low_impact_stats(args) {
   const li = low_impact_exports;
   const responses_path = args.responses;
   const log_path = path76.join(path76.dirname(responses_path), "low-impact-resolutions.md");
-  if (!fs79.existsSync(log_path)) {
+  if (!fs80.existsSync(log_path)) {
     _stdout2(
       `council:replay \xB7 no low-impact-resolutions.md alongside ${responses_path} \u2014 session had no fast-path entries.
 `
     );
     return 0;
   }
-  const body = fs79.readFileSync(log_path, "utf-8");
+  const body = fs80.readFileSync(log_path, "utf-8");
   const stats = li.parse_low_impact_log(body);
   const out = li.render_low_impact_stats(stats);
   if (_getattr3(args, "output", null)) {
@@ -50656,8 +50732,8 @@ function _cmd_replay_low_impact_stats(args) {
       kind: "sessions",
       subcommand: "replay"
     });
-    fs79.mkdirSync(path76.dirname(_resolveTarget(target)), { recursive: true });
-    fs79.writeFileSync(_resolveTarget(target), out, { encoding: "utf-8" });
+    fs80.mkdirSync(path76.dirname(_resolveTarget(target)), { recursive: true });
+    fs80.writeFileSync(_resolveTarget(target), out, { encoding: "utf-8" });
     _stdout2(`council:replay \xB7 wrote ${target}
 `);
     return 0;
@@ -50669,7 +50745,7 @@ function cmd_replay(args) {
   if (_getattr3(args, "low_impact_stats", false)) {
     return _cmd_replay_low_impact_stats(args);
   }
-  const payload = JSON.parse(fs79.readFileSync(args.responses, "utf-8"));
+  const payload = JSON.parse(fs80.readFileSync(args.responses, "utf-8"));
   const consensus = _deserialise_consensus(payload["consensus"]);
   if (consensus === null) {
     _stderr2(
@@ -50694,8 +50770,8 @@ function cmd_replay(args) {
       kind: "sessions",
       subcommand: "replay"
     });
-    fs79.mkdirSync(path76.dirname(_resolveTarget(out_path)), { recursive: true });
-    fs79.writeFileSync(_resolveTarget(out_path), body, { encoding: "utf-8" });
+    fs80.mkdirSync(path76.dirname(_resolveTarget(out_path)), { recursive: true });
+    fs80.writeFileSync(_resolveTarget(out_path), body, { encoding: "utf-8" });
     _stdout2(`council:replay \xB7 wrote ${out_path}
 `);
   } else {
@@ -50768,7 +50844,7 @@ function _resolveTarget(path_str) {
 function _resolveReal(p) {
   const abs = path76.resolve(p);
   try {
-    return fs79.realpathSync(abs);
+    return fs80.realpathSync(abs);
   } catch {
     return abs;
   }
@@ -51154,8 +51230,8 @@ function _isCliEntry31() {
     return true;
   }
   try {
-    const here = fs79.realpathSync(fileURLToPath46(import.meta.url));
-    const argv = fs79.realpathSync(path76.resolve(process.argv[1]));
+    const here = fs80.realpathSync(fileURLToPath46(import.meta.url));
+    const argv = fs80.realpathSync(path76.resolve(process.argv[1]));
     return here === argv;
   } catch {
     return false;
@@ -51355,13 +51431,13 @@ __export(skill_catalogue_exports, {
   resolveSkillsRoot: () => resolveSkillsRoot,
   truncationModeOf: () => truncationModeOf
 });
-import * as fs80 from "node:fs";
+import * as fs81 from "node:fs";
 import * as path77 from "node:path";
 function resolveSkillsRoot(workspaceRoot) {
   for (const candidate of DEFAULT_CATALOGUE_ROOTS) {
     const abs = path77.join(workspaceRoot, candidate);
     try {
-      if (fs80.existsSync(abs) && fs80.statSync(abs).isDirectory()) return abs;
+      if (fs81.existsSync(abs) && fs81.statSync(abs).isDirectory()) return abs;
     } catch {
     }
   }
@@ -51405,9 +51481,9 @@ function descriptionOf(frontmatter) {
   return "";
 }
 function readProjectedCatalogue(root) {
-  const names = fs80.readdirSync(root).filter((n) => fs80.existsSync(path77.join(root, n, "SKILL.md"))).sort();
+  const names = fs81.readdirSync(root).filter((n) => fs81.existsSync(path77.join(root, n, "SKILL.md"))).sort();
   return names.map((name, index) => {
-    const content = fs80.readFileSync(path77.join(root, name, "SKILL.md"), "utf-8");
+    const content = fs81.readFileSync(path77.join(root, name, "SKILL.md"), "utf-8");
     const frontmatter = frontmatterOf(content);
     const description = descriptionOf(frontmatter);
     return {
@@ -51609,12 +51685,12 @@ function buildNoTruncationRecord(host, observedAt, entriesOffered, projectedSkil
   };
 }
 function markdownFilesUnder(root) {
-  if (!fs80.existsSync(root)) return [];
+  if (!fs81.existsSync(root)) return [];
   const out = [];
   const walk = (dir) => {
-    for (const entry of fs80.readdirSync(dir, { withFileTypes: true })) {
+    for (const entry of fs81.readdirSync(dir, { withFileTypes: true })) {
       const full = path77.join(dir, entry.name);
-      if (fs80.statSync(full).isDirectory()) walk(full);
+      if (fs81.statSync(full).isDirectory()) walk(full);
       else if (entry.name.endsWith(".md")) out.push(full);
     }
   };
@@ -51623,7 +51699,7 @@ function markdownFilesUnder(root) {
 }
 function measureCatalogueVolume(host, root) {
   const skillsRoot = path77.join(root, "skills");
-  const skills = fs80.existsSync(skillsRoot) ? readProjectedCatalogue(skillsRoot) : [];
+  const skills = fs81.existsSync(skillsRoot) ? readProjectedCatalogue(skillsRoot) : [];
   const commandEntries = markdownFilesUnder(path77.join(root, "commands")).length;
   return {
     host,
@@ -51755,9 +51831,9 @@ function migrationPromptLines(host, eligibility, settingsPath) {
   ];
 }
 function readObservationLog(logPath) {
-  if (!fs80.existsSync(logPath)) return [];
+  if (!fs81.existsSync(logPath)) return [];
   const out = [];
-  for (const line of fs80.readFileSync(logPath, "utf-8").split("\n")) {
+  for (const line of fs81.readFileSync(logPath, "utf-8").split("\n")) {
     const trimmed = line.trim();
     if (trimmed.length === 0) continue;
     try {
@@ -51853,7 +51929,7 @@ __export(score_skill_relevance_exports, {
   parse_args: () => parse_args7,
   rank: () => rank
 });
-import * as fs81 from "node:fs";
+import * as fs82 from "node:fs";
 import * as path78 from "node:path";
 import { fileURLToPath as fileURLToPath47, pathToFileURL as pathToFileURL35 } from "node:url";
 function pyLen(s) {
@@ -51874,7 +51950,7 @@ function _tokenize(text) {
   return out;
 }
 function _parse_frontmatter2(filePath) {
-  const text = fs81.readFileSync(filePath, "utf-8");
+  const text = fs82.readFileSync(filePath, "utf-8");
   if (!text.startsWith("---")) {
     return {};
   }
@@ -51957,7 +52033,7 @@ function _truthyStr(v) {
 function _globSkillMd(root) {
   let names;
   try {
-    names = fs81.readdirSync(root);
+    names = fs82.readdirSync(root);
   } catch {
     return [];
   }
@@ -51966,7 +52042,7 @@ function _globSkillMd(root) {
     const dir = path78.join(root, name);
     const skillMd = path78.join(dir, "SKILL.md");
     try {
-      if (fs81.statSync(dir).isDirectory() && fs81.statSync(skillMd).isFile()) {
+      if (fs82.statSync(dir).isDirectory() && fs82.statSync(skillMd).isFile()) {
         dirs.push(name);
       }
     } catch {
@@ -52201,8 +52277,8 @@ function _isCliEntry32() {
     return true;
   }
   try {
-    const here = fs81.realpathSync(fileURLToPath47(import.meta.url));
-    const argv = fs81.realpathSync(path78.resolve(process.argv[1]));
+    const here = fs82.realpathSync(fileURLToPath47(import.meta.url));
+    const argv = fs82.realpathSync(path78.resolve(process.argv[1]));
     return here === argv;
   } catch {
     return false;
@@ -52348,7 +52424,7 @@ init_prompts();
 init_resources();
 
 // src/scripts/mcp_server/tools.ts
-import * as fs82 from "node:fs";
+import * as fs83 from "node:fs";
 import * as path79 from "node:path";
 import { fileURLToPath as fileURLToPath48 } from "node:url";
 
@@ -54583,7 +54659,7 @@ function _strip8(s) {
 }
 function _resolvePath2(p) {
   try {
-    return fs82.realpathSync(p);
+    return fs83.realpathSync(p);
   } catch {
     return path79.resolve(p);
   }
@@ -54657,7 +54733,7 @@ async function _lintSkillsHandler(args, consumerRoot) {
       if (_relativeUnder(resolved, root) === null) {
         throw new Error(`path escapes consumer_root: ${resolved}`);
       }
-      if (fs82.existsSync(resolved)) {
+      if (fs83.existsSync(resolved)) {
         paths.push(resolved);
       }
     }
@@ -54694,7 +54770,7 @@ async function _chatHistoryAppendHandler(args, consumerRoot) {
     if (typeof minSchema !== "number" || !Number.isInteger(minSchema) || typeof minSchema === "boolean") {
       throw new Error("'min_schema_version' must be an integer");
     }
-    const existingHeader = fs82.existsSync(target) ? _chReadHeader(target) : null;
+    const existingHeader = fs83.existsSync(target) ? _chReadHeader(target) : null;
     const observed = existingHeader !== null && typeof existingHeader === "object" ? _pyInt7(existingHeader.v ?? 0) : SCHEMA_VERSION3;
     if (observed < minSchema) {
       throw new Error(`chat-history schema ${observed} below required ${minSchema}`);
@@ -54709,8 +54785,8 @@ async function _chatHistoryAppendHandler(args, consumerRoot) {
       session: session === void 0 ? null : session
     };
   }
-  if (!fs82.existsSync(target) || _chReadHeader(target) === null) {
-    fs82.mkdirSync(path79.dirname(target), { recursive: true });
+  if (!fs83.existsSync(target) || _chReadHeader(target) === null) {
+    fs83.mkdirSync(path79.dirname(target), { recursive: true });
     _chInit(target);
   }
   _chAppend(entry, target, session ?? null);
@@ -54754,7 +54830,7 @@ async function _chatHistoryReadHandler(args, consumerRoot) {
   if (detail !== "full" && detail !== "index") {
     throw new Error("'detail' must be 'index' or 'full'");
   }
-  if (!fs82.existsSync(target)) {
+  if (!fs83.existsSync(target)) {
     return { path: target, entries: [], count: 0 };
   }
   if (around !== void 0 && around !== null) {
@@ -54904,7 +54980,7 @@ async function _roadmapProgressHandler(args, consumerRoot) {
   const roadmapRoot = path79.join(root, "agents", "roadmaps");
   const target = path79.join(root, "agents", "roadmaps-progress.md");
   const urp = await Promise.resolve().then(() => (init_update_roadmap_progress(), update_roadmap_progress_exports));
-  if (!fs82.existsSync(roadmapRoot)) {
+  if (!fs83.existsSync(roadmapRoot)) {
     return {
       written: false,
       path: target,
@@ -54919,7 +54995,7 @@ async function _roadmapProgressHandler(args, consumerRoot) {
   const stepsDone = roadmaps.reduce((s, r) => s + r.done, 0);
   const stepsTotal = roadmaps.reduce((s, r) => s + r.total_active, 0);
   if (!dryRun) {
-    fs82.writeFileSync(target, content, "utf-8");
+    fs83.writeFileSync(target, content, "utf-8");
   }
   return {
     written: !dryRun,
@@ -54941,9 +55017,9 @@ async function _roadmapArchiveHandler(_args, consumerRoot) {
   if (archived.length > 0) {
     const urp = await Promise.resolve().then(() => (init_update_roadmap_progress(), update_roadmap_progress_exports));
     const roadmapRoot = path79.join(root, "agents", "roadmaps");
-    if (fs82.existsSync(roadmapRoot)) {
+    if (fs83.existsSync(roadmapRoot)) {
       const roadmaps = urp.collect(roadmapRoot);
-      fs82.writeFileSync(
+      fs83.writeFileSync(
         path79.join(root, "agents", "roadmaps-progress.md"),
         urp.render(roadmaps, urp.collect_bundles(root), roadmapRoot),
         "utf-8"
@@ -54962,7 +55038,7 @@ async function _capabilitiesIndexHandler(args, consumerRoot) {
   const cap = await Promise.resolve().then(() => (init_generate_capabilities_index(), generate_capabilities_index_exports));
   const out = path79.join(_PACKAGE_ROOT3, "CAPABILITIES.yaml");
   const content = cap.build();
-  const onDisk = fs82.existsSync(out) ? fs82.readFileSync(out, "utf-8") : "";
+  const onDisk = fs83.existsSync(out) ? fs83.readFileSync(out, "utf-8") : "";
   const drift = onDisk !== content;
   if (check) {
     return { check: true, written: false, drift, path: out };
@@ -54973,7 +55049,7 @@ async function _capabilitiesIndexHandler(args, consumerRoot) {
       `CAPABILITIES.yaml path escapes consumer_root: ${out} not under ${root}`
     );
   }
-  fs82.writeFileSync(out, content, "utf-8");
+  fs83.writeFileSync(out, content, "utf-8");
   return { check: false, written: true, drift, path: out };
 }
 async function _runDoctorLeg(consumerRoot) {
@@ -55077,7 +55153,7 @@ async function _councilEstimateHandler(args, consumerRoot) {
   if (_relativeUnder(target, root) === null) {
     throw new Error(`path escapes consumer_root: ${target}`);
   }
-  if (!fs82.existsSync(target)) {
+  if (!fs83.existsSync(target)) {
     throw new Error(`input_path not found: ${target}`);
   }
   const cli = await Promise.resolve().then(() => (init_council_cli(), council_cli_exports));
@@ -55144,13 +55220,13 @@ async function _runTestsHandler(args, consumerRoot) {
     if (rel === null) {
       throw new Error(`path escapes consumer_root: ${resolved}`);
     }
-    if (!fs82.existsSync(resolved)) {
+    if (!fs83.existsSync(resolved)) {
       throw new Error(`path not found: ${resolved}`);
     }
     relArg = rel;
   }
   const vitestEntry = path79.join(root, "node_modules", "vitest", "vitest.mjs");
-  if (!fs82.existsSync(vitestEntry)) {
+  if (!fs83.existsSync(vitestEntry)) {
     throw new Error(
       "run_tests pilot supports vitest projects only \u2014 node_modules/vitest/vitest.mjs not found under consumer_root"
     );