@event4u/agent-config 16.3.0 → 16.5.0

package/dist/cli-delegate/cmd_conformance.js

@@ -1,7 +1,11 @@
 import { createRequire as __acCreateRequire } from 'node:module'; const require = globalThis.require ?? __acCreateRequire(import.meta.url);
 import {
+  THIN_ENTRY_MARKER,
   readRecentEntries
-} from "./chunk-NYX3L2PZ.js";
+} from "./chunk-6YQC2HLF.js";
+import {
+  detectToolPresence
+} from "./chunk-A4QJ6ENT.js";
 import {
   NO_RED_EVIDENCE_REASON,
   deriveSessionKey,
@@ -9,9 +13,10 @@ import {
   foldRefusal,
   foldShadow,
   hasRedThenGreen,
+  isAssetRenderCommand,
   isCiPoll,
   isVacuousOutput,
-  isVerificationCommand,
+  isVerificationAttempt,
   parseRecord,
   parseShadowRecord,
   pendingCount,
@@ -23,10 +28,7 @@ import {
   shadowSetBy,
   statePathFor,
   validateAssumption
-} from "./chunk-NQ7WT43P.js";
-import {
-  readHookStdin
-} from "./chunk-F7DQWYR5.js";
+} from "./chunk-TMWYUOK4.js";
 import {
   LexicalIndex,
   isSqliteAvailableSync,
@@ -35,9 +37,6 @@ import {
   stampUserVersion,
   tokenize
 } from "./chunk-ZBZV2G5R.js";
-import {
-  detectToolPresence
-} from "./chunk-A4QJ6ENT.js";
 import {
   ArgparseExit,
   STATUS_SYMBOLS,
@@ -56,7 +55,7 @@ import {
   proseEqual,
   resolveSessionRole,
   splitFrontmatter
-} from "./chunk-TRI6DQZ6.js";
+} from "./chunk-5GPULQBE.js";
 import "./chunk-FTAISGDQ.js";
 import "./chunk-6V6TA25H.js";
 import "./chunk-ROYYTEZU.js";
@@ -64,12 +63,15 @@ import "./chunk-BTWUYDGN.js";
 import {
   atomicAppendLine,
   probeHostCapabilities
-} from "./chunk-S4YWNRKO.js";
+} from "./chunk-MDPPKQCQ.js";
+import "./chunk-DMSZHXZS.js";
 import "./chunk-ULQRUR23.js";
 import {
   hardenedSpawnEnv,
   projectStoreSlug
-} from "./chunk-EEHDXSYD.js";
+} from "./chunk-OAFSJBHH.js";
+import "./chunk-IAYTIIQW.js";
+import "./chunk-LQOCRFWT.js";
 import {
   atomic_write_json,
   atomic_write_text,
@@ -79,45 +81,48 @@ import {
   prune_legacy_state_file,
   prune_stale_session_states,
   session_state_file
-} from "./chunk-E4XIZDIB.js";
-import "./chunk-T7L2QK3K.js";
-import "./chunk-DMSZHXZS.js";
-import "./chunk-NXEILF2K.js";
+} from "./chunk-7HKRE54K.js";
+import "./chunk-F3QDG2GT.js";
 import "./chunk-DEIV7XP7.js";
-import "./chunk-KB5FZ655.js";
-import "./chunk-JQOM7TTM.js";
 import {
   manifest_path,
   read_manifest
 } from "./chunk-OKJUIAPS.js";
+import "./chunk-WQWXGIWB.js";
+import "./chunk-KB5FZ655.js";
 import "./chunk-MWRD5YOH.js";
+import "./chunk-JQOM7TTM.js";
 import {
   DeadScopeError,
   assertScanned,
   reportScanned
 } from "./chunk-I3EIN2YG.js";
+import {
+  readHookStdin
+} from "./chunk-F7DQWYR5.js";
 import {
   require_dist
 } from "./chunk-OY53J6II.js";
-import {
-  resolvePackageRoot
-} from "./chunk-MCJYCQPF.js";
+import "./chunk-LF2KKJ4Q.js";
 import {
   load_agent_settings
-} from "./chunk-JY2I2DXV.js";
-import "./chunk-NDJLNC6Q.js";
+} from "./chunk-H76PHZBI.js";
 import {
   artefact_roots
 } from "./chunk-YCU3TIXH.js";
+import "./chunk-T6BP34WI.js";
+import {
+  resolvePackageRoot
+} from "./chunk-MCJYCQPF.js";
 import {
   __toESM
 } from "./chunk-J55WI3RR.js";
 
 // src/scripts/_cli/cmd_conformance.ts
 var YAML = __toESM(require_dist(), 1);
-import * as fs20 from "node:fs";
+import * as fs21 from "node:fs";
 import * as os7 from "node:os";
-import * as path18 from "node:path";
+import * as path19 from "node:path";
 import process5 from "node:process";
 import { spawnSync as spawnSync4 } from "node:child_process";
 import { fileURLToPath as fileURLToPath14, pathToFileURL as pathToFileURL14 } from "node:url";
@@ -133,10 +138,10 @@ var ROUTE_TARGET_TEMPLATES = Object.freeze({
   ])
 });
 function parseRouteTarget(target) {
-  const sep3 = target.indexOf(":");
-  if (sep3 <= 0) return null;
-  const kind = target.slice(0, sep3);
-  const id = target.slice(sep3 + 1);
+  const sep5 = target.indexOf(":");
+  if (sep5 <= 0) return null;
+  const kind = target.slice(0, sep5);
+  const id = target.slice(sep5 + 1);
   if (!id) return null;
   if (!Object.prototype.hasOwnProperty.call(ROUTE_TARGET_TEMPLATES, kind)) return null;
   return { kind, id };
@@ -148,17 +153,17 @@ function routeTargetPathsPosix(target) {
 }
 
 // src/scripts/report_conformance_funnel.ts
-import * as fs19 from "node:fs";
+import * as fs20 from "node:fs";
 import * as os6 from "node:os";
-import * as path17 from "node:path";
+import * as path18 from "node:path";
 import process4 from "node:process";
 import { fileURLToPath as fileURLToPath13, pathToFileURL as pathToFileURL13 } from "node:url";
 
 // src/scripts/conformance_scan.ts
-import { createHash as createHash4 } from "node:crypto";
-import fs15 from "node:fs";
+import { createHash as createHash5 } from "node:crypto";
+import fs16 from "node:fs";
 import os2 from "node:os";
-import path13 from "node:path";
+import path14 from "node:path";
 import { fileURLToPath as fileURLToPath9, pathToFileURL as pathToFileURL9 } from "node:url";
 
 // src/scripts/_lib/transcript_entry.ts
@@ -1943,8 +1948,8 @@ var COMMAND_OBJECTS = {
 };
 
 // src/scripts/hooks/turn_end_gate_hook.ts
-import * as fs12 from "node:fs";
-import * as path10 from "node:path";
+import * as fs13 from "node:fs";
+import * as path11 from "node:path";
 import { fileURLToPath as fileURLToPath6, pathToFileURL as pathToFileURL6 } from "node:url";
 
 // src/scripts/check_reply_consistency.ts
@@ -2111,11 +2116,11 @@ function _rglobMdSorted(dir) {
   return out;
 }
 function _relToPosixOrAbs(child, root) {
-  const rel = path3.relative(root, child);
-  if (rel === "" || rel.startsWith("..") || path3.isAbsolute(rel)) {
+  const rel2 = path3.relative(root, child);
+  if (rel2 === "" || rel2.startsWith("..") || path3.isAbsolute(rel2)) {
     return child.split(path3.sep).join("/");
   }
-  return rel.split(path3.sep).join("/");
+  return rel2.split(path3.sep).join("/");
 }
 function cmd_scan_dir(root) {
   let roots;
@@ -2502,8 +2507,8 @@ function looksLikeGraph(p) {
 function detectSources(root, nativeCache) {
   const abs = path4.resolve(root);
   const out = [];
-  for (const rel of consumerCandidates(abs)) {
-    const p = path4.join(abs, rel);
+  for (const rel2 of consumerCandidates(abs)) {
+    const p = path4.join(abs, rel2);
     if (fs4.existsSync(p)) {
       const { ok, sha } = looksLikeGraph(p);
       if (ok) out.push({ kind: "consumer", path: p, present: true, ...freshness(abs, p, sha) });
@@ -3139,10 +3144,51 @@ function untested(g, files, state) {
 
 // src/scripts/_lib/graph_feeder_record.ts
 var MAX_PATHS = 5;
+var OUTSIDE_WORKSPACE = "<outside-workspace>";
 var MAX_ROWS_PER_SESSION = 200;
 function feederFile(workspaceRoot, sessionKey) {
   return path6.join(workspaceRoot, "agents", "state", "graph-feeder", `${sessionKey}.jsonl`);
 }
+function toRepoRelative(root, paths) {
+  let realRoot = null;
+  return paths.map((p) => {
+    if (!path6.isAbsolute(p)) return p;
+    const raw = _relativeInside(root, p);
+    if (raw !== null) return raw;
+    realRoot ??= _resolveReal(root);
+    return _relativeInside(realRoot, _resolveReal(p)) ?? p;
+  });
+}
+function _relativeInside(from, to) {
+  let rel2;
+  try {
+    rel2 = path6.relative(from, to);
+  } catch {
+    return null;
+  }
+  if (rel2 === "") return ".";
+  if (rel2 === ".." || rel2.startsWith(`..${path6.sep}`) || path6.isAbsolute(rel2)) return null;
+  return rel2.split(path6.sep).join("/");
+}
+function _resolveReal(p) {
+  const abs = path6.resolve(p);
+  const tail = [];
+  let cur = abs;
+  for (; ; ) {
+    try {
+      const real = fs7.realpathSync(cur);
+      return tail.length === 0 ? real : path6.join(real, ...[...tail].reverse());
+    } catch {
+      const parent = path6.dirname(cur);
+      if (parent === cur) return abs;
+      tail.push(path6.basename(cur));
+      cur = parent;
+    }
+  }
+}
+function _escapesWorkspace(p) {
+  return path6.isAbsolute(p) || path6.win32.isAbsolute(p) || p === ".." || p.startsWith("../") || p.startsWith(`..${path6.sep}`);
+}
 function graphUntestedVerdict(root, state, paths) {
   const none = { verdict: null, untested: 0, tested: 0 };
   if (state !== "fresh" && state !== "edited") return none;
@@ -3161,7 +3207,7 @@ function graphUntestedVerdict(root, state, paths) {
     return none;
   }
   try {
-    const r = untested(g, paths, state);
+    const r = untested(g, toRepoRelative(root, paths), state);
     if (r.seeds.length === 0) return { verdict: "no-seeds", untested: 0, tested: 0 };
     return {
       verdict: r.untested.length > 0 ? "untested" : "tested",
@@ -3203,11 +3249,215 @@ function buildFeederRow(input) {
     graph: input.graph.verdict,
     graph_untested: input.graph.untested,
     graph_tested: input.graph.tested,
-    paths: input.paths.slice(0, MAX_PATHS).map((p) => p),
+    // An out-of-workspace edit is REDACTED, not dropped and not stored
+    // verbatim. After relativising, a still-absolute path is exactly one
+    // that lay outside the root.
+    //
+    // Verbatim is an egress surface: `paths` is handed to external council
+    // seats at step 3.3's labelling, and a home-rooted path names a real
+    // user and an unrelated project.
+    //
+    // Dropping it looked right and was worse, which a completion review
+    // caught before it shipped. It would have shortened `paths` below
+    // `path_count` and so reused the protocol's truncation signal for a
+    // second, different cause — two meanings on one wire, with no field
+    // separating them. Worse, a turn editing one in-repo file and one file
+    // outside the root would then be excluded from labelling altogether,
+    // losing a perfectly labellable in-repo path from a corpus that is
+    // blocked precisely for want of rows.
+    //
+    // The marker keeps the lengths equal, so truncation stays the only
+    // cause of `path_count > paths.length`; keeps the row honest that an
+    // edit happened outside the tree, so a labeller can answer
+    // `cannot tell` rather than be silently misled; and carries nothing
+    // identifying. The graph's answer is unchanged either way — the probe
+    // sees the real path and resolves no seeds for it.
+    paths: toRepoRelative(input.root, input.paths.slice(0, MAX_PATHS)).map(
+      (p) => _escapesWorkspace(p) ? OUTSIDE_WORKSPACE : p
+    ),
     path_count: input.paths.length
   };
 }
 
+// src/scripts/hooks/svg_obligation.ts
+import * as crypto from "node:crypto";
+import * as fs8 from "node:fs";
+import * as path7 from "node:path";
+var EDIT_TOOLS = /* @__PURE__ */ new Set(["Edit", "Write", "MultiEdit", "NotebookEdit"]);
+var RENDER_REL = path7.join("agents", "runtime", "state", "render");
+var PLANTED_PREFIXES = [
+  "tests/design-artifacts/fixtures/",
+  "tests/design-artifacts/scenarios/"
+];
+function hasErrorFinding(m) {
+  const f = m.asset?.findings;
+  return Array.isArray(f) && f.some((x) => x?.severity === "error");
+}
+var rel = (root, p) => {
+  const slashed = p.split(path7.sep).join("/");
+  if (!path7.isAbsolute(p)) return path7.posix.normalize(slashed).replace(/^\.\//, "");
+  const inside = path7.relative(root, p).split(path7.sep).join("/");
+  return inside === "" || inside.startsWith("../") ? slashed : inside;
+};
+function isPlantedFixture(relPath, root = "") {
+  const norm = rel(root, relPath);
+  return PLANTED_PREFIXES.some((prefix) => norm.startsWith(prefix));
+}
+function readAssetManifests(root) {
+  const dir = path7.join(root, RENDER_REL);
+  let entries;
+  try {
+    entries = fs8.readdirSync(dir);
+  } catch {
+    return [];
+  }
+  const out = [];
+  for (const name of entries) {
+    let raw;
+    try {
+      raw = fs8.readFileSync(path7.join(dir, name, "manifest.json"), "utf8");
+    } catch {
+      continue;
+    }
+    try {
+      const parsed = JSON.parse(raw);
+      if (parsed.profile === "asset") out.push(parsed);
+    } catch {
+    }
+  }
+  return out;
+}
+function dischargeFor(manifests, digest) {
+  let staticOnly = false;
+  for (const m of manifests) {
+    if (m.verification === "verified" && m.asset?.digest === digest && !hasErrorFinding(m)) {
+      return "verified";
+    }
+    if (m.reason === "renderer-absent" && m.static?.digest === digest && m.static.errors === 0) {
+      staticOnly = true;
+    }
+  }
+  return staticOnly ? "static-only" : null;
+}
+function readSvgObligations(root, inputs) {
+  const open = [];
+  const discharged = [];
+  const seen = /* @__PURE__ */ new Set();
+  let manifests = null;
+  for (const { path: raw, rendered } of inputs.edits) {
+    if (!/\.svg$/i.test(raw)) continue;
+    const relPath = rel(root, raw);
+    if (seen.has(relPath)) continue;
+    seen.add(relPath);
+    if (isPlantedFixture(relPath, root)) continue;
+    const abs = path7.isAbsolute(raw) ? raw : path7.join(root, relPath);
+    let bytes;
+    try {
+      bytes = fs8.readFileSync(abs);
+    } catch {
+      continue;
+    }
+    const digest = crypto.createHash("sha256").update(bytes).digest("hex");
+    if (!renderNames(rendered, relPath)) {
+      open.push({
+        file: relPath,
+        reason: "no `ui:render --profile asset` naming this file ran after THIS file's last edit, so no manifest on disk can be attributed to it \u2014 a manifest written by any other route, and a render of some other file, both discharge nothing"
+      });
+      continue;
+    }
+    if (inputs.renderDirTampered) {
+      open.push({
+        file: relPath,
+        reason: "this turn wrote into the render directory by a route other than `ui:render`, so no manifest there is evidence of a render \u2014 re-run the render in a turn that does not touch it"
+      });
+      continue;
+    }
+    manifests ??= readAssetManifests(root);
+    const kind = dischargeFor(manifests, digest);
+    if (kind === null) {
+      open.push({
+        file: relPath,
+        reason: "no asset manifest matches this file's current digest \u2014 a render that is `verified`, or a `renderer-absent` one whose static witness reports 0 errors on the same digest, discharges it"
+      });
+      continue;
+    }
+    discharged.push({ file: relPath, kind });
+  }
+  return { open, discharged };
+}
+function renderNames(commands, relPath) {
+  const base = relPath.split("/").pop() ?? relPath;
+  return commands.some((c) => {
+    const slashed = c.split(path7.sep).join("/");
+    const bounded = (needle) => new RegExp(`(^|[\\s/'"])${escapeRe(needle)}(\\s|$|['"])`).test(slashed);
+    return bounded(relPath) || bounded(base);
+  });
+}
+function isPureRender(command) {
+  if (!isAssetRenderCommand(command)) return false;
+  const [head, ...pipes] = command.replace(/^\s*cd\s+[^;&|<>`$\n]+&&\s*/, "").replace(/\s\d?>&\d\b/g, " ").replace(/\s2>\s*\/dev\/null\b/g, " ").split("|");
+  if (/[;&<>`\n]|\$\(/.test(head ?? "")) return false;
+  return pipes.every((p) => /^\s*(tail|head|grep|jq|cat|less|wc)\b[^;&<>`|]*$/.test(p) && !/\$\(/.test(p));
+}
+function writesRenderDir(command) {
+  if (isPureRender(command)) return false;
+  const slashed = command.split(path7.sep).join("/");
+  const names = /(^|[\s/'"])(render\/|manifest\.json\b)/.test(slashed) || slashed.includes("state/render");
+  const writes = />(?!&)|\b(tee|sponge)\b|\b(cp|mv|ln|install|rsync|dd)\s|\bsed\s+-i|\bwriteFile|\b(python[\d.]*|perl|ruby|node|deno|bun|php|osascript)\b/.test(
+    slashed.replace(/\s\d?>&\d\b/g, " ").replace(/\s2>\s*\/dev\/null\b/g, " ")
+  );
+  return names && writes;
+}
+function escapeRe(s) {
+  return s.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}
+function openSvgObligation(workspaceRoot, toolCalls) {
+  const lastEditOf = /* @__PURE__ */ new Map();
+  for (let i = 0; i < toolCalls.length; i += 1) {
+    const c = toolCalls[i];
+    if (!EDIT_TOOLS.has(c.name) || c.path === void 0) continue;
+    lastEditOf.set(c.path, i);
+  }
+  if (lastEditOf.size === 0) return null;
+  const edits = [...lastEditOf].map(([p, at]) => {
+    const rendered = [];
+    for (let i = at + 1; i < toolCalls.length; i += 1) {
+      const c = toolCalls[i];
+      if (c.name === "Bash" && c.command !== void 0 && isPureRender(c.command)) {
+        rendered.push(c.command);
+      }
+    }
+    return { path: p, rendered };
+  });
+  const renderDir = RENDER_REL.split(path7.sep).join("/");
+  const renderDirTampered = toolCalls.some((c) => {
+    if (EDIT_TOOLS.has(c.name) && c.path !== void 0) {
+      return rel(workspaceRoot, c.path).startsWith(`${renderDir}/`);
+    }
+    return c.name === "Bash" && c.command !== void 0 && writesRenderDir(c.command);
+  });
+  let reading;
+  try {
+    reading = readSvgObligations(workspaceRoot, { edits, renderDirTampered });
+  } catch {
+    return null;
+  }
+  const first = reading.open[0];
+  if (first === void 0) return null;
+  const more = reading.open.length > 1 ? ` (and ${String(reading.open.length - 1)} more)` : "";
+  return {
+    // Reported under `verification` rather than a seventh detector id: it
+    // IS a verification finding — a file changed and nothing that can fail
+    // ran over it — and a new id would ripple through DETECTOR_IDS, the
+    // per-detector counters and the demotion contract for a distinction the
+    // operator never makes.
+    detector: "verification",
+    mode: "transcript",
+    evidence: first.file,
+    reason: `this turn edited an .svg and no render describes it${more} \u2014 ${first.reason}. A bare \`ui:render --profile asset\` that rendered nothing, and a test or lint run over other files, both discharge nothing: the gate reads the render, never the call.`
+  };
+}
+
 // src/scripts/hooks/envelope.ts
 var ENVELOPE_KEYS = [
   "schema_version",
@@ -3263,9 +3513,9 @@ function unwrap(stdin_text, default_platform = "generic") {
 }
 
 // src/scripts/hooks/subagent_ledger_hook.ts
-import * as crypto from "node:crypto";
-import * as fs8 from "node:fs";
-import * as path7 from "node:path";
+import * as crypto2 from "node:crypto";
+import * as fs9 from "node:fs";
+import * as path8 from "node:path";
 import { fileURLToPath as fileURLToPath4, pathToFileURL as pathToFileURL4 } from "node:url";
 
 // src/scripts/_lib/subagent_response.ts
@@ -3407,11 +3657,11 @@ var EXIT_CODES = Object.freeze([
 function isObject2(v) {
   return typeof v === "object" && v !== null && !Array.isArray(v);
 }
-var LEDGER_DIR = path7.join("agents", "runtime", "state", "subagent-ledger");
+var LEDGER_DIR = path8.join("agents", "runtime", "state", "subagent-ledger");
 var OPEN_SUBDIR = "open";
 var OPEN_RECORD_TTL_MS = 24 * 60 * 60 * 1e3;
 function refFor(agentId) {
-  return crypto.createHash("sha256").update(agentId, "utf8").digest("hex").slice(0, 12);
+  return crypto2.createHash("sha256").update(agentId, "utf8").digest("hex").slice(0, 12);
 }
 function unwrapPayload(envelope) {
   const inner = envelope["payload"];
@@ -3497,10 +3747,10 @@ function _jsonObjectCandidates(message) {
   return out;
 }
 function openDir(root) {
-  return path7.join(root, LEDGER_DIR, OPEN_SUBDIR);
+  return path8.join(root, LEDGER_DIR, OPEN_SUBDIR);
 }
 function openFile(root, ref) {
-  return path7.join(openDir(root), `${ref}.json`);
+  return path8.join(openDir(root), `${ref}.json`);
 }
 var DEPTH_BASES = /* @__PURE__ */ new Set(["observed", "asserted-parent", "assumed-root"]);
 function _asOpenRecord(value, expectedRef) {
@@ -3527,7 +3777,7 @@ function readOpenRecords(root) {
   const out = /* @__PURE__ */ new Map();
   let names;
   try {
-    names = fs8.readdirSync(openDir(root));
+    names = fs9.readdirSync(openDir(root));
   } catch {
     return out;
   }
@@ -3535,7 +3785,7 @@ function readOpenRecords(root) {
     if (!name.endsWith(".json")) continue;
     const expectedRef = name.slice(0, -".json".length);
     try {
-      const raw = fs8.readFileSync(path7.join(openDir(root), name), "utf8");
+      const raw = fs9.readFileSync(path8.join(openDir(root), name), "utf8");
       const rec = _asOpenRecord(JSON.parse(raw), expectedRef);
       if (rec) out.set(rec.ref, rec);
     } catch {
@@ -3550,13 +3800,13 @@ function resolveDepth(parentRef, open) {
   return { depth: parent.depth + 1, depth_basis: "observed" };
 }
 function ledgerFileFor2(root, ts) {
-  return path7.join(root, LEDGER_DIR, `${ts.slice(0, 7)}.jsonl`);
+  return path8.join(root, LEDGER_DIR, `${ts.slice(0, 7)}.jsonl`);
 }
 function appendLedgerLine(root, ts, line) {
   if (is_replay_mode()) return;
   const file = ledgerFileFor2(root, ts);
-  fs8.mkdirSync(path7.dirname(file), { recursive: true });
-  fs8.appendFileSync(file, `${JSON.stringify(line)}
+  fs9.mkdirSync(path8.dirname(file), { recursive: true });
+  fs9.appendFileSync(file, `${JSON.stringify(line)}
 `, "utf8");
 }
 var WALL_CLOCK_ARMS_MS = [
@@ -3570,7 +3820,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 = fs8.existsSync(path7.join(root, LEDGER_DIR));
+  const ledgerPresent = fs9.existsSync(path8.join(root, LEDGER_DIR));
   const open = readOpenRecords(root);
   let maxDepth = 0;
   let counted = 0;
@@ -3598,13 +3848,13 @@ function writeOpenRecord(root, rec) {
 function removeOpenRecord(root, ref) {
   if (is_replay_mode()) return;
   try {
-    fs8.unlinkSync(openFile(root, ref));
+    fs9.unlinkSync(openFile(root, ref));
   } catch {
   }
 }
 function countOpen(root) {
   try {
-    return fs8.readdirSync(openDir(root)).filter((n) => n.endsWith(".json")).length;
+    return fs9.readdirSync(openDir(root)).filter((n) => n.endsWith(".json")).length;
   } catch {
     return 0;
   }
@@ -3770,10 +4020,10 @@ function _isCliEntry4() {
     return false;
   }
   if (process.argv[1] === void 0) return false;
-  const argvUrl = pathToFileURL4(path7.resolve(process.argv[1])).href;
+  const argvUrl = pathToFileURL4(path8.resolve(process.argv[1])).href;
   if (import.meta.url === argvUrl) return true;
   try {
-    return fs8.realpathSync(fileURLToPath4(import.meta.url)) === fs8.realpathSync(path7.resolve(process.argv[1]));
+    return fs9.realpathSync(fileURLToPath4(import.meta.url)) === fs9.realpathSync(path8.resolve(process.argv[1]));
   } catch {
     return false;
   }
@@ -3781,20 +4031,20 @@ function _isCliEntry4() {
 if (_isCliEntry4()) process.exit(main4());
 
 // src/scripts/_lib/turn_end_transcript.ts
-import * as fs11 from "node:fs";
+import * as fs12 from "node:fs";
 
 // src/scripts/hooks/end_review_nudge_hook.ts
 import { spawnSync as spawnSync2 } from "node:child_process";
-import * as crypto2 from "node:crypto";
-import * as fs10 from "node:fs";
+import * as crypto3 from "node:crypto";
+import * as fs11 from "node:fs";
 import * as os from "node:os";
-import * as path9 from "node:path";
+import * as path10 from "node:path";
 import { fileURLToPath as fileURLToPath5, pathToFileURL as pathToFileURL5 } from "node:url";
 
 // src/scripts/_lib/review_baseline.ts
 import { spawnSync } from "node:child_process";
-import * as fs9 from "node:fs";
-import * as path8 from "node:path";
+import * as fs10 from "node:fs";
+import * as path9 from "node:path";
 function currentHeadSha(cwd) {
   try {
     const r = spawnSync("git", ["rev-parse", "HEAD"], { cwd, encoding: "utf8" });
@@ -3805,12 +4055,12 @@ function currentHeadSha(cwd) {
     return null;
   }
 }
-var BASELINE_STATE_REL = path8.join("agents", "runtime", "state", "review-baseline");
+var BASELINE_STATE_REL = path9.join("agents", "runtime", "state", "review-baseline");
 function baselineStateDir(workspaceRoot) {
-  return path8.join(workspaceRoot, BASELINE_STATE_REL);
+  return path9.join(workspaceRoot, BASELINE_STATE_REL);
 }
 function baselineStateFile(workspaceRoot, sessionKey) {
-  return path8.join(baselineStateDir(workspaceRoot), `${sessionKey}.json`);
+  return path9.join(baselineStateDir(workspaceRoot), `${sessionKey}.json`);
 }
 function parseBaseline(raw) {
   let decoded;
@@ -3838,7 +4088,7 @@ function readBaseline(workspaceRoot, sessionKey) {
   const file = baselineStateFile(workspaceRoot, sessionKey);
   let raw;
   try {
-    raw = fs9.readFileSync(file, "utf-8");
+    raw = fs10.readFileSync(file, "utf-8");
   } catch (exc) {
     const code = exc?.code;
     return code === "ENOENT" ? "absent" : "unreadable";
@@ -3948,13 +4198,13 @@ function isSafeTranscriptPath(rawPath, opts = {}) {
   const homeDir = opts.homeDir ?? os.homedir();
   const maxBytes = opts.maxBytes ?? TRANSCRIPT_SCAN_MAX_BYTES;
   try {
-    const realHome = fs10.realpathSync(homeDir);
-    const realPath = fs10.realpathSync(rawPath);
-    const relative5 = path9.relative(realHome, realPath);
-    if (relative5 === "" || relative5.startsWith("..") || path9.isAbsolute(relative5)) {
+    const realHome = fs11.realpathSync(homeDir);
+    const realPath = fs11.realpathSync(rawPath);
+    const relative6 = path10.relative(realHome, realPath);
+    if (relative6 === "" || relative6.startsWith("..") || path10.isAbsolute(relative6)) {
       return false;
     }
-    const { size } = fs10.statSync(realPath);
+    const { size } = fs11.statSync(realPath);
     return size <= maxBytes;
   } catch {
     return false;
@@ -4012,13 +4262,13 @@ var BINARY_PROBE_BYTES = 8e3;
 var UNTRACKED_FILE_READ_CAP_BYTES = 8 * 1024 * 1024;
 function untrackedFileLineCount(cwd, relPath) {
   try {
-    const abs = path9.resolve(cwd, relPath);
-    const size = fs10.statSync(abs).size;
+    const abs = path10.resolve(cwd, relPath);
+    const size = fs11.statSync(abs).size;
     if (size === 0) return 0;
     if (size > UNTRACKED_FILE_READ_CAP_BYTES) {
       return MUTATION_LINE_THRESHOLD + 1;
     }
-    const buf = fs10.readFileSync(abs);
+    const buf = fs11.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;
@@ -4104,33 +4354,33 @@ function appendReviewSkippedTelemetry(workspaceRoot, diffLines, mutationMeasure,
     diff_lines: diffLines,
     mutation_measure: mutationMeasure,
     ts,
-    id: crypto2.randomUUID(),
+    id: crypto3.randomUUID(),
     baseline
   });
   if (errors.length || line === null) return;
   try {
-    const dir = path9.join(workspaceRoot, "agents", "runtime", "state", "audit");
-    fs10.mkdirSync(dir, { recursive: true });
-    const file = path9.join(dir, `${ts.slice(0, 7)}.jsonl`);
-    fs10.appendFileSync(file, `${JSON.stringify(line)}
+    const dir = path10.join(workspaceRoot, "agents", "runtime", "state", "audit");
+    fs11.mkdirSync(dir, { recursive: true });
+    const file = path10.join(dir, `${ts.slice(0, 7)}.jsonl`);
+    fs11.appendFileSync(file, `${JSON.stringify(line)}
 `, "utf8");
   } catch {
   }
 }
 function sessionStateDir(workspaceRoot) {
-  return path9.join(workspaceRoot, "agents", "runtime", "state", "end-review-nudge");
+  return path10.join(workspaceRoot, "agents", "runtime", "state", "end-review-nudge");
 }
 function sessionStateFile(workspaceRoot, sessionKey) {
-  return path9.join(sessionStateDir(workspaceRoot), `${sessionKey}.json`);
+  return path10.join(sessionStateDir(workspaceRoot), `${sessionKey}.json`);
 }
 function deriveSessionKey2(envelope, payload) {
   const raw = str2(envelope["session_id"]) || str2(payload["transcript_path"] ?? payload["transcriptPath"]);
   const material = raw || "unknown-session";
-  return crypto2.createHash("sha256").update(material).digest("hex");
+  return crypto3.createHash("sha256").update(material).digest("hex");
 }
 function hasFiredThisSession(workspaceRoot, sessionKey) {
   try {
-    return fs10.existsSync(sessionStateFile(workspaceRoot, sessionKey));
+    return fs11.existsSync(sessionStateFile(workspaceRoot, sessionKey));
   } catch {
     return false;
   }
@@ -4192,7 +4442,7 @@ function main5() {
   let reviewerRan = false;
   if (transcriptPath && isSafeTranscriptPath(transcriptPath)) {
     try {
-      reviewerRan = scanTranscriptForReviewer(fs10.readFileSync(transcriptPath, "utf-8"));
+      reviewerRan = scanTranscriptForReviewer(fs11.readFileSync(transcriptPath, "utf-8"));
     } catch {
       reviewerRan = false;
     }
@@ -4227,13 +4477,13 @@ function _isCliEntry5() {
   if (process.argv[1] === void 0) {
     return false;
   }
-  const argvUrl = pathToFileURL5(path9.resolve(process.argv[1])).href;
+  const argvUrl = pathToFileURL5(path10.resolve(process.argv[1])).href;
   if (import.meta.url === argvUrl) {
     return true;
   }
   try {
-    const here = fs10.realpathSync(fileURLToPath5(import.meta.url));
-    const argv = fs10.realpathSync(path9.resolve(process.argv[1]));
+    const here = fs11.realpathSync(fileURLToPath5(import.meta.url));
+    const argv = fs11.realpathSync(path10.resolve(process.argv[1]));
     return here === argv;
   } catch {
     return false;
@@ -4254,10 +4504,10 @@ function readTranscriptTail(transcriptPath, opts = {}) {
   if (!transcriptPath || !isSafeTranscriptPath(transcriptPath, opts)) return empty;
   let lines;
   try {
-    if (opts.maxBytes !== void 0 && fs11.statSync(transcriptPath).size > opts.maxBytes) {
+    if (opts.maxBytes !== void 0 && fs12.statSync(transcriptPath).size > opts.maxBytes) {
       return empty;
     }
-    lines = fs11.readFileSync(transcriptPath, "utf-8").split("\n");
+    lines = fs12.readFileSync(transcriptPath, "utf-8").split("\n");
   } catch {
     return empty;
   }
@@ -4444,7 +4694,7 @@ function detectPromissory(reply) {
 function readCiSettled(workspaceRoot, session_id) {
   if (!hasStableSessionId(session_id)) return { seen: false, settled: false };
   try {
-    const raw = fs12.readFileSync(path10.join(workspaceRoot, statePathFor(session_id)), "utf-8");
+    const raw = fs13.readFileSync(path11.join(workspaceRoot, 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)) {
@@ -4480,8 +4730,8 @@ function detectCompletionClaim(reply, ci) {
 function readLanguagePin(workspaceRoot, session_id) {
   if (!hasStableSessionId(session_id)) return "und";
   try {
-    const raw = fs12.readFileSync(
-      path10.join(workspaceRoot, statePathFor2(session_id)),
+    const raw = fs13.readFileSync(
+      path11.join(workspaceRoot, statePathFor2(session_id)),
       "utf-8"
     );
     const decoded = JSON.parse(raw);
@@ -4528,7 +4778,7 @@ function detectUnverifiedEdit(toolCalls, runState = null) {
   }
   for (let i = lastEdit + 1; i < toolCalls.length; i += 1) {
     const c = toolCalls[i];
-    if (c.name === "Bash" && c.command !== void 0 && isVerificationCommand(c.command)) {
+    if (c.name === "Bash" && c.command !== void 0 && isVerificationAttempt(c.command)) {
       return null;
     }
   }
@@ -4537,7 +4787,7 @@ function detectUnverifiedEdit(toolCalls, runState = null) {
     // The path, never the diff: the evidence span is quoted into a refusal,
     // and `ToolCall` is shaped so a file body cannot reach it.
     evidence: edited,
-    reason: "this turn changed a file and then ran no verification command \u2014 no test, type-check, lint or build call follows the last edit (verify-before-complete: a claim without a fresh run is unverified)",
+    reason: "this turn changed a file and then ran no verification command \u2014 no test, type-check, lint, build or asset render follows the last edit (verify-before-complete: a claim without a fresh run is unverified)",
     mode: "transcript"
   };
 }
@@ -4590,7 +4840,7 @@ function sessionStateFile2(workspaceRoot, sessionKey) {
 }
 function alreadyRefusedTurn(workspaceRoot, sessionKey, turnOrdinal) {
   try {
-    const raw = fs12.readFileSync(sessionStateFile2(workspaceRoot, sessionKey), "utf-8");
+    const raw = fs13.readFileSync(sessionStateFile2(workspaceRoot, sessionKey), "utf-8");
     const decoded = JSON.parse(raw);
     if (typeof decoded === "object" && decoded !== null && !Array.isArray(decoded)) {
       return decoded["refused_turn"] === turnOrdinal;
@@ -4604,7 +4854,7 @@ function markRefusedTurn(workspaceRoot, sessionKey, turnOrdinal, detectors, prom
   const file = sessionStateFile2(workspaceRoot, sessionKey);
   let prev = null;
   try {
-    prev = parseRecord(fs12.readFileSync(file, "utf-8"));
+    prev = parseRecord(fs13.readFileSync(file, "utf-8"));
   } catch {
   }
   let version;
@@ -4701,6 +4951,7 @@ function runDetectors(inputs) {
     // on a completion CLAIM, and a turn waiting on a subagent has not
     // finished — so its closing is not the claim F is about. Same slot,
     // opposite trigger, opposite treatment of `dispatchOpen`.
+    openSvgObligation(workspaceRoot, toolCalls),
     dispatchOpen ? null : detectUntestedChange(lastAssistant, toolCalls, runState)
   ]) {
     if (f) findings.push(f);
@@ -4723,6 +4974,7 @@ function recordGraphFeeder(inputs, findings, layer) {
       inputs.workspaceRoot,
       inputs.sessionKey,
       buildFeederRow({
+        root: inputs.workspaceRoot,
         turn: inputs.turnOrdinal,
         layer,
         state,
@@ -4744,7 +4996,7 @@ function recordShadow(inputs, layer) {
     const file = sessionShadowFile(inputs.workspaceRoot, inputs.sessionKey);
     let prev = null;
     try {
-      prev = parseShadowRecord(fs12.readFileSync(file, "utf-8"));
+      prev = parseShadowRecord(fs13.readFileSync(file, "utf-8"));
     } catch {
     }
     atomic_write_json(
@@ -4812,13 +5064,13 @@ function _isCliEntry6() {
   if (process.argv[1] === void 0) {
     return false;
   }
-  const argvUrl = pathToFileURL6(path10.resolve(process.argv[1])).href;
+  const argvUrl = pathToFileURL6(path11.resolve(process.argv[1])).href;
   if (import.meta.url === argvUrl) {
     return true;
   }
   try {
-    const here = fs12.realpathSync(fileURLToPath6(import.meta.url));
-    const argv = fs12.realpathSync(path10.resolve(process.argv[1]));
+    const here = fs13.realpathSync(fileURLToPath6(import.meta.url));
+    const argv = fs13.realpathSync(path11.resolve(process.argv[1]));
     return here === argv;
   } catch {
     return false;
@@ -4830,9 +5082,9 @@ if (_isCliEntry6()) {
 
 // src/scripts/hooks/evidence_independence.ts
 import { spawnSync as spawnSync3 } from "node:child_process";
-import crypto3 from "node:crypto";
-import fs13 from "node:fs";
-import path11 from "node:path";
+import crypto4 from "node:crypto";
+import fs14 from "node:fs";
+import path12 from "node:path";
 import { fileURLToPath as fileURLToPath7, pathToFileURL as pathToFileURL7 } from "node:url";
 
 // src/scripts/_lib/test_delta.ts
@@ -4851,7 +5103,7 @@ function isTestPath(p) {
 }
 
 // src/scripts/hooks/evidence_independence.ts
-var STATE_FILE3 = path11.join("agents", "state", "evidence-dispatch.json");
+var STATE_FILE3 = path12.join("agents", "state", "evidence-dispatch.json");
 function _isObject5(v) {
   return typeof v === "object" && v !== null && !Array.isArray(v);
 }
@@ -4917,10 +5169,10 @@ function extractDispatch(envelope) {
   }
   return [tool, ""];
 }
-function _ledgerStamp(consumer_root) {
+function _ledgerStamp(consumer_root, session_id) {
   try {
-    const raw = fs13.readFileSync(
-      path11.join(consumer_root, "agents", "state", "git-authorization.json"),
+    const raw = fs14.readFileSync(
+      path12.join(consumer_root, ledgerFileFor(session_id)),
       "utf8"
     );
     const d = JSON.parse(raw);
@@ -4931,7 +5183,7 @@ function _ledgerStamp(consumer_root) {
 }
 function _load(target) {
   try {
-    const decoded = JSON.parse(fs13.readFileSync(target, "utf8"));
+    const decoded = JSON.parse(fs14.readFileSync(target, "utf8"));
     if (_isObject5(decoded) && Array.isArray(decoded["evaluations"])) {
       return decoded;
     }
@@ -5015,10 +5267,10 @@ function run3(stdin_text, options) {
       return EXIT_ALLOW3;
     }
   }
-  const target = path11.join(options.consumer_root, STATE_FILE3);
+  const target = path12.join(options.consumer_root, STATE_FILE3);
   const state = _load(target);
   const session_id = typeof envelope["session_id"] === "string" ? envelope["session_id"] : "";
-  const turnMarker = `${session_id}:${_ledgerStamp(options.consumer_root)}`;
+  const turnMarker = `${session_id}:${_ledgerStamp(options.consumer_root, session_id)}`;
   if (state.session_id !== turnMarker) {
     state.session_id = turnMarker;
     state.turn_started_at = (/* @__PURE__ */ new Date()).toISOString();
@@ -5038,7 +5290,7 @@ function run3(stdin_text, options) {
   if (decision.evaluations > state.evaluations.length) {
     state.evaluations.push({
       at: (/* @__PURE__ */ new Date()).toISOString(),
-      digest: crypto3.createHash("sha256").update(prompt).digest("hex").slice(0, 16),
+      digest: crypto4.createHash("sha256").update(prompt).digest("hex").slice(0, 16),
       prompt_chars: prompt.length
     });
     try {
@@ -5083,13 +5335,13 @@ function _isCliEntry7() {
   if (process.argv[1] === void 0) {
     return false;
   }
-  const argvUrl = pathToFileURL7(path11.resolve(process.argv[1])).href;
+  const argvUrl = pathToFileURL7(path12.resolve(process.argv[1])).href;
   if (import.meta.url === argvUrl) {
     return true;
   }
   try {
-    const here = fs13.realpathSync(fileURLToPath7(import.meta.url));
-    const argv = fs13.realpathSync(path11.resolve(process.argv[1]));
+    const here = fs14.realpathSync(fileURLToPath7(import.meta.url));
+    const argv = fs14.realpathSync(path12.resolve(process.argv[1]));
     return here === argv;
   } catch {
     return false;
@@ -5100,8 +5352,8 @@ if (_isCliEntry7()) {
 }
 
 // src/scripts/hooks/delegation_nudge_hook.ts
-import fs14 from "node:fs";
-import path12 from "node:path";
+import fs15 from "node:fs";
+import path13 from "node:path";
 import { fileURLToPath as fileURLToPath8, pathToFileURL as pathToFileURL8 } from "node:url";
 
 // src/scripts/_lib/auto_dispatch.ts
@@ -5465,11 +5717,10 @@ function resolveActivation(workspace_root, hostId) {
   const emergency = settings["emergency"] ?? {};
   const halted = emergency["orchestration_halt"] === true;
   const host_manifest = probeHostCapabilities(hostId);
-  const sub = settings["subagents"] ?? {};
-  const downshift = sub["downshift"] !== false;
   return {
     activation: { halted, subagent_spawn: host_manifest.subagent_spawn },
-    downshift,
+    // Fixed on: the `subagents.downshift` key was retired with this default.
+    downshift: true,
     separate_quota_pool: host_manifest.separate_quota_pool,
     agentTeams: host_manifest.agent_teams
   };
@@ -5601,13 +5852,13 @@ function _isCliEntry8() {
   if (process.argv[1] === void 0) {
     return false;
   }
-  const argvUrl = pathToFileURL8(path12.resolve(process.argv[1])).href;
+  const argvUrl = pathToFileURL8(path13.resolve(process.argv[1])).href;
   if (import.meta.url === argvUrl) {
     return true;
   }
   try {
-    const here = fs14.realpathSync(fileURLToPath8(import.meta.url));
-    const argv = fs14.realpathSync(path12.resolve(process.argv[1]));
+    const here = fs15.realpathSync(fileURLToPath8(import.meta.url));
+    const argv = fs15.realpathSync(path13.resolve(process.argv[1]));
     return here === argv;
   } catch {
     return false;
@@ -5618,7 +5869,7 @@ if (_isCliEntry8()) {
 }
 
 // src/scripts/conformance_scan.ts
-var REPO_ROOT = path13.resolve(path13.dirname(fileURLToPath9(import.meta.url)), "..", "..");
+var REPO_ROOT = path14.resolve(path14.dirname(fileURLToPath9(import.meta.url)), "..", "..");
 var OBSERVED_BAND = { low: 9.1, high: 39.2 };
 var BAND_MIN_TURNS = 1978;
 var CARRIER_CHANGES = [
@@ -5984,7 +6235,7 @@ function scanSession(sessionId, lines) {
   closeWindow();
   return report;
 }
-var DEFAULT_RATE_SERIES = path13.join(
+var DEFAULT_RATE_SERIES = path14.join(
   REPO_ROOT,
   "agents",
   "runtime",
@@ -5993,7 +6244,7 @@ var DEFAULT_RATE_SERIES = path13.join(
 );
 function defaultStore(projectDir) {
   const slug = projectStoreSlug(projectDir);
-  return path13.join(process.env["HOME"] ?? "", ".claude", "projects", slug);
+  return path14.join(process.env["HOME"] ?? "", ".claude", "projects", slug);
 }
 function _tokens(chars) {
   return Math.round(chars / 4);
@@ -6004,13 +6255,13 @@ function measureDelivered(projectRulesDir, globalRulesDir) {
   return {
     project: {
       dir: projectRulesDir,
-      present: fs15.existsSync(projectRulesDir),
+      present: fs16.existsSync(projectRulesDir),
       files: p.files,
       tokens: _tokens(p.chars)
     },
     global: {
       dir: globalRulesDir,
-      present: fs15.existsSync(globalRulesDir),
+      present: fs16.existsSync(globalRulesDir),
       files: g.files,
       tokens: _tokens(g.chars)
     },
@@ -6018,13 +6269,13 @@ function measureDelivered(projectRulesDir, globalRulesDir) {
   };
 }
 function storeKey(store) {
-  return createHash4("sha256").update(path13.resolve(store)).digest("hex").slice(0, 12);
+  return createHash5("sha256").update(path14.resolve(store)).digest("hex").slice(0, 12);
 }
 function scanStore(store, limit) {
-  const files = fs15.readdirSync(store).filter((f) => f.endsWith(".jsonl")).map((f) => ({ f, m: fs15.statSync(path13.join(store, f)).mtimeMs })).sort((a, b) => b.m - a.m).slice(0, limit).map((x) => x.f);
+  const files = fs16.readdirSync(store).filter((f) => f.endsWith(".jsonl")).map((f) => ({ f, m: fs16.statSync(path14.join(store, f)).mtimeMs })).sort((a, b) => b.m - a.m).slice(0, limit).map((x) => x.f);
   const per_session = [];
   for (const f of files) {
-    const lines = fs15.readFileSync(path13.join(store, f), "utf8").split("\n");
+    const lines = fs16.readFileSync(path14.join(store, f), "utf8").split("\n");
     const r = scanSession(f.replace(/\.jsonl$/, "").slice(0, 8), lines);
     if (r.assistant_turns > 0) {
       per_session.push(r);
@@ -6052,10 +6303,10 @@ function scanStore(store, limit) {
   const task_completeness_rate_pct = completeness_windows === 0 ? 0 : Number((100 * task_completeness / completeness_windows).toFixed(1));
   const era = spansCarrierChange(per_session.map((s) => s.first_at));
   const delivered = measureDelivered(
-    path13.join(REPO_ROOT, ".claude", "rules"),
-    path13.join(process.env["HOME"] ?? os2.homedir(), ".claude", "rules")
+    path14.join(REPO_ROOT, ".claude", "rules"),
+    path14.join(process.env["HOME"] ?? os2.homedir(), ".claude", "rules")
   );
-  const ownStore = path13.resolve(store) === path13.resolve(defaultStore(REPO_ROOT));
+  const ownStore = path14.resolve(store) === path14.resolve(defaultStore(REPO_ROOT));
   return {
     scanned_at: (/* @__PURE__ */ new Date()).toISOString(),
     store,
@@ -6085,8 +6336,8 @@ function scanStore(store, limit) {
   };
 }
 function recordRate(file, scanned_at, rate) {
-  fs15.mkdirSync(path13.dirname(file), { recursive: true });
-  fs15.appendFileSync(file, `${JSON.stringify({ measured_at: scanned_at, ...rate })}
+  fs16.mkdirSync(path14.dirname(file), { recursive: true });
+  fs16.appendFileSync(file, `${JSON.stringify({ measured_at: scanned_at, ...rate })}
 `, "utf8");
 }
 function render(report) {
@@ -6217,14 +6468,14 @@ function main9(argv) {
     return 2;
   }
   const resolved = store ?? defaultStore(process.cwd());
-  if (!fs15.existsSync(resolved)) {
+  if (!fs16.existsSync(resolved)) {
     process.stderr.write(`conformance:behavior: no transcript store at ${resolved}
 `);
     return 1;
   }
   const report = scanStore(resolved, Number.isFinite(limit) && limit > 0 ? limit : 30);
   if (out) {
-    fs15.writeFileSync(out, `${JSON.stringify(report, null, 2)}
+    fs16.writeFileSync(out, `${JSON.stringify(report, null, 2)}
 `, "utf8");
   }
   if (record) {
@@ -6232,7 +6483,7 @@ function main9(argv) {
   }
   if (why !== null) {
     const id = why;
-    fs15.writeSync(
+    fs16.writeSync(
       1,
       json ? `${JSON.stringify(
         {
@@ -6252,7 +6503,7 @@ function main9(argv) {
     );
     return 0;
   }
-  fs15.writeSync(1, json ? `${JSON.stringify(report, null, 2)}
+  fs16.writeSync(1, json ? `${JSON.stringify(report, null, 2)}
 ` : `${render(report)}
 `);
   return 0;
@@ -6264,13 +6515,13 @@ function _isCliEntry9() {
   if (process.argv[1] === void 0) {
     return false;
   }
-  const argvUrl = pathToFileURL9(path13.resolve(process.argv[1])).href;
+  const argvUrl = pathToFileURL9(path14.resolve(process.argv[1])).href;
   if (import.meta.url === argvUrl) {
     return true;
   }
   try {
-    const here = fs15.realpathSync(fileURLToPath9(import.meta.url));
-    const argv = fs15.realpathSync(path13.resolve(process.argv[1]));
+    const here = fs16.realpathSync(fileURLToPath9(import.meta.url));
+    const argv = fs16.realpathSync(path14.resolve(process.argv[1]));
     return here === argv;
   } catch {
     return false;
@@ -6281,19 +6532,19 @@ if (_isCliEntry9()) {
 }
 
 // src/scripts/report_carrier_divergence.ts
-import * as fs16 from "node:fs";
+import * as fs17 from "node:fs";
 import * as os3 from "node:os";
-import * as path14 from "node:path";
+import * as path15 from "node:path";
 import process2 from "node:process";
 import { fileURLToPath as fileURLToPath10, pathToFileURL as pathToFileURL10 } from "node:url";
 var _HERE2 = fileURLToPath10(import.meta.url);
-var REPO_ROOT2 = path14.resolve(path14.dirname(_HERE2), "..", "..");
-var PROJECT_RULES = path14.join(".claude", "rules");
-var PROJECTION_SOURCE = path14.join("dist", "agent-src", "rules");
-var GLOBAL_RULES = path14.join(".claude", "rules");
+var REPO_ROOT2 = path15.resolve(path15.dirname(_HERE2), "..", "..");
+var PROJECT_RULES = path15.join(".claude", "rules");
+var PROJECTION_SOURCE = path15.join("dist", "agent-src", "rules");
+var GLOBAL_RULES = path15.join(".claude", "rules");
 function _listRules(dir) {
   try {
-    return fs16.readdirSync(dir).filter((f) => f.endsWith(".md")).sort();
+    return fs17.readdirSync(dir).filter((f) => f.endsWith(".md")).sort();
   } catch {
     return [];
   }
@@ -6301,7 +6552,7 @@ function _listRules(dir) {
 function _ruleType(file) {
   let text;
   try {
-    text = fs16.readFileSync(file, "utf-8");
+    text = fs17.readFileSync(file, "utf-8");
   } catch {
     return "";
   }
@@ -6312,8 +6563,8 @@ function compareCarriers(projectDir, globalDir, sourceDir) {
   const out = {
     projectDir,
     globalDir,
-    globalPresent: fs16.existsSync(globalDir),
-    projectPresent: fs16.existsSync(projectDir),
+    globalPresent: fs17.existsSync(globalDir),
+    projectPresent: fs17.existsSync(projectDir),
     shared: 0,
     identical: [],
     provenanceOnly: [],
@@ -6336,7 +6587,7 @@ function compareCarriers(projectDir, globalDir, sourceDir) {
     }
     if (!inP && inG) {
       out.globalOnly.push(rule);
-      if (sourceDir !== void 0 && _ruleType(path14.join(sourceDir, rule)) === "manual") {
+      if (sourceDir !== void 0 && _ruleType(path15.join(sourceDir, rule)) === "manual") {
         out.manualOnlyGlobal.push(rule);
       }
       continue;
@@ -6346,8 +6597,8 @@ function compareCarriers(projectDir, globalDir, sourceDir) {
     let projectCopy;
     let globalCopy;
     try {
-      projectCopy = fs16.readFileSync(path14.join(projectDir, rule));
-      globalCopy = fs16.readFileSync(path14.join(globalDir, rule));
+      projectCopy = fs17.readFileSync(path15.join(projectDir, rule));
+      globalCopy = fs17.readFileSync(path15.join(globalDir, rule));
       verdict = comparePair(projectCopy, globalCopy);
     } catch {
       out.shared -= 1;
@@ -6494,9 +6745,9 @@ function render2(d) {
 }
 function main10(argv) {
   const args = argv ?? process2.argv.slice(2);
-  let projectDir = path14.join(REPO_ROOT2, PROJECT_RULES);
-  let globalDir = path14.join(os3.homedir(), GLOBAL_RULES);
-  let sourceDir = path14.join(REPO_ROOT2, PROJECTION_SOURCE);
+  let projectDir = path15.join(REPO_ROOT2, PROJECT_RULES);
+  let globalDir = path15.join(os3.homedir(), GLOBAL_RULES);
+  let sourceDir = path15.join(REPO_ROOT2, PROJECTION_SOURCE);
   const value = (i) => {
     const v = args[i + 1];
     return v === void 0 || v.startsWith("-") ? null : v;
@@ -6510,7 +6761,7 @@ function main10(argv) {
 `);
         return 1;
       }
-      const resolved = path14.resolve(v);
+      const resolved = path15.resolve(v);
       if (a === "--project") projectDir = resolved;
       else if (a === "--global") globalDir = resolved;
       else sourceDir = resolved;
@@ -6532,9 +6783,9 @@ function main10(argv) {
 }
 function _isCliEntry10() {
   if (process2.argv[1] === void 0) return false;
-  if (import.meta.url === pathToFileURL10(path14.resolve(process2.argv[1])).href) return true;
+  if (import.meta.url === pathToFileURL10(path15.resolve(process2.argv[1])).href) return true;
   try {
-    return fs16.realpathSync(_HERE2) === fs16.realpathSync(path14.resolve(process2.argv[1]));
+    return fs17.realpathSync(_HERE2) === fs17.realpathSync(path15.resolve(process2.argv[1]));
   } catch {
     return false;
   }
@@ -6544,12 +6795,12 @@ if (_isCliEntry10()) {
 }
 
 // src/scripts/report_skill_activation.ts
-import * as fs17 from "node:fs";
+import * as fs18 from "node:fs";
 import * as os4 from "node:os";
-import * as path15 from "node:path";
+import * as path16 from "node:path";
 import { fileURLToPath as fileURLToPath11, pathToFileURL as pathToFileURL11 } from "node:url";
 var _HERE3 = fileURLToPath11(import.meta.url);
-var REPO_ROOT3 = path15.resolve(path15.dirname(_HERE3), "..", "..");
+var REPO_ROOT3 = path16.resolve(path16.dirname(_HERE3), "..", "..");
 var SKILLS_ROOT = "src/skills";
 var TRIGGER_KEYS = ["triggers:", "trigger_description:", "file_pattern:", "path_prefix:"];
 var DETERMINISTIC_RE = /^\s*(?:[-*]\s*)?(?:\*\*)?(MUST|NEVER|ALWAYS)\b/m;
@@ -6560,25 +6811,25 @@ function censusSkills(root) {
     withTriggerCorpus: [],
     withDeterministicObligation: []
   };
-  if (!fs17.existsSync(root)) {
+  if (!fs18.existsSync(root)) {
     return out;
   }
-  for (const entry of fs17.readdirSync(root, { withFileTypes: true }).sort((a, b) => a.name.localeCompare(b.name))) {
+  for (const entry of fs18.readdirSync(root, { withFileTypes: true }).sort((a, b) => a.name.localeCompare(b.name))) {
     if (!entry.isDirectory()) {
       continue;
     }
-    const file = path15.join(root, entry.name, "SKILL.md");
-    if (!fs17.existsSync(file)) {
+    const file = path16.join(root, entry.name, "SKILL.md");
+    if (!fs18.existsSync(file)) {
       continue;
     }
     out.total += 1;
-    const text = fs17.readFileSync(file, "utf8");
+    const text = fs18.readFileSync(file, "utf8");
     const fmEnd = text.startsWith("---") ? text.indexOf("\n---", 3) : -1;
     const fm = fmEnd === -1 ? "" : text.slice(0, fmEnd);
     if (TRIGGER_KEYS.some((k) => new RegExp(`^${k}`, "m").test(fm))) {
       out.withTriggerKey.push(entry.name);
     }
-    if (fs17.existsSync(path15.join(root, entry.name, "evals", "triggers.json"))) {
+    if (fs18.existsSync(path16.join(root, entry.name, "evals", "triggers.json"))) {
       out.withTriggerCorpus.push(entry.name);
     }
     const body = fmEnd === -1 ? text : text.slice(fmEnd + 4);
@@ -6589,17 +6840,17 @@ function censusSkills(root) {
   return out;
 }
 function defaultStore2(cwd) {
-  return path15.join(os4.homedir(), ".claude", "projects", projectStoreSlug(cwd));
+  return path16.join(os4.homedir(), ".claude", "projects", projectStoreSlug(cwd));
 }
 function measureUsage(store, limit) {
   const rep = { store, sessions: 0, assistantTurns: 0, invocations: 0, bySkill: {} };
-  if (!fs17.existsSync(store)) {
+  if (!fs18.existsSync(store)) {
     return rep;
   }
-  const files = fs17.readdirSync(store).filter((f) => f.endsWith(".jsonl")).map((f) => path15.join(store, f)).sort((a, b) => fs17.statSync(b).mtimeMs - fs17.statSync(a).mtimeMs).slice(0, limit);
+  const files = fs18.readdirSync(store).filter((f) => f.endsWith(".jsonl")).map((f) => path16.join(store, f)).sort((a, b) => fs18.statSync(b).mtimeMs - fs18.statSync(a).mtimeMs).slice(0, limit);
   rep.sessions = files.length;
   for (const file of files) {
-    for (const line of fs17.readFileSync(file, "utf8").split("\n")) {
+    for (const line of fs18.readFileSync(file, "utf8").split("\n")) {
       if (!line.trim()) {
         continue;
       }
@@ -6672,15 +6923,15 @@ function buildRecord(census, usage, today) {
     assistant_turns: usage.reduce((a, u) => a + u.assistantTurns, 0),
     invocations: usage.reduce((a, u) => a + u.invocations, 0),
     distinct_skills_invoked: distinct.size,
-    stores: usage.map((u) => path15.basename(u.store))
+    stores: usage.map((u) => path16.basename(u.store))
   };
 }
 function readRecord(repoRoot) {
-  const file = path15.join(repoRoot, RECORD_PATH);
-  if (!fs17.existsSync(file)) {
+  const file = path16.join(repoRoot, RECORD_PATH);
+  if (!fs18.existsSync(file)) {
     return null;
   }
-  return JSON.parse(fs17.readFileSync(file, "utf8"));
+  return JSON.parse(fs18.readFileSync(file, "utf8"));
 }
 function render3(census, usage, published = null) {
   const lines = [];
@@ -6715,7 +6966,7 @@ function render3(census, usage, published = null) {
     }
     totalInv += u.invocations;
     lines.push(
-      `  ${path15.basename(u.store).slice(-38).padEnd(38)} sessions=${String(u.sessions).padStart(3)} asst=${String(u.assistantTurns).padStart(6)} Skill calls=${String(u.invocations).padStart(3)}`
+      `  ${path16.basename(u.store).slice(-38).padEnd(38)} sessions=${String(u.sessions).padStart(3)} asst=${String(u.assistantTurns).padStart(6)} Skill calls=${String(u.invocations).padStart(3)}`
     );
   }
   lines.push("");
@@ -6819,7 +7070,7 @@ function main11(argv) {
   if (stores.length === 0) {
     stores.push(defaultStore2(REPO_ROOT3));
   }
-  const census = censusSkills(path15.join(root, SKILLS_ROOT));
+  const census = censusSkills(path16.join(root, SKILLS_ROOT));
   const usage = stores.map((s) => measureUsage(s, limit));
   process.stdout.write(`${render3(census, usage, readRecord(root))}
 `);
@@ -6840,27 +7091,27 @@ function main11(argv) {
     return 1;
   }
   const today = (/* @__PURE__ */ new Date()).toISOString().slice(0, 10);
-  const file = path15.join(root, RECORD_PATH);
-  fs17.mkdirSync(path15.dirname(file), { recursive: true });
-  fs17.writeFileSync(file, `${JSON.stringify(buildRecord(census, usage, today), null, 2)}
+  const file = path16.join(root, RECORD_PATH);
+  fs18.mkdirSync(path16.dirname(file), { recursive: true });
+  fs18.writeFileSync(file, `${JSON.stringify(buildRecord(census, usage, today), null, 2)}
 `);
   process.stdout.write(`
 wrote ${RECORD_PATH} (measured ${today})
 `);
   return 0;
 }
-if (process.argv[1] !== void 0 && import.meta.url === pathToFileURL11(path15.resolve(process.argv[1])).href) {
+if (process.argv[1] !== void 0 && import.meta.url === pathToFileURL11(path16.resolve(process.argv[1])).href) {
   process.exit(main11(process.argv.slice(2)));
 }
 
 // src/scripts/report_skill_obligation_violations.ts
-import * as fs18 from "node:fs";
+import * as fs19 from "node:fs";
 import * as os5 from "node:os";
-import * as path16 from "node:path";
+import * as path17 from "node:path";
 import process3 from "node:process";
 import { fileURLToPath as fileURLToPath12, pathToFileURL as pathToFileURL12 } from "node:url";
 var _HERE4 = fileURLToPath12(import.meta.url);
-var REPO_ROOT4 = path16.resolve(path16.dirname(_HERE4), "..", "..");
+var REPO_ROOT4 = path17.resolve(path17.dirname(_HERE4), "..", "..");
 var OBLIGATION_LINE_RE = new RegExp(`${DETERMINISTIC_RE.source}.*`, "gm");
 var PATH_RE = /`([A-Za-z0-9_./-]*\/[A-Za-z0-9_.-]+\.[a-z]{2,6})`/g;
 var CMD_RE = /`([a-z][a-z0-9-]*(?: [a-z][a-z0-9:._-]*){1,3})`/g;
@@ -6898,7 +7149,7 @@ function _artefacts(line) {
   return out;
 }
 function extractObligations(repoRoot) {
-  const skillsRoot = path16.join(repoRoot, SKILLS_ROOT);
+  const skillsRoot = path17.join(repoRoot, SKILLS_ROOT);
   const census = censusSkills(skillsRoot);
   const out = {
     skills: census.withDeterministicObligation,
@@ -6912,7 +7163,7 @@ function extractObligations(repoRoot) {
   for (const skill of census.withDeterministicObligation) {
     let text;
     try {
-      text = fs18.readFileSync(path16.join(skillsRoot, skill, "SKILL.md"), "utf-8");
+      text = fs19.readFileSync(path17.join(skillsRoot, skill, "SKILL.md"), "utf-8");
     } catch {
       continue;
     }
@@ -7028,7 +7279,7 @@ function scanSessionForViolations(session, lines, forbidden, parsed) {
   return flags;
 }
 function defaultStore3(cwd) {
-  return path16.join(os5.homedir(), ".claude", "projects", projectStoreSlug(cwd));
+  return path17.join(os5.homedir(), ".claude", "projects", projectStoreSlug(cwd));
 }
 function scanStore2(repoRoot, store, limit) {
   const census = extractObligations(repoRoot);
@@ -7041,14 +7292,14 @@ function scanStore2(repoRoot, store, limit) {
   };
   let files;
   try {
-    files = fs18.readdirSync(store).filter((f) => f.endsWith(".jsonl")).map((f) => ({ p: path16.join(store, f), m: fs18.statSync(path16.join(store, f)).mtimeMs })).sort((a, b) => b.m - a.m).slice(0, limit).map((x) => x.p);
+    files = fs19.readdirSync(store).filter((f) => f.endsWith(".jsonl")).map((f) => ({ p: path17.join(store, f), m: fs19.statSync(path17.join(store, f)).mtimeMs })).sort((a, b) => b.m - a.m).slice(0, limit).map((x) => x.p);
   } catch {
     return report;
   }
   report.sessions = files.length;
   for (const file of files) {
-    const lines = fs18.readFileSync(file, "utf-8").split("\n");
-    const id = path16.basename(file).replace(/\.jsonl$/, "").slice(0, 8);
+    const lines = fs19.readFileSync(file, "utf-8").split("\n");
+    const id = path17.basename(file).replace(/\.jsonl$/, "").slice(0, 8);
     const entries = _parseSession(lines);
     if (loadedSkillsFrom(entries).size > 0) report.sessionsWithASkill += 1;
     report.flags.push(...scanSessionForViolations(id, lines, census.forbidden, entries));
@@ -7173,9 +7424,9 @@ function main12(argv) {
 }
 function _isCliEntry11() {
   if (process3.argv[1] === void 0) return false;
-  if (import.meta.url === pathToFileURL12(path16.resolve(process3.argv[1])).href) return true;
+  if (import.meta.url === pathToFileURL12(path17.resolve(process3.argv[1])).href) return true;
   try {
-    return fs18.realpathSync(_HERE4) === fs18.realpathSync(path16.resolve(process3.argv[1]));
+    return fs19.realpathSync(_HERE4) === fs19.realpathSync(path17.resolve(process3.argv[1]));
   } catch {
     return false;
   }
@@ -7186,20 +7437,20 @@ if (_isCliEntry11()) {
 
 // src/scripts/report_conformance_funnel.ts
 var _HERE5 = fileURLToPath13(import.meta.url);
-var REPO_ROOT5 = path17.resolve(path17.dirname(_HERE5), "..", "..");
+var REPO_ROOT5 = path18.resolve(path18.dirname(_HERE5), "..", "..");
 function buildFunnel(opts = {}) {
   const repoRoot = opts.repoRoot ?? REPO_ROOT5;
-  const projectRulesDir = opts.projectRulesDir ?? path17.join(repoRoot, PROJECT_RULES);
-  const globalRulesDir = opts.globalRulesDir ?? path17.join(os6.homedir(), GLOBAL_RULES);
-  const sourceDir = opts.sourceDir ?? path17.join(repoRoot, PROJECTION_SOURCE);
+  const projectRulesDir = opts.projectRulesDir ?? path18.join(repoRoot, PROJECT_RULES);
+  const globalRulesDir = opts.globalRulesDir ?? path18.join(os6.homedir(), GLOBAL_RULES);
+  const sourceDir = opts.sourceDir ?? path18.join(repoRoot, PROJECTION_SOURCE);
   const store = opts.store ?? defaultStore(repoRoot);
   const limit = opts.limit ?? 30;
   return {
     delivered: measureDelivered(projectRulesDir, globalRulesDir),
     divergence: compareCarriers(projectRulesDir, globalRulesDir, sourceDir),
-    skills: censusSkills(path17.join(repoRoot, SKILLS_ROOT)),
+    skills: censusSkills(path18.join(repoRoot, SKILLS_ROOT)),
     usage: measureUsage(store, limit),
-    storePresent: fs19.existsSync(store),
+    storePresent: fs20.existsSync(store),
     sk2: scanStore2(repoRoot, store, limit)
   };
 }
@@ -7340,7 +7591,7 @@ function main13(argv) {
 `);
         return 1;
       }
-      const resolved = path17.resolve(v);
+      const resolved = path18.resolve(v);
       if (a === "--store") opts.store = resolved;
       else if (a === "--project") opts.projectRulesDir = resolved;
       else if (a === "--global") opts.globalRulesDir = resolved;
@@ -7372,9 +7623,9 @@ function main13(argv) {
 }
 function _isCliEntry12() {
   if (process4.argv[1] === void 0) return false;
-  if (import.meta.url === pathToFileURL13(path17.resolve(process4.argv[1])).href) return true;
+  if (import.meta.url === pathToFileURL13(path18.resolve(process4.argv[1])).href) return true;
   try {
-    return fs19.realpathSync(_HERE5) === fs19.realpathSync(path17.resolve(process4.argv[1]));
+    return fs20.realpathSync(_HERE5) === fs20.realpathSync(path18.resolve(process4.argv[1]));
   } catch {
     return false;
   }
@@ -7393,7 +7644,7 @@ var CONFORMANCE_CHECK_IDS = [
   "lean-projection",
   "host-manifest"
 ];
-var THIN_STUB_MARKER = "Routed rule \u2014 load the body on trigger-match";
+var THIN_STUB_MARKER = THIN_ENTRY_MARKER;
 var CONFORMANCE_STATUS_SYMBOLS = {
   ...STATUS_SYMBOLS,
   unknown: "\u2754"
@@ -7411,20 +7662,20 @@ function conformanceLogPath() {
   if (override && override.trim().length > 0) {
     return override;
   }
-  return path18.join(os7.homedir(), ".event4u", "agent-config", "conformance-log.jsonl");
+  return path19.join(os7.homedir(), ".event4u", "agent-config", "conformance-log.jsonl");
 }
 function installLogPath() {
   const override = process5.env["AGENT_CONFIG_INSTALL_LOG"];
   if (override && override.trim().length > 0) {
     return override;
   }
-  return path18.join(os7.homedir(), ".event4u", "agent-config", "install-log.jsonl");
+  return path19.join(os7.homedir(), ".event4u", "agent-config", "install-log.jsonl");
 }
 function _installLogExpected(projectRoot) {
-  return fs20.existsSync(manifest_path(projectRoot));
+  return fs21.existsSync(manifest_path(projectRoot));
 }
 function _check_txlog_clean(logPath = installLogPath(), projectRoot = null) {
-  const entries = fs20.existsSync(logPath) ? readRecentEntries(logPath) : [];
+  const entries = fs21.existsSync(logPath) ? readRecentEntries(logPath) : [];
   if (entries.length === 0) {
     if (projectRoot !== null && _installLogExpected(projectRoot)) {
       return {
@@ -7458,11 +7709,11 @@ function _check_txlog_clean(logPath = installLogPath(), projectRoot = null) {
   };
 }
 function routeTargetPaths(target) {
-  return routeTargetPathsPosix(target).map((rel) => path18.join(...rel.split("/")));
+  return routeTargetPathsPosix(target).map((rel2) => path19.join(...rel2.split("/")));
 }
 function _check_router_pointers(packageRoot = PACKAGE_ROOT) {
-  const routerPath = path18.join(packageRoot, "dist", "router.json");
-  if (!fs20.existsSync(routerPath)) {
+  const routerPath = path19.join(packageRoot, "dist", "router.json");
+  if (!fs21.existsSync(routerPath)) {
     return {
       id: "router-pointers",
       status: "fail",
@@ -7472,7 +7723,7 @@ function _check_router_pointers(packageRoot = PACKAGE_ROOT) {
   }
   let router;
   try {
-    router = JSON.parse(fs20.readFileSync(routerPath, "utf8"));
+    router = JSON.parse(fs21.readFileSync(routerPath, "utf8"));
   } catch (exc) {
     return {
       id: "router-pointers",
@@ -7481,13 +7732,13 @@ function _check_router_pointers(packageRoot = PACKAGE_ROOT) {
       remedy: "reinstall the package \u2014 dist/router.json is corrupt"
     };
   }
-  const rulesDir = path18.join(packageRoot, "dist", "agent-src", "rules");
+  const rulesDir = path19.join(packageRoot, "dist", "agent-src", "rules");
   const broken = [];
   let ids = 0;
   let targets = 0;
   for (const kernelId of router["kernel"] ?? []) {
     ids += 1;
-    if (!fs20.existsSync(path18.join(rulesDir, `${kernelId}.md`))) {
+    if (!fs21.existsSync(path19.join(rulesDir, `${kernelId}.md`))) {
       broken.push(`kernel:${kernelId} \u2192 rules/${kernelId}.md missing`);
     }
   }
@@ -7495,7 +7746,7 @@ function _check_router_pointers(packageRoot = PACKAGE_ROOT) {
     for (const entry of router[tier] ?? []) {
       const ruleId = String(entry["id"] ?? "");
       ids += 1;
-      if (!fs20.existsSync(path18.join(rulesDir, `${ruleId}.md`))) {
+      if (!fs21.existsSync(path19.join(rulesDir, `${ruleId}.md`))) {
         broken.push(`${tier}:${ruleId} \u2192 rules/${ruleId}.md missing`);
       }
       for (const target of entry["routes_to"] ?? []) {
@@ -7505,7 +7756,7 @@ function _check_router_pointers(packageRoot = PACKAGE_ROOT) {
           broken.push(`${ruleId} \u2192 unparseable routes_to ${JSON.stringify(target)}`);
           continue;
         }
-        if (!candidates.some((rel) => fs20.existsSync(path18.join(packageRoot, rel)))) {
+        if (!candidates.some((rel2) => fs21.existsSync(path19.join(packageRoot, rel2)))) {
           broken.push(`${ruleId} \u2192 ${target} (${candidates[0]} missing)`);
         }
       }
@@ -7537,9 +7788,9 @@ function detectSmokePlatform(projectRoot) {
   return "claude";
 }
 function dispatcherRunner(packageRoot) {
-  const localTsx = path18.join(packageRoot, "node_modules", ".bin", "tsx");
-  const script = path18.join(packageRoot, "src", "scripts", "hooks", "dispatch_hook.ts");
-  if (fs20.existsSync(localTsx)) {
+  const localTsx = path19.join(packageRoot, "node_modules", ".bin", "tsx");
+  const script = path19.join(packageRoot, "src", "scripts", "hooks", "dispatch_hook.ts");
+  if (fs21.existsSync(localTsx)) {
     return [localTsx, script];
   }
   return ["npx", "tsx", script];
@@ -7589,12 +7840,12 @@ function _check_hook_dispatcher(projectRoot, packageRoot = PACKAGE_ROOT, opts =
   };
 }
 function readSettingsMode(projectRoot) {
-  const settingsPath = path18.join(projectRoot, ".agent-settings.yml");
-  if (!fs20.existsSync(settingsPath)) {
+  const settingsPath = path19.join(projectRoot, ".agent-settings.yml");
+  if (!fs21.existsSync(settingsPath)) {
     return "eager-all";
   }
   try {
-    const parsed = YAML.parse(fs20.readFileSync(settingsPath, "utf8"));
+    const parsed = YAML.parse(fs21.readFileSync(settingsPath, "utf8"));
     const lean = parsed?.["lean_projection"] ?? null;
     const mode = lean?.["mode"];
     return typeof mode === "string" && mode.length > 0 ? mode : "eager-all";
@@ -7605,7 +7856,7 @@ function readSettingsMode(projectRoot) {
 function kernelIdsFromRouter(packageRoot) {
   try {
     const router = JSON.parse(
-      fs20.readFileSync(path18.join(packageRoot, "dist", "router.json"), "utf8")
+      fs21.readFileSync(path19.join(packageRoot, "dist", "router.json"), "utf8")
     );
     return new Set((router["kernel"] ?? []).map(String));
   } catch {
@@ -7622,8 +7873,8 @@ function _check_lean_projection(projectRoot, packageRoot = PACKAGE_ROOT, project
       remedy: "set lean_projection.mode to 'eager-all' or 'thin' in .agent-settings.yml"
     };
   }
-  const rulesDir = projectedRulesDir ?? path18.join(projectRoot, ".augment", "rules");
-  if (!fs20.existsSync(rulesDir)) {
+  const rulesDir = projectedRulesDir ?? path19.join(projectRoot, ".augment", "rules");
+  if (!fs21.existsSync(rulesDir)) {
     return {
       id: "lean-projection",
       status: "skipped",
@@ -7632,7 +7883,7 @@ function _check_lean_projection(projectRoot, packageRoot = PACKAGE_ROOT, project
     };
   }
   const kernel = kernelIdsFromRouter(packageRoot);
-  const files = fs20.readdirSync(rulesDir).filter((f) => f.endsWith(".md") && f !== "INDEX.md").sort();
+  const files = fs21.readdirSync(rulesDir).filter((f) => f.endsWith(".md") && f !== "INDEX.md").sort();
   const nonKernel = files.filter((f) => !kernel.has(f.replace(/\.md$/, "")));
   if (nonKernel.length === 0) {
     return {
@@ -7646,7 +7897,7 @@ function _check_lean_projection(projectRoot, packageRoot = PACKAGE_ROOT, project
   for (const f of nonKernel) {
     let text = "";
     try {
-      text = fs20.readFileSync(path18.join(rulesDir, f), "utf8");
+      text = fs21.readFileSync(path19.join(rulesDir, f), "utf8");
     } catch {
       continue;
     }
@@ -7677,8 +7928,8 @@ function _check_lean_projection(projectRoot, packageRoot = PACKAGE_ROOT, project
 function _check_host_manifest(projectRoot) {
   const detected = Object.entries(detectToolPresence(projectRoot)).filter(([, v]) => v === true).map(([k]) => k);
   const detectedNote = detected.length > 0 ? `detected surfaces: ${detected.join(", ")}` : "no surfaces detected";
-  const settingsPath = path18.join(projectRoot, ".agent-settings.yml");
-  if (!fs20.existsSync(settingsPath)) {
+  const settingsPath = path19.join(projectRoot, ".agent-settings.yml");
+  if (!fs21.existsSync(settingsPath)) {
     return {
       id: "host-manifest",
       status: "ok",
@@ -7688,7 +7939,7 @@ function _check_host_manifest(projectRoot) {
   }
   let parsed = null;
   try {
-    parsed = YAML.parse(fs20.readFileSync(settingsPath, "utf8"));
+    parsed = YAML.parse(fs21.readFileSync(settingsPath, "utf8"));
   } catch (exc) {
     return {
       id: "host-manifest",
@@ -7862,13 +8113,13 @@ function _isCliEntry13() {
   if (process5.argv[1] === void 0) {
     return false;
   }
-  const argvUrl = pathToFileURL14(path18.resolve(process5.argv[1])).href;
+  const argvUrl = pathToFileURL14(path19.resolve(process5.argv[1])).href;
   if (import.meta.url === argvUrl) {
     return true;
   }
   try {
-    const here = fs20.realpathSync(fileURLToPath14(import.meta.url));
-    const argv = fs20.realpathSync(path18.resolve(process5.argv[1]));
+    const here = fs21.realpathSync(fileURLToPath14(import.meta.url));
+    const argv = fs21.realpathSync(path19.resolve(process5.argv[1]));
     return here === argv;
   } catch {
     return false;