@event4u/agent-config 14.7.0 → 14.8.0

package/dist/hooks/dispatch.js

@@ -6913,14 +6913,14 @@ var require_parser = __commonJS({
             case "scalar":
             case "single-quoted-scalar":
             case "double-quoted-scalar": {
-              const fs89 = this.flowScalar(this.type);
+              const fs88 = this.flowScalar(this.type);
               if (atNextItem || it.value) {
-                map.items.push({ start, key: fs89, sep: [] });
+                map.items.push({ start, key: fs88, sep: [] });
                 this.onKeyLine = true;
               } else if (it.sep) {
-                this.stack.push(fs89);
+                this.stack.push(fs88);
               } else {
-                Object.assign(it, { key: fs89, sep: [] });
+                Object.assign(it, { key: fs88, sep: [] });
                 this.onKeyLine = true;
               }
               return;
@@ -7048,13 +7048,13 @@ var require_parser = __commonJS({
             case "scalar":
             case "single-quoted-scalar":
             case "double-quoted-scalar": {
-              const fs89 = this.flowScalar(this.type);
+              const fs88 = this.flowScalar(this.type);
               if (!it || it.value)
-                fc.items.push({ start: [], key: fs89, sep: [] });
+                fc.items.push({ start: [], key: fs88, sep: [] });
               else if (it.sep)
-                this.stack.push(fs89);
+                this.stack.push(fs88);
               else
-                Object.assign(it, { key: fs89, sep: [] });
+                Object.assign(it, { key: fs88, sep: [] });
               return;
             }
             case "flow-map-end":
@@ -7369,7 +7369,7 @@ import { fileURLToPath as fileURLToPath60 } from "node:url";
 // src/scripts/hooks/dispatch_hook.ts
 var import_yaml6 = __toESM(require_dist(), 1);
 import { spawnSync as spawnSync8 } from "node:child_process";
-import fs88 from "node:fs";
+import fs87 from "node:fs";
 import path89 from "node:path";
 import * as tty2 from "node:tty";
 import { fileURLToPath as fileURLToPath59, pathToFileURL as pathToFileURL53 } from "node:url";
@@ -7732,6 +7732,39 @@ function owns_session_state(state, session_id) {
   if (typeof state !== "object" || state === null || Array.isArray(state)) return false;
   return state["session_id"] === session_id;
 }
+function update_text_under_lock(target, transform, options = {}) {
+  if (is_replay_mode()) return "failed";
+  const targetPath = path.resolve(target);
+  const state_dir = path.dirname(targetPath);
+  try {
+    fs.mkdirSync(state_dir, { recursive: true });
+  } catch {
+    return "failed";
+  }
+  const lock_path = _target_lock_path(targetPath);
+  let fd;
+  try {
+    fd = _acquire_lock(lock_path, { blocking: options.blocking ?? true });
+  } catch {
+    return "failed";
+  }
+  if (fd === null) return "failed";
+  try {
+    let loaded = null;
+    try {
+      loaded = fs.readFileSync(targetPath, "utf-8");
+    } catch {
+    }
+    const next = transform(loaded);
+    if (next === null) return "skipped";
+    _publish_text_locked(targetPath, next);
+    return "written";
+  } catch {
+    return "failed";
+  } finally {
+    _release_lock(fd, lock_path);
+  }
+}
 function update_json_under_lock(target, mutate, options = {}) {
   if (is_replay_mode()) return "failed";
   const targetPath = path.resolve(target);
@@ -7771,7 +7804,6 @@ function update_json_under_lock(target, mutate, options = {}) {
 }
 
 // src/scripts/hooks/dispatch_issues.ts
-import fs2 from "node:fs";
 import path2 from "node:path";
 var LOG_CAP = 200;
 var VALID_ISSUE = /* @__PURE__ */ new Set([
@@ -7867,23 +7899,21 @@ function log_dispatch_issue(workspace_root, hook, issue, detail, resolution) {
     resolution: String(resolution)
   };
   try {
-    fs2.mkdirSync(path2.dirname(log), { recursive: true });
-    let existing = [];
-    if (fs2.existsSync(log)) {
-      try {
-        existing = fs2.readFileSync(log, "utf-8").split("\n");
-        if (existing.length > 0 && existing[existing.length - 1] === "") {
-          existing.pop();
-        }
-      } catch {
-        existing = [];
+    const outcome = update_text_under_lock(log, (loaded) => {
+      const existing = loaded === null ? [] : loaded.split("\n");
+      if (existing.length > 0 && existing[existing.length - 1] === "") {
+        existing.pop();
       }
+      existing.push(_json_dumps_flat(entry));
+      const capped = existing.length > LOG_CAP ? existing.slice(existing.length - LOG_CAP) : existing;
+      return capped.join("\n") + "\n";
+    });
+    if (outcome !== "written") {
+      process.stderr.write(
+        `dispatch_issues: could not append to ${log} (${outcome}) \u2014 the entry was dropped: ${entry.issue} on ${entry.hook}
+`
+      );
     }
-    existing.push(_json_dumps_flat(entry));
-    if (existing.length > LOG_CAP) {
-      existing = existing.slice(existing.length - LOG_CAP);
-    }
-    fs2.writeFileSync(log, existing.join("\n") + "\n", { encoding: "utf-8" });
   } catch (exc) {
     const msg = exc instanceof Error ? exc.message : String(exc);
     process.stderr.write(`dispatch_issues: failed to append to ${log}: ${msg}
@@ -7895,7 +7925,7 @@ function fix_hint(_workspace_root) {
 }
 
 // src/scripts/hooks/injection_budget.ts
-import * as fs3 from "node:fs";
+import * as fs2 from "node:fs";
 import * as path3 from "node:path";
 
 // src/scripts/hooks/host_semantics.ts
@@ -7916,6 +7946,10 @@ var CLAUDE_BLOCK_CAPABLE_EVENTS = /* @__PURE__ */ new Set([
   "user_prompt_submit",
   "stop"
 ]);
+function isBlockCapable(platform, event) {
+  if (!VERIFIED_PLATFORMS.has(platform)) return false;
+  return CLAUDE_BLOCK_CAPABLE_EVENTS.has(event);
+}
 function _joinReasons(reasons) {
   return reasons.map((r) => r.trim()).filter((r) => r.length > 0).join(" \xB7 ");
 }
@@ -8059,17 +8093,17 @@ function turnSpendPath(workspaceRoot2, session) {
 }
 function _pruneTurnSpend(dir) {
   try {
-    const entries = fs3.readdirSync(dir).filter((n) => n.endsWith(".json") || n.endsWith(".tmp")).map((n) => {
+    const entries = fs2.readdirSync(dir).filter((n) => n.endsWith(".json") || n.endsWith(".tmp")).map((n) => {
       const p = path3.join(dir, n);
       try {
-        return { p, mtime: fs3.statSync(p).mtimeMs };
+        return { p, mtime: fs2.statSync(p).mtimeMs };
       } catch {
         return { p, mtime: 0 };
       }
     }).sort((a, b) => b.mtime - a.mtime);
     for (const stale of entries.slice(TURN_SPEND_MAX_FILES)) {
       try {
-        fs3.unlinkSync(stale.p);
+        fs2.unlinkSync(stale.p);
       } catch {
       }
     }
@@ -8078,7 +8112,7 @@ function _pruneTurnSpend(dir) {
 }
 function readTurnSpend(workspaceRoot2, session) {
   try {
-    const raw = fs3.readFileSync(turnSpendPath(workspaceRoot2, session), "utf-8");
+    const raw = fs2.readFileSync(turnSpendPath(workspaceRoot2, session), "utf-8");
     const parsed = JSON.parse(raw);
     if (parsed.session !== session) return 0;
     return typeof parsed.bytes === "number" && Number.isFinite(parsed.bytes) && parsed.bytes >= 0 ? parsed.bytes : 0;
@@ -8093,10 +8127,10 @@ function recordTurnSpend(workspaceRoot2, session, bytes, opts = {}) {
   try {
     const target = turnSpendPath(workspaceRoot2, session);
     const dir = path3.dirname(target);
-    fs3.mkdirSync(dir, { recursive: true });
+    fs2.mkdirSync(dir, { recursive: true });
     const tmp = `${target}.${String(process.pid)}.tmp`;
-    fs3.writeFileSync(tmp, JSON.stringify(entry) + "\n", { encoding: "utf-8" });
-    fs3.renameSync(tmp, target);
+    fs2.writeFileSync(tmp, JSON.stringify(entry) + "\n", { encoding: "utf-8" });
+    fs2.renameSync(tmp, target);
     _pruneTurnSpend(dir);
   } catch {
   }
@@ -8107,7 +8141,7 @@ function _turnStartBound(packageRoot, platform) {
     ["src", "scripts", "hook_manifest.yaml"]
   ]) {
     try {
-      const raw = fs3.readFileSync(path3.join(packageRoot, ...rel), "utf-8");
+      const raw = fs2.readFileSync(path3.join(packageRoot, ...rel), "utf-8");
       if (rel[2] === "hook_manifest.json") {
         const parsed = JSON.parse(raw);
         const platforms = parsed.manifest?.["platforms"];
@@ -8134,7 +8168,7 @@ function resolveVolumeCap(ctx) {
   if (_sessionKey(ctx) === null) return null;
   if (!_turnStartBound(ctx.packageRoot, ctx.platform)) return null;
   try {
-    const raw = fs3.readFileSync(
+    const raw = fs2.readFileSync(
       path3.join(ctx.packageRoot, "src", "config", "hook-token-budget.json"),
       "utf-8"
     );
@@ -8201,26 +8235,26 @@ function shapeAndRecord(ctx, messages, finalRc) {
 
 // src/scripts/chat_history.ts
 import { createHash as createHash3 } from "node:crypto";
-import * as fs14 from "node:fs";
+import * as fs13 from "node:fs";
 import * as path13 from "node:path";
 import { fileURLToPath as fileURLToPath8, pathToFileURL as pathToFileURL5 } from "node:url";
 
 // src/scripts/memory_lookup.ts
 var import_yaml2 = __toESM(require_dist(), 1);
-import * as fs10 from "node:fs";
+import * as fs9 from "node:fs";
 import * as path10 from "node:path";
 import process5 from "node:process";
 import { fileURLToPath as fileURLToPath6, pathToFileURL as pathToFileURL4 } from "node:url";
 import { createRequire as createRequire2 } from "node:module";
 
 // src/scripts/lint_hidden_unicode.ts
-import * as fs5 from "node:fs";
+import * as fs4 from "node:fs";
 import * as path5 from "node:path";
 import { spawnSync } from "node:child_process";
 import { fileURLToPath as fileURLToPath2, pathToFileURL } from "node:url";
 
 // src/scripts/_lib/security_lint.ts
-import * as fs4 from "node:fs";
+import * as fs3 from "node:fs";
 import * as path4 from "node:path";
 import { fileURLToPath } from "node:url";
 var _HERE = path4.dirname(fileURLToPath(import.meta.url));
@@ -8365,7 +8399,7 @@ function scan_file(filePath) {
   } else {
     rel = filePath.split(path4.sep).join("/");
   }
-  const raw = fs4.readFileSync(filePath, "utf-8");
+  const raw = fs3.readFileSync(filePath, "utf-8");
   const lines = _splitlines(raw);
   const n = lines.length;
   const in_example = new Array(n + 1).fill(false);
@@ -8420,7 +8454,7 @@ function _rglobSorted(base) {
   const walk = (dir) => {
     let entries;
     try {
-      entries = fs4.readdirSync(dir, { withFileTypes: true });
+      entries = fs3.readdirSync(dir, { withFileTypes: true });
     } catch {
       return;
     }
@@ -8451,13 +8485,13 @@ function _pathCmp(a, b) {
 function* iter_corpus(roots = DEFAULT_SCAN_ROOTS, exts = [".md"]) {
   for (const root of roots) {
     const base = path4.join(ROOT, root);
-    if (!fs4.existsSync(base)) {
+    if (!fs3.existsSync(base)) {
       continue;
     }
     for (const p of _rglobSorted(base)) {
       let st;
       try {
-        st = fs4.statSync(p);
+        st = fs3.statSync(p);
       } catch {
         continue;
       }
@@ -9018,7 +9052,7 @@ function _scanSourceControlBytes(files = null) {
     if (_BINARY_EXT.has(_extensionOf(rel))) continue;
     let data;
     try {
-      data = fs5.readFileSync(path5.join(ROOT, rel));
+      data = fs4.readFileSync(path5.join(ROOT, rel));
     } catch {
       continue;
     }
@@ -9052,7 +9086,7 @@ function _scanSourceControlBytes(files = null) {
   return out;
 }
 function _sanitize(filePath) {
-  const raw = fs5.readFileSync(filePath, "utf-8");
+  const raw = fs4.readFileSync(filePath, "utf-8");
   let cleaned = "";
   for (const ch of raw) {
     const cp = ch.codePointAt(0);
@@ -9062,7 +9096,7 @@ function _sanitize(filePath) {
   }
   cleaned = cleaned.normalize("NFKC");
   const out = filePath + ".sanitized";
-  fs5.writeFileSync(out, cleaned, "utf-8");
+  fs4.writeFileSync(out, cleaned, "utf-8");
   return out;
 }
 function _argError(msg) {
@@ -9159,8 +9193,8 @@ function _isCliEntry() {
     return true;
   }
   try {
-    const here = fs5.realpathSync(fileURLToPath2(import.meta.url));
-    const argv = fs5.realpathSync(path5.resolve(process.argv[1]));
+    const here = fs4.realpathSync(fileURLToPath2(import.meta.url));
+    const argv = fs4.realpathSync(path5.resolve(process.argv[1]));
     return here === argv;
   } catch {
     return false;
@@ -9338,7 +9372,7 @@ var LexicalIndex = class {
 };
 
 // src/scripts/_lib/memory_fts_index.ts
-import * as fs8 from "node:fs";
+import * as fs7 from "node:fs";
 import * as path8 from "node:path";
 
 // src/scripts/_lib/sqlite_guard.ts
@@ -9417,14 +9451,14 @@ function stampUserVersion(conn, version) {
 
 // src/scripts/memory_report.ts
 var import_yaml = __toESM(require_dist(), 1);
-import * as fs7 from "node:fs";
+import * as fs6 from "node:fs";
 import * as path7 from "node:path";
 import process3 from "node:process";
 import { fileURLToPath as fileURLToPath4, pathToFileURL as pathToFileURL3 } from "node:url";
 
 // src/scripts/memory_status.ts
 import process2 from "node:process";
-import * as fs6 from "node:fs";
+import * as fs5 from "node:fs";
 import * as path6 from "node:path";
 import { fileURLToPath as fileURLToPath3, pathToFileURL as pathToFileURL2 } from "node:url";
 var CONTRACT_VERSION = 1;
@@ -9567,8 +9601,8 @@ function _isCliEntry2() {
     return true;
   }
   try {
-    const here = fs6.realpathSync(fileURLToPath3(import.meta.url));
-    const argv = fs6.realpathSync(path6.resolve(process2.argv[1]));
+    const here = fs5.realpathSync(fileURLToPath3(import.meta.url));
+    const argv = fs5.realpathSync(path6.resolve(process2.argv[1]));
     return here === argv;
   } catch {
     return false;
@@ -9637,20 +9671,20 @@ function _isPlainObject2(v) {
 }
 function _isFile(p) {
   try {
-    return fs7.statSync(p).isFile();
+    return fs6.statSync(p).isFile();
   } catch {
     return false;
   }
 }
 function _isDir(p) {
   try {
-    return fs7.statSync(p).isDirectory();
+    return fs6.statSync(p).isDirectory();
   } catch {
     return false;
   }
 }
 function _load_yaml(p) {
-  const text = fs7.readFileSync(p, "utf-8");
+  const text = fs6.readFileSync(p, "utf-8");
   const doc = (0, import_yaml.parseDocument)(text, { version: "1.1", prettyErrors: false });
   if (doc.errors.length > 0) {
     const err = doc.errors[0];
@@ -9746,7 +9780,7 @@ function _rglobYml(root) {
   const walk = (dir) => {
     let entries;
     try {
-      entries = fs7.readdirSync(dir, { withFileTypes: true });
+      entries = fs6.readdirSync(dir, { withFileTypes: true });
     } catch {
       return;
     }
@@ -9766,7 +9800,7 @@ function _rglobYml(root) {
 function _globJsonl(root) {
   let names;
   try {
-    names = fs7.readdirSync(root);
+    names = fs6.readdirSync(root);
   } catch {
     return [];
   }
@@ -9805,7 +9839,7 @@ function _intake_stats() {
 function _readJsonl(p) {
   let text;
   try {
-    text = fs7.readFileSync(p, "utf-8");
+    text = fs6.readFileSync(p, "utf-8");
   } catch {
     return [];
   }
@@ -9968,7 +10002,7 @@ function _role_mode_stats() {
     for (const md of _rglobMd(root)) {
       let text;
       try {
-        text = fs7.readFileSync(md, "utf-8");
+        text = fs6.readFileSync(md, "utf-8");
       } catch {
         continue;
       }
@@ -9997,7 +10031,7 @@ function _role_mode_stats() {
 }
 function _exists(p) {
   try {
-    fs7.statSync(p);
+    fs6.statSync(p);
     return true;
   } catch {
     return false;
@@ -10008,7 +10042,7 @@ function _rglobMd(root) {
   const walk = (dir) => {
     let entries;
     try {
-      entries = fs7.readdirSync(dir, { withFileTypes: true });
+      entries = fs6.readdirSync(dir, { withFileTypes: true });
     } catch {
       return;
     }
@@ -10262,8 +10296,8 @@ function _isCliEntry3() {
     return true;
   }
   try {
-    const here = fs7.realpathSync(fileURLToPath4(import.meta.url));
-    const argv = fs7.realpathSync(path7.resolve(process3.argv[1]));
+    const here = fs6.realpathSync(fileURLToPath4(import.meta.url));
+    const argv = fs6.realpathSync(path7.resolve(process3.argv[1]));
     return here === argv;
   } catch {
     return false;
@@ -10319,7 +10353,7 @@ function _collectCurated(memoryRoot) {
 function _globJsonl2(intakeRoot) {
   let names;
   try {
-    names = fs8.readdirSync(intakeRoot);
+    names = fs7.readdirSync(intakeRoot);
   } catch {
     return [];
   }
@@ -10332,7 +10366,7 @@ function _collectIntake(intakeRoot) {
     const superseded = /* @__PURE__ */ new Set();
     let content;
     try {
-      content = fs8.readFileSync(jsonl, "utf-8");
+      content = fs7.readFileSync(jsonl, "utf-8");
     } catch {
       continue;
     }
@@ -10369,7 +10403,7 @@ function _sourcesMaxMtimeMs(memoryRoot, intakeRoot) {
   let max = 0;
   const bump = (p) => {
     try {
-      const st = fs8.statSync(p);
+      const st = fs7.statSync(p);
       if (st.mtimeMs > max) max = st.mtimeMs;
     } catch {
     }
@@ -10377,7 +10411,7 @@ function _sourcesMaxMtimeMs(memoryRoot, intakeRoot) {
   const walk = (dir) => {
     let entries;
     try {
-      entries = fs8.readdirSync(dir, { withFileTypes: true });
+      entries = fs7.readdirSync(dir, { withFileTypes: true });
     } catch {
       return;
     }
@@ -10389,7 +10423,7 @@ function _sourcesMaxMtimeMs(memoryRoot, intakeRoot) {
   };
   let memEntries;
   try {
-    memEntries = fs8.readdirSync(memoryRoot, { withFileTypes: true });
+    memEntries = fs7.readdirSync(memoryRoot, { withFileTypes: true });
     for (const e of memEntries) {
       const full = path8.join(memoryRoot, e.name);
       if (e.isFile() && e.name.endsWith(".yml")) bump(full);
@@ -10402,7 +10436,7 @@ function _sourcesMaxMtimeMs(memoryRoot, intakeRoot) {
 }
 var META_KEY_SOURCES_MTIME = "sources_mtime_ms";
 function isStale(indexPath, memoryRoot, intakeRoot) {
-  if (!fs8.existsSync(indexPath)) return true;
+  if (!fs7.existsSync(indexPath)) return true;
   let sqlite;
   try {
     sqlite = loadSqliteSync("memory_fts_index.isStale");
@@ -10428,11 +10462,11 @@ function isStale(indexPath, memoryRoot, intakeRoot) {
   }
 }
 function buildIndex(indexPath, memoryRoot, intakeRoot) {
-  fs8.mkdirSync(path8.dirname(indexPath), { recursive: true });
+  fs7.mkdirSync(path8.dirname(indexPath), { recursive: true });
   try {
-    fs8.rmSync(indexPath, { force: true });
-    fs8.rmSync(`${indexPath}-wal`, { force: true });
-    fs8.rmSync(`${indexPath}-shm`, { force: true });
+    fs7.rmSync(indexPath, { force: true });
+    fs7.rmSync(`${indexPath}-wal`, { force: true });
+    fs7.rmSync(`${indexPath}-shm`, { force: true });
   } catch {
   }
   const { DatabaseSync } = loadSqliteSync("memory_fts_index.buildIndex");
@@ -10517,7 +10551,7 @@ function queryIndex(indexPath, keys, types) {
 
 // src/scripts/learning_sidecar.ts
 import { createHash as createHash2 } from "node:crypto";
-import * as fs9 from "node:fs";
+import * as fs8 from "node:fs";
 import * as path9 from "node:path";
 import process4 from "node:process";
 import { fileURLToPath as fileURLToPath5 } from "node:url";
@@ -10537,7 +10571,7 @@ function _bodyHash(body) {
 function _globSignalFiles(dir) {
   let names;
   try {
-    names = fs9.readdirSync(dir);
+    names = fs8.readdirSync(dir);
   } catch {
     return [];
   }
@@ -10548,7 +10582,7 @@ function readSignals(intakeDir) {
   for (const file of _globSignalFiles(intakeDir)) {
     let content;
     try {
-      content = fs9.readFileSync(file, "utf-8");
+      content = fs8.readFileSync(file, "utf-8");
     } catch {
       continue;
     }
@@ -10708,9 +10742,9 @@ function main4(argv) {
     return 3;
   }
   if (write) {
-    fs9.mkdirSync(outDir, { recursive: true });
-    fs9.writeFileSync(path9.join(outDir, SIDECAR_NAME), JSON.stringify(sidecar, null, 2) + "\n");
-    fs9.writeFileSync(path9.join(outDir, LESSONS_NAME), renderLessonsMd(sidecar));
+    fs8.mkdirSync(outDir, { recursive: true });
+    fs8.writeFileSync(path9.join(outDir, SIDECAR_NAME), JSON.stringify(sidecar, null, 2) + "\n");
+    fs8.writeFileSync(path9.join(outDir, LESSONS_NAME), renderLessonsMd(sidecar));
   }
   if (format === "json") {
     process4.stdout.write(JSON.stringify(sidecar, null, 2) + "\n");
@@ -10760,7 +10794,7 @@ function _loadLearningOverlay() {
   if (_learningOverlay !== void 0) return _learningOverlay;
   const file = path10.join(MEMORY_ROOT2, SIDECAR_NAME);
   try {
-    const parsed = JSON.parse(fs10.readFileSync(file, "utf-8"));
+    const parsed = JSON.parse(fs9.readFileSync(file, "utf-8"));
     const lessons = _isPlainObject4(parsed) ? parsed["lessons"] : null;
     if (!Array.isArray(lessons)) {
       _learningOverlay = null;
@@ -10838,20 +10872,20 @@ function _isPlainObject4(v) {
 }
 function _isFile2(p) {
   try {
-    return fs10.statSync(p).isFile();
+    return fs9.statSync(p).isFile();
   } catch {
     return false;
   }
 }
 function _isDir2(p) {
   try {
-    return fs10.statSync(p).isDirectory();
+    return fs9.statSync(p).isDirectory();
   } catch {
     return false;
   }
 }
 function _load_yaml2(p) {
-  const text = fs10.readFileSync(p, "utf-8");
+  const text = fs9.readFileSync(p, "utf-8");
   const doc = (0, import_yaml2.parseDocument)(text, { version: "1.1", prettyErrors: false });
   if (doc.errors.length > 0) {
     const err = doc.errors[0];
@@ -10982,7 +11016,7 @@ function* _iter_intake_entries(mtype) {
   for (const jsonl of _globJsonlSorted(INTAKE_ROOT2)) {
     const by_id = /* @__PURE__ */ new Map();
     const superseded = /* @__PURE__ */ new Set();
-    const content = fs10.readFileSync(jsonl, "utf-8");
+    const content = fs9.readFileSync(jsonl, "utf-8");
     for (let line of content.split(/\n/)) {
       line = line.trim();
       if (!line) {
@@ -11032,7 +11066,7 @@ function* _iter_knowledge_entries() {
     let manifest = {};
     if (_isFile2(manifest_path)) {
       try {
-        const parsed = JSON.parse(fs10.readFileSync(manifest_path, "utf-8"));
+        const parsed = JSON.parse(fs9.readFileSync(manifest_path, "utf-8"));
         manifest = _isPlainObject4(parsed) ? parsed : {};
       } catch {
         manifest = {};
@@ -11048,7 +11082,7 @@ function* _iter_knowledge_entries() {
     for (const chunk of _globMdSorted(chunks_dir)) {
       let body;
       try {
-        body = fs10.readFileSync(chunk, "utf-8");
+        body = fs9.readFileSync(chunk, "utf-8");
       } catch {
         continue;
       }
@@ -11194,7 +11228,7 @@ function _entry_tokens_estimate(envelope_entry) {
 function _countMdFiles(dir) {
   let entries;
   try {
-    entries = fs10.readdirSync(dir, { withFileTypes: true });
+    entries = fs9.readdirSync(dir, { withFileTypes: true });
   } catch {
     return 0;
   }
@@ -11210,7 +11244,7 @@ function _countCorpusFiles() {
   const perType = /* @__PURE__ */ new Map();
   let total = 0;
   for (const t of CURATED_TYPES2) {
-    const exists = fs10.existsSync(path10.join(MEMORY_ROOT2, `${t}.yml`));
+    const exists = fs9.existsSync(path10.join(MEMORY_ROOT2, `${t}.yml`));
     const c = exists ? 1 : 0;
     perType.set(t, c);
     total += c;
@@ -11219,7 +11253,7 @@ function _countCorpusFiles() {
   perType.set(KNOWLEDGE_TYPE, kn);
   total += kn;
   try {
-    for (const e of fs10.readdirSync(INTAKE_ROOT2, { withFileTypes: true })) {
+    for (const e of fs9.readdirSync(INTAKE_ROOT2, { withFileTypes: true })) {
       if (e.isFile() && e.name.endsWith(".jsonl")) total += 1;
     }
   } catch {
@@ -11724,7 +11758,7 @@ function _rglobYmlSorted(root) {
   const walk = (dir) => {
     let entries;
     try {
-      entries = fs10.readdirSync(dir, { withFileTypes: true });
+      entries = fs9.readdirSync(dir, { withFileTypes: true });
     } catch {
       return;
     }
@@ -11751,7 +11785,7 @@ function _globMdSorted(dir) {
 function _globSorted(dir, suffix) {
   let entries;
   try {
-    entries = fs10.readdirSync(dir, { withFileTypes: true });
+    entries = fs9.readdirSync(dir, { withFileTypes: true });
   } catch {
     return [];
   }
@@ -11762,7 +11796,7 @@ function _globSorted(dir, suffix) {
 function _iterdirSorted(dir) {
   let names;
   try {
-    names = fs10.readdirSync(dir);
+    names = fs9.readdirSync(dir);
   } catch {
     return [];
   }
@@ -11897,8 +11931,8 @@ function _isCliEntry4() {
     return true;
   }
   try {
-    const here = fs10.realpathSync(fileURLToPath6(import.meta.url));
-    const argv = fs10.realpathSync(path10.resolve(process5.argv[1]));
+    const here = fs9.realpathSync(fileURLToPath6(import.meta.url));
+    const argv = fs9.realpathSync(path10.resolve(process5.argv[1]));
     return here === argv;
   } catch {
     return false;
@@ -11911,12 +11945,12 @@ if (_isMain3) {
 
 // src/scripts/_lib/agent_settings.ts
 import { createRequire as createRequire3 } from "node:module";
-import * as fs12 from "node:fs";
+import * as fs11 from "node:fs";
 import * as path12 from "node:path";
 import { fileURLToPath as fileURLToPath7 } from "node:url";
 
 // src/scripts/_lib/user_global_paths.ts
-import * as fs11 from "node:fs";
+import * as fs10 from "node:fs";
 import * as os from "node:os";
 import * as path11 from "node:path";
 var EVENT4U_HOME_ENV = "EVENT4U_CONFIG_HOME";
@@ -11955,11 +11989,11 @@ function resolve_with_fallback(relative_name, options = {}) {
     );
   }
   const new_path = path11.join(event4u_root(options.env ?? null), relative_name);
-  if (fs11.existsSync(new_path)) {
+  if (fs10.existsSync(new_path)) {
     return new_path;
   }
   const legacy_path = path11.join(legacy_xdg_root(), relative_name);
-  if (fs11.existsSync(legacy_path)) {
+  if (fs10.existsSync(legacy_path)) {
     return legacy_path;
   }
   return null;
@@ -12177,8 +12211,8 @@ var _AGENTS_DIR_MARKERS = [
 var _LEGACY_ANCHOR_ENV = "AGENT_CONFIG_LEGACY_ANCHOR";
 function _exists2(p) {
   try {
-    fs12.lstatSync(p);
-    fs12.statSync(p);
+    fs11.lstatSync(p);
+    fs11.statSync(p);
     return true;
   } catch {
     return false;
@@ -12186,14 +12220,14 @@ function _exists2(p) {
 }
 function _is_dir(p) {
   try {
-    return fs12.statSync(p).isDirectory();
+    return fs11.statSync(p).isDirectory();
   } catch {
     return false;
   }
 }
 function _is_file(p) {
   try {
-    return fs12.statSync(p).isFile();
+    return fs11.statSync(p).isFile();
   } catch {
     return false;
   }
@@ -12201,7 +12235,7 @@ function _is_file(p) {
 function _resolve(p) {
   const absolute = path12.resolve(p);
   try {
-    return fs12.realpathSync(absolute);
+    return fs11.realpathSync(absolute);
   } catch {
     return absolute;
   }
@@ -12381,7 +12415,7 @@ function _read_yaml(p) {
   }
   let data;
   try {
-    const text = fs12.readFileSync(p, "utf-8");
+    const text = fs11.readFileSync(p, "utf-8");
     data = YAML4.parse(text, { version: "1.1" });
     if (data === null || data === void 0) {
       data = {};
@@ -12484,7 +12518,7 @@ function _is_plain_dict(value) {
 import * as tty from "node:tty";
 
 // src/scripts/_lib/stdin.ts
-import * as fs13 from "node:fs";
+import * as fs12 from "node:fs";
 var CHUNK = 64 * 1024;
 var RETRY_SLEEP_MS = 5;
 var MAX_RETRIES = 2e3;
@@ -12500,7 +12534,7 @@ function readStdinText(fd = 0, opts = {}) {
   for (; ; ) {
     let read;
     try {
-      read = fs13.readSync(fd, buf, 0, CHUNK, null);
+      read = fs12.readSync(fd, buf, 0, CHUNK, null);
       retries = 0;
     } catch (exc) {
       const code = exc.code;
@@ -12777,14 +12811,14 @@ function derive_session_tag(session_id) {
 }
 function _isFile3(p) {
   try {
-    return fs14.statSync(p).isFile();
+    return fs13.statSync(p).isFile();
   } catch {
     return false;
   }
 }
 function _statSize(p) {
   try {
-    return fs14.statSync(p).size;
+    return fs13.statSync(p).size;
   } catch {
     return -1;
   }
@@ -12835,7 +12869,7 @@ function _session_tag_enabled() {
   return (process.env.AGENT_CHAT_HISTORY_SESSION_TAG ?? "true").trim().toLowerCase() !== "false";
 }
 function _readLines(p) {
-  const raw = fs14.readFileSync(p, "utf-8");
+  const raw = fs13.readFileSync(p, "utf-8");
   if (raw === "") {
     return [];
   }
@@ -12881,7 +12915,7 @@ function read_header(p) {
   }
   let first;
   try {
-    const raw = fs14.readFileSync(target, "utf-8");
+    const raw = fs13.readFileSync(target, "utf-8");
     first = _strip(raw.split("\n", 1)[0] ?? "");
   } catch {
     return null;
@@ -12911,8 +12945,8 @@ function init(freq = "per_phase", options = {}) {
   if (_is_replay_mode()) {
     return header;
   }
-  fs14.mkdirSync(path13.dirname(target), { recursive: true });
-  fs14.writeFileSync(target, _pyDumps(header) + "\n", { encoding: "utf-8" });
+  fs13.mkdirSync(path13.dirname(target), { recursive: true });
+  fs13.writeFileSync(target, _pyDumps(header) + "\n", { encoding: "utf-8" });
   return header;
 }
 function migrate_header(p, options = {}) {
@@ -12938,7 +12972,7 @@ function migrate_header(p, options = {}) {
   if (typeof existing.started === "string") {
     new_header.started = existing.started;
   }
-  const raw = fs14.readFileSync(target, "utf-8");
+  const raw = fs13.readFileSync(target, "utf-8");
   const lines = _pySplitlines(raw);
   if (lines.length === 0) {
     return null;
@@ -12993,7 +13027,7 @@ function append(entry, options = {}) {
   if (_is_replay_mode()) {
     return;
   }
-  fs14.appendFileSync(target, _pyDumps(entry) + "\n", { encoding: "utf-8" });
+  fs13.appendFileSync(target, _pyDumps(entry) + "\n", { encoding: "utf-8" });
 }
 function _atomic_write_text2(target, text) {
   if (_is_replay_mode()) {
@@ -13003,11 +13037,11 @@ function _atomic_write_text2(target, text) {
   const uniq = `${process.pid}.${createHash3("sha256").update(`${process.pid}:${Date.now()}:${Math.random()}`).digest("hex").slice(0, 8)}`;
   const tmp = target.slice(0, target.length - suffix.length) + `${suffix}.${uniq}.tmp`;
   try {
-    fs14.writeFileSync(tmp, text, { encoding: "utf-8" });
-    fs14.renameSync(tmp, target);
+    fs13.writeFileSync(tmp, text, { encoding: "utf-8" });
+    fs13.renameSync(tmp, target);
   } catch (exc) {
     try {
-      fs14.unlinkSync(tmp);
+      fs13.unlinkSync(tmp);
     } catch {
     }
     throw exc;
@@ -13037,7 +13071,7 @@ function reset_with_entries(entries, freq = "per_phase", options = {}) {
   const target = options.path ?? file_path();
   const header = _build_header(freq);
   const body = _normalize_entries(entries);
-  fs14.mkdirSync(path13.dirname(target), { recursive: true });
+  fs13.mkdirSync(path13.dirname(target), { recursive: true });
   const lines = [_pyDumps(header), ...body.map((e) => _pyDumps(e))];
   _atomic_write_text2(target, lines.join("\n") + "\n");
   return header;
@@ -13058,7 +13092,7 @@ function prepend_entries(entries, options = {}) {
   return new_lines.length;
 }
 function _readLinesKeepNewline(p) {
-  const raw = fs14.readFileSync(p, "utf-8");
+  const raw = fs13.readFileSync(p, "utf-8");
   if (raw === "") {
     return [];
   }
@@ -13080,8 +13114,8 @@ function clear(options = {}) {
     return;
   }
   const target = options.path ?? file_path();
-  if (fs14.existsSync(target)) {
-    fs14.unlinkSync(target);
+  if (fs13.existsSync(target)) {
+    fs13.unlinkSync(target);
   }
 }
 function read_entries(options = {}) {
@@ -14538,8 +14572,8 @@ function _isCliEntry5() {
     return true;
   }
   try {
-    const here = fs14.realpathSync(fileURLToPath8(import.meta.url));
-    const argv = fs14.realpathSync(path13.resolve(process.argv[1]));
+    const here = fs13.realpathSync(fileURLToPath8(import.meta.url));
+    const argv = fs13.realpathSync(path13.resolve(process.argv[1]));
     return here === argv;
   } catch {
     return false;
@@ -14562,7 +14596,7 @@ if (_invokedDirectly) {
 
 // src/scripts/hot_context_hook.ts
 import { spawnSync as spawnSync3 } from "node:child_process";
-import * as fs19 from "node:fs";
+import * as fs18 from "node:fs";
 import { createRequire as createRequire4 } from "node:module";
 import * as path18 from "node:path";
 import process6 from "node:process";
@@ -14570,12 +14604,12 @@ import { fileURLToPath as fileURLToPath10 } from "node:url";
 
 // src/scripts/ai_council/config.ts
 var import_yaml3 = __toESM(require_dist(), 1);
-import * as fs18 from "node:fs";
+import * as fs17 from "node:fs";
 import * as os3 from "node:os";
 import * as path17 from "node:path";
 
 // src/scripts/ai_council/cli_call_budget.ts
-import * as fs15 from "node:fs";
+import * as fs14 from "node:fs";
 import * as path14 from "node:path";
 var CLI_CALLS_ATTRIBUTION_SUFFIX = ".attribution.json";
 var CLI_CONSUMER_UNKNOWN = "unknown";
@@ -14606,14 +14640,14 @@ function resolveCliCallCaps(raw, validProviders) {
   return out;
 }
 function writeStateAtomically(target, payload) {
-  fs15.mkdirSync(path14.dirname(target), { recursive: true });
+  fs14.mkdirSync(path14.dirname(target), { recursive: true });
   const tmp = `${target}.${process.pid}.${_monotonicish()}.tmp`;
   try {
-    fs15.writeFileSync(tmp, payload, { encoding: "utf-8" });
-    fs15.renameSync(tmp, target);
+    fs14.writeFileSync(tmp, payload, { encoding: "utf-8" });
+    fs14.renameSync(tmp, target);
   } catch (exc) {
     try {
-      fs15.unlinkSync(tmp);
+      fs14.unlinkSync(tmp);
     } catch {
     }
     throw exc;
@@ -14626,14 +14660,14 @@ function withStateLock(target, fn) {
   const started = _monotonicish();
   while (_monotonicish() - started < waitMs) {
     try {
-      fs15.mkdirSync(path14.dirname(lockPath), { recursive: true });
-      fs15.closeSync(fs15.openSync(lockPath, "wx"));
+      fs14.mkdirSync(path14.dirname(lockPath), { recursive: true });
+      fs14.closeSync(fs14.openSync(lockPath, "wx"));
       held = true;
       break;
     } catch {
       try {
-        if (_monotonicish() - fs15.statSync(lockPath).mtimeMs > waitMs) {
-          fs15.unlinkSync(lockPath);
+        if (_monotonicish() - fs14.statSync(lockPath).mtimeMs > waitMs) {
+          fs14.unlinkSync(lockPath);
           continue;
         }
       } catch {
@@ -14646,7 +14680,7 @@ function withStateLock(target, fn) {
   } finally {
     if (held) {
       try {
-        fs15.unlinkSync(lockPath);
+        fs14.unlinkSync(lockPath);
       } catch {
       }
     }
@@ -14654,12 +14688,12 @@ function withStateLock(target, fn) {
 }
 function readAttribution(target, todayIso) {
   const p = attributionPath(target);
-  if (!fs15.existsSync(p)) {
+  if (!fs14.existsSync(p)) {
     return {};
   }
   let data;
   try {
-    data = JSON.parse(fs15.readFileSync(p, { encoding: "utf-8" }));
+    data = JSON.parse(fs14.readFileSync(p, { encoding: "utf-8" }));
   } catch {
     return {};
   }
@@ -14709,7 +14743,7 @@ function _spin(ms) {
 
 // src/scripts/ai_council/clients.ts
 import { spawnSync as spawnSync2 } from "node:child_process";
-import * as fs17 from "node:fs";
+import * as fs16 from "node:fs";
 import * as os2 from "node:os";
 import * as path16 from "node:path";
 
@@ -14809,7 +14843,7 @@ function _pyJsonStringAscii(s) {
 
 // src/scripts/ai_council/events_log.ts
 import * as crypto from "node:crypto";
-import * as fs16 from "node:fs";
+import * as fs15 from "node:fs";
 import * as path15 from "node:path";
 import { fileURLToPath as fileURLToPath9 } from "node:url";
 
@@ -14939,9 +14973,9 @@ function appendEvent(event, opts = {}) {
     }
   }
   const target = opts.logPath != null ? opts.logPath : _DEFAULT_LOG_PATH;
-  fs16.mkdirSync(path15.dirname(target), { recursive: true });
+  fs15.mkdirSync(path15.dirname(target), { recursive: true });
   const line = _pyJsonDumpsCompact(record);
-  fs16.appendFileSync(target, line + "\n", { encoding: "utf-8" });
+  fs15.appendFileSync(target, line + "\n", { encoding: "utf-8" });
   return true;
 }
 function _isoSecondsZ(d) {
@@ -15154,12 +15188,12 @@ function _today_utc_iso() {
 }
 function load_cli_call_counts(p = null) {
   const target = p !== null ? p : _cliCallsStatePath();
-  if (!fs17.existsSync(target)) {
+  if (!fs16.existsSync(target)) {
     return {};
   }
   let data;
   try {
-    data = JSON.parse(fs17.readFileSync(target, { encoding: "utf-8" }));
+    data = JSON.parse(fs16.readFileSync(target, { encoding: "utf-8" }));
   } catch {
     return {};
   }
@@ -16118,7 +16152,7 @@ function _which(name) {
 }
 function _isExecutable(p) {
   try {
-    const st = fs17.statSync(p);
+    const st = fs16.statSync(p);
     if (!st.isFile()) {
       return false;
     }
@@ -16407,14 +16441,14 @@ function resolve_config_path(project_root, options = {}) {
   });
 }
 function load_council_config(p) {
-  if (!fs18.existsSync(p)) {
+  if (!fs17.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 = fs18.readFileSync(p, "utf-8");
+    const text = fs17.readFileSync(p, "utf-8");
     const parsed = (0, import_yaml3.parse)(text, { version: "1.1" });
     raw = parsed === null || parsed === void 0 ? {} : parsed;
   } catch (exc) {
@@ -17653,7 +17687,7 @@ function _current_branch(root) {
 function _read_history(root) {
   let text;
   try {
-    text = fs19.readFileSync(_history_path(root), "utf-8");
+    text = fs18.readFileSync(_history_path(root), "utf-8");
   } catch {
     return [];
   }
@@ -17766,22 +17800,22 @@ function build_hot_context(root, now = /* @__PURE__ */ new Date()) {
 function _write_hot_context(root) {
   const target = _hot_context_path(root);
   const text = build_hot_context(root);
-  fs19.mkdirSync(path18.dirname(target), { recursive: true });
+  fs18.mkdirSync(path18.dirname(target), { recursive: true });
   const tmp = `${target}.tmp-${process6.pid}`;
-  fs19.writeFileSync(tmp, text, { encoding: "utf-8" });
-  fs19.renameSync(tmp, target);
+  fs18.writeFileSync(tmp, text, { encoding: "utf-8" });
+  fs18.renameSync(tmp, target);
 }
 function restore_hot_context(root, source, now = /* @__PURE__ */ new Date()) {
   const target = _hot_context_path(root);
   let text;
   try {
-    text = fs19.readFileSync(target, "utf-8");
+    text = fs18.readFileSync(target, "utf-8");
   } catch {
     return { action: "absent", reason: "no cache file" };
   }
   const discard = (reason) => {
     try {
-      fs19.unlinkSync(target);
+      fs18.unlinkSync(target);
     } catch {
     }
     return { action: "discard", reason };
@@ -17890,17 +17924,17 @@ if (!_bundled2 && fileURLToPath10(import.meta.url) === path18.resolve(process6.a
 }
 
 // src/scripts/handoff_context_hook.ts
-import * as fs23 from "node:fs";
+import * as fs22 from "node:fs";
 import * as path22 from "node:path";
 import process7 from "node:process";
 import { fileURLToPath as fileURLToPath12 } from "node:url";
 
 // src/scripts/_lib/envelope_grounding.ts
 import { execFileSync } from "node:child_process";
-import * as fs22 from "node:fs";
+import * as fs21 from "node:fs";
 
 // src/scripts/before_complete_hook.ts
-import fs20 from "node:fs";
+import fs19 from "node:fs";
 import path19 from "node:path";
 import { fileURLToPath as fileURLToPath11, pathToFileURL as pathToFileURL6 } from "node:url";
 var STATE_FILE = path19.join("agents", "state", "verify-before-complete.json");
@@ -18211,8 +18245,8 @@ function _isCliEntry6() {
     return true;
   }
   try {
-    const here = fs20.realpathSync(fileURLToPath11(import.meta.url));
-    const argv = fs20.realpathSync(path19.resolve(process.argv[1]));
+    const here = fs19.realpathSync(fileURLToPath11(import.meta.url));
+    const argv = fs19.realpathSync(path19.resolve(process.argv[1]));
     return here === argv;
   } catch {
     return false;
@@ -18224,11 +18258,11 @@ if (isCliEntry) {
 }
 
 // src/scripts/_lib/git_common_dir.ts
-import fs21 from "node:fs";
+import fs20 from "node:fs";
 import path20 from "node:path";
 function realpath_or_self(p) {
   try {
-    return fs21.realpathSync(p);
+    return fs20.realpathSync(p);
   } catch {
     return p;
   }
@@ -18236,11 +18270,11 @@ function realpath_or_self(p) {
 function git_dir(project_root) {
   const dot_git = path20.join(project_root, ".git");
   try {
-    const st = fs21.statSync(dot_git);
+    const st = fs20.statSync(dot_git);
     if (st.isDirectory()) {
       return realpath_or_self(dot_git);
     }
-    const m = fs21.readFileSync(dot_git, "utf-8").match(/^gitdir:\s*(.+)\s*$/m);
+    const m = fs20.readFileSync(dot_git, "utf-8").match(/^gitdir:\s*(.+)\s*$/m);
     if (m === null) {
       return null;
     }
@@ -18253,7 +18287,7 @@ function current_branch(project_root) {
   const gd = git_dir(project_root);
   if (gd === null) return null;
   try {
-    const head = fs21.readFileSync(path20.join(gd, "HEAD"), "utf-8").trim();
+    const head = fs20.readFileSync(path20.join(gd, "HEAD"), "utf-8").trim();
     const m = head.match(/^ref:\s*refs\/heads\/(.+)$/);
     return m === null ? null : m[1].trim();
   } catch {
@@ -18263,18 +18297,18 @@ function current_branch(project_root) {
 function git_common_dir(project_root) {
   const dot_git = path20.join(project_root, ".git");
   try {
-    const st = fs21.statSync(dot_git);
+    const st = fs20.statSync(dot_git);
     if (st.isDirectory()) {
       return realpath_or_self(dot_git);
     }
-    const m = fs21.readFileSync(dot_git, "utf-8").match(/^gitdir:\s*(.+)\s*$/m);
+    const m = fs20.readFileSync(dot_git, "utf-8").match(/^gitdir:\s*(.+)\s*$/m);
     if (m === null) {
       return null;
     }
     const gitdir = path20.resolve(project_root, m[1].trim());
     const commondir_file = path20.join(gitdir, "commondir");
-    if (fs21.existsSync(commondir_file)) {
-      const common = path20.resolve(gitdir, fs21.readFileSync(commondir_file, "utf-8").trim());
+    if (fs20.existsSync(commondir_file)) {
+      const common = path20.resolve(gitdir, fs20.readFileSync(commondir_file, "utf-8").trim());
       return realpath_or_self(common);
     }
     return realpath_or_self(gitdir);
@@ -18340,7 +18374,7 @@ function collectRepoAnchor(root) {
     const common = git_common_dir(root);
     if (common !== null) {
       try {
-        identity = fs22.realpathSync(common);
+        identity = fs21.realpathSync(common);
       } catch {
         identity = common;
       }
@@ -18880,13 +18914,13 @@ function consume_handoff_context(root, now = /* @__PURE__ */ new Date()) {
   const target = _handoff_context_path(root);
   let text;
   try {
-    text = fs23.readFileSync(target, "utf-8");
+    text = fs22.readFileSync(target, "utf-8");
   } catch {
     return { action: "absent", reason: "no handoff file" };
   }
   const remove = () => {
     try {
-      fs23.unlinkSync(target);
+      fs22.unlinkSync(target);
     } catch {
     }
   };
@@ -18917,16 +18951,16 @@ function consume_recycle_envelope(root, now = /* @__PURE__ */ new Date()) {
   const target = process7.env.AGENT_RECYCLE_ENVELOPE_FILE || path22.join(root, RECYCLE_ENVELOPE_REL);
   let text;
   try {
-    text = fs23.readFileSync(target, "utf-8");
+    text = fs22.readFileSync(target, "utf-8");
   } catch {
     return { action: "absent", reason: "no recycle envelope" };
   }
   const consume = () => {
     try {
-      fs23.renameSync(target, path22.join(path22.dirname(target), path22.basename(RECYCLE_CONSUMED_REL)));
+      fs22.renameSync(target, path22.join(path22.dirname(target), path22.basename(RECYCLE_CONSUMED_REL)));
     } catch {
       try {
-        fs23.unlinkSync(target);
+        fs22.unlinkSync(target);
       } catch {
       }
     }
@@ -18953,8 +18987,8 @@ function consume_recycle_envelope(root, now = /* @__PURE__ */ new Date()) {
     return { action: "discard", reason: `recycle envelope stale: ${ageHours.toFixed(1)}h > ${RECYCLE_MAX_AGE_HOURS}h` };
   }
   try {
-    const envelopeWs = fs23.realpathSync(String(envelope["workspace"]));
-    const thisWs = fs23.realpathSync(root);
+    const envelopeWs = fs22.realpathSync(String(envelope["workspace"]));
+    const thisWs = fs22.realpathSync(root);
     if (envelopeWs !== thisWs) {
       consume();
       return { action: "discard", reason: `recycle envelope belongs to ${envelopeWs}, not ${thisWs}` };
@@ -19037,7 +19071,7 @@ if (!_bundled3 && fileURLToPath12(import.meta.url) === path22.resolve(process7.a
 // src/scripts/roadmap_progress_hook.ts
 import { spawnSync as spawnSync4 } from "node:child_process";
 import * as crypto2 from "node:crypto";
-import fs24 from "node:fs";
+import fs23 from "node:fs";
 import path23 from "node:path";
 import { fileURLToPath as fileURLToPath13, pathToFileURL as pathToFileURL7 } from "node:url";
 var REPLAY_ENV_VAR5 = "AGENT_CONFIG_REPLAY";
@@ -19076,7 +19110,7 @@ function _entry_path(consumer_root, root) {
 function read_dirty_roots(consumer_root) {
   let names;
   try {
-    names = fs24.readdirSync(_ledger_dir(consumer_root));
+    names = fs23.readdirSync(_ledger_dir(consumer_root));
   } catch {
     return [];
   }
@@ -19084,7 +19118,7 @@ function read_dirty_roots(consumer_root) {
   for (const name of names.sort()) {
     if (!name.endsWith(".json")) continue;
     try {
-      const raw = fs24.readFileSync(path23.join(_ledger_dir(consumer_root), name), "utf8");
+      const raw = fs23.readFileSync(path23.join(_ledger_dir(consumer_root), name), "utf8");
       const parsed = JSON.parse(raw);
       if (typeof parsed !== "object" || parsed === null || Array.isArray(parsed)) continue;
       const root = parsed.root;
@@ -19111,7 +19145,7 @@ function mark_dirty(consumer_root, roots) {
 }
 function clear_dirty(consumer_root) {
   try {
-    fs24.rmSync(_ledger_dir(consumer_root), { recursive: true, force: true });
+    fs23.rmSync(_ledger_dir(consumer_root), { recursive: true, force: true });
   } catch {
   }
 }
@@ -19233,7 +19267,7 @@ function _resolve_regenerator(consumer_root) {
 var _module = { _package_roots };
 function _isFile4(p) {
   try {
-    return fs24.statSync(p).isFile();
+    return fs23.statSync(p).isFile();
   } catch {
     return false;
   }
@@ -19424,8 +19458,8 @@ function _isCliEntry7() {
     return true;
   }
   try {
-    const here = fs24.realpathSync(fileURLToPath13(import.meta.url));
-    const argv = fs24.realpathSync(path23.resolve(process.argv[1]));
+    const here = fs23.realpathSync(fileURLToPath13(import.meta.url));
+    const argv = fs23.realpathSync(path23.resolve(process.argv[1]));
     return here === argv;
   } catch {
     return false;
@@ -19437,7 +19471,7 @@ if (isCliEntry2) {
 }
 
 // src/scripts/onboarding_gate_hook.ts
-import fs25 from "node:fs";
+import fs24 from "node:fs";
 import path24 from "node:path";
 import { fileURLToPath as fileURLToPath14, pathToFileURL as pathToFileURL8 } from "node:url";
 var SETTINGS_FILE = ".agent-settings.yml";
@@ -19449,7 +19483,7 @@ function resolve_settings_path(consumer_root) {
   for (const rel of SETTINGS_CANDIDATES) {
     const candidate = path24.join(consumer_root, rel);
     try {
-      if (fs25.statSync(candidate).isFile()) {
+      if (fs24.statSync(candidate).isFile()) {
         return candidate;
       }
     } catch {
@@ -19463,7 +19497,7 @@ var STATE_FILE2 = path24.join(STATE_DIR2, "onboarding-gate.json");
 function _read_onboarded(settings_path) {
   let isFile = false;
   try {
-    isFile = fs25.statSync(settings_path).isFile();
+    isFile = fs24.statSync(settings_path).isFile();
   } catch {
     isFile = false;
   }
@@ -19472,7 +19506,7 @@ function _read_onboarded(settings_path) {
   }
   let text;
   try {
-    text = fs25.readFileSync(settings_path, "utf-8");
+    text = fs24.readFileSync(settings_path, "utf-8");
   } catch {
     return [false, "settings_file_unreadable"];
   }
@@ -19526,7 +19560,7 @@ function run3(options) {
   const settings_path = resolve_settings_path(consumer_root);
   let settings_present = false;
   try {
-    settings_present = fs25.statSync(settings_path).isFile();
+    settings_present = fs24.statSync(settings_path).isFile();
   } catch {
     settings_present = false;
   }
@@ -19592,8 +19626,8 @@ function _isCliEntry8() {
     return true;
   }
   try {
-    const here = fs25.realpathSync(fileURLToPath14(import.meta.url));
-    const argv = fs25.realpathSync(path24.resolve(process.argv[1]));
+    const here = fs24.realpathSync(fileURLToPath14(import.meta.url));
+    const argv = fs24.realpathSync(path24.resolve(process.argv[1]));
     return here === argv;
   } catch {
     return false;
@@ -19605,7 +19639,7 @@ if (isCliEntry3) {
 }
 
 // src/scripts/context_hygiene_hook.ts
-import fs26 from "node:fs";
+import fs25 from "node:fs";
 import path25 from "node:path";
 import { fileURLToPath as fileURLToPath15, pathToFileURL as pathToFileURL9 } from "node:url";
 var STATE_DIR3 = path25.join("agents", "state");
@@ -19626,7 +19660,7 @@ function _empty_state2() {
 function _load_state(target) {
   let isFile = false;
   try {
-    isFile = fs26.statSync(target).isFile();
+    isFile = fs25.statSync(target).isFile();
   } catch {
     isFile = false;
   }
@@ -19634,7 +19668,7 @@ function _load_state(target) {
     return _empty_state2();
   }
   try {
-    const decoded = JSON.parse(fs26.readFileSync(target, "utf-8"));
+    const decoded = JSON.parse(fs25.readFileSync(target, "utf-8"));
     if (typeof decoded === "object" && decoded !== null && !Array.isArray(decoded)) {
       return decoded;
     }
@@ -19784,8 +19818,8 @@ function _isCliEntry9() {
     return true;
   }
   try {
-    const here = fs26.realpathSync(fileURLToPath15(import.meta.url));
-    const argv = fs26.realpathSync(path25.resolve(process.argv[1]));
+    const here = fs25.realpathSync(fileURLToPath15(import.meta.url));
+    const argv = fs25.realpathSync(path25.resolve(process.argv[1]));
     return here === argv;
   } catch {
     return false;
@@ -19797,7 +19831,7 @@ if (isCliEntry4) {
 }
 
 // src/scripts/minimal_safe_diff_hook.ts
-import fs27 from "node:fs";
+import fs26 from "node:fs";
 import path26 from "node:path";
 import { fileURLToPath as fileURLToPath16, pathToFileURL as pathToFileURL10 } from "node:url";
 var STATE_FILE4 = path26.join("agents", "state", "minimal-safe-diff.json");
@@ -19845,7 +19879,7 @@ function _read_threshold(consumer_root) {
   const settings = path26.join(consumer_root, SETTINGS_FILE2);
   let isFile = false;
   try {
-    isFile = fs27.statSync(settings).isFile();
+    isFile = fs26.statSync(settings).isFile();
   } catch {
     isFile = false;
   }
@@ -19854,7 +19888,7 @@ function _read_threshold(consumer_root) {
   }
   let text;
   try {
-    text = fs27.readFileSync(settings, "utf-8");
+    text = fs26.readFileSync(settings, "utf-8");
   } catch {
     return DEFAULT_THRESHOLD;
   }
@@ -19892,7 +19926,7 @@ function _read_threshold(consumer_root) {
 function _load_state2(target, threshold) {
   let isFile = false;
   try {
-    isFile = fs27.statSync(target).isFile();
+    isFile = fs26.statSync(target).isFile();
   } catch {
     isFile = false;
   }
@@ -19900,7 +19934,7 @@ function _load_state2(target, threshold) {
     return _empty_state3(threshold);
   }
   try {
-    const decoded = JSON.parse(fs27.readFileSync(target, "utf-8"));
+    const decoded = JSON.parse(fs26.readFileSync(target, "utf-8"));
     if (typeof decoded === "object" && decoded !== null && !Array.isArray(decoded)) {
       const base = _empty_state3(threshold);
       Object.assign(base, decoded);
@@ -20062,8 +20096,8 @@ function _isCliEntry10() {
     return true;
   }
   try {
-    const here = fs27.realpathSync(fileURLToPath16(import.meta.url));
-    const argv = fs27.realpathSync(path26.resolve(process.argv[1]));
+    const here = fs26.realpathSync(fileURLToPath16(import.meta.url));
+    const argv = fs26.realpathSync(path26.resolve(process.argv[1]));
     return here === argv;
   } catch {
     return false;
@@ -20076,7 +20110,7 @@ if (isCliEntry5) {
 
 // src/scripts/hooks/ship_diff_volume_hook.ts
 import { execFileSync as execFileSync2 } from "node:child_process";
-import fs28 from "node:fs";
+import fs27 from "node:fs";
 import path27 from "node:path";
 import { fileURLToPath as fileURLToPath17, pathToFileURL as pathToFileURL11 } from "node:url";
 
@@ -20348,7 +20382,7 @@ function main14(argv) {
   const { volume, excluded, files } = correctedVolume(numstat);
   const over = volume >= DEFAULT_THRESHOLD2;
   try {
-    fs28.mkdirSync(path27.dirname(STATE_FILE5), { recursive: true });
+    fs27.mkdirSync(path27.dirname(STATE_FILE5), { recursive: true });
     atomic_write_json(STATE_FILE5, {
       schema_version: 1,
       base,
@@ -20373,7 +20407,7 @@ function _isCliEntry11() {
   if (process.argv[1] === void 0) return false;
   if (import.meta.url === pathToFileURL11(path27.resolve(process.argv[1])).href) return true;
   try {
-    return fs28.realpathSync(fileURLToPath17(import.meta.url)) === fs28.realpathSync(path27.resolve(process.argv[1]));
+    return fs27.realpathSync(fileURLToPath17(import.meta.url)) === fs27.realpathSync(path27.resolve(process.argv[1]));
   } catch {
     return false;
   }
@@ -20383,7 +20417,7 @@ if (_isCliEntry11()) {
 }
 
 // src/scripts/injection_scan_hook.ts
-import fs29 from "node:fs";
+import fs28 from "node:fs";
 import path28 from "node:path";
 import { fileURLToPath as fileURLToPath18, pathToFileURL as pathToFileURL12 } from "node:url";
 var SETTINGS_FILE3 = ".agent-settings.yml";
@@ -20434,7 +20468,7 @@ function _enabled(root) {
   const f = path28.join(root, SETTINGS_FILE3);
   let isFile = false;
   try {
-    isFile = fs29.statSync(f).isFile();
+    isFile = fs28.statSync(f).isFile();
   } catch {
     isFile = false;
   }
@@ -20443,7 +20477,7 @@ function _enabled(root) {
   }
   let text;
   try {
-    text = fs29.readFileSync(f, "utf-8");
+    text = fs28.readFileSync(f, "utf-8");
   } catch {
     return false;
   }
@@ -20478,9 +20512,38 @@ function _enabled(root) {
   }
   return false;
 }
+var OUTPUT_KEYS = [
+  // payload_stub.BODY_KEYS.result — the spellings the dispatcher serves.
+  "tool_response",
+  "toolResponse",
+  "tool_result",
+  "toolUseResult",
+  // Generic spellings accepted since this concern shipped.
+  "output",
+  "result"
+];
+var STUB_MARKER2 = "_agent_config_body_omitted";
+function _isStub(v) {
+  return _isObject2(v) && v[STUB_MARKER2] === true;
+}
+function _payload_of(root) {
+  const inner = root["payload"];
+  return _isObject2(inner) ? inner : root;
+}
 function _tool_output(envelope) {
-  for (const key of ["tool_response", "tool_result", "toolResponse", "output", "result"]) {
-    const v = envelope[key];
+  const payload = _payload_of(envelope);
+  for (const key of OUTPUT_KEYS) {
+    const v = payload[key];
+    if (v === void 0 || v === null) {
+      continue;
+    }
+    if (_isStub(v)) {
+      process.stderr.write(
+        `injection-scan: ${key} arrived stubbed; the concern declares needs_payload_bodies: [input, result] and cannot scan tool output without it. Nothing was scanned on this event.
+`
+      );
+      return "";
+    }
     if (typeof v === "string") {
       return v;
     }
@@ -20488,7 +20551,14 @@ function _tool_output(envelope) {
       return _pyJsonDumpsCompact2(v);
     }
   }
-  return _pyJsonDumpsCompact2(envelope);
+  const names = Object.keys(payload);
+  if (names.length > 0) {
+    process.stderr.write(
+      `injection-scan: no recognised tool-output key in this payload; nothing scanned. Present keys: ${names.sort().join(", ")}. Expected one of: ${OUTPUT_KEYS.join(", ")}.
+`
+    );
+  }
+  return "";
 }
 function _scan2(text) {
   const hits = [];
@@ -20605,8 +20675,8 @@ function _isCliEntry12() {
     return true;
   }
   try {
-    const here = fs29.realpathSync(fileURLToPath18(import.meta.url));
-    const argv = fs29.realpathSync(path28.resolve(process.argv[1]));
+    const here = fs28.realpathSync(fileURLToPath18(import.meta.url));
+    const argv = fs28.realpathSync(path28.resolve(process.argv[1]));
     return here === argv;
   } catch {
     return false;
@@ -20617,7 +20687,7 @@ if (_isCliEntry12()) {
 }
 
 // src/scripts/memory_learn_hook.ts
-import fs30 from "node:fs";
+import fs29 from "node:fs";
 import path29 from "node:path";
 import { fileURLToPath as fileURLToPath19, pathToFileURL as pathToFileURL13 } from "node:url";
 
@@ -20668,7 +20738,7 @@ function readLearnValue(root) {
   const p = path29.join(root, SETTINGS_FILE4);
   let text;
   try {
-    text = fs30.readFileSync(p, "utf8");
+    text = fs29.readFileSync(p, "utf8");
   } catch {
     return void 0;
   }
@@ -20704,13 +20774,13 @@ function runLearn(root, nowIso, budgetMs = BUDGET_MS) {
   const started = Date.now();
   const intakeDir = path29.join(root, "agents", "memory", "intake");
   const outDir = path29.join(root, "agents", "memory");
-  if (!fs30.existsSync(intakeDir)) return null;
+  if (!fs29.existsSync(intakeDir)) return null;
   const sidecar = buildSidecar(intakeDir, nowIso);
   if (Date.now() - started > budgetMs) return null;
   if (sidecar.lessons.length === 0) return null;
-  fs30.writeFileSync(path29.join(outDir, SIDECAR_NAME), `${JSON.stringify(sidecar, null, 2)}
+  fs29.writeFileSync(path29.join(outDir, SIDECAR_NAME), `${JSON.stringify(sidecar, null, 2)}
 `, "utf8");
-  fs30.writeFileSync(path29.join(outDir, LESSONS_NAME), renderLessonsMd(sidecar), "utf8");
+  fs29.writeFileSync(path29.join(outDir, LESSONS_NAME), renderLessonsMd(sidecar), "utf8");
   const promoted = sidecar.lessons.filter((l) => l.verdict === "preferred").length;
   const deadEnds = sidecar.lessons.filter((l) => l.verdict === "dead_end").length;
   return `\u{1F9E0} Memory: sidecar refreshed \u2014 ${sidecar.lessons.length} lesson(s) (${promoted} preferred \xB7 ${deadEnds} dead-end); promote via /memory:propose`;
@@ -20730,7 +20800,7 @@ var _isMain4 = (() => {
   if (true) return false;
   if (process.argv[1] === void 0) return false;
   try {
-    return pathToFileURL13(fs30.realpathSync(path29.resolve(process.argv[1]))).href === import.meta.url;
+    return pathToFileURL13(fs29.realpathSync(path29.resolve(process.argv[1]))).href === import.meta.url;
   } catch {
     return pathToFileURL13(path29.resolve(process.argv[1])).href === import.meta.url;
   }
@@ -20741,7 +20811,7 @@ if (_isMain4) {
 var _HERE3 = fileURLToPath19(import.meta.url);
 
 // src/scripts/first_run_gate_hook.ts
-import fs31 from "node:fs";
+import fs30 from "node:fs";
 import path30 from "node:path";
 import { fileURLToPath as fileURLToPath20, pathToFileURL as pathToFileURL14 } from "node:url";
 var PLUGIN_ID = "agent-config@event4u-agent-config";
@@ -20781,14 +20851,14 @@ this file manually.
 `;
 function _isFile5(p) {
   try {
-    return fs31.statSync(p).isFile();
+    return fs30.statSync(p).isFile();
   } catch {
     return false;
   }
 }
 function _exists3(p) {
   try {
-    fs31.statSync(p);
+    fs30.statSync(p);
     return true;
   } catch {
     return false;
@@ -20801,7 +20871,7 @@ function _plugin_enabled(consumer_root) {
   }
   let data;
   try {
-    data = JSON.parse(fs31.readFileSync(settings, "utf-8"));
+    data = JSON.parse(fs30.readFileSync(settings, "utf-8"));
   } catch {
     return false;
   }
@@ -20820,7 +20890,7 @@ function _agent_config_executable(consumer_root) {
     return false;
   }
   try {
-    fs31.accessSync(p, fs31.constants.X_OK);
+    fs30.accessSync(p, fs30.constants.X_OK);
     return true;
   } catch {
     return false;
@@ -20837,8 +20907,8 @@ function _setup_complete(consumer_root) {
 function _write_action_file(consumer_root) {
   const target = path30.join(consumer_root, ACTION_NEEDED_FILE);
   try {
-    fs31.mkdirSync(path30.dirname(target), { recursive: true });
-    fs31.writeFileSync(target, ACTION_NEEDED_BODY, { encoding: "utf-8" });
+    fs30.mkdirSync(path30.dirname(target), { recursive: true });
+    fs30.writeFileSync(target, ACTION_NEEDED_BODY, { encoding: "utf-8" });
     return true;
   } catch (exc) {
     process.stderr.write(
@@ -20852,7 +20922,7 @@ function _cleanup_action_file(consumer_root) {
   const target = path30.join(consumer_root, ACTION_NEEDED_FILE);
   if (_exists3(target)) {
     try {
-      fs31.unlinkSync(target);
+      fs30.unlinkSync(target);
     } catch {
     }
   }
@@ -20909,8 +20979,8 @@ function _isCliEntry13() {
     return true;
   }
   try {
-    const here = fs31.realpathSync(fileURLToPath20(import.meta.url));
-    const argv = fs31.realpathSync(path30.resolve(process.argv[1]));
+    const here = fs30.realpathSync(fileURLToPath20(import.meta.url));
+    const argv = fs30.realpathSync(path30.resolve(process.argv[1]));
     return here === argv;
   } catch {
     return false;
@@ -20923,12 +20993,12 @@ if (isCliEntry6) {
 
 // src/scripts/profile_staleness_hook.ts
 var import_yaml4 = __toESM(require_dist(), 1);
-import fs33 from "node:fs";
+import fs32 from "node:fs";
 import path32 from "node:path";
 import { fileURLToPath as fileURLToPath21, pathToFileURL as pathToFileURL15 } from "node:url";
 
 // src/scripts/hooks/probe_throttle.ts
-import fs32 from "node:fs";
+import fs31 from "node:fs";
 import path31 from "node:path";
 var STATE_SUBDIR = ["agents", "runtime", "state", "probe-throttle"];
 function _stampPath(projectRoot, concern) {
@@ -20943,7 +21013,7 @@ function _localDay(d) {
 function probeRanToday(projectRoot, concern) {
   if (is_replay_mode()) return false;
   try {
-    const st = fs32.statSync(_stampPath(projectRoot, concern));
+    const st = fs31.statSync(_stampPath(projectRoot, concern));
     return _localDay(st.mtime) === _localDay(/* @__PURE__ */ new Date());
   } catch {
     return false;
@@ -20953,8 +21023,8 @@ function stampProbeRun(projectRoot, concern) {
   if (is_replay_mode()) return;
   try {
     const p = _stampPath(projectRoot, concern);
-    fs32.mkdirSync(path31.dirname(p), { recursive: true });
-    fs32.writeFileSync(p, `${(/* @__PURE__ */ new Date()).toISOString()}
+    fs31.mkdirSync(path31.dirname(p), { recursive: true });
+    fs31.writeFileSync(p, `${(/* @__PURE__ */ new Date()).toISOString()}
 `);
   } catch {
   }
@@ -20969,10 +21039,10 @@ function _isObject3(v) {
 }
 function _read_yaml2(p) {
   try {
-    if (!fs33.existsSync(p)) {
+    if (!fs32.existsSync(p)) {
       return null;
     }
-    return (0, import_yaml4.parse)(fs33.readFileSync(p, "utf-8"), { version: "1.1" });
+    return (0, import_yaml4.parse)(fs32.readFileSync(p, "utf-8"), { version: "1.1" });
   } catch {
     return null;
   }
@@ -21057,8 +21127,8 @@ function _isCliEntry14() {
     return true;
   }
   try {
-    const here = fs33.realpathSync(fileURLToPath21(import.meta.url));
-    const argv = fs33.realpathSync(path32.resolve(process.argv[1]));
+    const here = fs32.realpathSync(fileURLToPath21(import.meta.url));
+    const argv = fs32.realpathSync(path32.resolve(process.argv[1]));
     return here === argv;
   } catch {
     return false;
@@ -21070,12 +21140,12 @@ if (isCliEntry7) {
 }
 
 // src/scripts/wrapper_freshness_hook.ts
-import fs35 from "node:fs";
+import fs34 from "node:fs";
 import path34 from "node:path";
 import { fileURLToPath as fileURLToPath23, pathToFileURL as pathToFileURL16 } from "node:url";
 
 // src/scripts/_lib/cli_wrapper.ts
-import fs34 from "node:fs";
+import fs33 from "node:fs";
 import path33 from "node:path";
 import { fileURLToPath as fileURLToPath22 } from "node:url";
 var _PACKAGE_ROOT2 = path33.resolve(
@@ -21092,7 +21162,7 @@ var _TEMPLATE = path33.join(
 );
 function _is_file2(p) {
   try {
-    return fs34.statSync(p).isFile();
+    return fs33.statSync(p).isFile();
   } catch {
     return false;
   }
@@ -21105,7 +21175,7 @@ function needs_refresh(project_root) {
   const target = _target(project_root);
   if (!_is_file2(target)) return true;
   try {
-    return fs34.readFileSync(target, "utf-8") !== fs34.readFileSync(_TEMPLATE, "utf-8");
+    return fs33.readFileSync(target, "utf-8") !== fs33.readFileSync(_TEMPLATE, "utf-8");
   } catch {
     return true;
   }
@@ -21113,8 +21183,8 @@ function needs_refresh(project_root) {
 function install_cli_wrapper(project_root) {
   if (!_is_file2(_TEMPLATE)) return null;
   const target = _target(project_root);
-  fs34.copyFileSync(_TEMPLATE, target);
-  fs34.chmodSync(target, 493);
+  fs33.copyFileSync(_TEMPLATE, target);
+  fs33.chmodSync(target, 493);
   return target;
 }
 
@@ -21130,14 +21200,14 @@ function _project_root2() {
 }
 function _isDir3(p) {
   try {
-    return fs35.statSync(p).isDirectory();
+    return fs34.statSync(p).isDirectory();
   } catch {
     return false;
   }
 }
 function _isFile6(p) {
   try {
-    return fs35.statSync(p).isFile();
+    return fs34.statSync(p).isFile();
   } catch {
     return false;
   }
@@ -21149,7 +21219,7 @@ function _is_source_repo(project_root) {
   try {
     const packagesDir = path34.join(project_root, "packages");
     if (_isDir3(packagesDir)) {
-      for (const entry of fs35.readdirSync(packagesDir)) {
+      for (const entry of fs34.readdirSync(packagesDir)) {
         if (_isDir3(path34.join(packagesDir, entry, ".agent-src.uncondensed"))) {
           return true;
         }
@@ -21160,7 +21230,7 @@ function _is_source_repo(project_root) {
   const pkg = path34.join(project_root, "package.json");
   if (_isFile6(pkg)) {
     try {
-      const data = JSON.parse(fs35.readFileSync(pkg, "utf-8"));
+      const data = JSON.parse(fs34.readFileSync(pkg, "utf-8"));
       if (typeof data === "object" && data !== null && data["name"] === "@event4u/agent-config") {
         return true;
       }
@@ -21192,7 +21262,7 @@ function _git_hooks_dir(root) {
   }
   if (_isFile6(dotGit)) {
     try {
-      const m = /^gitdir:\s*(.+)\s*$/m.exec(fs35.readFileSync(dotGit, "utf-8"));
+      const m = /^gitdir:\s*(.+)\s*$/m.exec(fs34.readFileSync(dotGit, "utf-8"));
       if (m && m[1] !== void 0) {
         const gitDir = path34.isAbsolute(m[1]) ? m[1] : path34.join(root, m[1]);
         return path34.join(gitDir, "hooks");
@@ -21223,16 +21293,16 @@ function refresh_precommit_hook(root) {
     if (!_isFile6(target)) {
       return null;
     }
-    const current = fs35.readFileSync(target, "utf-8");
+    const current = fs34.readFileSync(target, "utf-8");
     if (!current.includes(_PRECOMMIT_MARKER)) {
       return null;
     }
-    const canonical2 = fs35.readFileSync(template, "utf-8");
+    const canonical2 = fs34.readFileSync(template, "utf-8");
     if (current === canonical2) {
       return null;
     }
-    fs35.writeFileSync(target, canonical2);
-    fs35.chmodSync(target, 493);
+    fs34.writeFileSync(target, canonical2);
+    fs34.chmodSync(target, 493);
     return target;
   } catch {
     return null;
@@ -21298,8 +21368,8 @@ function _isCliEntry15() {
     return true;
   }
   try {
-    const here = fs35.realpathSync(fileURLToPath23(import.meta.url));
-    const argv = fs35.realpathSync(path34.resolve(process.argv[1]));
+    const here = fs34.realpathSync(fileURLToPath23(import.meta.url));
+    const argv = fs34.realpathSync(path34.resolve(process.argv[1]));
     return here === argv;
   } catch {
     return false;
@@ -21312,7 +21382,7 @@ if (isCliEntry8) {
 
 // src/scripts/surface_probe_hook.ts
 var import_yaml5 = __toESM(require_dist(), 1);
-import fs36 from "node:fs";
+import fs35 from "node:fs";
 import os4 from "node:os";
 import path35 from "node:path";
 import { fileURLToPath as fileURLToPath24, pathToFileURL as pathToFileURL17 } from "node:url";
@@ -21337,7 +21407,7 @@ function _readStdinIfNotTty3() {
 }
 function _exists4(p) {
   try {
-    fs36.statSync(p);
+    fs35.statSync(p);
     return true;
   } catch {
     return false;
@@ -21345,7 +21415,7 @@ function _exists4(p) {
 }
 function _auto_converge(global_settings_path) {
   try {
-    const raw = (0, import_yaml5.parse)(fs36.readFileSync(global_settings_path, "utf-8"), { version: "1.1" });
+    const raw = (0, import_yaml5.parse)(fs35.readFileSync(global_settings_path, "utf-8"), { version: "1.1" });
     const install = raw?.["install"];
     if (install && typeof install === "object" && !Array.isArray(install)) {
       return install["auto_converge"] === true;
@@ -21359,7 +21429,7 @@ function _default_global_settings(home) {
 }
 function _rate_limited(state_path, now_ms) {
   try {
-    const raw = JSON.parse(fs36.readFileSync(state_path, "utf-8"));
+    const raw = JSON.parse(fs35.readFileSync(state_path, "utf-8"));
     const last = raw["last_check_utc"];
     if (typeof last === "number" && now_ms - last < CHECK_WINDOW_MS && last <= now_ms) {
       return true;
@@ -21370,8 +21440,8 @@ function _rate_limited(state_path, now_ms) {
 }
 function _stamp(state_path, now_ms) {
   try {
-    fs36.mkdirSync(path35.dirname(state_path), { recursive: true });
-    fs36.writeFileSync(state_path, `${JSON.stringify({ last_check_utc: now_ms })}
+    fs35.mkdirSync(path35.dirname(state_path), { recursive: true });
+    fs35.writeFileSync(state_path, `${JSON.stringify({ last_check_utc: now_ms })}
 `, "utf-8");
   } catch {
   }
@@ -21380,7 +21450,7 @@ function _detect(pkg_root, home) {
   const matrix_path = path35.join(pkg_root, "src", "config", "surface-matrix.yml");
   let tools = {};
   try {
-    const raw = (0, import_yaml5.parse)(fs36.readFileSync(matrix_path, "utf-8"), { version: "1.1" });
+    const raw = (0, import_yaml5.parse)(fs35.readFileSync(matrix_path, "utf-8"), { version: "1.1" });
     const t = raw?.["tools"];
     if (t && typeof t === "object" && !Array.isArray(t)) {
       tools = t;
@@ -21457,8 +21527,8 @@ function _isCliEntry16() {
     return true;
   }
   try {
-    const here = fs36.realpathSync(fileURLToPath24(import.meta.url));
-    const argv = fs36.realpathSync(path35.resolve(process.argv[1]));
+    const here = fs35.realpathSync(fileURLToPath24(import.meta.url));
+    const argv = fs35.realpathSync(path35.resolve(process.argv[1]));
     return here === argv;
   } catch {
     return false;
@@ -21469,13 +21539,13 @@ if (_isCliEntry16()) {
 }
 
 // src/scripts/team_review_gate_hook.ts
-import fs38 from "node:fs";
+import fs37 from "node:fs";
 import path38 from "node:path";
 import { fileURLToPath as fileURLToPath25, pathToFileURL as pathToFileURL18 } from "node:url";
 
 // src/scripts/ai_team/review_gate.ts
 import * as crypto3 from "node:crypto";
-import * as fs37 from "node:fs";
+import * as fs36 from "node:fs";
 import * as os6 from "node:os";
 import * as path37 from "node:path";
 
@@ -21668,7 +21738,7 @@ function _read_state(state_path) {
   const empty = { schema_version: 1, sessions: {} };
   let parsed;
   try {
-    parsed = JSON.parse(fs37.readFileSync(state_path, "utf-8"));
+    parsed = JSON.parse(fs36.readFileSync(state_path, "utf-8"));
   } catch {
     return empty;
   }
@@ -21724,8 +21794,8 @@ function _append_ledger_line(target, entry) {
   if (_kill_switch_active2()) {
     return false;
   }
-  fs37.mkdirSync(path37.dirname(target), { recursive: true });
-  fs37.appendFileSync(target, JSON.stringify(entry) + "\n", { encoding: "utf-8" });
+  fs36.mkdirSync(path37.dirname(target), { recursive: true });
+  fs36.appendFileSync(target, JSON.stringify(entry) + "\n", { encoding: "utf-8" });
   return true;
 }
 function format_gate_ledger_line(entry) {
@@ -21821,7 +21891,7 @@ var UPSTREAM_GATE_JOB_TITLE = "Codex Stop Gate Review";
 function _workspace_state_segment(workspace_root) {
   let canonical2 = workspace_root;
   try {
-    canonical2 = fs37.realpathSync.native(workspace_root);
+    canonical2 = fs36.realpathSync.native(workspace_root);
   } catch {
     canonical2 = workspace_root;
   }
@@ -21849,7 +21919,7 @@ function find_latest_gate_transcript(workspace_root, session_id) {
     const jobs_dir = path37.join(dir, "jobs");
     let names;
     try {
-      names = fs37.readdirSync(jobs_dir);
+      names = fs36.readdirSync(jobs_dir);
     } catch {
       continue;
     }
@@ -21859,7 +21929,7 @@ function find_latest_gate_transcript(workspace_root, session_id) {
       }
       let job;
       try {
-        job = JSON.parse(fs37.readFileSync(path37.join(jobs_dir, name), "utf-8"));
+        job = JSON.parse(fs36.readFileSync(path37.join(jobs_dir, name), "utf-8"));
       } catch {
         continue;
       }
@@ -22003,8 +22073,8 @@ function _isCliEntry17() {
     return true;
   }
   try {
-    const here = fs38.realpathSync(fileURLToPath25(import.meta.url));
-    const argv = fs38.realpathSync(path38.resolve(process.argv[1]));
+    const here = fs37.realpathSync(fileURLToPath25(import.meta.url));
+    const argv = fs37.realpathSync(path38.resolve(process.argv[1]));
     return here === argv;
   } catch {
     return false;
@@ -22015,7 +22085,7 @@ if (_isCliEntry17()) {
 }
 
 // src/scripts/pr_url_reminder_hook.ts
-import fs39 from "node:fs";
+import fs38 from "node:fs";
 import path39 from "node:path";
 import { fileURLToPath as fileURLToPath26, pathToFileURL as pathToFileURL19 } from "node:url";
 var EXIT_ALLOW3 = 0;
@@ -22128,8 +22198,8 @@ function _isCliEntry18() {
     return true;
   }
   try {
-    const here = fs39.realpathSync(fileURLToPath26(import.meta.url));
-    const argv = fs39.realpathSync(path39.resolve(process.argv[1]));
+    const here = fs38.realpathSync(fileURLToPath26(import.meta.url));
+    const argv = fs38.realpathSync(path39.resolve(process.argv[1]));
     return here === argv;
   } catch {
     return false;
@@ -22140,7 +22210,7 @@ if (_isCliEntry18()) {
 }
 
 // src/scripts/session_canary_hook.ts
-import fs40 from "node:fs";
+import fs39 from "node:fs";
 import path40 from "node:path";
 import { fileURLToPath as fileURLToPath27, pathToFileURL as pathToFileURL20 } from "node:url";
 var EXIT_ALLOW4 = 0;
@@ -22151,10 +22221,10 @@ function _isObject6(v) {
 function read_canary_name(settings_path) {
   let text;
   try {
-    if (!fs40.statSync(settings_path).isFile()) {
+    if (!fs39.statSync(settings_path).isFile()) {
       return null;
     }
-    text = fs40.readFileSync(settings_path, "utf-8");
+    text = fs39.readFileSync(settings_path, "utf-8");
   } catch {
     return null;
   }
@@ -22179,10 +22249,10 @@ function read_canary_name(settings_path) {
 function read_identity_name(user_yml_path) {
   let text;
   try {
-    if (!fs40.statSync(user_yml_path).isFile()) {
+    if (!fs39.statSync(user_yml_path).isFile()) {
       return null;
     }
-    text = fs40.readFileSync(user_yml_path, "utf-8");
+    text = fs39.readFileSync(user_yml_path, "utf-8");
   } catch {
     return null;
   }
@@ -22303,8 +22373,8 @@ function _isCliEntry19() {
     return true;
   }
   try {
-    const here = fs40.realpathSync(fileURLToPath27(import.meta.url));
-    const argv = fs40.realpathSync(path40.resolve(process.argv[1]));
+    const here = fs39.realpathSync(fileURLToPath27(import.meta.url));
+    const argv = fs39.realpathSync(path40.resolve(process.argv[1]));
     return here === argv;
   } catch {
     return false;
@@ -22315,7 +22385,7 @@ if (_isCliEntry19()) {
 }
 
 // src/scripts/council_availability_hook.ts
-import * as fs41 from "node:fs";
+import * as fs40 from "node:fs";
 import * as path41 from "node:path";
 import { fileURLToPath as fileURLToPath28, pathToFileURL as pathToFileURL21 } from "node:url";
 var EXIT_ALLOW5 = 0;
@@ -22326,7 +22396,7 @@ function resolveAvailability(cwd, env) {
   } catch {
     return null;
   }
-  const exists = fs41.existsSync(p);
+  const exists = fs40.existsSync(p);
   const provenance2 = env[COUNCIL_CONFIG_ENV] ? "env-override" : "user-global";
   if (!exists) {
     return { configured: false, path: p, exists: false, provenance: provenance2, membersEnabled: 0, memberNames: [] };
@@ -22421,7 +22491,7 @@ if (_isCliEntry20()) {
 }
 
 // src/scripts/telemetry_disclosure_hook.ts
-import * as fs46 from "node:fs";
+import * as fs45 from "node:fs";
 import * as path45 from "node:path";
 import { pathToFileURL as pathToFileURL23 } from "node:url";
 
@@ -22429,11 +22499,11 @@ import { pathToFileURL as pathToFileURL23 } from "node:url";
 import * as os7 from "node:os";
 import * as path44 from "node:path";
 import { fileURLToPath as fileURLToPath29, pathToFileURL as pathToFileURL22 } from "node:url";
-import * as fs45 from "node:fs";
+import * as fs44 from "node:fs";
 
 // src/agent-src/templates/scripts/telemetry/settings.ts
 import { createRequire as createRequire5 } from "node:module";
-import * as fs42 from "node:fs";
+import * as fs41 from "node:fs";
 var YAML3 = createRequire5(import.meta.url)("yaml");
 function _isPlainObject7(v) {
   return typeof v === "object" && v !== null && !Array.isArray(v) && !(v instanceof Date);
@@ -22471,7 +22541,7 @@ function _coerce_path(value, def) {
 }
 function _isFile7(p) {
   try {
-    return fs42.statSync(p).isFile();
+    return fs41.statSync(p).isFile();
   } catch {
     return false;
   }
@@ -22482,7 +22552,7 @@ function _read_telemetry_section(p, key) {
   }
   let raw = {};
   try {
-    raw = YAML3.parse(fs42.readFileSync(p, "utf-8"), { version: "1.1" });
+    raw = YAML3.parse(fs41.readFileSync(p, "utf-8"), { version: "1.1" });
     if (raw === null || raw === void 0) {
       raw = {};
     }
@@ -22593,7 +22663,7 @@ function read_remote_settings(p) {
 
 // src/agent-src/templates/scripts/telemetry/remote.ts
 import * as crypto4 from "node:crypto";
-import * as fs43 from "node:fs";
+import * as fs42 from "node:fs";
 import * as path42 from "node:path";
 
 // src/agent-src/templates/scripts/telemetry/engagement.ts
@@ -22892,13 +22962,13 @@ var RETENTION_HEAD_WINDOW_BYTES = 8192;
 function _oldest_datable_ms(log_path) {
   let fd;
   try {
-    fd = fs43.openSync(log_path, "r");
+    fd = fs42.openSync(log_path, "r");
   } catch {
     return null;
   }
   try {
     const buf = Buffer.alloc(RETENTION_HEAD_WINDOW_BYTES);
-    const read = fs43.readSync(fd, buf, 0, buf.length, 0);
+    const read = fs42.readSync(fd, buf, 0, buf.length, 0);
     if (read <= 0) {
       return null;
     }
@@ -22915,13 +22985,13 @@ function _oldest_datable_ms(log_path) {
   } catch {
     return null;
   } finally {
-    fs43.closeSync(fd);
+    fs42.closeSync(fd);
   }
 }
 function retention_due(log_path, policy = DEFAULT_RETENTION_POLICY, now = /* @__PURE__ */ new Date()) {
   let size;
   try {
-    size = fs43.statSync(log_path).size;
+    size = fs42.statSync(log_path).size;
   } catch {
     return false;
   }
@@ -22940,7 +23010,7 @@ function retention_due(log_path, policy = DEFAULT_RETENTION_POLICY, now = /* @__
 function enforce_retention(log_path, policy = DEFAULT_RETENTION_POLICY, now = /* @__PURE__ */ new Date()) {
   let raw;
   try {
-    raw = fs43.readFileSync(log_path, "utf-8");
+    raw = fs42.readFileSync(log_path, "utf-8");
   } catch {
     return { kept: 0, dropped_by_age: 0, dropped_by_size: 0 };
   }
@@ -22972,13 +23042,13 @@ function enforce_retention(log_path, policy = DEFAULT_RETENTION_POLICY, now = /*
   const payload = kept_lines.length === 0 ? "" : `${kept_lines.join("\n")}
 `;
   const tmp = `${log_path}.retention.${process.pid}.tmp`;
-  fs43.writeFileSync(tmp, payload, { encoding: "utf-8" });
-  fs43.renameSync(tmp, log_path);
+  fs42.writeFileSync(tmp, payload, { encoding: "utf-8" });
+  fs42.renameSync(tmp, log_path);
   return { kept: kept_lines.length, dropped_by_age, dropped_by_size };
 }
 function _append_and_bound(target, payload, policy, now) {
-  fs43.mkdirSync(path42.dirname(target) || ".", { recursive: true });
-  fs43.appendFileSync(target, payload, { encoding: "utf-8" });
+  fs42.mkdirSync(path42.dirname(target) || ".", { recursive: true });
+  fs42.appendFileSync(target, payload, { encoding: "utf-8" });
   if (retention_due(target, policy, now)) {
     enforce_retention(target, policy, now);
   }
@@ -22994,7 +23064,7 @@ function append_class_a_record(log_path, record, policy = DEFAULT_RETENTION_POLI
 
 // src/agent-src/templates/scripts/telemetry/transport.ts
 import { spawn } from "node:child_process";
-import * as fs44 from "node:fs";
+import * as fs43 from "node:fs";
 import * as path43 from "node:path";
 var DEFAULT_FLUSH_TIMEOUT_MS = 1e3;
 var FLUSH_SESSION_END = "session-end";
@@ -23026,7 +23096,7 @@ function spawn_detached_sender(input) {
 }
 function spool_has_work(spool_path) {
   try {
-    return fs44.statSync(spool_path).size > 0;
+    return fs43.statSync(spool_path).size > 0;
   } catch {
     return false;
   }
@@ -23092,7 +23162,7 @@ function resolveSettingsPath(start) {
   for (; ; ) {
     const candidate = path44.join(dir, SETTINGS_FILENAME);
     try {
-      if (fs45.statSync(candidate).isFile()) return candidate;
+      if (fs44.statSync(candidate).isFile()) return candidate;
     } catch {
     }
     const parent = path44.dirname(dir);
@@ -23106,7 +23176,7 @@ function readSettingsFor(consumerRoot) {
   if (cached !== void 0) return cached;
   let text = "";
   try {
-    text = fs45.readFileSync(p, "utf-8");
+    text = fs44.readFileSync(p, "utf-8");
   } catch {
     text = "";
   }
@@ -23179,7 +23249,7 @@ function _isCliEntry21() {
   const argvUrl = pathToFileURL22(path44.resolve(process.argv[1])).href;
   if (import.meta.url === argvUrl) return true;
   try {
-    return fs45.realpathSync(fileURLToPath29(import.meta.url)) === fs45.realpathSync(path44.resolve(process.argv[1]));
+    return fs44.realpathSync(fileURLToPath29(import.meta.url)) === fs44.realpathSync(path44.resolve(process.argv[1]));
   } catch {
     return false;
   }
@@ -23205,7 +23275,7 @@ function disclosureKey(facts) {
 }
 function alreadyDisclosed(root, facts) {
   try {
-    const raw = fs46.readFileSync(path45.join(root, DISCLOSURE_STATE_REL), "utf-8");
+    const raw = fs45.readFileSync(path45.join(root, DISCLOSURE_STATE_REL), "utf-8");
     const parsed = JSON.parse(raw);
     if (parsed === null || typeof parsed !== "object") {
       return false;
@@ -23218,8 +23288,8 @@ function alreadyDisclosed(root, facts) {
 function recordDisclosure(root, facts, at) {
   try {
     const p = path45.join(root, DISCLOSURE_STATE_REL);
-    fs46.mkdirSync(path45.dirname(p), { recursive: true });
-    fs46.writeFileSync(
+    fs45.mkdirSync(path45.dirname(p), { recursive: true });
+    fs45.writeFileSync(
       p,
       `${JSON.stringify({ disclosed: disclosureKey(facts), at }, null, 2)}
 `,
@@ -23307,7 +23377,7 @@ if (_isCliEntry22()) {
 }
 
 // src/scripts/self_repair_hook.ts
-import * as fs48 from "node:fs";
+import * as fs47 from "node:fs";
 import * as path48 from "node:path";
 import { fileURLToPath as fileURLToPath30, pathToFileURL as pathToFileURL24 } from "node:url";
 
@@ -23546,7 +23616,7 @@ function mergeRecord(existing, finding, now) {
 }
 
 // src/scripts/_lib/self_repair_store.ts
-import * as fs47 from "node:fs";
+import * as fs46 from "node:fs";
 import * as path46 from "node:path";
 var STORE_REL = path46.join("agents", "runtime", "self-repair");
 function storeDir(root) {
@@ -23564,7 +23634,7 @@ function isRecord(v) {
 }
 function readRecord(root, fp) {
   try {
-    const parsed = JSON.parse(fs47.readFileSync(recordPath(root, fp), "utf-8"));
+    const parsed = JSON.parse(fs46.readFileSync(recordPath(root, fp), "utf-8"));
     return isRecord(parsed) ? parsed : null;
   } catch {
     return null;
@@ -23572,8 +23642,8 @@ function readRecord(root, fp) {
 }
 function writeRecord(root, record) {
   const dir = storeDir(root);
-  fs47.mkdirSync(dir, { recursive: true });
-  fs47.writeFileSync(
+  fs46.mkdirSync(dir, { recursive: true });
+  fs46.writeFileSync(
     recordPath(root, record.fingerprint),
     `${JSON.stringify(record, null, 2)}
 `,
@@ -23583,7 +23653,7 @@ function writeRecord(root, record) {
 function listRecords(root) {
   let names;
   try {
-    names = fs47.readdirSync(storeDir(root));
+    names = fs46.readdirSync(storeDir(root));
   } catch {
     return [];
   }
@@ -23609,7 +23679,7 @@ function overflowPath(root) {
 }
 function readOverflow(root) {
   try {
-    const parsed = JSON.parse(fs47.readFileSync(overflowPath(root), "utf-8"));
+    const parsed = JSON.parse(fs46.readFileSync(overflowPath(root), "utf-8"));
     return typeof parsed === "object" && parsed !== null ? parsed : {};
   } catch {
     return {};
@@ -23620,8 +23690,8 @@ function bumpOverflow(root, source, now) {
   const prev = counts[source]?.dropped ?? 0;
   counts[source] = { dropped: prev + 1, last_seen: now };
   const dir = storeDir(root);
-  fs47.mkdirSync(dir, { recursive: true });
-  fs47.writeFileSync(overflowPath(root), `${JSON.stringify(counts, null, 2)}
+  fs46.mkdirSync(dir, { recursive: true });
+  fs46.writeFileSync(overflowPath(root), `${JSON.stringify(counts, null, 2)}
 `, "utf-8");
 }
 function upsertFinding(root, finding, now) {
@@ -23707,7 +23777,7 @@ function readTurn(transcriptPath, pinned) {
   }
   let lines;
   try {
-    lines = fs48.readFileSync(transcriptPath, "utf-8").split("\n");
+    lines = fs47.readFileSync(transcriptPath, "utf-8").split("\n");
   } catch {
     return empty;
   }
@@ -23853,7 +23923,7 @@ function isCliEntry9() {
     return true;
   }
   try {
-    return fs48.realpathSync(fileURLToPath30(import.meta.url)) === fs48.realpathSync(path48.resolve(process.argv[1]));
+    return fs47.realpathSync(fileURLToPath30(import.meta.url)) === fs47.realpathSync(path48.resolve(process.argv[1]));
   } catch {
     return false;
   }
@@ -23863,17 +23933,17 @@ if (isCliEntry9()) {
 }
 
 // src/scripts/session_register_hook.ts
-import * as fs53 from "node:fs";
+import * as fs52 from "node:fs";
 import * as path53 from "node:path";
 import process9 from "node:process";
 import { fileURLToPath as fileURLToPath31 } from "node:url";
 
 // src/scripts/_lib/session_register.ts
-import fs50 from "node:fs";
+import fs49 from "node:fs";
 import path50 from "node:path";
 
 // src/scripts/_lib/fs_atomic.ts
-import fs49 from "node:fs";
+import fs48 from "node:fs";
 import path49 from "node:path";
 import { randomBytes } from "node:crypto";
 function _normalize_encoding(encoding) {
@@ -23892,7 +23962,7 @@ function write_atomic(p, data, options = {}) {
   const encoding = options.encoding ?? "utf-8";
   const target = path49.normalize(p);
   const parent = path49.dirname(target);
-  fs49.mkdirSync(parent, { recursive: true });
+  fs48.mkdirSync(parent, { recursive: true });
   let payload;
   if (typeof data === "string") {
     payload = Buffer.from(data, _normalize_encoding(encoding));
@@ -23911,7 +23981,7 @@ function write_atomic(p, data, options = {}) {
       `.${path49.basename(target)}.tmp.${randomBytes(6).toString("hex")}`
     );
     try {
-      fd = fs49.openSync(tmp_path, "wx", 384);
+      fd = fs48.openSync(tmp_path, "wx", 384);
       break;
     } catch (err) {
       if (err.code === "EEXIST") continue;
@@ -23925,24 +23995,24 @@ function write_atomic(p, data, options = {}) {
   try {
     let offset = 0;
     while (offset < payload.length) {
-      offset += fs49.writeSync(fd, payload, offset, payload.length - offset);
+      offset += fs48.writeSync(fd, payload, offset, payload.length - offset);
     }
     try {
-      fs49.fsyncSync(fd);
+      fs48.fsyncSync(fd);
     } catch {
     }
-    fs49.closeSync(fd);
+    fs48.closeSync(fd);
     closed = true;
-    fs49.renameSync(tmp_path, target);
+    fs48.renameSync(tmp_path, target);
   } catch (err) {
     if (!closed) {
       try {
-        fs49.closeSync(fd);
+        fs48.closeSync(fd);
       } catch {
       }
     }
     try {
-      fs49.unlinkSync(tmp_path);
+      fs48.unlinkSync(tmp_path);
     } catch {
     }
     throw err;
@@ -23953,17 +24023,17 @@ function write_atomic(p, data, options = {}) {
 function _fsync_dir(directory) {
   let dir_fd;
   try {
-    dir_fd = fs49.openSync(directory, fs49.constants.O_RDONLY);
+    dir_fd = fs48.openSync(directory, fs48.constants.O_RDONLY);
   } catch {
     return;
   }
   try {
     try {
-      fs49.fsyncSync(dir_fd);
+      fs48.fsyncSync(dir_fd);
     } catch {
     }
   } finally {
-    fs49.closeSync(dir_fd);
+    fs48.closeSync(dir_fd);
   }
 }
 
@@ -24035,7 +24105,7 @@ function write_record(dir, rec) {
 function read_own_record(dir, session_id) {
   try {
     const target = path50.join(dir, `${safe_stem(session_id)}.json`);
-    const parsed = JSON.parse(fs50.readFileSync(target, "utf-8"));
+    const parsed = JSON.parse(fs49.readFileSync(target, "utf-8"));
     return is_record(parsed) ? parsed : null;
   } catch {
     return null;
@@ -24043,7 +24113,7 @@ function read_own_record(dir, session_id) {
 }
 function delete_record(dir, session_id) {
   try {
-    fs50.unlinkSync(path50.join(dir, `${safe_stem(session_id)}.json`));
+    fs49.unlinkSync(path50.join(dir, `${safe_stem(session_id)}.json`));
     return true;
   } catch {
     return false;
@@ -24056,7 +24126,7 @@ function read_live_records(dir, options = {}) {
   const grace = options.prune_grace_ms ?? PRUNE_GRACE_MS;
   let names;
   try {
-    names = fs50.readdirSync(dir).filter((n) => n.endsWith(".json"));
+    names = fs49.readdirSync(dir).filter((n) => n.endsWith(".json"));
   } catch {
     return [];
   }
@@ -24065,7 +24135,7 @@ function read_live_records(dir, options = {}) {
     const full = path50.join(dir, name);
     let rec = null;
     try {
-      const parsed = JSON.parse(fs50.readFileSync(full, "utf-8"));
+      const parsed = JSON.parse(fs49.readFileSync(full, "utf-8"));
       rec = is_record(parsed) ? parsed : null;
     } catch {
       rec = null;
@@ -24073,7 +24143,7 @@ function read_live_records(dir, options = {}) {
     if (rec === null || is_expired(rec, now)) {
       if (prune && (rec === null || is_expired(rec, new Date(now.getTime() - grace)))) {
         try {
-          fs50.unlinkSync(full);
+          fs49.unlinkSync(full);
         } catch {
         }
       }
@@ -24104,11 +24174,11 @@ function classify_collisions(others, here) {
 
 // src/scripts/_lib/turn_end_refusals.ts
 import * as crypto5 from "node:crypto";
-import * as fs52 from "node:fs";
+import * as fs51 from "node:fs";
 import * as path52 from "node:path";
 
 // src/scripts/_lib/installed_lock.ts
-import * as fs51 from "node:fs";
+import * as fs50 from "node:fs";
 import * as os9 from "node:os";
 import * as path51 from "node:path";
 var LOCKFILE_ENV = "AGENT_CONFIG_INSTALLED_LOCK";
@@ -24147,7 +24217,7 @@ function read_lockfile(path91) {
   const target = path91 ?? lockfile_path();
   let text;
   try {
-    text = fs51.readFileSync(target, { encoding: "utf-8" });
+    text = fs50.readFileSync(target, { encoding: "utf-8" });
   } catch {
     return null;
   }
@@ -24226,7 +24296,7 @@ function sessionRefusalFile(workspaceRoot2, sessionKey) {
 }
 function readSessionCounts(workspaceRoot2, sessionId2) {
   try {
-    const raw = fs52.readFileSync(
+    const raw = fs51.readFileSync(
       sessionRefusalFile(workspaceRoot2, deriveSessionKey(sessionId2)),
       "utf-8"
     );
@@ -24328,7 +24398,7 @@ function pruneAgedRefusalState(workspaceRoot2, opts = {}) {
   const result = { scanned: 0, pruned: 0, kept: 0 };
   let entries;
   try {
-    entries = fs52.readdirSync(dir);
+    entries = fs51.readdirSync(dir);
   } catch {
     return result;
   }
@@ -24339,7 +24409,7 @@ function pruneAgedRefusalState(workspaceRoot2, opts = {}) {
     const file = path52.join(dir, name);
     let rec = null;
     try {
-      rec = parseRecord(fs52.readFileSync(file, "utf-8"));
+      rec = parseRecord(fs51.readFileSync(file, "utf-8"));
     } catch {
       rec = null;
     }
@@ -24353,7 +24423,7 @@ function pruneAgedRefusalState(workspaceRoot2, opts = {}) {
       continue;
     }
     try {
-      fs52.unlinkSync(file);
+      fs51.unlinkSync(file);
       result.pruned += 1;
     } catch {
       result.kept += 1;
@@ -24404,7 +24474,7 @@ function _is_replay_mode4() {
 }
 function _read_claim_file(file) {
   try {
-    const parsed = JSON.parse(fs53.readFileSync(file, "utf-8"));
+    const parsed = JSON.parse(fs52.readFileSync(file, "utf-8"));
     if (parsed === null || typeof parsed !== "object" || Array.isArray(parsed)) {
       return null;
     }
@@ -24468,7 +24538,7 @@ function claim_is_stale(workspace_root, slug, peer_worktree) {
   );
   for (const root of roots) {
     try {
-      if (fs53.existsSync(path53.join(root, rel))) {
+      if (fs52.existsSync(path53.join(root, rel))) {
         return false;
       }
     } catch {
@@ -24483,8 +24553,8 @@ function session_checkout(workspace_root, payload_cwd) {
   if (cwd === "") return fallback;
   let start;
   try {
-    if (!fs53.statSync(cwd).isDirectory()) return fallback;
-    start = fs53.realpathSync(cwd);
+    if (!fs52.statSync(cwd).isDirectory()) return fallback;
+    start = fs52.realpathSync(cwd);
   } catch {
     return fallback;
   }
@@ -24498,7 +24568,7 @@ function session_checkout(workspace_root, payload_cwd) {
 function canonical(p) {
   const abs = path53.resolve(p);
   try {
-    return fs53.realpathSync(abs);
+    return fs52.realpathSync(abs);
   } catch {
     return abs;
   }
@@ -24671,7 +24741,7 @@ function main28() {
       for (const p of claim_read_paths(root, session_id)) {
         if (path53.basename(p) !== path53.basename(roadmap_claim_rel(session_id))) continue;
         try {
-          fs53.unlinkSync(p);
+          fs52.unlinkSync(p);
         } catch {
         }
       }
@@ -24724,7 +24794,7 @@ if (!_bundled4 && fileURLToPath31(import.meta.url) === path53.resolve(process9.a
 }
 
 // src/scripts/language_mirror_hook.ts
-import fs54 from "node:fs";
+import fs53 from "node:fs";
 import path54 from "node:path";
 import { fileURLToPath as fileURLToPath32, pathToFileURL as pathToFileURL25 } from "node:url";
 
@@ -24856,7 +24926,7 @@ This pin exists because the trigger is not observable from the transcript alone:
 }
 function _loadState(target) {
   try {
-    const raw = fs54.readFileSync(target, "utf8");
+    const raw = fs53.readFileSync(target, "utf8");
     const decoded = JSON.parse(raw);
     return _isObject7(decoded) ? decoded : {};
   } catch {
@@ -24913,8 +24983,8 @@ function _sessionId(envelope) {
 function _migrateLegacyMarker(consumer_root) {
   const legacy = path54.join(consumer_root, PIN_LOST_DIR);
   try {
-    if (fs54.statSync(legacy).isFile()) {
-      fs54.rmSync(legacy, { force: true });
+    if (fs53.statSync(legacy).isFile()) {
+      fs53.rmSync(legacy, { force: true });
     }
   } catch {
   }
@@ -24929,7 +24999,7 @@ function _setPinLost(consumer_root, session_id) {
 }
 function _pinLost(consumer_root, session_id) {
   try {
-    return fs54.existsSync(path54.join(consumer_root, pinLostMarker(session_id)));
+    return fs53.existsSync(path54.join(consumer_root, pinLostMarker(session_id)));
   } catch {
     return false;
   }
@@ -24937,7 +25007,7 @@ function _pinLost(consumer_root, session_id) {
 function _clearPinLost(consumer_root, session_id) {
   if (is_replay_mode()) return;
   try {
-    fs54.rmSync(path54.join(consumer_root, pinLostMarker(session_id)), { force: true });
+    fs53.rmSync(path54.join(consumer_root, pinLostMarker(session_id)), { force: true });
   } catch {
   }
 }
@@ -24976,7 +25046,7 @@ function _reEmitAfterCompaction(consumer_root, session_id, write_json = atomic_w
 function _pruneLegacyState(consumer_root) {
   prune_legacy_state_file(path54.join(consumer_root, STATE_FILE6));
 }
-function _pruneStaleSessions(consumer_root, now_ms, mtimeOf = (target) => fs54.statSync(target).mtimeMs) {
+function _pruneStaleSessions(consumer_root, now_ms, mtimeOf = (target) => fs53.statSync(target).mtimeMs) {
   return prune_stale_session_states(
     path54.join(consumer_root, STATE_DIR4),
     now_ms,
@@ -24990,20 +25060,20 @@ function _withToolWriteLock(consumer_root, session_id, when_busy, body, now_ms =
   let fd;
   const acquire = () => {
     try {
-      fs54.mkdirSync(path54.dirname(lock), { recursive: true });
-      return fs54.openSync(lock, "wx");
+      fs53.mkdirSync(path54.dirname(lock), { recursive: true });
+      return fs53.openSync(lock, "wx");
     } catch (err) {
       if (err.code !== "EEXIST") return null;
       let age;
       try {
-        age = now_ms - fs54.statSync(lock).mtimeMs;
+        age = now_ms - fs53.statSync(lock).mtimeMs;
       } catch {
         return null;
       }
       if (age < LOCK_STALE_MS2) return null;
       try {
-        fs54.rmSync(lock, { force: true });
-        return fs54.openSync(lock, "wx");
+        fs53.rmSync(lock, { force: true });
+        return fs53.openSync(lock, "wx");
       } catch {
         return null;
       }
@@ -25016,11 +25086,11 @@ function _withToolWriteLock(consumer_root, session_id, when_busy, body, now_ms =
     return body();
   } finally {
     try {
-      fs54.closeSync(fd);
+      fs53.closeSync(fd);
     } catch {
     }
     try {
-      fs54.rmSync(lock, { force: true });
+      fs53.rmSync(lock, { force: true });
     } catch {
     }
   }
@@ -25188,8 +25258,8 @@ function _isCliEntry23() {
     return true;
   }
   try {
-    const here = fs54.realpathSync(fileURLToPath32(import.meta.url));
-    const argv = fs54.realpathSync(path54.resolve(process.argv[1]));
+    const here = fs53.realpathSync(fileURLToPath32(import.meta.url));
+    const argv = fs53.realpathSync(path54.resolve(process.argv[1]));
     return here === argv;
   } catch {
     return false;
@@ -25200,7 +25270,7 @@ if (_isCliEntry23()) {
 }
 
 // src/scripts/git_authorization_hook.ts
-import fs55 from "node:fs";
+import fs54 from "node:fs";
 import path55 from "node:path";
 import { fileURLToPath as fileURLToPath33, pathToFileURL as pathToFileURL26 } from "node:url";
 var EXIT_ALLOW10 = 0;
@@ -25338,12 +25408,12 @@ function takePending(consumer_root, session_id, now) {
   const file = path55.join(consumer_root, pendingFileFor(session_id));
   let raw;
   try {
-    raw = fs55.readFileSync(file, "utf8");
+    raw = fs54.readFileSync(file, "utf8");
   } catch {
     return null;
   }
   try {
-    fs55.rmSync(file, { force: true });
+    fs54.rmSync(file, { force: true });
   } catch {
   }
   try {
@@ -25438,8 +25508,8 @@ function _isCliEntry24() {
     return true;
   }
   try {
-    const here = fs55.realpathSync(fileURLToPath33(import.meta.url));
-    const argv = fs55.realpathSync(path55.resolve(process.argv[1]));
+    const here = fs54.realpathSync(fileURLToPath33(import.meta.url));
+    const argv = fs54.realpathSync(path55.resolve(process.argv[1]));
     return here === argv;
   } catch {
     return false;
@@ -25450,7 +25520,7 @@ if (_isCliEntry24()) {
 }
 
 // src/scripts/hooks/block_unauthorized_git.ts
-import fs56 from "node:fs";
+import fs55 from "node:fs";
 import path56 from "node:path";
 import { fileURLToPath as fileURLToPath34, pathToFileURL as pathToFileURL27 } from "node:url";
 var EXIT_ALLOW11 = 0;
@@ -25691,7 +25761,7 @@ function commandOp(command) {
   }
   return found;
 }
-var LEDGER_MAX_AGE_MS = 6 * 60 * 60 * 1e3;
+var LEDGER_MAX_AGE_MS = 30 * 60 * 1e3;
 function _loadLedger(consumer_root, session_id, now) {
   const candidates = [ledgerFileFor(session_id)];
   if (!candidates.includes(STATE_FILE7)) {
@@ -25707,7 +25777,7 @@ function _loadLedger(consumer_root, session_id, now) {
 }
 function _readLedgerFile(file, session_id, now) {
   try {
-    const raw = fs56.readFileSync(file, "utf8");
+    const raw = fs55.readFileSync(file, "utf8");
     const decoded = JSON.parse(raw);
     if (_isObject9(decoded) && Array.isArray(decoded["authorized"])) {
       const ledgerSession = typeof decoded["session_id"] === "string" ? decoded["session_id"] : "";
@@ -25813,8 +25883,8 @@ function _isCliEntry25() {
     return true;
   }
   try {
-    const here = fs56.realpathSync(fileURLToPath34(import.meta.url));
-    const argv = fs56.realpathSync(path56.resolve(process.argv[1]));
+    const here = fs55.realpathSync(fileURLToPath34(import.meta.url));
+    const argv = fs55.realpathSync(path56.resolve(process.argv[1]));
     return here === argv;
   } catch {
     return false;
@@ -25826,7 +25896,7 @@ if (_isCliEntry25()) {
 
 // src/scripts/hooks/evidence_independence.ts
 import crypto6 from "node:crypto";
-import fs57 from "node:fs";
+import fs56 from "node:fs";
 import path57 from "node:path";
 import { fileURLToPath as fileURLToPath35, pathToFileURL as pathToFileURL28 } from "node:url";
 var EXIT_ALLOW12 = 0;
@@ -25899,7 +25969,7 @@ function extractDispatch(envelope) {
 }
 function _ledgerStamp(consumer_root) {
   try {
-    const raw = fs57.readFileSync(
+    const raw = fs56.readFileSync(
       path57.join(consumer_root, "agents", "state", "git-authorization.json"),
       "utf8"
     );
@@ -25911,7 +25981,7 @@ function _ledgerStamp(consumer_root) {
 }
 function _load(target) {
   try {
-    const decoded = JSON.parse(fs57.readFileSync(target, "utf8"));
+    const decoded = JSON.parse(fs56.readFileSync(target, "utf8"));
     if (_isObject10(decoded) && Array.isArray(decoded["evaluations"])) {
       return decoded;
     }
@@ -26025,8 +26095,8 @@ function _isCliEntry26() {
     return true;
   }
   try {
-    const here = fs57.realpathSync(fileURLToPath35(import.meta.url));
-    const argv = fs57.realpathSync(path57.resolve(process.argv[1]));
+    const here = fs56.realpathSync(fileURLToPath35(import.meta.url));
+    const argv = fs56.realpathSync(path57.resolve(process.argv[1]));
     return here === argv;
   } catch {
     return false;
@@ -26037,7 +26107,7 @@ if (_isCliEntry26()) {
 }
 
 // src/scripts/hooks/block_no_verify.ts
-import * as fs58 from "node:fs";
+import * as fs57 from "node:fs";
 import { fileURLToPath as fileURLToPath36, pathToFileURL as pathToFileURL29 } from "node:url";
 import * as path58 from "node:path";
 var _HERE4 = fileURLToPath36(import.meta.url);
@@ -26488,8 +26558,8 @@ function _isCliEntry27() {
     return true;
   }
   try {
-    const here = fs58.realpathSync(fileURLToPath36(import.meta.url));
-    const argv = fs58.realpathSync(path58.resolve(process.argv[1]));
+    const here = fs57.realpathSync(fileURLToPath36(import.meta.url));
+    const argv = fs57.realpathSync(path58.resolve(process.argv[1]));
     return here === argv;
   } catch {
     return false;
@@ -26500,7 +26570,7 @@ if (_isCliEntry27() || false) {
 }
 
 // src/scripts/hooks/block_kernel_rule_writes.ts
-import * as fs59 from "node:fs";
+import * as fs58 from "node:fs";
 import { fileURLToPath as fileURLToPath37, pathToFileURL as pathToFileURL30 } from "node:url";
 import * as path59 from "node:path";
 var _HERE5 = fileURLToPath37(import.meta.url);
@@ -26706,8 +26776,8 @@ function _isCliEntry28() {
     return true;
   }
   try {
-    const here = fs59.realpathSync(fileURLToPath37(import.meta.url));
-    const argv = fs59.realpathSync(path59.resolve(process.argv[1]));
+    const here = fs58.realpathSync(fileURLToPath37(import.meta.url));
+    const argv = fs58.realpathSync(path59.resolve(process.argv[1]));
     return here === argv;
   } catch {
     return false;
@@ -26718,7 +26788,7 @@ if (_isCliEntry28() || false) {
 }
 
 // src/scripts/hooks/block_config_weakening.ts
-import * as fs60 from "node:fs";
+import * as fs59 from "node:fs";
 import * as path60 from "node:path";
 import { fileURLToPath as fileURLToPath38, pathToFileURL as pathToFileURL31 } from "node:url";
 var _HERE6 = fileURLToPath38(import.meta.url);
@@ -26812,7 +26882,7 @@ function bump_session(root, session, key, added) {
   const f = _state_file(root);
   let data = {};
   try {
-    data = JSON.parse(fs60.readFileSync(f, "utf-8"));
+    data = JSON.parse(fs59.readFileSync(f, "utf-8"));
   } catch {
     data = {};
   }
@@ -26821,8 +26891,8 @@ function bump_session(root, session, key, added) {
   bucket[key] = total;
   data[session] = bucket;
   try {
-    fs60.mkdirSync(path60.dirname(f), { recursive: true });
-    fs60.writeFileSync(f, `${JSON.stringify(data, null, 2)}
+    fs59.mkdirSync(path60.dirname(f), { recursive: true });
+    fs59.writeFileSync(f, `${JSON.stringify(data, null, 2)}
 `, "utf-8");
   } catch {
   }
@@ -26872,7 +26942,7 @@ function main35() {
     const abs = path60.isAbsolute(p) ? p : path60.join(root, p);
     let on_disk = null;
     try {
-      on_disk = fs60.readFileSync(abs, "utf-8");
+      on_disk = fs59.readFileSync(abs, "utf-8");
     } catch {
       on_disk = null;
     }
@@ -26908,7 +26978,7 @@ function _isCliEntry29() {
     return true;
   }
   try {
-    return fs60.realpathSync(fileURLToPath38(import.meta.url)) === fs60.realpathSync(path60.resolve(process.argv[1]));
+    return fs59.realpathSync(fileURLToPath38(import.meta.url)) === fs59.realpathSync(path60.resolve(process.argv[1]));
   } catch {
     return false;
   }
@@ -26918,7 +26988,7 @@ if (_isCliEntry29() || process.argv[1] === _HERE6) {
 }
 
 // src/scripts/hooks/rtk_wrap_hook.ts
-import fs61 from "node:fs";
+import fs60 from "node:fs";
 import path61 from "node:path";
 import { fileURLToPath as fileURLToPath39, pathToFileURL as pathToFileURL32 } from "node:url";
 
@@ -27064,13 +27134,13 @@ function _isObject13(v) {
 function _enabled2(root) {
   const f = path61.join(root, SETTINGS_FILE6);
   try {
-    if (!fs61.statSync(f).isFile()) return false;
+    if (!fs60.statSync(f).isFile()) return false;
   } catch {
     return false;
   }
   let text;
   try {
-    text = fs61.readFileSync(f, "utf-8");
+    text = fs60.readFileSync(f, "utf-8");
   } catch {
     return false;
   }
@@ -27106,7 +27176,7 @@ function rtk_available(env = process.env) {
     for (const ext of exts) {
       const candidate = path61.join(dir, `rtk${ext}`);
       try {
-        const st = fs61.statSync(candidate);
+        const st = fs60.statSync(candidate);
         if (st.isFile()) {
           if (process.platform === "win32" || (st.mode & 73) !== 0) return true;
         }
@@ -27258,8 +27328,8 @@ function _isCliEntry30() {
     return true;
   }
   try {
-    const here = fs61.realpathSync(fileURLToPath39(import.meta.url));
-    const argv = fs61.realpathSync(path61.resolve(process.argv[1]));
+    const here = fs60.realpathSync(fileURLToPath39(import.meta.url));
+    const argv = fs60.realpathSync(path61.resolve(process.argv[1]));
     return here === argv;
   } catch {
     return false;
@@ -27270,7 +27340,7 @@ if (_isCliEntry30()) {
 }
 
 // src/scripts/hooks/design_slop_hook.ts
-import fs63 from "node:fs";
+import fs62 from "node:fs";
 import path63 from "node:path";
 import { fileURLToPath as fileURLToPath40, pathToFileURL as pathToFileURL33 } from "node:url";
 
@@ -27313,7 +27383,7 @@ function isUiTreePath(p) {
 }
 
 // src/scripts/lint_design_slop.ts
-import fs62 from "node:fs";
+import fs61 from "node:fs";
 import path62 from "node:path";
 
 // src/scripts/design_slop_rules.ts
@@ -27819,8 +27889,8 @@ function enginesForExt(ext) {
   return /* @__PURE__ */ new Set();
 }
 function* walkDir(dir, ext) {
-  if (!fs62.existsSync(dir)) return;
-  for (const entry of fs62.readdirSync(dir, { withFileTypes: true })) {
+  if (!fs61.existsSync(dir)) return;
+  for (const entry of fs61.readdirSync(dir, { withFileTypes: true })) {
     const full = path62.join(dir, entry.name);
     if (entry.name.startsWith(".") || entry.name === "node_modules") continue;
     if (entry.isDirectory()) yield* walkDir(full, ext);
@@ -27829,9 +27899,9 @@ function* walkDir(dir, ext) {
 }
 function loadConfig(dir) {
   const p = path62.join(dir, ".design-quality.json");
-  if (!fs62.existsSync(p)) return {};
+  if (!fs61.existsSync(p)) return {};
   try {
-    return JSON.parse(fs62.readFileSync(p, "utf-8"));
+    return JSON.parse(fs61.readFileSync(p, "utf-8"));
   } catch {
     return {};
   }
@@ -27844,8 +27914,8 @@ function loadDesignContext(scanDir) {
   ];
   let raw = "";
   for (const c of candidates) {
-    if (fs62.existsSync(c)) {
-      raw = fs62.readFileSync(c, "utf-8").toLowerCase();
+    if (fs61.existsSync(c)) {
+      raw = fs61.readFileSync(c, "utf-8").toLowerCase();
       break;
     }
   }
@@ -27914,7 +27984,7 @@ function main37() {
   const scanDir = dirIdx >= 0 && args[dirIdx + 1] ? path62.resolve(args[dirIdx + 1]) : path62.resolve(process.cwd(), "src");
   const failIdx = args.indexOf("--fail-on");
   const failOn = failIdx >= 0 ? args[failIdx + 1] : void 0;
-  if (!fs62.existsSync(scanDir)) {
+  if (!fs61.existsSync(scanDir)) {
     if (!quiet) {
       process.stderr.write(`[lint_design_slop] scan directory not found: ${scanDir}
 `);
@@ -27950,7 +28020,7 @@ function main37() {
   for (const fp of files) {
     const rel = path62.relative(process.cwd(), fp);
     try {
-      const fileFindings = scanFile(fs62.readFileSync(fp, "utf-8"), rel, ctx).filter(
+      const fileFindings = scanFile(fs61.readFileSync(fp, "utf-8"), rel, ctx).filter(
         (f) => !ignoreRules.has(f.rule.toLowerCase())
       );
       findings.push(...fileFindings);
@@ -27997,8 +28067,8 @@ function enabled2(root) {
   const f = path63.join(root, SETTINGS_FILE7);
   let text;
   try {
-    if (!fs63.statSync(f).isFile()) return false;
-    text = fs63.readFileSync(f, "utf-8");
+    if (!fs62.statSync(f).isFile()) return false;
+    text = fs62.readFileSync(f, "utf-8");
   } catch {
     return false;
   }
@@ -28044,7 +28114,7 @@ function stateFile(root) {
 }
 function readState(root) {
   try {
-    const t = fs63.readFileSync(stateFile(root), "utf-8");
+    const t = fs62.readFileSync(stateFile(root), "utf-8");
     const parsed = JSON.parse(t);
     return isObject4(parsed) ? parsed : {};
   } catch {
@@ -28054,8 +28124,8 @@ function readState(root) {
 function writeState(root, state) {
   try {
     const sf = stateFile(root);
-    fs63.mkdirSync(path63.dirname(sf), { recursive: true });
-    fs63.writeFileSync(sf, JSON.stringify(state, null, 2) + "\n");
+    fs62.mkdirSync(path63.dirname(sf), { recursive: true });
+    fs62.writeFileSync(sf, JSON.stringify(state, null, 2) + "\n");
   } catch {
   }
 }
@@ -28118,8 +28188,8 @@ function _isCliEntry31() {
     return true;
   }
   try {
-    const here = fs63.realpathSync(fileURLToPath40(import.meta.url));
-    const argv = fs63.realpathSync(path63.resolve(process.argv[1]));
+    const here = fs62.realpathSync(fileURLToPath40(import.meta.url));
+    const argv = fs62.realpathSync(path63.resolve(process.argv[1]));
     return here === argv;
   } catch {
     return false;
@@ -28129,13 +28199,13 @@ var isCliEntry10 = _isCliEntry31();
 if (isCliEntry10) process.exit(main38());
 
 // src/scripts/hooks/code_graph_nudge_hook.ts
-import fs65 from "node:fs";
+import fs64 from "node:fs";
 import path65 from "node:path";
 import { fileURLToPath as fileURLToPath41, pathToFileURL as pathToFileURL34 } from "node:url";
 
 // src/scripts/code_graph/detect.ts
 import { execFileSync as execFileSync3 } from "node:child_process";
-import * as fs64 from "node:fs";
+import * as fs63 from "node:fs";
 import * as path64 from "node:path";
 
 // src/scripts/code_graph/validate.ts
@@ -28217,7 +28287,7 @@ function freshness(root, file, embeddedSha) {
   const last = gitLastCommitEpoch(root);
   if (last === null) return {};
   try {
-    const mtime = Math.floor(fs64.statSync(file).mtimeMs / 1e3);
+    const mtime = Math.floor(fs63.statSync(file).mtimeMs / 1e3);
     return { stale: mtime < last };
   } catch {
     return {};
@@ -28225,7 +28295,7 @@ function freshness(root, file, embeddedSha) {
 }
 function looksLikeGraph(p) {
   try {
-    const raw = JSON.parse(fs64.readFileSync(p, "utf-8"));
+    const raw = JSON.parse(fs63.readFileSync(p, "utf-8"));
     if (validateGraph(raw).ok) return { ok: true, sha: raw["head_at_build"] ?? null };
     const nodes = raw["nodes"];
     const edges = raw["edges"] ?? raw["links"];
@@ -28240,19 +28310,19 @@ function detectSources(root, nativeCache) {
   const out = [];
   for (const rel of CONSUMER_CANDIDATES) {
     const p = path64.join(abs, rel);
-    if (fs64.existsSync(p)) {
+    if (fs63.existsSync(p)) {
       const { ok, sha } = looksLikeGraph(p);
       if (ok) out.push({ kind: "consumer", path: p, present: true, ...freshness(abs, p, sha) });
     }
   }
   const scipCandidates = [path64.join(abs, "index.scip")];
   try {
-    for (const e of fs64.readdirSync(abs)) if (e.endsWith(".scip")) scipCandidates.push(path64.join(abs, e));
+    for (const e of fs63.readdirSync(abs)) if (e.endsWith(".scip")) scipCandidates.push(path64.join(abs, e));
   } catch {
   }
-  const scip = scipCandidates.find((p) => fs64.existsSync(p));
+  const scip = scipCandidates.find((p) => fs63.existsSync(p));
   if (scip) out.push({ kind: "scip", path: scip, present: true, note: "SCIP detected \u2014 peer tooling required (no owned reader)" });
-  if (fs64.existsSync(nativeCache)) out.push({ kind: "native", path: nativeCache, present: true, ...freshness(abs, nativeCache, null) });
+  if (fs63.existsSync(nativeCache)) out.push({ kind: "native", path: nativeCache, present: true, ...freshness(abs, nativeCache, null) });
   return out;
 }
 function pickSource(verdicts) {
@@ -28275,8 +28345,8 @@ function enabled3(root) {
   const f = path65.join(root, SETTINGS_FILE8);
   let text;
   try {
-    if (!fs65.statSync(f).isFile()) return false;
-    text = fs65.readFileSync(f, "utf-8");
+    if (!fs64.statSync(f).isFile()) return false;
+    text = fs64.readFileSync(f, "utf-8");
   } catch {
     return false;
   }
@@ -28323,7 +28393,7 @@ function latchFile(root) {
 }
 function alreadyNudged(root, session) {
   try {
-    const state = JSON.parse(fs65.readFileSync(latchFile(root), "utf-8"));
+    const state = JSON.parse(fs64.readFileSync(latchFile(root), "utf-8"));
     return state[session] === true;
   } catch {
     return false;
@@ -28334,12 +28404,12 @@ function latch(root, session) {
     const p = latchFile(root);
     let state = {};
     try {
-      state = JSON.parse(fs65.readFileSync(p, "utf-8"));
+      state = JSON.parse(fs64.readFileSync(p, "utf-8"));
     } catch {
     }
     state[session] = true;
-    fs65.mkdirSync(path65.dirname(p), { recursive: true });
-    fs65.writeFileSync(p, JSON.stringify(state));
+    fs64.mkdirSync(path65.dirname(p), { recursive: true });
+    fs64.writeFileSync(p, JSON.stringify(state));
   } catch {
   }
 }
@@ -28391,7 +28461,7 @@ function isCliEntry11() {
   const argvUrl = pathToFileURL34(path65.resolve(process.argv[1])).href;
   if (import.meta.url === argvUrl) return true;
   try {
-    return fs65.realpathSync(fileURLToPath41(import.meta.url)) === fs65.realpathSync(path65.resolve(process.argv[1]));
+    return fs64.realpathSync(fileURLToPath41(import.meta.url)) === fs64.realpathSync(path65.resolve(process.argv[1]));
   } catch {
     return false;
   }
@@ -28399,20 +28469,20 @@ function isCliEntry11() {
 if (isCliEntry11()) process.exit(main39());
 
 // src/scripts/hooks/ui_route_nudge_hook.ts
-import * as fs67 from "node:fs";
+import * as fs66 from "node:fs";
 import * as path67 from "node:path";
 import { fileURLToPath as fileURLToPath42, pathToFileURL as pathToFileURL35 } from "node:url";
 
 // src/scripts/_lib/hook_settings.ts
-import * as fs66 from "node:fs";
+import * as fs65 from "node:fs";
 import * as path66 from "node:path";
 var SETTINGS_FILE9 = ".agent-settings.yml";
 function hookSectionEnabled(root, section) {
   const file = path66.join(root, SETTINGS_FILE9);
   let text;
   try {
-    if (!fs66.statSync(file).isFile()) return false;
-    text = fs66.readFileSync(file, "utf-8");
+    if (!fs65.statSync(file).isFile()) return false;
+    text = fs65.readFileSync(file, "utf-8");
   } catch {
     return false;
   }
@@ -28487,7 +28557,7 @@ function stateFile2(root) {
 }
 function readState2(root, session) {
   try {
-    const all = JSON.parse(fs67.readFileSync(stateFile2(root), "utf-8"));
+    const all = JSON.parse(fs66.readFileSync(stateFile2(root), "utf-8"));
     const entry = all[session];
     if (entry && typeof entry.consulted === "boolean" && typeof entry.nudges === "number") {
       return entry;
@@ -28510,13 +28580,13 @@ function writeState2(root, session, state) {
     const file = stateFile2(root);
     let all = {};
     try {
-      all = JSON.parse(fs67.readFileSync(file, "utf-8"));
+      all = JSON.parse(fs66.readFileSync(file, "utf-8"));
     } catch {
     }
     if (typeof all !== "object" || all === null || Array.isArray(all)) all = {};
     all[session] = state;
-    fs67.mkdirSync(path67.dirname(file), { recursive: true });
-    fs67.writeFileSync(file, JSON.stringify(pruneSessions(all)));
+    fs66.mkdirSync(path67.dirname(file), { recursive: true });
+    fs66.writeFileSync(file, JSON.stringify(pruneSessions(all)));
   } catch {
   }
 }
@@ -28572,7 +28642,7 @@ var _HOOK_FILE = fileURLToPath42(import.meta.url);
 
 // src/scripts/hooks/orchestration_record_hook.ts
 import * as crypto8 from "node:crypto";
-import * as fs69 from "node:fs";
+import * as fs68 from "node:fs";
 import * as path69 from "node:path";
 import { fileURLToPath as fileURLToPath43, pathToFileURL as pathToFileURL37 } from "node:url";
 
@@ -28770,7 +28840,7 @@ function buildOrchestrationLine(input) {
 
 // src/scripts/orchestration_record.ts
 import * as crypto7 from "node:crypto";
-import * as fs68 from "node:fs";
+import * as fs67 from "node:fs";
 import * as path68 from "node:path";
 import { pathToFileURL as pathToFileURL36 } from "node:url";
 var DEFAULT_DIR = "agents/runtime/state/audit";
@@ -28883,9 +28953,9 @@ function main41(argv = process.argv.slice(2)) {
     process.stdout.write(serialized + "\n");
     return 0;
   }
-  fs68.mkdirSync(dir, { recursive: true });
+  fs67.mkdirSync(dir, { recursive: true });
   const file = path68.join(dir, `${ts.slice(0, 7)}.jsonl`);
-  fs68.appendFileSync(file, serialized + "\n", "utf8");
+  fs67.appendFileSync(file, serialized + "\n", "utf8");
   process.stdout.write(`orchestration telemetry recorded \u2192 ${file} (id ${line.id})
 `);
   return 0;
@@ -28992,8 +29062,8 @@ function auditFileFor(consumerRoot, ts) {
 function appendLine(consumerRoot, ts, line) {
   if (is_replay_mode()) return;
   const file = auditFileFor(consumerRoot, ts);
-  fs69.mkdirSync(path69.dirname(file), { recursive: true });
-  fs69.appendFileSync(file, `${JSON.stringify(line)}
+  fs68.mkdirSync(path69.dirname(file), { recursive: true });
+  fs68.appendFileSync(file, `${JSON.stringify(line)}
 `, "utf8");
 }
 function processEnvelope2(envelope, consumer_root) {
@@ -29041,7 +29111,7 @@ function _isCliEntry32() {
   const argvUrl = pathToFileURL37(path69.resolve(process.argv[1])).href;
   if (import.meta.url === argvUrl) return true;
   try {
-    return fs69.realpathSync(fileURLToPath43(import.meta.url)) === fs69.realpathSync(path69.resolve(process.argv[1]));
+    return fs68.realpathSync(fileURLToPath43(import.meta.url)) === fs68.realpathSync(path69.resolve(process.argv[1]));
   } catch {
     return false;
   }
@@ -29049,7 +29119,7 @@ function _isCliEntry32() {
 if (_isCliEntry32()) process.exit(main42());
 
 // src/scripts/hooks/telemetry_flush_hook.ts
-import * as fs70 from "node:fs";
+import * as fs69 from "node:fs";
 import * as path70 from "node:path";
 import { fileURLToPath as fileURLToPath44, pathToFileURL as pathToFileURL38 } from "node:url";
 var EXIT_ALLOW19 = 0;
@@ -29058,7 +29128,7 @@ function resolveSenderScript() {
   try {
     const here = path70.dirname(fileURLToPath44(import.meta.url));
     const candidate = path70.resolve(here, SENDER_REL);
-    return fs70.statSync(candidate).isFile() ? candidate : null;
+    return fs69.statSync(candidate).isFile() ? candidate : null;
   } catch {
     return null;
   }
@@ -29103,7 +29173,7 @@ function _isCliEntry33() {
   const argvUrl = pathToFileURL38(path70.resolve(process.argv[1])).href;
   if (import.meta.url === argvUrl) return true;
   try {
-    return fs70.realpathSync(fileURLToPath44(import.meta.url)) === fs70.realpathSync(path70.resolve(process.argv[1]));
+    return fs69.realpathSync(fileURLToPath44(import.meta.url)) === fs69.realpathSync(path70.resolve(process.argv[1]));
   } catch {
     return false;
   }
@@ -29111,7 +29181,7 @@ function _isCliEntry33() {
 if (_isCliEntry33()) process.exit(main43());
 
 // src/scripts/hooks/delegation_nudge_hook.ts
-import fs71 from "node:fs";
+import fs70 from "node:fs";
 import path71 from "node:path";
 import { fileURLToPath as fileURLToPath45, pathToFileURL as pathToFileURL39 } from "node:url";
 
@@ -29652,8 +29722,8 @@ function _isCliEntry34() {
     return true;
   }
   try {
-    const here = fs71.realpathSync(fileURLToPath45(import.meta.url));
-    const argv = fs71.realpathSync(path71.resolve(process.argv[1]));
+    const here = fs70.realpathSync(fileURLToPath45(import.meta.url));
+    const argv = fs70.realpathSync(path71.resolve(process.argv[1]));
     return here === argv;
   } catch {
     return false;
@@ -29664,19 +29734,19 @@ if (_isCliEntry34()) {
 }
 
 // src/scripts/hooks/skill_route_hook.ts
-import fs74 from "node:fs";
+import fs73 from "node:fs";
 import path74 from "node:path";
 import { fileURLToPath as fileURLToPath47, pathToFileURL as pathToFileURL41 } from "node:url";
 
 // src/scripts/_lib/skill_catalogue.ts
-import * as fs72 from "node:fs";
+import * as fs71 from "node:fs";
 import * as path72 from "node:path";
 var DEFAULT_CATALOGUE_ROOTS = [".claude/skills", "src/skills"];
 function resolveSkillsRoot(workspaceRoot2) {
   for (const candidate of DEFAULT_CATALOGUE_ROOTS) {
     const abs = path72.join(workspaceRoot2, candidate);
     try {
-      if (fs72.existsSync(abs) && fs72.statSync(abs).isDirectory()) return abs;
+      if (fs71.existsSync(abs) && fs71.statSync(abs).isDirectory()) return abs;
     } catch {
     }
   }
@@ -29708,9 +29778,9 @@ function headlineRecordPerHost(records) {
   return out;
 }
 function readObservationLog(logPath) {
-  if (!fs72.existsSync(logPath)) return [];
+  if (!fs71.existsSync(logPath)) return [];
   const out = [];
-  for (const line of fs72.readFileSync(logPath, "utf-8").split("\n")) {
+  for (const line of fs71.readFileSync(logPath, "utf-8").split("\n")) {
     const trimmed = line.trim();
     if (trimmed.length === 0) continue;
     try {
@@ -29735,7 +29805,7 @@ function knownBareNames(records, host) {
 }
 
 // src/scripts/skill_tools/score_skill_relevance.ts
-import * as fs73 from "node:fs";
+import * as fs72 from "node:fs";
 import * as path73 from "node:path";
 import { fileURLToPath as fileURLToPath46, pathToFileURL as pathToFileURL40 } from "node:url";
 
@@ -29868,7 +29938,7 @@ function _tokenize(text) {
   return out;
 }
 function _parse_frontmatter(filePath) {
-  const text = fs73.readFileSync(filePath, "utf-8");
+  const text = fs72.readFileSync(filePath, "utf-8");
   if (!text.startsWith("---")) {
     return {};
   }
@@ -29951,7 +30021,7 @@ function _truthyStr(v) {
 function _globSkillMd(root) {
   let names;
   try {
-    names = fs73.readdirSync(root);
+    names = fs72.readdirSync(root);
   } catch {
     return [];
   }
@@ -29960,7 +30030,7 @@ function _globSkillMd(root) {
     const dir = path73.join(root, name);
     const skillMd = path73.join(dir, "SKILL.md");
     try {
-      if (fs73.statSync(dir).isDirectory() && fs73.statSync(skillMd).isFile()) {
+      if (fs72.statSync(dir).isDirectory() && fs72.statSync(skillMd).isFile()) {
         dirs.push(name);
       }
     } catch {
@@ -30199,8 +30269,8 @@ function _isCliEntry35() {
     return true;
   }
   try {
-    const here = fs73.realpathSync(fileURLToPath46(import.meta.url));
-    const argv = fs73.realpathSync(path73.resolve(process.argv[1]));
+    const here = fs72.realpathSync(fileURLToPath46(import.meta.url));
+    const argv = fs72.realpathSync(path73.resolve(process.argv[1]));
     return here === argv;
   } catch {
     return false;
@@ -30318,8 +30388,8 @@ function _isCliEntry36() {
   const argvUrl = pathToFileURL41(path74.resolve(process.argv[1])).href;
   if (import.meta.url === argvUrl) return true;
   try {
-    const here = fs74.realpathSync(fileURLToPath47(import.meta.url));
-    const argv = fs74.realpathSync(path74.resolve(process.argv[1]));
+    const here = fs73.realpathSync(fileURLToPath47(import.meta.url));
+    const argv = fs73.realpathSync(path74.resolve(process.argv[1]));
     return here === argv;
   } catch {
     return false;
@@ -30332,7 +30402,7 @@ if (_isCliEntry36()) {
 // src/scripts/hooks/end_review_nudge_hook.ts
 import { spawnSync as spawnSync6 } from "node:child_process";
 import * as crypto9 from "node:crypto";
-import * as fs75 from "node:fs";
+import * as fs74 from "node:fs";
 import * as os10 from "node:os";
 import * as path75 from "node:path";
 import { fileURLToPath as fileURLToPath48, pathToFileURL as pathToFileURL42 } from "node:url";
@@ -30382,13 +30452,13 @@ function isSafeTranscriptPath(rawPath, opts = {}) {
   const homeDir = opts.homeDir ?? os10.homedir();
   const maxBytes = opts.maxBytes ?? TRANSCRIPT_SCAN_MAX_BYTES;
   try {
-    const realHome = fs75.realpathSync(homeDir);
-    const realPath = fs75.realpathSync(rawPath);
+    const realHome = fs74.realpathSync(homeDir);
+    const realPath = fs74.realpathSync(rawPath);
     const relative9 = path75.relative(realHome, realPath);
     if (relative9 === "" || relative9.startsWith("..") || path75.isAbsolute(relative9)) {
       return false;
     }
-    const { size } = fs75.statSync(realPath);
+    const { size } = fs74.statSync(realPath);
     return size <= maxBytes;
   } catch {
     return false;
@@ -30448,12 +30518,12 @@ var UNTRACKED_FILE_READ_CAP_BYTES = 8 * 1024 * 1024;
 function untrackedFileLineCount(cwd, relPath) {
   try {
     const abs = path75.resolve(cwd, relPath);
-    const size = fs75.statSync(abs).size;
+    const size = fs74.statSync(abs).size;
     if (size === 0) return 0;
     if (size > UNTRACKED_FILE_READ_CAP_BYTES) {
       return MUTATION_LINE_THRESHOLD + 1;
     }
-    const buf = fs75.readFileSync(abs);
+    const buf = fs74.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;
@@ -30544,9 +30614,9 @@ function appendReviewSkippedTelemetry(workspaceRoot2, diffLines, mutationMeasure
   if (errors.length || line === null) return;
   try {
     const dir = path75.join(workspaceRoot2, "agents", "runtime", "state", "audit");
-    fs75.mkdirSync(dir, { recursive: true });
+    fs74.mkdirSync(dir, { recursive: true });
     const file = path75.join(dir, `${ts.slice(0, 7)}.jsonl`);
-    fs75.appendFileSync(file, `${JSON.stringify(line)}
+    fs74.appendFileSync(file, `${JSON.stringify(line)}
 `, "utf8");
   } catch {
   }
@@ -30564,7 +30634,7 @@ function deriveSessionKey2(envelope, payload) {
 }
 function hasFiredThisSession(workspaceRoot2, sessionKey) {
   try {
-    return fs75.existsSync(sessionStateFile(workspaceRoot2, sessionKey));
+    return fs74.existsSync(sessionStateFile(workspaceRoot2, sessionKey));
   } catch {
     return false;
   }
@@ -30607,7 +30677,7 @@ function main47() {
   let reviewerRan = false;
   if (transcriptPath && isSafeTranscriptPath(transcriptPath)) {
     try {
-      reviewerRan = scanTranscriptForReviewer(fs75.readFileSync(transcriptPath, "utf-8"));
+      reviewerRan = scanTranscriptForReviewer(fs74.readFileSync(transcriptPath, "utf-8"));
     } catch {
       reviewerRan = false;
     }
@@ -30642,8 +30712,8 @@ function _isCliEntry37() {
     return true;
   }
   try {
-    const here = fs75.realpathSync(fileURLToPath48(import.meta.url));
-    const argv = fs75.realpathSync(path75.resolve(process.argv[1]));
+    const here = fs74.realpathSync(fileURLToPath48(import.meta.url));
+    const argv = fs74.realpathSync(path75.resolve(process.argv[1]));
     return here === argv;
   } catch {
     return false;
@@ -30654,13 +30724,13 @@ if (_isCliEntry37()) {
 }
 
 // src/scripts/hooks/turn_end_gate_hook.ts
-import * as fs77 from "node:fs";
+import * as fs76 from "node:fs";
 import * as path77 from "node:path";
 import { fileURLToPath as fileURLToPath50, pathToFileURL as pathToFileURL44 } from "node:url";
 
 // src/scripts/hooks/subagent_ledger_hook.ts
 import * as crypto10 from "node:crypto";
-import * as fs76 from "node:fs";
+import * as fs75 from "node:fs";
 import * as path76 from "node:path";
 import { fileURLToPath as fileURLToPath49, pathToFileURL as pathToFileURL43 } from "node:url";
 
@@ -30867,7 +30937,7 @@ function readOpenRecords(root) {
   const out = /* @__PURE__ */ new Map();
   let names;
   try {
-    names = fs76.readdirSync(openDir(root));
+    names = fs75.readdirSync(openDir(root));
   } catch {
     return out;
   }
@@ -30875,7 +30945,7 @@ function readOpenRecords(root) {
     if (!name.endsWith(".json")) continue;
     const expectedRef = name.slice(0, -".json".length);
     try {
-      const raw = fs76.readFileSync(path76.join(openDir(root), name), "utf8");
+      const raw = fs75.readFileSync(path76.join(openDir(root), name), "utf8");
       const rec = _asOpenRecord(JSON.parse(raw), expectedRef);
       if (rec) out.set(rec.ref, rec);
     } catch {
@@ -30895,8 +30965,8 @@ function ledgerFileFor2(root, ts) {
 function appendLedgerLine(root, ts, line) {
   if (is_replay_mode()) return;
   const file = ledgerFileFor2(root, ts);
-  fs76.mkdirSync(path76.dirname(file), { recursive: true });
-  fs76.appendFileSync(file, `${JSON.stringify(line)}
+  fs75.mkdirSync(path76.dirname(file), { recursive: true });
+  fs75.appendFileSync(file, `${JSON.stringify(line)}
 `, "utf8");
 }
 var WALL_CLOCK_ARMS_MS = [
@@ -30910,7 +30980,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 = fs76.existsSync(path76.join(root, LEDGER_DIR));
+  const ledgerPresent = fs75.existsSync(path76.join(root, LEDGER_DIR));
   const open = readOpenRecords(root);
   let maxDepth = 0;
   let counted = 0;
@@ -30938,13 +31008,13 @@ function writeOpenRecord(root, rec) {
 function removeOpenRecord(root, ref) {
   if (is_replay_mode()) return;
   try {
-    fs76.unlinkSync(openFile(root, ref));
+    fs75.unlinkSync(openFile(root, ref));
   } catch {
   }
 }
 function countOpen(root) {
   try {
-    return fs76.readdirSync(openDir(root)).filter((n) => n.endsWith(".json")).length;
+    return fs75.readdirSync(openDir(root)).filter((n) => n.endsWith(".json")).length;
   } catch {
     return 0;
   }
@@ -31110,7 +31180,7 @@ function _isCliEntry38() {
   const argvUrl = pathToFileURL43(path76.resolve(process.argv[1])).href;
   if (import.meta.url === argvUrl) return true;
   try {
-    return fs76.realpathSync(fileURLToPath49(import.meta.url)) === fs76.realpathSync(path76.resolve(process.argv[1]));
+    return fs75.realpathSync(fileURLToPath49(import.meta.url)) === fs75.realpathSync(path76.resolve(process.argv[1]));
   } catch {
     return false;
   }
@@ -31224,7 +31294,7 @@ function detectPromissory(reply) {
 function readCiSettled(workspaceRoot2, session_id) {
   if (!hasStableSessionId(session_id)) return { seen: false, settled: false };
   try {
-    const raw = fs77.readFileSync(path77.join(workspaceRoot2, statePathFor(session_id)), "utf-8");
+    const raw = fs76.readFileSync(path77.join(workspaceRoot2, statePathFor(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)) {
@@ -31260,7 +31330,7 @@ function detectCompletionClaim(reply, ci) {
 function readLanguagePin(workspaceRoot2, session_id) {
   if (!hasStableSessionId(session_id)) return "und";
   try {
-    const raw = fs77.readFileSync(
+    const raw = fs76.readFileSync(
       path77.join(workspaceRoot2, statePathFor2(session_id)),
       "utf-8"
     );
@@ -31317,7 +31387,7 @@ function sessionStateFile2(workspaceRoot2, sessionKey) {
 }
 function alreadyRefusedTurn(workspaceRoot2, sessionKey, turnOrdinal) {
   try {
-    const raw = fs77.readFileSync(sessionStateFile2(workspaceRoot2, sessionKey), "utf-8");
+    const raw = fs76.readFileSync(sessionStateFile2(workspaceRoot2, sessionKey), "utf-8");
     const decoded = JSON.parse(raw);
     if (typeof decoded === "object" && decoded !== null && !Array.isArray(decoded)) {
       return decoded["refused_turn"] === turnOrdinal;
@@ -31331,7 +31401,7 @@ function markRefusedTurn(workspaceRoot2, sessionKey, turnOrdinal, detectors) {
   const file = sessionStateFile2(workspaceRoot2, sessionKey);
   let prev = null;
   try {
-    prev = parseRecord(fs77.readFileSync(file, "utf-8"));
+    prev = parseRecord(fs76.readFileSync(file, "utf-8"));
   } catch {
   }
   let version;
@@ -31358,10 +31428,10 @@ function readTranscriptTail(transcriptPath, opts = {}) {
   if (!transcriptPath || !isSafeTranscriptPath(transcriptPath, opts)) return empty;
   let lines;
   try {
-    if (opts.maxBytes !== void 0 && fs77.statSync(transcriptPath).size > opts.maxBytes) {
+    if (opts.maxBytes !== void 0 && fs76.statSync(transcriptPath).size > opts.maxBytes) {
       return empty;
     }
-    lines = fs77.readFileSync(transcriptPath, "utf-8").split("\n");
+    lines = fs76.readFileSync(transcriptPath, "utf-8").split("\n");
   } catch {
     return empty;
   }
@@ -31516,8 +31586,8 @@ function _isCliEntry39() {
     return true;
   }
   try {
-    const here = fs77.realpathSync(fileURLToPath50(import.meta.url));
-    const argv = fs77.realpathSync(path77.resolve(process.argv[1]));
+    const here = fs76.realpathSync(fileURLToPath50(import.meta.url));
+    const argv = fs76.realpathSync(path77.resolve(process.argv[1]));
     return here === argv;
   } catch {
     return false;
@@ -31530,7 +31600,7 @@ if (_isCliEntry39()) {
 // src/scripts/hooks/edit_shape_hook.ts
 import { spawnSync as spawnSync7 } from "node:child_process";
 import * as crypto11 from "node:crypto";
-import * as fs78 from "node:fs";
+import * as fs77 from "node:fs";
 import * as path78 from "node:path";
 import { fileURLToPath as fileURLToPath51, pathToFileURL as pathToFileURL45 } from "node:url";
 var EXIT_ALLOW24 = 0;
@@ -31585,7 +31655,7 @@ function effectiveDiffLines(cwd, relPath) {
 }
 function fileLineCount(absPath) {
   try {
-    const text = fs78.readFileSync(absPath, "utf8");
+    const text = fs77.readFileSync(absPath, "utf8");
     if (text.length === 0) return 0;
     return text.split("\n").length - (text.endsWith("\n") ? 1 : 0);
   } catch {
@@ -31606,7 +31676,7 @@ function sessionStateFile3(workspaceRoot2, sessionKey) {
 }
 function hasFiredThisSession2(workspaceRoot2, sessionKey) {
   try {
-    return fs78.existsSync(sessionStateFile3(workspaceRoot2, sessionKey));
+    return fs77.existsSync(sessionStateFile3(workspaceRoot2, sessionKey));
   } catch {
     return false;
   }
@@ -31673,8 +31743,8 @@ function _isCliEntry40() {
     return true;
   }
   try {
-    const here = fs78.realpathSync(fileURLToPath51(import.meta.url));
-    const argv = fs78.realpathSync(path78.resolve(process.argv[1]));
+    const here = fs77.realpathSync(fileURLToPath51(import.meta.url));
+    const argv = fs77.realpathSync(path78.resolve(process.argv[1]));
     return here === argv;
   } catch {
     return false;
@@ -31686,7 +31756,7 @@ if (_isCliEntry40()) {
 
 // src/scripts/hooks/reread_guard_hook.ts
 import * as crypto12 from "node:crypto";
-import * as fs79 from "node:fs";
+import * as fs78 from "node:fs";
 import * as path79 from "node:path";
 import { fileURLToPath as fileURLToPath52, pathToFileURL as pathToFileURL46 } from "node:url";
 var EXIT_ALLOW25 = 0;
@@ -31728,7 +31798,7 @@ function ledgerFile(workspaceRoot2, sessionKey) {
 }
 function readLedger(workspaceRoot2, sessionKey) {
   try {
-    const parsed = JSON.parse(fs79.readFileSync(ledgerFile(workspaceRoot2, sessionKey), "utf8"));
+    const parsed = JSON.parse(fs78.readFileSync(ledgerFile(workspaceRoot2, sessionKey), "utf8"));
     if (!isObject11(parsed)) return emptyLedger();
     return {
       reads: isObject11(parsed["reads"]) ? parsed["reads"] : {},
@@ -31799,7 +31869,7 @@ function main51() {
     let mtime;
     let size;
     try {
-      const st = fs79.statSync(absPath);
+      const st = fs78.statSync(absPath);
       mtime = st.mtimeMs;
       size = st.size;
     } catch {
@@ -31844,8 +31914,8 @@ function _isCliEntry41() {
     return true;
   }
   try {
-    const here = fs79.realpathSync(fileURLToPath52(import.meta.url));
-    const argv = fs79.realpathSync(path79.resolve(process.argv[1]));
+    const here = fs78.realpathSync(fileURLToPath52(import.meta.url));
+    const argv = fs78.realpathSync(path79.resolve(process.argv[1]));
     return here === argv;
   } catch {
     return false;
@@ -31856,7 +31926,7 @@ if (_isCliEntry41()) {
 }
 
 // src/scripts/hooks/session_eol_hook.ts
-import * as fs82 from "node:fs";
+import * as fs81 from "node:fs";
 import * as path83 from "node:path";
 import process11 from "node:process";
 import { fileURLToPath as fileURLToPath53, pathToFileURL as pathToFileURL47 } from "node:url";
@@ -31877,7 +31947,7 @@ var recycle_threshold_budget_default = {
 
 // src/scripts/_lib/session_eol.ts
 import * as crypto13 from "node:crypto";
-import * as fs80 from "node:fs";
+import * as fs79 from "node:fs";
 import * as path81 from "node:path";
 
 // src/scripts/_lib/cc_transcript.ts
@@ -32002,7 +32072,7 @@ function eolSessionKey(raw) {
 }
 function readNewCompleteLines(filePath, fromByte) {
   try {
-    const { size } = fs80.statSync(filePath);
+    const { size } = fs79.statSync(filePath);
     if (size < fromByte) {
       return { text: "", nextOffset: 0, truncated: true };
     }
@@ -32011,11 +32081,11 @@ function readNewCompleteLines(filePath, fromByte) {
     }
     const length = size - fromByte;
     const buffer = Buffer.alloc(length);
-    const fd = fs80.openSync(filePath, "r");
+    const fd = fs79.openSync(filePath, "r");
     try {
-      fs80.readSync(fd, buffer, 0, length, fromByte);
+      fs79.readSync(fd, buffer, 0, length, fromByte);
     } finally {
-      fs80.closeSync(fd);
+      fs79.closeSync(fd);
     }
     const lastNewline = buffer.lastIndexOf(10);
     if (lastNewline === -1) {
@@ -32032,7 +32102,7 @@ function readNewCompleteLines(filePath, fromByte) {
 }
 
 // src/scripts/_lib/run_checkpoint.ts
-import * as fs81 from "node:fs";
+import * as fs80 from "node:fs";
 import * as path82 from "node:path";
 
 // src/scripts/_lib/roadmap_checkboxes.ts
@@ -32092,26 +32162,26 @@ function roadmapPath(repoRoot, slug) {
 function readHead(repoRoot) {
   try {
     let gitDir = path82.join(repoRoot, ".git");
-    if (fs81.statSync(gitDir).isFile()) {
-      const m = /^gitdir:\s*(.+)$/m.exec(fs81.readFileSync(gitDir, "utf-8").trim());
+    if (fs80.statSync(gitDir).isFile()) {
+      const m = /^gitdir:\s*(.+)$/m.exec(fs80.readFileSync(gitDir, "utf-8").trim());
       if (m === null) return null;
       gitDir = path82.resolve(repoRoot, m[1]);
     }
     let refRoot = gitDir;
     try {
-      const common = fs81.readFileSync(path82.join(gitDir, "commondir"), "utf-8").trim();
+      const common = fs80.readFileSync(path82.join(gitDir, "commondir"), "utf-8").trim();
       if (common !== "") refRoot = path82.resolve(gitDir, common);
     } catch {
     }
-    const head = fs81.readFileSync(path82.join(gitDir, "HEAD"), "utf-8").trim();
+    const head = fs80.readFileSync(path82.join(gitDir, "HEAD"), "utf-8").trim();
     if (/^[0-9a-f]{40}$/.test(head)) return head;
     const ref = /^ref:\s*(.+)$/.exec(head);
     if (ref === null) return null;
     const refName = ref[1];
     try {
-      return fs81.readFileSync(path82.join(refRoot, refName), "utf-8").trim() || null;
+      return fs80.readFileSync(path82.join(refRoot, refName), "utf-8").trim() || null;
     } catch {
-      const packed = fs81.readFileSync(path82.join(refRoot, "packed-refs"), "utf-8");
+      const packed = fs80.readFileSync(path82.join(refRoot, "packed-refs"), "utf-8");
       for (const line of packed.split("\n")) {
         const pm = /^([0-9a-f]{40})\s+(.+)$/.exec(line.trim());
         if (pm !== null && pm[2] === refName) return pm[1];
@@ -32125,7 +32195,7 @@ function readHead(repoRoot) {
 function buildCheckpoint(repoRoot, runId, slug, opts = {}) {
   let text;
   try {
-    text = fs81.readFileSync(roadmapPath(repoRoot, slug), "utf-8");
+    text = fs80.readFileSync(roadmapPath(repoRoot, slug), "utf-8");
   } catch {
     return null;
   }
@@ -32145,8 +32215,8 @@ function buildCheckpoint(repoRoot, runId, slug, opts = {}) {
 function writeCheckpoint(repoRoot, cp) {
   const file = checkpointFile(repoRoot, cp.run_id);
   try {
-    fs81.mkdirSync(path82.dirname(file), { recursive: true });
-    fs81.writeFileSync(file, `${JSON.stringify(cp, null, 2)}
+    fs80.mkdirSync(path82.dirname(file), { recursive: true });
+    fs80.writeFileSync(file, `${JSON.stringify(cp, null, 2)}
 `, "utf-8");
     return file;
   } catch {
@@ -32172,7 +32242,7 @@ function payloadSessionId(payload, envelope) {
 }
 function readState3(file) {
   try {
-    const parsed = JSON.parse(fs82.readFileSync(file, "utf-8"));
+    const parsed = JSON.parse(fs81.readFileSync(file, "utf-8"));
     if (parsed && typeof parsed === "object" && parsed.schema_version === 1 && parsed.counters && typeof parsed.counters.scanned_bytes === "number") {
       return {
         schema_version: 1,
@@ -32196,7 +32266,7 @@ function envelopeExists(workspaceRoot2, since = null) {
   const target = path83.join(workspaceRoot2, RECYCLE_ENVELOPE_REL);
   let raw;
   try {
-    raw = fs82.readFileSync(target, "utf-8");
+    raw = fs81.readFileSync(target, "utf-8");
   } catch (exc) {
     return exc?.code !== "ENOENT";
   }
@@ -32331,8 +32401,8 @@ function _isCliEntry42() {
     return true;
   }
   try {
-    const here = fs82.realpathSync(fileURLToPath53(import.meta.url));
-    const argv = fs82.realpathSync(path83.resolve(process11.argv[1]));
+    const here = fs81.realpathSync(fileURLToPath53(import.meta.url));
+    const argv = fs81.realpathSync(path83.resolve(process11.argv[1]));
     return here === argv;
   } catch {
     return false;
@@ -32343,7 +32413,7 @@ if (_isCliEntry42()) {
 }
 
 // src/scripts/hooks/tool_result_bytes_hook.ts
-import * as fs83 from "node:fs";
+import * as fs82 from "node:fs";
 import * as path84 from "node:path";
 import { fileURLToPath as fileURLToPath54, pathToFileURL as pathToFileURL48 } from "node:url";
 var EXIT_ALLOW26 = 0;
@@ -32390,8 +32460,8 @@ function censusFile(consumerRoot) {
 function _appendCensusLine(consumerRoot, line) {
   if (is_replay_mode()) return;
   const file = censusFile(consumerRoot);
-  fs83.mkdirSync(path84.dirname(file), { recursive: true });
-  fs83.appendFileSync(file, `${JSON.stringify(line)}
+  fs82.mkdirSync(path84.dirname(file), { recursive: true });
+  fs82.appendFileSync(file, `${JSON.stringify(line)}
 `, "utf8");
 }
 function processEnvelope4(envelope, consumerRoot) {
@@ -32440,7 +32510,7 @@ function _isCliEntry43() {
   const argvUrl = pathToFileURL48(path84.resolve(process.argv[1])).href;
   if (import.meta.url === argvUrl) return true;
   try {
-    return fs83.realpathSync(fileURLToPath54(import.meta.url)) === fs83.realpathSync(path84.resolve(process.argv[1]));
+    return fs82.realpathSync(fileURLToPath54(import.meta.url)) === fs82.realpathSync(path84.resolve(process.argv[1]));
   } catch {
     return false;
   }
@@ -32448,7 +32518,7 @@ function _isCliEntry43() {
 if (_isCliEntry43()) process.exit(main53());
 
 // src/scripts/hooks/spawn_guard_shadow_hook.ts
-import * as fs84 from "node:fs";
+import * as fs83 from "node:fs";
 import * as path85 from "node:path";
 import { fileURLToPath as fileURLToPath55, pathToFileURL as pathToFileURL49 } from "node:url";
 var EXIT_ALLOW27 = 0;
@@ -32530,7 +32600,7 @@ function _isCliEntry44() {
   const argvUrl = pathToFileURL49(path85.resolve(process.argv[1])).href;
   if (import.meta.url === argvUrl) return true;
   try {
-    return fs84.realpathSync(fileURLToPath55(import.meta.url)) === fs84.realpathSync(path85.resolve(process.argv[1]));
+    return fs83.realpathSync(fileURLToPath55(import.meta.url)) === fs83.realpathSync(path85.resolve(process.argv[1]));
   } catch {
     return false;
   }
@@ -32538,7 +32608,7 @@ function _isCliEntry44() {
 if (_isCliEntry44()) process.exit(main54());
 
 // src/scripts/hooks/source_first_gate_hook.ts
-import * as fs85 from "node:fs";
+import * as fs84 from "node:fs";
 import * as path86 from "node:path";
 import { fileURLToPath as fileURLToPath56, pathToFileURL as pathToFileURL50 } from "node:url";
 var EXIT_ALLOW28 = 0;
@@ -32618,7 +32688,7 @@ var EMPTY_STATE = { handoverSeen: false, sourceRead: false, wouldWarn: 0 };
 var MAX_SESSIONS2 = 50;
 function readState4(root, session) {
   try {
-    const all = JSON.parse(fs85.readFileSync(path86.join(root, STATE_FILE9), "utf-8"));
+    const all = JSON.parse(fs84.readFileSync(path86.join(root, STATE_FILE9), "utf-8"));
     const entry = all[session];
     if (entry && typeof entry.handoverSeen === "boolean" && typeof entry.sourceRead === "boolean" && typeof entry.wouldWarn === "number") {
       return entry;
@@ -32633,7 +32703,7 @@ function writeState3(root, session, state) {
     const file = path86.join(root, STATE_FILE9);
     let all = {};
     try {
-      all = JSON.parse(fs85.readFileSync(file, "utf-8"));
+      all = JSON.parse(fs84.readFileSync(file, "utf-8"));
     } catch {
     }
     if (!isObject14(all)) all = {};
@@ -32644,8 +32714,8 @@ function writeState3(root, session, state) {
       for (const key of keys.slice(keys.length - MAX_SESSIONS2)) pruned[key] = all[key];
       all = pruned;
     }
-    fs85.mkdirSync(path86.dirname(file), { recursive: true });
-    fs85.writeFileSync(file, JSON.stringify(all));
+    fs84.mkdirSync(path86.dirname(file), { recursive: true });
+    fs84.writeFileSync(file, JSON.stringify(all));
   } catch {
   }
 }
@@ -32666,7 +32736,7 @@ function evaluateCandidates2(handoverSeen, handoverOnDisk, sourceRead) {
 }
 function handoverPresentOnDisk(root) {
   try {
-    return fs85.statSync(path86.join(root, ".claude", "design-system")).isDirectory();
+    return fs84.statSync(path86.join(root, ".claude", "design-system")).isDirectory();
   } catch {
     return false;
   }
@@ -32675,8 +32745,8 @@ function appendShadowLine(root, line) {
   if (is_replay_mode()) return;
   try {
     const file = path86.join(root, SHADOW_LOG);
-    fs85.mkdirSync(path86.dirname(file), { recursive: true });
-    fs85.appendFileSync(file, `${JSON.stringify(line)}
+    fs84.mkdirSync(path86.dirname(file), { recursive: true });
+    fs84.appendFileSync(file, `${JSON.stringify(line)}
 `, "utf8");
   } catch {
   }
@@ -32755,7 +32825,7 @@ function _isCliEntry45() {
   const argvUrl = pathToFileURL50(path86.resolve(process.argv[1])).href;
   if (import.meta.url === argvUrl) return true;
   try {
-    return fs85.realpathSync(fileURLToPath56(import.meta.url)) === fs85.realpathSync(path86.resolve(process.argv[1]));
+    return fs84.realpathSync(fileURLToPath56(import.meta.url)) === fs84.realpathSync(path86.resolve(process.argv[1]));
   } catch {
     return false;
   }
@@ -32763,7 +32833,7 @@ function _isCliEntry45() {
 if (_isCliEntry45()) process.exit(main55());
 
 // src/scripts/hooks/interruption_ledger_hook.ts
-import * as fs86 from "node:fs";
+import * as fs85 from "node:fs";
 import * as path87 from "node:path";
 import { fileURLToPath as fileURLToPath57, pathToFileURL as pathToFileURL51 } from "node:url";
 var EXIT_OK2 = 0;
@@ -32799,7 +32869,7 @@ function readClaimedRoadmap(workspaceRoot2, sessionId2) {
       "state",
       `roadmap-claim-${sessionId2}.json`
     );
-    const parsed = JSON.parse(fs86.readFileSync(file, "utf8"));
+    const parsed = JSON.parse(fs85.readFileSync(file, "utf8"));
     if (parsed === null || typeof parsed !== "object") return null;
     const slug = parsed["slug"];
     return typeof slug === "string" && slug.length > 0 ? slug : null;
@@ -32810,7 +32880,7 @@ function readClaimedRoadmap(workspaceRoot2, sessionId2) {
 function alreadyRecorded(ledgerPath, runId, turn) {
   let raw;
   try {
-    raw = fs86.readFileSync(ledgerPath, "utf8");
+    raw = fs85.readFileSync(ledgerPath, "utf8");
   } catch {
     return false;
   }
@@ -32866,8 +32936,8 @@ function main56() {
     at: (/* @__PURE__ */ new Date()).toISOString()
   };
   try {
-    fs86.mkdirSync(path87.dirname(ledgerPath), { recursive: true });
-    fs86.appendFileSync(ledgerPath, `${JSON.stringify(record)}
+    fs85.mkdirSync(path87.dirname(ledgerPath), { recursive: true });
+    fs85.appendFileSync(ledgerPath, `${JSON.stringify(record)}
 `, "utf8");
   } catch {
   }
@@ -32882,8 +32952,8 @@ function _isCliEntry46() {
     return true;
   }
   try {
-    const here = fs86.realpathSync(fileURLToPath57(import.meta.url));
-    const argv = fs86.realpathSync(path87.resolve(process.argv[1]));
+    const here = fs85.realpathSync(fileURLToPath57(import.meta.url));
+    const argv = fs85.realpathSync(path87.resolve(process.argv[1]));
     return here === argv;
   } catch {
     return false;
@@ -32894,7 +32964,7 @@ if (_isCliEntry46()) {
 }
 
 // src/scripts/hooks/run_continuation_hook.ts
-import * as fs87 from "node:fs";
+import * as fs86 from "node:fs";
 import * as path88 from "node:path";
 import { fileURLToPath as fileURLToPath58, pathToFileURL as pathToFileURL52 } from "node:url";
 var EXIT_ALLOW29 = 0;
@@ -33027,8 +33097,8 @@ function readRunState(workspaceRoot2, runId, slug) {
 }
 function writeState4(file, state) {
   try {
-    fs87.mkdirSync(path88.dirname(file), { recursive: true });
-    fs87.writeFileSync(file, `${JSON.stringify(state)}
+    fs86.mkdirSync(path88.dirname(file), { recursive: true });
+    fs86.writeFileSync(file, `${JSON.stringify(state)}
 `, "utf8");
     return true;
   } catch {
@@ -33037,25 +33107,25 @@ function writeState4(file, state) {
 }
 function clearRunState(workspaceRoot2, runId, keyedFile, adoptedLegacy) {
   try {
-    fs87.rmSync(keyedFile, { force: true });
+    fs86.rmSync(keyedFile, { force: true });
   } catch {
   }
   if (!adoptedLegacy) return;
   try {
-    fs87.rmSync(path88.join(workspaceRoot2, legacyStateRelPath(runId)), { force: true });
+    fs86.rmSync(path88.join(workspaceRoot2, legacyStateRelPath(runId)), { force: true });
   } catch {
   }
 }
 function fileExists(p) {
   try {
-    return fs87.statSync(p).isFile();
+    return fs86.statSync(p).isFile();
   } catch {
     return false;
   }
 }
 function readState5(file) {
   try {
-    const parsed = JSON.parse(fs87.readFileSync(file, "utf8"));
+    const parsed = JSON.parse(fs86.readFileSync(file, "utf8"));
     if (parsed === null || typeof parsed !== "object") return null;
     const o = parsed;
     if (typeof o["started_at"] !== "string") return null;
@@ -33097,7 +33167,7 @@ function readState5(file) {
 function normalizeDir(p) {
   const abs = path88.resolve(p);
   try {
-    return fs87.realpathSync(abs);
+    return fs86.realpathSync(abs);
   } catch {
     return abs;
   }
@@ -33143,7 +33213,7 @@ function resolveRoadmap(sessionRoot, workspaceRoot2, slug) {
 }
 function isDirectory(p) {
   try {
-    return fs87.statSync(p).isDirectory();
+    return fs86.statSync(p).isDirectory();
   } catch {
     return false;
   }
@@ -33151,16 +33221,16 @@ function isDirectory(p) {
 function eventAlreadyLogged(workspaceRoot2, runId, slug, event) {
   try {
     const file = path88.join(workspaceRoot2, EVENTS_RELPATH);
-    const size = fs87.statSync(file).size;
+    const size = fs86.statSync(file).size;
     const start = Math.max(0, size - LEDGER_TAIL_MAX_BYTES);
-    const fd = fs87.openSync(file, "r");
+    const fd = fs86.openSync(file, "r");
     let text;
     try {
       const buf = Buffer.alloc(size - start);
-      const read = fs87.readSync(fd, buf, 0, buf.length, start);
+      const read = fs86.readSync(fd, buf, 0, buf.length, start);
       text = buf.subarray(0, read).toString("utf8");
     } finally {
-      fs87.closeSync(fd);
+      fs86.closeSync(fd);
     }
     for (const line of text.split("\n")) {
       if (line === "") continue;
@@ -33184,8 +33254,8 @@ function eventAlreadyLogged(workspaceRoot2, runId, slug, event) {
 function appendEvent2(workspaceRoot2, record) {
   try {
     const file = path88.join(workspaceRoot2, EVENTS_RELPATH);
-    fs87.mkdirSync(path88.dirname(file), { recursive: true });
-    fs87.appendFileSync(file, `${JSON.stringify(record)}
+    fs86.mkdirSync(path88.dirname(file), { recursive: true });
+    fs86.appendFileSync(file, `${JSON.stringify(record)}
 `, "utf8");
   } catch {
   }
@@ -33193,7 +33263,7 @@ function appendEvent2(workspaceRoot2, record) {
 function refusedThisTurn(workspaceRoot2, sessionId2, turnOrdinal) {
   try {
     const file = sessionRefusalFile(workspaceRoot2, deriveSessionKey(sessionId2 || "unknown-session"));
-    const rec = parseRecord(fs87.readFileSync(file, "utf-8"));
+    const rec = parseRecord(fs86.readFileSync(file, "utf-8"));
     return rec !== null && rec.refused_turn === turnOrdinal;
   } catch {
     return false;
@@ -33227,7 +33297,7 @@ function main57() {
   let roadmapText = null;
   if (roadmapPath2 !== null) {
     try {
-      roadmapText = fs87.readFileSync(roadmapPath2, "utf8");
+      roadmapText = fs86.readFileSync(roadmapPath2, "utf8");
       roadmapFile = roadmapPath2;
     } catch {
       roadmapText = null;
@@ -33276,7 +33346,7 @@ function main57() {
   );
   if (!transcriptPath) return EXIT_ALLOW29;
   try {
-    if (fs87.statSync(transcriptPath).size > TRANSCRIPT_READ_MAX_BYTES) {
+    if (fs86.statSync(transcriptPath).size > TRANSCRIPT_READ_MAX_BYTES) {
       const inert = readRunState(workspaceRoot2, runId, slug);
       if (inert.state !== null && inert.state.inert_reported !== true) {
         const inertRoots = provenance(
@@ -33417,8 +33487,8 @@ function _isCliEntry47() {
   const argvUrl = pathToFileURL52(path88.resolve(process.argv[1])).href;
   if (import.meta.url === argvUrl) return true;
   try {
-    const here = fs87.realpathSync(fileURLToPath58(import.meta.url));
-    const argv = fs87.realpathSync(path88.resolve(process.argv[1]));
+    const here = fs86.realpathSync(fileURLToPath58(import.meta.url));
+    const argv = fs86.realpathSync(path88.resolve(process.argv[1]));
     return here === argv;
   } catch {
     return false;
@@ -33481,6 +33551,101 @@ var CONCERN_REGISTRY = {
   "src/scripts/hooks/run_continuation_hook.ts": main57
 };
 
+// src/scripts/hooks/stdin_failure_policy.ts
+function stdinReadFailure(read = readFd0ToEnd) {
+  try {
+    return { text: read(), failure: null };
+  } catch (exc) {
+    return { text: "", failure: exc instanceof Error ? exc.message : String(exc) };
+  }
+}
+function _is_fail_closed_blocking(concern) {
+  const severity = String(concern["severity"] ?? "").trim().toLowerCase();
+  return concern["fail_closed"] === true && severity === "blocking";
+}
+function denyOnStdinFailure(platform, event, concerns, failure) {
+  if (!isBlockCapable(platform, event)) return null;
+  const silenced = concerns.filter(_is_fail_closed_blocking).map((c) => String(c["name"]));
+  if (silenced.length === 0) return null;
+  return {
+    reason: `agent-config: refusing this action \u2014 the hook payload could not be read (${failure}), so ${silenced.join(", ")} evaluated nothing. A fail-closed guard on a block-capable slot must not pass by default. Retry.`
+  };
+}
+
+// src/scripts/hooks/py_json_dumps.ts
+function _py_json_dumps2(value, indent) {
+  const pad = " ".repeat(indent);
+  const escapeString = (s) => {
+    let out = '"';
+    for (const ch of s) {
+      const code = ch.codePointAt(0);
+      switch (ch) {
+        case '"':
+          out += '\\"';
+          break;
+        case "\\":
+          out += "\\\\";
+          break;
+        case "\n":
+          out += "\\n";
+          break;
+        case "\r":
+          out += "\\r";
+          break;
+        case "	":
+          out += "\\t";
+          break;
+        case "\b":
+          out += "\\b";
+          break;
+        case "\f":
+          out += "\\f";
+          break;
+        default:
+          if (code < 32 || code > 126) {
+            if (code > 65535) {
+              const c = code - 65536;
+              const hi = 55296 + (c >> 10);
+              const lo = 56320 + (c & 1023);
+              out += "\\u" + hi.toString(16).padStart(4, "0") + "\\u" + lo.toString(16).padStart(4, "0");
+            } else {
+              out += "\\u" + code.toString(16).padStart(4, "0");
+            }
+          } else {
+            out += ch;
+          }
+      }
+    }
+    return out + '"';
+  };
+  const render = (v, depth) => {
+    if (v === null || v === void 0) return "null";
+    if (typeof v === "boolean") return v ? "true" : "false";
+    if (typeof v === "number") {
+      if (!Number.isFinite(v)) {
+        if (Number.isNaN(v)) return "NaN";
+        return v > 0 ? "Infinity" : "-Infinity";
+      }
+      return String(v);
+    }
+    if (typeof v === "string") return escapeString(v);
+    const curPad = pad.repeat(depth + 1);
+    const closePad = pad.repeat(depth);
+    if (Array.isArray(v)) {
+      if (v.length === 0) return "[]";
+      return "[\n" + v.map((item) => curPad + render(item, depth + 1)).join(",\n") + "\n" + closePad + "]";
+    }
+    if (typeof v === "object") {
+      const obj = v;
+      const keys = Object.keys(obj);
+      if (keys.length === 0) return "{}";
+      return "{\n" + keys.map((k) => curPad + escapeString(k) + ": " + render(obj[k], depth + 1)).join(",\n") + "\n" + closePad + "}";
+    }
+    throw new TypeError(`Object of type ${typeof v} is not JSON serializable`);
+  };
+  return render(value, 0);
+}
+
 // src/scripts/hooks/dispatch_hook.ts
 var _IN_BUNDLE = true;
 var REPO_ROOT = path89.resolve(
@@ -33549,11 +33714,11 @@ function _manifest_fingerprint(text) {
   return `${h.toString(16)}:${String(text.length)}`;
 }
 function _load_yaml3(p) {
-  const text = fs88.readFileSync(p, "utf-8");
+  const text = fs87.readFileSync(p, "utf-8");
   const compiled = p.replace(/\.ya?ml$/u, ".json");
   if (compiled !== p) {
     try {
-      const raw = JSON.parse(fs88.readFileSync(compiled, "utf-8"));
+      const raw = JSON.parse(fs87.readFileSync(compiled, "utf-8"));
       if (_isObject16(raw) && raw["fingerprint"] === _manifest_fingerprint(text) && _isObject16(raw["manifest"])) {
         return raw["manifest"];
       }
@@ -33652,78 +33817,6 @@ function _resolve_concerns(manifest, platform, event, role = "orchestrator", opt
   }
   return out;
 }
-function _py_json_dumps2(value, indent) {
-  const pad = " ".repeat(indent);
-  const escapeString = (s) => {
-    let out = '"';
-    for (const ch of s) {
-      const code = ch.codePointAt(0);
-      switch (ch) {
-        case '"':
-          out += '\\"';
-          break;
-        case "\\":
-          out += "\\\\";
-          break;
-        case "\n":
-          out += "\\n";
-          break;
-        case "\r":
-          out += "\\r";
-          break;
-        case "	":
-          out += "\\t";
-          break;
-        case "\b":
-          out += "\\b";
-          break;
-        case "\f":
-          out += "\\f";
-          break;
-        default:
-          if (code < 32 || code > 126) {
-            if (code > 65535) {
-              const c = code - 65536;
-              const hi = 55296 + (c >> 10);
-              const lo = 56320 + (c & 1023);
-              out += "\\u" + hi.toString(16).padStart(4, "0") + "\\u" + lo.toString(16).padStart(4, "0");
-            } else {
-              out += "\\u" + code.toString(16).padStart(4, "0");
-            }
-          } else {
-            out += ch;
-          }
-      }
-    }
-    return out + '"';
-  };
-  const render = (v, depth) => {
-    if (v === null || v === void 0) return "null";
-    if (typeof v === "boolean") return v ? "true" : "false";
-    if (typeof v === "number") {
-      if (!Number.isFinite(v)) {
-        if (Number.isNaN(v)) return "NaN";
-        return v > 0 ? "Infinity" : "-Infinity";
-      }
-      return String(v);
-    }
-    if (typeof v === "string") return escapeString(v);
-    const curPad = pad.repeat(depth + 1);
-    const closePad = pad.repeat(depth);
-    if (Array.isArray(v)) {
-      if (v.length === 0) return "[]";
-      return "[\n" + v.map((item) => curPad + render(item, depth + 1)).join(",\n") + "\n" + closePad + "]";
-    }
-    if (typeof v === "object") {
-      const obj = v;
-      const keys = Object.keys(obj);
-      if (keys.length === 0) return "{}";
-      return "{\n" + keys.map((k) => curPad + escapeString(k) + ": " + render(obj[k], depth + 1)).join(",\n") + "\n" + closePad + "}";
-    }
-    throw new TypeError(`Object of type ${typeof v} is not JSON serializable`);
-  };
-  return render(value, 0);
-}
 function _maybe_capture_payload(args, payload_text) {
   const capture_dir = (process.env["AGENT_HOOK_CAPTURE_DIR"] ?? "").trim();
   if (!capture_dir) {
@@ -33731,7 +33824,7 @@ function _maybe_capture_payload(args, payload_text) {
   }
   try {
     const target = _expanduser3(capture_dir);
-    fs88.mkdirSync(target, { recursive: true });
+    fs87.mkdirSync(target, { recursive: true });
     let payload;
     try {
       payload = payload_text.trim() ? JSON.parse(payload_text) : {};
@@ -33748,7 +33841,7 @@ function _maybe_capture_payload(args, payload_text) {
     const ts = Date.now();
     const native = (args.native_event || args.event).replace(/\//g, "_");
     const fname = `${args.platform}__${native}__${ts}__${process.pid}.json`;
-    fs88.writeFileSync(
+    fs87.writeFileSync(
       path89.join(target, fname),
       _py_json_dumps2(record, 2) + "\n",
       { encoding: "utf-8" }
@@ -33944,7 +34037,7 @@ function _run_concern(concern, envelope) {
 }
 function _isFile8(p) {
   try {
-    return fs88.statSync(p).isFile();
+    return fs87.statSync(p).isFile();
   } catch {
     return false;
   }
@@ -33969,7 +34062,7 @@ function _write_feedback(envelope, session_id, entries, final_rc, started_at) {
   const state_root = path89.join(workspace, "agents", "runtime", "state");
   const fb_dir = feedback_dir(state_root, session_id);
   try {
-    fs88.mkdirSync(fb_dir, { recursive: true });
+    fs87.mkdirSync(fb_dir, { recursive: true });
   } catch (exc) {
     const msg = exc instanceof Error ? exc.message : String(exc);
     process.stderr.write(`dispatch_hook: feedback dir unavailable: ${msg}
@@ -34025,13 +34118,26 @@ function _write_feedback(envelope, session_id, entries, final_rc, started_at) {
     })
   };
   try {
-    atomic_write_json(path89.join(fb_dir, "summary.json"), summary);
+    const invocation = `${String(process.pid)}-${process.hrtime.bigint().toString()}`;
+    update_json_under_lock(path89.join(fb_dir, "summary.json"), (loaded) => {
+      const priorRaw = loaded["invocations"];
+      const prior = Array.isArray(priorRaw) ? priorRaw : [];
+      const next = [...prior, { invocation, ...summary }];
+      return {
+        schema_version: 2,
+        session_id,
+        // Newest last, oldest dropped — the same rotation direction
+        // `dispatch-issues.jsonl` uses, so a reader learns one convention.
+        invocations: next.slice(Math.max(0, next.length - SUMMARY_INVOCATION_CAP))
+      };
+    });
   } catch (exc) {
     const msg = exc instanceof Error ? exc.message : String(exc);
     process.stderr.write(`dispatch_hook: summary write failed: ${msg}
 `);
   }
 }
+var SUMMARY_INVOCATION_CAP = 20;
 function _record_rule_trips(envelope, entries) {
   if (is_replay_mode()) return;
   const tripped = entries.filter(
@@ -34042,27 +34148,25 @@ function _record_rule_trips(envelope, entries) {
     const workspace = String(envelope["workspace_root"] || process.cwd());
     const state_dir = path89.join(workspace, "agents", "runtime", "state");
     const target = path89.join(state_dir, "rule-trips.json");
-    fs88.mkdirSync(state_dir, { recursive: true });
-    let doc = { schema_version: 1, concerns: {} };
-    try {
-      const parsed = JSON.parse(fs88.readFileSync(target, "utf-8"));
-      if (parsed && typeof parsed === "object" && !Array.isArray(parsed)) doc = parsed;
-    } catch {
-    }
-    const concerns = doc["concerns"] ?? {};
     const today = _now_iso3().slice(0, 10);
-    for (const e of tripped) {
-      const name = String(e["concern"]);
-      const prev = concerns[name] ?? { block: 0, warn: 0 };
-      concerns[name] = {
-        block: (Number(prev["block"]) || 0) + (e["exit_code"] === EXIT_BLOCK6 ? 1 : 0),
-        warn: (Number(prev["warn"]) || 0) + (e["exit_code"] === EXIT_WARN15 ? 1 : 0),
-        last_trip: today
-      };
-    }
-    doc["schema_version"] = 1;
-    doc["concerns"] = concerns;
-    atomic_write_json(target, doc);
+    update_json_under_lock(target, (loaded) => {
+      const doc = { schema_version: 1, concerns: {}, ...loaded };
+      const concernsRaw = doc["concerns"];
+      const concerns = _isObject16(concernsRaw) ? concernsRaw : {};
+      for (const e of tripped) {
+        const name = String(e["concern"]);
+        const prevRaw = concerns[name];
+        const prev = _isObject16(prevRaw) ? prevRaw : { block: 0, warn: 0 };
+        concerns[name] = {
+          block: (Number(prev["block"]) || 0) + (e["exit_code"] === EXIT_BLOCK6 ? 1 : 0),
+          warn: (Number(prev["warn"]) || 0) + (e["exit_code"] === EXIT_WARN15 ? 1 : 0),
+          last_trip: today
+        };
+      }
+      doc["schema_version"] = 1;
+      doc["concerns"] = concerns;
+      return doc;
+    });
   } catch {
   }
 }
@@ -34074,7 +34178,8 @@ function _parse_args(argv) {
     manifest: MANIFEST_PATH,
     dry_run: false,
     project_dir: "",
-    min_version: 0
+    min_version: 0,
+    read_exit: false
   };
   let sawPlatform = false;
   let sawEvent = false;
@@ -34098,6 +34203,9 @@ function _parse_args(argv) {
       case "--dry-run":
         args.dry_run = true;
         break;
+      case "--read-exit":
+        args.read_exit = true;
+        break;
       case "--project-dir":
         args.project_dir = argv[++i] ?? "";
         break;
@@ -34157,6 +34265,20 @@ function main58(argv) {
       );
     }
   }
+  if (args.read_exit === true) {
+    const probe = tty2.isatty(0) ? { text: "", failure: null } : stdinReadFailure();
+    if (probe.failure !== null) {
+      process.stderr.write(`dispatch_hook: --read-exit read failed: ${probe.failure}
+`);
+      return EXIT_ALLOW30;
+    }
+    const envelope2 = _build_envelope(args, probe.text);
+    process.stderr.write(
+      `dispatch_hook: --read-exit ok (${probe.text.length} chars, ${Object.keys(_isObject16(envelope2["payload"]) ? envelope2["payload"] : {}).length} payload keys)
+`
+    );
+    return EXIT_ALLOW30;
+  }
   if (!EVENT_VOCABULARY.has(args.event)) {
     process.stderr.write(
       `dispatch_hook: unknown event '${args.event}'; allowed: ${_sortedRepr(EVENT_VOCABULARY)}
@@ -34165,7 +34287,7 @@ function main58(argv) {
     return EXIT_ALLOW30;
   }
   const manifest_path = args.manifest;
-  if (!fs88.existsSync(manifest_path)) {
+  if (!fs87.existsSync(manifest_path)) {
     process.stderr.write(`dispatch_hook: manifest missing at ${manifest_path}
 `);
     return EXIT_ALLOW30;
@@ -34180,7 +34302,9 @@ function main58(argv) {
       );
     }
   }
-  const payload_text = tty2.isatty(0) ? "" : _readStdin14();
+  const read = tty2.isatty(0) ? { text: "", failure: null } : stdinReadFailure();
+  const payload_text = read.text;
+  _stdin_read_failed = read.failure;
   if (_stdin_read_failed !== null) {
     process.stderr.write(
       `dispatch_hook: STDIN READ FAILED (${_stdin_read_failed}) \u2014 the concern chain for '${args.event}' ran against an EMPTY payload and could not evaluate anything. This is not an empty stdin.
@@ -34217,6 +34341,15 @@ function main58(argv) {
   if (concerns.length === 0) {
     return EXIT_ALLOW30;
   }
+  if (_stdin_read_failed !== null) {
+    const deny = denyOnStdinFailure(args.platform, args.event, concerns, _stdin_read_failed);
+    if (deny !== null) {
+      const emission2 = emitFor(args.platform, args.event, "block", [deny.reason], EXIT_BLOCK6);
+      if (emission2.stdout) process.stdout.write(emission2.stdout);
+      if (emission2.stderr) process.stderr.write(emission2.stderr);
+      return emission2.exit;
+    }
+  }
   const envelope = _build_envelope(args, payload_text);
   const session_id = _resolve_session_id(envelope);
   const started_at = _now_iso3();
@@ -34321,7 +34454,7 @@ function main58(argv) {
 }
 function _isDir4(p) {
   try {
-    return fs88.statSync(p).isDirectory();
+    return fs87.statSync(p).isDirectory();
   } catch {
     return false;
   }
@@ -34331,14 +34464,6 @@ function _sortedRepr(s) {
   return `[${items.map((x) => `'${x}'`).join(", ")}]`;
 }
 var _stdin_read_failed = null;
-function _readStdin14() {
-  try {
-    return readFd0ToEnd();
-  } catch (exc) {
-    _stdin_read_failed = exc instanceof Error ? exc.message : String(exc);
-    return "";
-  }
-}
 function _isCliEntry48() {
   if (true) {
     return false;
@@ -34351,8 +34476,8 @@ function _isCliEntry48() {
     return true;
   }
   try {
-    const here = fs88.realpathSync(fileURLToPath59(import.meta.url));
-    const argv = fs88.realpathSync(path89.resolve(process.argv[1]));
+    const here = fs87.realpathSync(fileURLToPath59(import.meta.url));
+    const argv = fs87.realpathSync(path89.resolve(process.argv[1]));
     return here === argv;
   } catch {
     return false;