@event4u/agent-config 14.17.0 → 14.19.0

package/dist/cli-delegate/cmd_conformance.js

@@ -16,6 +16,9 @@ import {
 import {
   readHookStdin
 } from "./chunk-F7DQWYR5.js";
+import {
+  reportScanned
+} from "./chunk-I3EIN2YG.js";
 import {
   ArgparseExit,
   STATUS_SYMBOLS,
@@ -33,7 +36,7 @@ import {
   frontmatterPaths,
   proseEqual,
   splitFrontmatter
-} from "./chunk-7RXIKF62.js";
+} from "./chunk-IDHUQIXP.js";
 import "./chunk-FTAISGDQ.js";
 import "./chunk-M2DPGFZ4.js";
 import "./chunk-BTWUYDGN.js";
@@ -78,12 +81,12 @@ import {
 
 // src/scripts/_cli/cmd_conformance.ts
 var YAML = __toESM(require_dist(), 1);
-import * as fs14 from "node:fs";
+import * as fs13 from "node:fs";
 import * as os7 from "node:os";
-import * as path14 from "node:path";
+import * as path13 from "node:path";
 import process6 from "node:process";
 import { spawnSync as spawnSync2 } from "node:child_process";
-import { fileURLToPath as fileURLToPath14, pathToFileURL as pathToFileURL14 } from "node:url";
+import { fileURLToPath as fileURLToPath13, pathToFileURL as pathToFileURL13 } from "node:url";
 
 // src/install/txlog.ts
 import { createReadStream, createWriteStream, existsSync, readFileSync, renameSync, statSync, unlinkSync } from "node:fs";
@@ -144,18 +147,18 @@ function routeTargetPathsPosix(target) {
 }
 
 // src/scripts/report_conformance_funnel.ts
-import * as fs13 from "node:fs";
+import * as fs12 from "node:fs";
 import * as os6 from "node:os";
-import * as path13 from "node:path";
+import * as path12 from "node:path";
 import process5 from "node:process";
-import { fileURLToPath as fileURLToPath13, pathToFileURL as pathToFileURL13 } from "node:url";
+import { fileURLToPath as fileURLToPath12, pathToFileURL as pathToFileURL12 } from "node:url";
 
 // src/scripts/conformance_scan.ts
 import { createHash as createHash3 } from "node:crypto";
-import fs9 from "node:fs";
+import fs8 from "node:fs";
 import os2 from "node:os";
-import path9 from "node:path";
-import { fileURLToPath as fileURLToPath9, pathToFileURL as pathToFileURL9 } from "node:url";
+import path8 from "node:path";
+import { fileURLToPath as fileURLToPath8, pathToFileURL as pathToFileURL8 } from "node:url";
 
 // src/scripts/_lib/transcript_entry.ts
 function _isObject(v) {
@@ -432,7 +435,11 @@ function _setPinLost(consumer_root, session_id) {
   _migrateLegacyMarker(consumer_root);
   try {
     atomic_write_text(path.join(consumer_root, pinLostMarker(session_id)), (/* @__PURE__ */ new Date()).toISOString());
-  } catch {
+  } catch (err) {
+    process.stderr.write(
+      `language-mirror: pin-lost marker write failed (${_errText(err)}) \u2014 the pin will NOT be re-emitted after this compaction. Turn outcome unchanged.
+`
+    );
   }
 }
 function _pinLost(consumer_root, session_id) {
@@ -658,7 +665,11 @@ function run(stdin_text, options) {
       atomic_write_json(target, next);
       _pruneLegacyState(options.consumer_root);
       _pruneStaleSessions(options.consumer_root, Date.now());
-    } catch {
+    } catch (err) {
+      process.stderr.write(
+        `language-mirror: pin-state write failed (${_errText(err)}) \u2014 the language pin did NOT persist and the next turn re-derives it. This turn's notice is unchanged.
+`
+      );
     }
   }
   if (effective === "de" || effective === "en") {
@@ -670,6 +681,10 @@ function run(stdin_text, options) {
   }
   return EXIT_ALLOW;
 }
+function _errText(err) {
+  const t = err instanceof Error ? err.message : String(err);
+  return t.replace(/\s+/g, " ").trim().slice(0, 200);
+}
 function main(argv) {
   const args = argv ?? process.argv.slice(2);
   let consumer_root = process.cwd();
@@ -727,6 +742,128 @@ function humanTypedThisTurn(prompt) {
   return true;
 }
 
+// src/scripts/_lib/consequence_objects.ts
+var CONSEQUENCE_PHRASES = [
+  {
+    op: "prod-deploy",
+    re: /(?<![A-Za-z0-9_À-ɏ])(deploy(e|en|t|st)?|ausroll(e|en)?|ship(pe|pen)?|live\s*schalt(e|en)?|rollout)\b[^.\n]{0,30}\b(produktion|production|prod|live|prod-umgebung)\b|\b(produktion|production|prod|live)\b[^.\n]{0,30}\b(deploy(e|en)?|ausrollen|ausroll(e|en)?|live\s*schalten|rollout)\b/i
+  },
+  {
+    op: "prod-data-destroy",
+    re: /(?<![A-Za-z0-9_À-ɏ])(l(ö|oe)sch(e|en)?|entfern(e|en)?|leer(e|en)?|verwerf(e|en)?|drop|truncate|delete|wipe|purge|zerst(ö|oe)r(e|en)?)\b[^.\n]{0,40}\b(tabelle|tabellen|datenbank|daten|bucket|collection|zeilen|rows|table|database|dataset)\b|\b(tabelle|tabellen|datenbank|daten|bucket|collection|table|database)\b[^.\n]{0,40}\b(l(ö|oe)schen|leeren|verwerfen|droppen|truncaten|entfernen|drop|truncate|delete|wipe|purge)\b/i
+  },
+  {
+    op: "prod-infra-change",
+    re: /(?<![A-Za-z0-9_À-ɏ])((ver)?(ä|ae)nder(e|n)?|anpass(e|en)?|umbau(e|en)?|apply|destroy|(neu\s*)?provisionier(e|en)?)\b[^.\n]{0,40}\b(infrastruktur|infrastructure|cluster|terraform|iam|dns|netzwerk|network|firewall|policy|policies|security[-\s]group)\b|\b(infrastruktur|infrastructure|cluster|terraform|iam|dns|netzwerk|firewall)\b[^.\n]{0,40}\b((ver)?(ä|ae)ndern|anpassen|umbauen|zerst(ö|oe)ren|apply|destroy)\b/i
+  },
+  {
+    op: "external-send",
+    re: /(?<![A-Za-z0-9_À-ɏ])(schick(e|en)?|verschick(e|en)?|send(e|en|et)?|mail(e|en)?|raussend(e|en)?|versend(e|en)?|post|publish)\b[^.\n]{0,40}\b(mail|mails|email|e-mail|nachricht|nachrichten|newsletter|webhook|kunden|kundin|kunde|empf(ä|ae)nger|customers?|recipients?|message)\b|\b(mail|email|e-mail|nachricht|newsletter|kunden|customers?)\b[^.\n]{0,40}\b(schicken|verschicken|senden|versenden|rausschicken|send|deliver)\b/i
+  },
+  {
+    op: "money-movement",
+    re: /(?<![A-Za-z0-9_À-ɏ])(erstatt(e|en)?|r(ü|ue)ckerstatt(e|en)?|zahl(e|en)?|(ü|ue)berweis(e|en)?|abbuch(e|en)?|belast(e|en)?|refund|charge|payout|transfer|bill)\b[^.\n]{0,40}\b(betrag|geld|rechnung|zahlung|euro|dollar|kunde|kunden|karte|konto|invoice|payment|customer|card|account)\b|\b(betrag|geld|rechnung|zahlung|invoice|payment)\b[^.\n]{0,40}\b(erstatten|zur(ü|ue)ckzahlen|(ü|ue)berweisen|abbuchen|belasten|refund|charge|transfer)\b/i
+  },
+  {
+    op: "trunk-force-push",
+    re: /(?<![A-Za-z0-9_À-ɏ])(force[-\s]?push(e|en|t)?|force[-\s]?pushen|(ü|ue)berschreib(e|en)?)\b[^.\n]{0,40}\b(main|master|trunk|produktions?[-\s]?branch|production|release[-\s]?branch)\b|\b(main|master|trunk|production)\b[^.\n]{0,40}\b(force[-\s]?pushen|force[-\s]?push|(ü|ue)berschreiben)\b/i
+  },
+  {
+    op: "out-of-scope-destruction",
+    re: /(?<![A-Za-z0-9_À-ɏ])(l(ö|oe)sch(e|en)?|entfern(e|en)?|r(ä|ae)um(e|en)?\s*auf|aufr(ä|ae)um(e|en)?|delete|remove|wipe)\b[^.\n]{0,40}\b(au(ß|ss)erhalb|ausserhalb|unabh(ä|ae)ngig|nicht\s+zur\s+aufgabe|outside\s+(the\s+)?(task|scope)|unrelated|everything\s+else|alles\s+andere)\b|\b(au(ß|ss)erhalb|outside\s+(the\s+)?(task|scope)|unrelated)\b[^.\n]{0,40}\b(l(ö|oe)schen|entfernen|aufr(ä|ae)umen|delete|remove|wipe)\b/i
+  }
+];
+var OBJECT_REQUIRED_OPS = /* @__PURE__ */ new Set([
+  "prod-data-destroy",
+  "external-send",
+  "money-movement"
+]);
+var OBJECT_STOP_WORDS = /* @__PURE__ */ new Set([
+  "bitte",
+  "doch",
+  "mal",
+  "nicht",
+  "jetzt",
+  "gleich",
+  "auch",
+  "noch",
+  "wieder",
+  "in",
+  "im",
+  "aus",
+  "von",
+  "vom",
+  ": ",
+  "der",
+  "die",
+  "das",
+  "den",
+  "dem",
+  "und",
+  "oder",
+  "mit",
+  "auf",
+  "zu",
+  "komplett",
+  "ganz",
+  "alle",
+  "allen",
+  "please",
+  "now",
+  "again",
+  "too",
+  "also",
+  "from",
+  "and",
+  "or",
+  "the",
+  "a",
+  "an",
+  "there",
+  "here",
+  "completely",
+  "all",
+  "with",
+  "on",
+  "to",
+  "in"
+]);
+function _normalizeObject(raw) {
+  return raw.trim().replace(/^["'`]+|["'`]+$/g, "").replace(/[.,;:]+$/, "").toLowerCase();
+}
+var OBJECT_PATTERNS = {
+  "prod-data-destroy": [
+    /\b(?:tabelle|table|datenbank|database|schema|collection|index)\s+["'`]?([A-Za-z_][\w.$-]*)/gi,
+    /\bs3:\/\/([\w.-]+)/gi,
+    /\b(?:bucket)\s+["'`]?([A-Za-z_][\w.-]*)/gi
+  ],
+  "external-send": [
+    /([A-Za-z0-9._%+-]+@[A-Za-z0-9.-]+\.[A-Za-z]{2,})/g,
+    /\bhttps?:\/\/([^\s/"'`]+)/gi,
+    /\b(?:an\s+(?:die|den|alle)|to\s+(?:the|all))\s+([A-Za-z][\w-]*)/gi
+  ],
+  "money-movement": [
+    /(\d[\d.,]*)\s*(?:€|eur\b|euro\b|\$|usd\b)/gi,
+    /(?:€|\$)\s*(\d[\d.,]*)/g,
+    /\b(?:kunde|kunden|customer|account|konto)\s+["'`]?([A-Za-z0-9][\w.-]*)/gi
+  ]
+};
+function extractObjects(op, text) {
+  const patterns = OBJECT_PATTERNS[op];
+  if (!patterns) return [];
+  const out = [];
+  for (const re of patterns) {
+    const local = new RegExp(re.source, re.flags.includes("g") ? re.flags : `${re.flags}g`);
+    let m;
+    while ((m = local.exec(text)) !== null) {
+      const value = _normalizeObject(m[1] ?? "");
+      if (value && !OBJECT_STOP_WORDS.has(value) && !out.includes(value)) out.push(value);
+      if (m.index === local.lastIndex) local.lastIndex++;
+    }
+  }
+  return out;
+}
+
 // src/scripts/git_authorization_hook.ts
 var EXIT_ALLOW2 = 0;
 var STATE_FILE2 = path2.join("agents", "state", "git-authorization.json");
@@ -778,7 +915,14 @@ var ALL_OPS = [
   "clean",
   "stash-drop",
   "branch-delete",
-  "close"
+  "close",
+  "prod-deploy",
+  "prod-data-destroy",
+  "prod-infra-change",
+  "external-send",
+  "money-movement",
+  "trunk-force-push",
+  "out-of-scope-destruction"
 ];
 var PHRASES = [
   { op: "commit", re: /\b(commit(e|et|te|ten)?|committe|einchecken)\b/i },
@@ -936,7 +1080,8 @@ var PHRASES = [
   {
     op: "pr-merge-auto",
     re: /\bauto[-\s]?merge\b|\bmerge\b[^.\n]{0,20}\bautomatisch\b|\bautomatisch\b[^.\n]{0,20}\bmerg(e|en)\b/i
-  }
+  },
+  ...CONSEQUENCE_PHRASES
 ];
 var OUTPUT_LINE = /^\s*(To\s+\S+|remote:|error:|fatal:|hint:|warning:|!\s|\?\?\s|\s*\^|[-+]{3}\s|@@\s|\$\s|>\s|\d+\s+(pass|fail)|npm ERR!|Error:|Traceback|at\s+\S+:\d+)/i;
 function isInterrogative(prose) {
@@ -1000,7 +1145,7 @@ function splitFences(prompt) {
 function _commandLines(fence) {
   return fence.split("\n").map((l) => l.trim()).filter((l) => l.length > 0).filter((l) => !/^(remote:|error:|hint:|fatal:|warning:|To |!\s|\s*\^)/i.test(l)).map((l) => l.replace(/^[$>#]\s*/, "")).filter((l) => /^(git|gh|npm|pnpm|yarn|task)\b/.test(l));
 }
-function _errText(err) {
+function _errText2(err) {
   const t = err instanceof Error ? err.message : String(err);
   return t.replace(/\s+/g, " ").trim().slice(0, 200);
 }
@@ -1017,9 +1162,20 @@ function extractMergeTargets(prompt) {
   }
   return [...out].sort((a, b) => a - b);
 }
-var REVOKE_RE = /\b(stop|stopp|halt|abbrechen|abbruch|cancel|revoke|widerruf(en)?|zur(ü|ue)ck(nehmen|ziehen)|hold\s+(everything|on|the\s+merge)|warte|wait)\b|(?:\b(nicht|kein(e|en)?|no|not|dont|don't|never|niemals|nie)\b[^.!?\n]{0,30}\b(merg(e|en|ing)|zusammenf(ü|ue)hren)\b)/iu;
+var REVOKE_STOP_WORD = /\b(stop|stopp|halt|abbrechen|abbruch|cancel|revoke|widerruf(en)?|zur(ü|ue)ck(nehmen|ziehen)|hold\s+(everything|on|the\s+merge)|warte|wait)\b/iu;
+var MERGE_VERB = /\b(merg(e|en|ing)|zusammenf(ü|ue)hren)\b/giu;
 function isRevocation(prompt) {
-  return REVOKE_RE.test(prompt);
+  if (REVOKE_STOP_WORD.test(prompt) || isBareRefusal(prompt)) {
+    return true;
+  }
+  MERGE_VERB.lastIndex = 0;
+  let m;
+  while ((m = MERGE_VERB.exec(prompt)) !== null) {
+    if (negatedBefore(prompt, m.index, m[0])) {
+      return true;
+    }
+  }
+  return false;
 }
 function _grantId(session_id, at, targets) {
   return `${sessionSlug(session_id) || "nosession"}:${at}:${targets.join(",")}`;
@@ -1054,8 +1210,12 @@ function foldGrants(prior, prompt, authorized, session_id, now) {
     }
   ];
 }
-var NEGATION_WORD = /\b(nicht|nichts|kein(e|en|em|er|es)?|niemals|nie|no|not|dont|don't|never|without|ohne)\b/i;
-var CONTRAST_CUE = /\b(aber|sondern|jedoch|but|however|instead)\b/gi;
+var APOSTROPHE = "'\u2019\u2018\u02BC";
+var NEGATION_ALTERNATION = `nicht|nichts|kein(?:e|en|em|er|es)?|niemals|nie|no|not|don[${APOSTROPHE}]?t|never|without|ohne`;
+var NEGATION_WORD = new RegExp(`\\b(${NEGATION_ALTERNATION})\\b`, "i");
+var NEGATION_TOKEN = new RegExp(`^(?:${NEGATION_ALTERNATION})$`, "i");
+var CONTRAST_ALTERNATION = "aber|sondern|jedoch|but|however|instead";
+var CONTRAST_CUE = new RegExp(`\\b(${CONTRAST_ALTERNATION})\\b`, "gi");
 var ABBREVIATION_BEFORE_DOT = /(?:^|[\s("'\u2018\u201c])(?:[a-z]|z\.b|bzw|ca|usw|d\.h|u\.a|evtl|ggf|inkl|max|min|nr|abb|e\.g|i\.e|etc|vs|approx|fig|no|st|dr|prof)\.$/i;
 function isSentenceBoundary(text, at) {
   const mark = text[at];
@@ -1142,6 +1302,19 @@ function negatedBefore(text, index, matched = "") {
   const after = afterFrom < end ? text.slice(afterFrom, clauseEnd(text, afterFrom, end)) : "";
   return NEGATION_WORD.test(before) || NEGATION_WORD.test(matched) || NEGATION_WORD.test(after);
 }
+var WORD_TOKEN = new RegExp(`[\\p{L}\\p{N}${APOSTROPHE}]+`, "gu");
+var CLAUSE_SPLIT = new RegExp(`[,;:]|\\b(?:${CONTRAST_ALTERNATION})\\b`, "iu");
+function isBareRefusal(text) {
+  for (const sentence of _sentences(text)) {
+    for (const clause of sentence.split(CLAUSE_SPLIT)) {
+      const tokens = (clause ?? "").match(WORD_TOKEN) ?? [];
+      if (tokens.length > 0 && tokens.every((t) => NEGATION_TOKEN.test(t))) {
+        return true;
+      }
+    }
+  }
+  return false;
+}
 function classifyAuthorization(prompt) {
   const { prose, fences } = splitFences(prompt);
   const authorized = /* @__PURE__ */ new Set();
@@ -1209,40 +1382,6 @@ function readGrants(consumer_root, session_id) {
     return [];
   }
 }
-function consumeGrantTarget(consumer_root, session_id, target) {
-  const file = path2.join(consumer_root, ledgerFileFor(session_id));
-  let decoded;
-  try {
-    decoded = JSON.parse(fs2.readFileSync(file, "utf8"));
-  } catch {
-    return;
-  }
-  if (!_isObject3(decoded) || !Array.isArray(decoded["grants"])) {
-    return;
-  }
-  let touched = false;
-  for (const g of decoded["grants"]) {
-    if (!_isObject3(g) || !Array.isArray(g["targets"]) || !Array.isArray(g["consumed"])) {
-      continue;
-    }
-    const targets = g["targets"];
-    const consumed = g["consumed"];
-    if (targets.includes(target) && !consumed.includes(target)) {
-      consumed.push(target);
-      touched = true;
-    }
-  }
-  if (touched) {
-    try {
-      atomic_write_json(file, decoded);
-    } catch (err) {
-      process.stderr.write(
-        `git-authorization: grant-consumption write failed (${_errText(err)}) \u2014 the target stays UNSPENT, so one further merge of a PR the user named will still be authorized. Authorization outcome unchanged.
-`
-      );
-    }
-  }
-}
 function takePending(consumer_root, session_id, now) {
   const file = path2.join(consumer_root, pendingFileFor(session_id));
   let raw;
@@ -1311,6 +1450,11 @@ function run2(stdin_text, options) {
     authorized.push(pending.op);
     evidence[pending.op] = `confirmation of the refused \`${pending.op}\` (refused ${pending.refused_at}): "${prompt.trim().slice(0, 40)}"`;
   }
+  const objects = {};
+  for (const op of authorized) {
+    const named = extractObjects(op, prompt);
+    if (named.length > 0) objects[op] = named;
+  }
   const now = /* @__PURE__ */ new Date();
   const ledger = {
     session_id: typeof envelope["session_id"] === "string" ? envelope["session_id"] : "",
@@ -1318,6 +1462,7 @@ function run2(stdin_text, options) {
     authorized,
     evidence,
     prompt_chars: prompt.length,
+    objects,
     // Grants survive this write; `authorized` does not. That asymmetry IS the
     // decision. A bare operation name stays one-shot exactly as `commit-policy`
     // requires, and only an authorization that also froze its objects earns a
@@ -1334,7 +1479,7 @@ function run2(stdin_text, options) {
     atomic_write_json(path2.join(options.consumer_root, ledgerFileFor(session)), ledger);
   } catch (err) {
     process.stderr.write(
-      `git-authorization: session-ledger write failed (${_errText(err)}) \u2014 the gate degrades to "no ledger" for this session, which denies the irreversible subset and warns on the rest. Authorization outcome unchanged.
+      `git-authorization: session-ledger write failed (${_errText2(err)}) \u2014 the gate degrades to "no ledger" for this session, which denies the irreversible subset and warns on the rest. Authorization outcome unchanged.
 `
     );
   }
@@ -1377,125 +1522,7 @@ if (_isCliEntry2()) {
   process.exit(main2());
 }
 
-// src/scripts/hooks/block_unauthorized_git.ts
-import fs3 from "node:fs";
-import path3 from "node:path";
-import { fileURLToPath as fileURLToPath3, pathToFileURL as pathToFileURL3 } from "node:url";
-
-// src/scripts/hooks/merge_impact.ts
-import { execFileSync } from "node:child_process";
-var DESTRUCTIVE_MARKERS = [
-  // Schema removal. Matched on ADDED lines only — a migration that *removes* a
-  // dropColumn call is the opposite of destructive, and matching the raw patch
-  // would score it the same way.
-  { label: "migration drops a column or table", re: /^\+.*\b(dropColumn|dropTable|dropIfExists|removeColumn|drop_column|drop_table)\b/im },
-  { label: "raw DROP or TRUNCATE in a migration", re: /^\+.*\b(DROP\s+(TABLE|COLUMN|INDEX|CONSTRAINT)|TRUNCATE\s+TABLE)\b/im },
-  // The author said so themselves. Conventional Commits marks a breaking change
-  // with a `!` before the colon or a body trailer.
-  { label: "author marked a BREAKING CHANGE", re: /^\+.*BREAKING[ -]CHANGE/m },
-  // A removed export is the shape most likely to break an importer.
-  { label: "an exported symbol was removed", re: /^-\s*export\s+(default\s+|const\s+|function\s+|class\s+|interface\s+|type\s+|async\s+)/m },
-  { label: "a public PHP or Python symbol was removed", re: /^-\s*(public\s+function|def\s+[a-z_]+\s*\()/m },
-  // Route removal breaks callers that never imported anything.
-  { label: "a route or endpoint was removed", re: /^-.*\b(Route::(get|post|put|patch|delete)|@(Get|Post|Put|Patch|Delete)Mapping|app\.(get|post|put|patch|delete)\s*\()/m },
-  { label: "a whole file was deleted", re: /^deleted file mode /m }
-];
-var SCHEMA_REMOVAL_BODY = /\b(dropColumn|dropTable|dropIfExists|removeColumn|drop_column|drop_table|DROP\s+(TABLE|COLUMN|INDEX|CONSTRAINT)|TRUNCATE\s+TABLE)\b/i;
-var RENAME_METADATA = /^rename (?:from|to) /m;
-function fileBlocks(patch) {
-  return patch.split(/^(?=diff --git )/m).filter((b) => b.startsWith("diff --git "));
-}
-function renamedSchemaRemoval(patch) {
-  for (const block of fileBlocks(patch)) {
-    if (!RENAME_METADATA.test(block)) {
-      continue;
-    }
-    for (const line of block.split("\n")) {
-      if (line.startsWith("-") && !line.startsWith("---") && SCHEMA_REMOVAL_BODY.test(line)) {
-        return true;
-      }
-    }
-  }
-  return false;
-}
-var MAJOR_BUMP = /^-\s*"version"\s*:\s*"(\d+)\.[^"]*"[\s\S]{0,200}?^\+\s*"version"\s*:\s*"(\d+)\./m;
-function classifyDiff(patch) {
-  if (patch.trim() === "") {
-    return { verdict: "undecidable", markers: [], reason: "empty diff" };
-  }
-  const markers = [];
-  for (const { label, re } of DESTRUCTIVE_MARKERS) {
-    if (re.test(patch)) {
-      markers.push(label);
-    }
-  }
-  if (renamedSchemaRemoval(patch)) {
-    markers.push("a renamed file drops a column or table");
-  }
-  const bump = MAJOR_BUMP.exec(patch);
-  if (bump && bump[1] !== bump[2]) {
-    markers.push(`major version bump ${bump[1]}.x to ${bump[2]}.x`);
-  }
-  const filesChanged = (patch.match(/^diff --git /gm) ?? []).length;
-  if (markers.length > 0) {
-    return { verdict: "destructive", markers, filesChanged };
-  }
-  return { verdict: "additive", markers: [], filesChanged };
-}
-function fetchPatch(pr, opts = {}) {
-  const run5 = opts.exec ?? execFileSync;
-  const cwd = opts.cwd ?? process.cwd();
-  const capture = (file, args) => run5(file, args, { cwd, encoding: "utf-8", stdio: ["ignore", "pipe", "ignore"], timeout: 15e3 });
-  for (const ref of [`refs/pull/${pr}/head`, `pull/${pr}/head`]) {
-    try {
-      const base = capture("git", ["merge-base", "HEAD", ref]).trim();
-      if (base) {
-        const patch = capture("git", ["diff", `${base}...${ref}`]);
-        if (patch.trim() !== "") {
-          return { patch, source: "local" };
-        }
-      }
-    } catch {
-    }
-  }
-  if (opts.allowNetwork === false) {
-    return { patch: "", source: "none", reason: "no local ref and network reads disabled" };
-  }
-  try {
-    const patch = capture("gh", ["pr", "diff", String(pr), "--patch"]);
-    if (patch.trim() !== "") {
-      return { patch, source: "gh" };
-    }
-    return { patch: "", source: "none", reason: "gh returned an empty diff" };
-  } catch {
-    return { patch: "", source: "none", reason: "no local ref, and gh pr diff failed" };
-  }
-}
-function analyseMergeImpact(pr, opts = {}) {
-  const got = fetchPatch(pr, opts);
-  if (got.source === "none") {
-    return { verdict: "undecidable", markers: [], ...got.reason ? { reason: got.reason } : {} };
-  }
-  return classifyDiff(got.patch);
-}
-function describeImpact(pr, impact) {
-  const say = `Say "merge #${pr}" to authorize it.`;
-  switch (impact.verdict) {
-    case "additive":
-      return `Impact scan: PR #${pr} touches ${impact.filesChanged ?? 0} file(s) and trips no destructive marker \u2014 no schema drop, no removed export or route, no major bump, no BREAKING CHANGE. Additive as far as the diff can show, which is not the same as safe to merge: the base has moved since review and merging may trigger a deploy. ${say}`;
-    case "destructive":
-      return `Impact scan: PR #${pr} is NOT additive \u2014 ${impact.markers.join("; ")}. Read the diff before authorizing. ${say}`;
-    default:
-      return `Impact scan: could not read the diff for PR #${pr} (${impact.reason ?? "unknown"}), so nothing is known about what it changes. ${say}`;
-  }
-}
-
-// src/scripts/hooks/block_unauthorized_git.ts
-var EXIT_ALLOW3 = 0;
-var EXIT_BLOCK = 1;
-function _isObject4(v) {
-  return typeof v === "object" && v !== null && !Array.isArray(v);
-}
+// src/scripts/hooks/git_command_classifier.ts
 var BLOCK_OPS = /* @__PURE__ */ new Set([
   "publish",
   "tag",
@@ -1527,31 +1554,26 @@ var BLOCK_OPS = /* @__PURE__ */ new Set([
   /** Destroys uncommitted work belonging to a session this one cannot see. */
   "worktree-remove",
   /** `-x` is the flag that takes `.env` and local certificates. */
-  "clean-ignored"
-]);
-var WARN_OPS = /* @__PURE__ */ new Set([
-  "commit",
-  "push",
-  "pr-create",
-  "branch",
-  // ── Added 2026-09-03, deliberately at warn rather than block.
+  "clean-ignored",
+  // ── The consequence vocabulary, added 2026-09-06. Every one is already
+  // never-autonomous in the `non-destructive-by-default` prose.
   //
-  // Each is destructive in some reading, and each is also routine enough that
-  // blocking it would be the friction that gets the whole guard routed around —
-  // the failure mode this estate has already recorded twice. `reset-hard` is the
-  // sharpest case and stays here for a decidable reason: the Hard Floor's
-  // qualifier is "past unpushed work", and the command text cannot say whether
-  // the work was pushed.
-  "tag-force",
-  "rebase",
-  "reset-hard",
-  "clean",
-  "stash-drop",
-  "branch-delete",
-  "close"
+  // MEMBERSHIP HERE IS A COUNTING DECISION, NOT A REFUSAL. The set's name
+  // predates ADR-254, which deleted the reader that blocked: the one consumer
+  // that acts on it now is `conformance_scan`'s after-the-fact tally, so
+  // "blocked" describes what the Hard Floor requires of the model, never what
+  // this package does at tool-call time.
+  "prod-deploy",
+  "prod-data-destroy",
+  "prod-infra-change",
+  "external-send",
+  "money-movement",
+  "trunk-force-push",
+  "out-of-scope-destruction"
 ]);
 var G = "(?:-[A-Za-z-]+(?:=\\S+)?(?:\\s+\\S+)?\\s+)*";
 var P = "^(?:\\S*\\/)?";
+var CONSEQUENCE_TOOL_HEAD = /^(?:\S*\/)?(terraform|pulumi|kubectl|helm|aws|gcloud|az|vercel|netlify|flyctl|fly|wrangler|serverless|sls|eb|heroku|cap|psql|mysql|mariadb|sqlite3|mongosh|mongo|redis-cli|sendmail|msmtp|mail|mailx|curl|stripe|braintree|paypal|rm)\b/i;
 function ghApiWrite(pathRe) {
   return new RegExp(
     `${P}gh\\s+api\\b(?=[^\\n]*${pathRe})(?=[^\\n]*(?:-X|--method)\\s+(?:POST|PATCH|PUT|DELETE)\\b)`,
@@ -1632,6 +1654,13 @@ var COMMAND_OPS = [
   // Above `push`, and both spellings: `--force` and `--force-with-lease`. The
   // "safe force" is in the same class here because what it is safe against is a
   // stale local view, not a collaborator who pushed after your fetch.
+  {
+    op: "trunk-force-push",
+    re: new RegExp(
+      `${P}git\\s+${G}push\\b[^\\n;|&]*(--force\\b|--force-with-lease\\b|\\s-f\\b)[^\\n;|&]*\\b(main|master|trunk|production|prod)\\b`,
+      "i"
+    )
+  },
   {
     op: "force-push",
     re: new RegExp(`${P}git\\s+${G}push\\b[^\\n;|&]*(--force\\b|--force-with-lease\\b|\\s-f\\b)`, "i")
@@ -1660,37 +1689,64 @@ var COMMAND_OPS = [
     )
   },
   { op: "close", re: new RegExp(`${P}gh\\s+(pr|issue)\\s+close\\b`, "i") },
+  // ── Consequence operations, added 2026-09-06
+  // (`road-to-authorization-that-reaches-further` 2.1).
+  //
+  // ORDER: above the generic `push`/`commit` fallbacks, because
+  // `trunk-force-push` is a `git push` and the most specific pattern must win —
+  // the rule this table states at its head.
+  //
+  // These classify commands the count could not see before. They add NOTHING to
+  // any refusal path: `commandOp` and `BLOCK_OPS` have exactly one consumer
+  // that acts on them, the after-the-fact tally in `conformance_scan`, and this
+  // change does not add a second.
+  {
+    op: "prod-data-destroy",
+    re: new RegExp(
+      `${P}(psql|mysql|mariadb|sqlite3|mongosh?)\\b[^\\n]*\\b(drop\\s+(table|database|schema)|truncate|delete\\s+from)\\b|${P}aws\\s+s3\\s+(rm|rb)\\b|${P}aws\\s+(dynamodb|rds)\\s+delete-\\S+|${P}redis-cli\\b[^\\n]*\\bflush(all|db)\\b`,
+      "i"
+    )
+  },
+  {
+    op: "prod-infra-change",
+    re: new RegExp(
+      `${P}terraform\\s+(apply|destroy)\\b|${P}pulumi\\s+(up|destroy)\\b|${P}kubectl\\s+(apply|delete|scale|drain)\\b|${P}helm\\s+(install|upgrade|uninstall|rollback)\\b|${P}aws\\s+(iam|ec2|route53|elbv2)\\s+(create|delete|put|update|modify|attach|detach)-\\S+|${P}(gcloud|az)\\s+\\S+\\s+(create|delete|update)\\b`,
+      "i"
+    )
+  },
+  {
+    op: "prod-deploy",
+    re: new RegExp(
+      `${P}(vercel|netlify|flyctl|fly|wrangler|serverless|sls|eb|heroku)\\s+${G}deploy\\b|${P}(vercel|netlify)\\b[^\\n]*--prod\\b|${P}(npm|pnpm|yarn)\\s+run\\s+deploy\\b|${P}cap\\s+production\\s+deploy\\b`,
+      "i"
+    )
+  },
+  {
+    op: "external-send",
+    re: new RegExp(
+      `${P}(sendmail|msmtp|mailx?)\\b|${P}curl\\b(?=[^\\n]*(?:-X|--request)\\s+(?:POST|PUT|PATCH)\\b)(?=[^\\n]*https?:\\/\\/)`,
+      "i"
+    )
+  },
+  {
+    op: "money-movement",
+    re: new RegExp(
+      `${P}(stripe|braintree|paypal)\\s+\\S*(charge|refund|payout|transfer|payment)\\S*\\b`,
+      "i"
+    )
+  },
+  {
+    // `rm -rf` on an ABSOLUTE path or a home-relative one. Deliberately not
+    // "outside the working tree" — this function receives a command string and
+    // no cwd, so that reading is not decidable here and a classifier that
+    // guesses is worse than one that under-reports.
+    op: "out-of-scope-destruction",
+    re: new RegExp(`${P}rm\\s+(-\\S+\\s+)*-\\S*[rR]\\S*\\s+(-\\S+\\s+)*(~|/)\\S*`, "i")
+  },
   { op: "push", re: new RegExp(`${P}git\\s+${G}push\\b`, "i") },
   { op: "commit", re: new RegExp(`${P}git\\s+${G}commit\\b`, "i") },
   { op: "branch", re: new RegExp(`${P}git\\s+${G}(checkout\\s+-b|switch\\s+-c)\\b`, "i") }
 ];
-var COMMAND_TOOLS = /* @__PURE__ */ new Set([
-  "launch-process",
-  "launch_process",
-  "Bash",
-  "BashTool",
-  "run-process",
-  "runProcess",
-  "shell",
-  "execute_shell",
-  "RunShellCommand"
-]);
-function extractCommand(envelope) {
-  const payload = _isObject4(envelope["payload"]) ? envelope["payload"] : envelope;
-  const toolRaw = payload["tool_name"] ?? payload["toolName"] ?? payload["tool"];
-  const tool = typeof toolRaw === "string" ? toolRaw : null;
-  if (tool !== null && !COMMAND_TOOLS.has(tool)) {
-    return null;
-  }
-  const input = _isObject4(payload["tool_input"]) ? payload["tool_input"] : _isObject4(payload["toolInput"]) ? payload["toolInput"] : payload;
-  for (const key of ["command", "cmd", "script"]) {
-    const v = input[key];
-    if (typeof v === "string" && v.trim()) {
-      return v;
-    }
-  }
-  return null;
-}
 function splitOutsideQuotes(command) {
   const parts = [];
   let cur = "";
@@ -1837,7 +1893,7 @@ function invokedSegments(command, depth = 0) {
 function commandOp(command) {
   let found = null;
   for (const seg of invokedSegments(command)) {
-    if (!/^(?:\S*\/)?(git|gh|npm|pnpm|yarn)\b/.test(seg)) {
+    if (!/^(?:\S*\/)?(git|gh|npm|pnpm|yarn)\b/.test(seg) && !CONSEQUENCE_TOOL_HEAD.test(seg)) {
       continue;
     }
     for (const { op, re } of COMMAND_OPS) {
@@ -1852,191 +1908,50 @@ function commandOp(command) {
   }
   return found;
 }
-function mergeTargetOf(command) {
-  const gh = /\bgh\s+pr\s+merge\s+(?:-{1,2}\S+\s+)*?(\d{1,10})\b/i.exec(command);
-  if (gh) {
-    return _boundedTarget(gh[1]);
-  }
-  const api = /\/pulls\/(\d{1,10})\/merge\b/i.exec(command);
-  return api ? _boundedTarget(api[1]) : null;
-}
-function _boundedTarget(digits) {
-  const n = Number.parseInt(digits, 10);
-  return Number.isSafeInteger(n) && n > 0 && n <= PR_NUMBER_MAX ? n : null;
-}
-function grantCovers(grants, op, target) {
-  if (op !== "pr-merge" || target === null) {
-    return null;
-  }
-  return grants.find(
-    (g) => g.op === "pr-merge" && g.targets.includes(target) && !g.consumed.includes(target)
-  ) ?? null;
-}
-var LEDGER_MAX_AGE_MS = 30 * 60 * 1e3;
-function _loadLedger(consumer_root, session_id, now) {
-  const grants = readGrants(consumer_root, session_id);
-  const candidates = [ledgerFileFor(session_id)];
-  if (!candidates.includes(STATE_FILE2)) {
-    candidates.push(STATE_FILE2);
-  }
-  for (const rel of candidates) {
-    const found = _readLedgerFile(path3.join(consumer_root, rel), session_id, now);
-    if (found !== null) {
-      return { ...found, grants };
-    }
-  }
-  return { authorized: /* @__PURE__ */ new Set(), present: false, grants };
-}
-function _readLedgerFile(file, session_id, now) {
-  try {
-    const raw = fs3.readFileSync(file, "utf8");
-    const decoded = JSON.parse(raw);
-    if (_isObject4(decoded) && Array.isArray(decoded["authorized"])) {
-      const ledgerSession = typeof decoded["session_id"] === "string" ? decoded["session_id"] : "";
-      if (session_id && ledgerSession && ledgerSession !== session_id) {
-        return null;
-      }
-      const at = Date.parse(String(decoded["detected_at"] ?? ""));
-      if (Number.isFinite(at) && now - at > LEDGER_MAX_AGE_MS) {
-        return null;
-      }
-      return {
-        authorized: new Set(decoded["authorized"].filter(Boolean)),
-        present: true
-      };
+function commandObject(op, command) {
+  const patterns = COMMAND_OBJECTS[op];
+  if (!patterns) return null;
+  for (const re of patterns) {
+    const m = new RegExp(re.source, re.flags.replace("g", "")).exec(command);
+    const raw = m?.[1];
+    if (raw) {
+      const value = raw.trim().replace(/^["'`]+|["'`]+$/g, "").replace(/[.,;:]+$/, "").toLowerCase();
+      if (value) return value;
     }
-  } catch {
   }
   return null;
 }
-function decide(command, ledger, impact) {
-  if (command === null) {
-    return { exit: EXIT_ALLOW3, stdout: "", stderr: "" };
-  }
-  const op = commandOp(command);
-  if (op === null || ledger.authorized.has(op)) {
-    return { exit: EXIT_ALLOW3, stdout: "", stderr: "" };
-  }
-  const target = mergeTargetOf(command);
-  if (grantCovers(ledger.grants ?? [], op, target) && target !== null) {
-    return { exit: EXIT_ALLOW3, stdout: "", stderr: "", consumedTarget: target };
-  }
-  const shown = command.length > 120 ? `${command.slice(0, 117)}\u2026` : command;
-  if (BLOCK_OPS.has(op)) {
-    const scan = op === "pr-merge" && target !== null && impact ? ` ${impact}` : "";
-    const reason = `Blocked: \`${op}\` with no authorization in this turn's prompt. This operation is irreversible and non-destructive-by-default already declares it never-autonomous. Command: ${shown}.${scan} Ask the user, in one numbered-options block, and run it only after they answer this turn.`;
-    return { exit: EXIT_BLOCK, stdout: "", stderr: `${reason}
-`, blockedOp: op };
-  }
-  if (WARN_OPS.has(op)) {
-    const reason = `No \`${op}\` authorization found in this turn's prompt (commit-policy: a one-shot authorization is spent on the operation it named). If the user did authorize it this turn, proceed; otherwise stop and ask. Command: ${shown}`;
-    return {
-      exit: EXIT_ALLOW3,
-      stdout: `${JSON.stringify({ decision: "warn", reason })}
-`,
-      stderr: ""
-    };
-  }
-  return { exit: EXIT_ALLOW3, stdout: "", stderr: "" };
-}
-function run3(stdin_text, options) {
-  let envelope = {};
-  if (stdin_text.trim()) {
-    try {
-      const decoded = JSON.parse(stdin_text);
-      if (_isObject4(decoded)) {
-        envelope = decoded;
-      }
-    } catch {
-      return EXIT_ALLOW3;
-    }
-  }
-  const session_id = typeof envelope["session_id"] === "string" ? envelope["session_id"] : "";
-  const command = extractCommand(envelope);
-  const ledger = _loadLedger(options.consumer_root, session_id, Date.now());
-  let impact;
-  const stage1 = command === null ? null : commandOp(command);
-  const stage2Target = command === null ? null : mergeTargetOf(command);
-  if (stage1 === "pr-merge" && stage2Target !== null && !ledger.authorized.has("pr-merge") && !grantCovers(ledger.grants ?? [], "pr-merge", stage2Target)) {
-    try {
-      impact = describeImpact(
-        stage2Target,
-        analyseMergeImpact(stage2Target, { cwd: options.consumer_root })
-      );
-    } catch {
-    }
-  }
-  const decision = decide(command, ledger, impact);
-  if (decision.consumedTarget !== void 0) {
-    consumeGrantTarget(options.consumer_root, session_id, decision.consumedTarget);
-  }
-  if (decision.blockedOp) {
-    try {
-      atomic_write_json(path3.join(options.consumer_root, pendingFileFor(session_id)), {
-        op: decision.blockedOp,
-        session_id,
-        refused_at: (/* @__PURE__ */ new Date()).toISOString()
-      });
-    } catch {
-    }
-  }
-  if (decision.stdout) {
-    process.stdout.write(decision.stdout);
-  }
-  if (decision.stderr) {
-    process.stderr.write(decision.stderr);
-  }
-  return decision.exit;
-}
-function main3(argv) {
-  const args = argv ?? process.argv.slice(2);
-  let consumer_root = process.cwd();
-  for (let i = 0; i < args.length; i += 1) {
-    const a = args[i];
-    if (a === "--project-dir" && args[i + 1] !== void 0) {
-      consumer_root = args[i + 1];
-      i += 1;
-    } else if (a !== void 0 && a.startsWith("--project-dir=")) {
-      consumer_root = a.slice("--project-dir=".length);
-    }
-  }
-  return run3(readHookStdin(), { consumer_root });
-}
-function _isCliEntry3() {
-  if (true) {
-    return false;
-  }
-  if (process.argv[1] === void 0) {
-    return false;
-  }
-  const argvUrl = pathToFileURL3(path3.resolve(process.argv[1])).href;
-  if (import.meta.url === argvUrl) {
-    return true;
-  }
-  try {
-    const here = fs3.realpathSync(fileURLToPath3(import.meta.url));
-    const argv = fs3.realpathSync(path3.resolve(process.argv[1]));
-    return here === argv;
-  } catch {
-    return false;
-  }
-}
-if (_isCliEntry3()) {
-  process.exit(main3());
-}
+var COMMAND_OBJECTS = {
+  "prod-data-destroy": [
+    /\bdrop\s+(?:table|database|schema|collection)\s+(?:if\s+exists\s+)?["'`]?([\w.$-]+)/i,
+    /\btruncate\s+(?:table\s+)?["'`]?([\w.$-]+)/i,
+    /\bdelete\s+from\s+["'`]?([\w.$-]+)/i,
+    /\bs3:\/\/([\w.-]+)/i,
+    /--table-name[= ]["'`]?([\w.-]+)/i
+  ],
+  "external-send": [
+    /\bhttps?:\/\/([^\s/"'`]+)/i,
+    /([A-Za-z0-9._%+-]+@[A-Za-z0-9.-]+\.[A-Za-z]{2,})/
+  ],
+  "money-movement": [
+    /--customer[= ]["'`]?([\w.-]+)/i,
+    /--amount[= ]["'`]?([\d.,]+)/i,
+    /\b(\d[\d.,]*)\s*(?:eur|usd)\b/i
+  ]
+};
 
 // src/scripts/hooks/turn_end_gate_hook.ts
-import * as fs6 from "node:fs";
-import * as path6 from "node:path";
-import { fileURLToPath as fileURLToPath6, pathToFileURL as pathToFileURL6 } from "node:url";
+import * as fs5 from "node:fs";
+import * as path5 from "node:path";
+import { fileURLToPath as fileURLToPath5, pathToFileURL as pathToFileURL5 } from "node:url";
 
 // src/scripts/hooks/end_review_nudge_hook.ts
 import { spawnSync } from "node:child_process";
 import * as crypto from "node:crypto";
-import * as fs4 from "node:fs";
+import * as fs3 from "node:fs";
 import * as os from "node:os";
-import * as path4 from "node:path";
-import { fileURLToPath as fileURLToPath4, pathToFileURL as pathToFileURL4 } from "node:url";
+import * as path3 from "node:path";
+import { fileURLToPath as fileURLToPath3, pathToFileURL as pathToFileURL3 } from "node:url";
 
 // src/scripts/_lib/review_skipped_record.ts
 var PRODUCER_PRIVACY_CLASS = "ids-only";
@@ -2091,11 +2006,11 @@ var ENVELOPE_KEYS = [
   "event",
   "payload"
 ];
-function _isObject5(obj) {
+function _isObject4(obj) {
   return typeof obj === "object" && obj !== null && !Array.isArray(obj);
 }
 function looks_like_envelope(obj) {
-  if (!_isObject5(obj)) {
+  if (!_isObject4(obj)) {
     return false;
   }
   return ENVELOPE_KEYS.every((key) => key in obj);
@@ -2114,14 +2029,14 @@ function unwrap(stdin_text, default_platform = "generic") {
   if (looks_like_envelope(decoded)) {
     const env = decoded;
     let payload2 = env["payload"];
-    if (!payload2 || !_isObject5(payload2)) {
+    if (!payload2 || !_isObject4(payload2)) {
       payload2 = {};
     }
     const platRaw = env["platform"];
     const platform = String(platRaw || default_platform);
     return [env, payload2, platform];
   }
-  const payload = _isObject5(decoded) ? decoded : {};
+  const payload = _isObject4(decoded) ? decoded : {};
   return [
     {
       schema_version: 1,
@@ -2147,13 +2062,13 @@ function isSafeTranscriptPath(rawPath, opts = {}) {
   const homeDir = opts.homeDir ?? os.homedir();
   const maxBytes = opts.maxBytes ?? TRANSCRIPT_SCAN_MAX_BYTES;
   try {
-    const realHome = fs4.realpathSync(homeDir);
-    const realPath = fs4.realpathSync(rawPath);
-    const relative2 = path4.relative(realHome, realPath);
-    if (relative2 === "" || relative2.startsWith("..") || path4.isAbsolute(relative2)) {
+    const realHome = fs3.realpathSync(homeDir);
+    const realPath = fs3.realpathSync(rawPath);
+    const relative2 = path3.relative(realHome, realPath);
+    if (relative2 === "" || relative2.startsWith("..") || path3.isAbsolute(relative2)) {
       return false;
     }
-    const { size } = fs4.statSync(realPath);
+    const { size } = fs3.statSync(realPath);
     return size <= maxBytes;
   } catch {
     return false;
@@ -2212,13 +2127,13 @@ var BINARY_PROBE_BYTES = 8e3;
 var UNTRACKED_FILE_READ_CAP_BYTES = 8 * 1024 * 1024;
 function untrackedFileLineCount(cwd, relPath) {
   try {
-    const abs = path4.resolve(cwd, relPath);
-    const size = fs4.statSync(abs).size;
+    const abs = path3.resolve(cwd, relPath);
+    const size = fs3.statSync(abs).size;
     if (size === 0) return 0;
     if (size > UNTRACKED_FILE_READ_CAP_BYTES) {
       return MUTATION_LINE_THRESHOLD + 1;
     }
-    const buf = fs4.readFileSync(abs);
+    const buf = fs3.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;
@@ -2308,19 +2223,19 @@ function appendReviewSkippedTelemetry(workspaceRoot, diffLines, mutationMeasure)
   });
   if (errors.length || line === null) return;
   try {
-    const dir = path4.join(workspaceRoot, "agents", "runtime", "state", "audit");
-    fs4.mkdirSync(dir, { recursive: true });
-    const file = path4.join(dir, `${ts.slice(0, 7)}.jsonl`);
-    fs4.appendFileSync(file, `${JSON.stringify(line)}
+    const dir = path3.join(workspaceRoot, "agents", "runtime", "state", "audit");
+    fs3.mkdirSync(dir, { recursive: true });
+    const file = path3.join(dir, `${ts.slice(0, 7)}.jsonl`);
+    fs3.appendFileSync(file, `${JSON.stringify(line)}
 `, "utf8");
   } catch {
   }
 }
 function sessionStateDir(workspaceRoot) {
-  return path4.join(workspaceRoot, "agents", "runtime", "state", "end-review-nudge");
+  return path3.join(workspaceRoot, "agents", "runtime", "state", "end-review-nudge");
 }
 function sessionStateFile(workspaceRoot, sessionKey) {
-  return path4.join(sessionStateDir(workspaceRoot), `${sessionKey}.json`);
+  return path3.join(sessionStateDir(workspaceRoot), `${sessionKey}.json`);
 }
 function deriveSessionKey2(envelope, payload) {
   const raw = str(envelope["session_id"]) || str(payload["transcript_path"] ?? payload["transcriptPath"]);
@@ -2329,7 +2244,7 @@ function deriveSessionKey2(envelope, payload) {
 }
 function hasFiredThisSession(workspaceRoot, sessionKey) {
   try {
-    return fs4.existsSync(sessionStateFile(workspaceRoot, sessionKey));
+    return fs3.existsSync(sessionStateFile(workspaceRoot, sessionKey));
   } catch {
     return false;
   }
@@ -2343,7 +2258,7 @@ function markFiredThisSession(workspaceRoot, sessionKey, ts) {
 function _read_stdin() {
   return readHookStdin();
 }
-function main4() {
+function main3() {
   const [envelope, payload] = unwrap(_read_stdin(), "claude");
   const event = String(envelope["event"] ?? "");
   if (event !== "" && event !== "stop") {
@@ -2372,7 +2287,7 @@ function main4() {
   let reviewerRan = false;
   if (transcriptPath && isSafeTranscriptPath(transcriptPath)) {
     try {
-      reviewerRan = scanTranscriptForReviewer(fs4.readFileSync(transcriptPath, "utf-8"));
+      reviewerRan = scanTranscriptForReviewer(fs3.readFileSync(transcriptPath, "utf-8"));
     } catch {
       reviewerRan = false;
     }
@@ -2395,34 +2310,34 @@ function main4() {
   );
   return EXIT_WARN2;
 }
-function _isCliEntry4() {
+function _isCliEntry3() {
   if (true) {
     return false;
   }
   if (process.argv[1] === void 0) {
     return false;
   }
-  const argvUrl = pathToFileURL4(path4.resolve(process.argv[1])).href;
+  const argvUrl = pathToFileURL3(path3.resolve(process.argv[1])).href;
   if (import.meta.url === argvUrl) {
     return true;
   }
   try {
-    const here = fs4.realpathSync(fileURLToPath4(import.meta.url));
-    const argv = fs4.realpathSync(path4.resolve(process.argv[1]));
+    const here = fs3.realpathSync(fileURLToPath3(import.meta.url));
+    const argv = fs3.realpathSync(path3.resolve(process.argv[1]));
     return here === argv;
   } catch {
     return false;
   }
 }
-if (_isCliEntry4()) {
-  process.exit(main4());
+if (_isCliEntry3()) {
+  process.exit(main3());
 }
 
 // src/scripts/hooks/subagent_ledger_hook.ts
 import * as crypto2 from "node:crypto";
-import * as fs5 from "node:fs";
-import * as path5 from "node:path";
-import { fileURLToPath as fileURLToPath5, pathToFileURL as pathToFileURL5 } from "node:url";
+import * as fs4 from "node:fs";
+import * as path4 from "node:path";
+import { fileURLToPath as fileURLToPath4, pathToFileURL as pathToFileURL4 } from "node:url";
 
 // src/scripts/_lib/subagent_response.ts
 var MAX_SUMMARY_CHARS = 2e3;
@@ -2524,11 +2439,11 @@ function validateResponse(input) {
 }
 
 // src/scripts/hooks/subagent_ledger_hook.ts
-var EXIT_ALLOW4 = 0;
+var EXIT_ALLOW3 = 0;
 function isObject2(v) {
   return typeof v === "object" && v !== null && !Array.isArray(v);
 }
-var LEDGER_DIR = path5.join("agents", "runtime", "state", "subagent-ledger");
+var LEDGER_DIR = path4.join("agents", "runtime", "state", "subagent-ledger");
 var OPEN_SUBDIR = "open";
 var OPEN_RECORD_TTL_MS = 24 * 60 * 60 * 1e3;
 function refFor(agentId) {
@@ -2618,10 +2533,10 @@ function _jsonObjectCandidates(message) {
   return out;
 }
 function openDir(root) {
-  return path5.join(root, LEDGER_DIR, OPEN_SUBDIR);
+  return path4.join(root, LEDGER_DIR, OPEN_SUBDIR);
 }
 function openFile(root, ref) {
-  return path5.join(openDir(root), `${ref}.json`);
+  return path4.join(openDir(root), `${ref}.json`);
 }
 var DEPTH_BASES = /* @__PURE__ */ new Set(["observed", "asserted-parent", "assumed-root"]);
 function _asOpenRecord(value, expectedRef) {
@@ -2648,7 +2563,7 @@ function readOpenRecords(root) {
   const out = /* @__PURE__ */ new Map();
   let names;
   try {
-    names = fs5.readdirSync(openDir(root));
+    names = fs4.readdirSync(openDir(root));
   } catch {
     return out;
   }
@@ -2656,7 +2571,7 @@ function readOpenRecords(root) {
     if (!name.endsWith(".json")) continue;
     const expectedRef = name.slice(0, -".json".length);
     try {
-      const raw = fs5.readFileSync(path5.join(openDir(root), name), "utf8");
+      const raw = fs4.readFileSync(path4.join(openDir(root), name), "utf8");
       const rec = _asOpenRecord(JSON.parse(raw), expectedRef);
       if (rec) out.set(rec.ref, rec);
     } catch {
@@ -2671,13 +2586,13 @@ function resolveDepth(parentRef, open) {
   return { depth: parent.depth + 1, depth_basis: "observed" };
 }
 function ledgerFileFor2(root, ts) {
-  return path5.join(root, LEDGER_DIR, `${ts.slice(0, 7)}.jsonl`);
+  return path4.join(root, LEDGER_DIR, `${ts.slice(0, 7)}.jsonl`);
 }
 function appendLedgerLine(root, ts, line) {
   if (is_replay_mode()) return;
   const file = ledgerFileFor2(root, ts);
-  fs5.mkdirSync(path5.dirname(file), { recursive: true });
-  fs5.appendFileSync(file, `${JSON.stringify(line)}
+  fs4.mkdirSync(path4.dirname(file), { recursive: true });
+  fs4.appendFileSync(file, `${JSON.stringify(line)}
 `, "utf8");
 }
 var WALL_CLOCK_ARMS_MS = [
@@ -2691,7 +2606,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 = fs5.existsSync(path5.join(root, LEDGER_DIR));
+  const ledgerPresent = fs4.existsSync(path4.join(root, LEDGER_DIR));
   const open = readOpenRecords(root);
   let maxDepth = 0;
   let counted = 0;
@@ -2719,13 +2634,13 @@ function writeOpenRecord(root, rec) {
 function removeOpenRecord(root, ref) {
   if (is_replay_mode()) return;
   try {
-    fs5.unlinkSync(openFile(root, ref));
+    fs4.unlinkSync(openFile(root, ref));
   } catch {
   }
 }
 function countOpen(root) {
   try {
-    return fs5.readdirSync(openDir(root)).filter((n) => n.endsWith(".json")).length;
+    return fs4.readdirSync(openDir(root)).filter((n) => n.endsWith(".json")).length;
   } catch {
     return 0;
   }
@@ -2852,9 +2767,9 @@ function handleStop(root, payload, nowIso, sessionId) {
 }
 function processEnvelope(envelope, consumerRoot) {
   try {
-    if (!isObject2(envelope)) return EXIT_ALLOW4;
+    if (!isObject2(envelope)) return EXIT_ALLOW3;
     const event = envelope["event"];
-    if (event !== "subagent_start" && event !== "subagent_stop") return EXIT_ALLOW4;
+    if (event !== "subagent_start" && event !== "subagent_stop") return EXIT_ALLOW3;
     const payload = unwrapPayload(envelope);
     const nowIso = (/* @__PURE__ */ new Date()).toISOString();
     const sessionId = str2(payload, "session_id", "sessionId") ?? str2(envelope, "session_id", "sessionId");
@@ -2862,9 +2777,9 @@ function processEnvelope(envelope, consumerRoot) {
     if (event === "subagent_start") handleStart(consumerRoot, payload, nowIso, sessionId);
     else handleStop(consumerRoot, payload, nowIso, sessionId);
   } catch {
-    return EXIT_ALLOW4;
+    return EXIT_ALLOW3;
   }
-  return EXIT_ALLOW4;
+  return EXIT_ALLOW3;
 }
 function resolveConsumerRoot(envelope) {
   if (isObject2(envelope)) {
@@ -2876,34 +2791,34 @@ function resolveConsumerRoot(envelope) {
   }
   return process.cwd();
 }
-function main5() {
+function main4() {
   const raw = readHookStdin();
   let envelope = {};
   try {
     envelope = raw.trim() ? JSON.parse(raw) : {};
   } catch {
-    return EXIT_ALLOW4;
+    return EXIT_ALLOW3;
   }
   return processEnvelope(envelope, resolveConsumerRoot(envelope));
 }
-function _isCliEntry5() {
+function _isCliEntry4() {
   if (true) {
     return false;
   }
   if (process.argv[1] === void 0) return false;
-  const argvUrl = pathToFileURL5(path5.resolve(process.argv[1])).href;
+  const argvUrl = pathToFileURL4(path4.resolve(process.argv[1])).href;
   if (import.meta.url === argvUrl) return true;
   try {
-    return fs5.realpathSync(fileURLToPath5(import.meta.url)) === fs5.realpathSync(path5.resolve(process.argv[1]));
+    return fs4.realpathSync(fileURLToPath4(import.meta.url)) === fs4.realpathSync(path4.resolve(process.argv[1]));
   } catch {
     return false;
   }
 }
-if (_isCliEntry5()) process.exit(main5());
+if (_isCliEntry4()) process.exit(main4());
 
 // src/scripts/hooks/turn_end_gate_hook.ts
-var EXIT_BLOCK2 = 1;
-var EXIT_ALLOW5 = 0;
+var EXIT_BLOCK = 1;
+var EXIT_ALLOW4 = 0;
 var TRANSCRIPT_READ_MAX_BYTES = 8 * 1024 * 1024;
 function stripFencedBlocks(text) {
   const out = [];
@@ -3008,7 +2923,7 @@ function detectPromissory(reply) {
 function readCiSettled(workspaceRoot, session_id) {
   if (!hasStableSessionId(session_id)) return { seen: false, settled: false };
   try {
-    const raw = fs6.readFileSync(path6.join(workspaceRoot, statePathFor(session_id)), "utf-8");
+    const raw = fs5.readFileSync(path5.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)) {
@@ -3044,8 +2959,8 @@ function detectCompletionClaim(reply, ci) {
 function readLanguagePin(workspaceRoot, session_id) {
   if (!hasStableSessionId(session_id)) return "und";
   try {
-    const raw = fs6.readFileSync(
-      path6.join(workspaceRoot, statePathFor2(session_id)),
+    const raw = fs5.readFileSync(
+      path5.join(workspaceRoot, statePathFor2(session_id)),
       "utf-8"
     );
     const decoded = JSON.parse(raw);
@@ -3101,7 +3016,7 @@ function sessionStateFile2(workspaceRoot, sessionKey) {
 }
 function alreadyRefusedTurn(workspaceRoot, sessionKey, turnOrdinal) {
   try {
-    const raw = fs6.readFileSync(sessionStateFile2(workspaceRoot, sessionKey), "utf-8");
+    const raw = fs5.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;
@@ -3115,7 +3030,7 @@ function markRefusedTurn(workspaceRoot, sessionKey, turnOrdinal, detectors) {
   const file = sessionStateFile2(workspaceRoot, sessionKey);
   let prev = null;
   try {
-    prev = parseRecord(fs6.readFileSync(file, "utf-8"));
+    prev = parseRecord(fs5.readFileSync(file, "utf-8"));
   } catch {
   }
   let version;
@@ -3142,10 +3057,10 @@ function readTranscriptTail(transcriptPath, opts = {}) {
   if (!transcriptPath || !isSafeTranscriptPath(transcriptPath, opts)) return empty;
   let lines;
   try {
-    if (opts.maxBytes !== void 0 && fs6.statSync(transcriptPath).size > opts.maxBytes) {
+    if (opts.maxBytes !== void 0 && fs5.statSync(transcriptPath).size > opts.maxBytes) {
       return empty;
     }
-    lines = fs6.readFileSync(transcriptPath, "utf-8").split("\n");
+    lines = fs5.readFileSync(transcriptPath, "utf-8").split("\n");
   } catch {
     return empty;
   }
@@ -3221,15 +3136,15 @@ function _messageText(content) {
 function str3(v) {
   return typeof v === "string" ? v : "";
 }
-function main6() {
+function main5() {
   let envelope;
   let payload;
   try {
     [envelope, payload] = unwrap(readHookStdin(), "claude");
   } catch {
-    return EXIT_ALLOW5;
+    return EXIT_ALLOW4;
   }
-  if (payload["stop_hook_active"] === true) return EXIT_ALLOW5;
+  if (payload["stop_hook_active"] === true) return EXIT_ALLOW4;
   const workspaceRoot = str3(envelope["workspace_root"]) || process.cwd();
   let dispatchOpen = false;
   try {
@@ -3242,10 +3157,10 @@ function main6() {
   const { lastAssistant, turnOrdinal, toolCalls } = readTranscriptTail(transcriptPath, {
     maxBytes: TRANSCRIPT_READ_MAX_BYTES
   });
-  if (!lastAssistant) return EXIT_ALLOW5;
+  if (!lastAssistant) return EXIT_ALLOW4;
   const rawSessionId = str3(envelope["session_id"]) || "";
   const sessionKey = deriveSessionKey(rawSessionId || "unknown-session");
-  if (alreadyRefusedTurn(workspaceRoot, sessionKey, turnOrdinal)) return EXIT_ALLOW5;
+  if (alreadyRefusedTurn(workspaceRoot, sessionKey, turnOrdinal)) return EXIT_ALLOW4;
   const findings = [];
   for (const f of [
     // A and D are the completion-adjacent pair a pending dispatch excuses
@@ -3268,7 +3183,7 @@ function main6() {
   ]) {
     if (f) findings.push(f);
   }
-  if (findings.length === 0) return EXIT_ALLOW5;
+  if (findings.length === 0) return EXIT_ALLOW4;
   markRefusedTurn(
     workspaceRoot,
     sessionKey,
@@ -3286,40 +3201,40 @@ ${lines.join("\n")}
   This turn will not be refused a second time.
 `
   );
-  return EXIT_BLOCK2;
+  return EXIT_BLOCK;
 }
-function _isCliEntry6() {
+function _isCliEntry5() {
   if (true) {
     return false;
   }
   if (process.argv[1] === void 0) {
     return false;
   }
-  const argvUrl = pathToFileURL6(path6.resolve(process.argv[1])).href;
+  const argvUrl = pathToFileURL5(path5.resolve(process.argv[1])).href;
   if (import.meta.url === argvUrl) {
     return true;
   }
   try {
-    const here = fs6.realpathSync(fileURLToPath6(import.meta.url));
-    const argv = fs6.realpathSync(path6.resolve(process.argv[1]));
+    const here = fs5.realpathSync(fileURLToPath5(import.meta.url));
+    const argv = fs5.realpathSync(path5.resolve(process.argv[1]));
     return here === argv;
   } catch {
     return false;
   }
 }
-if (_isCliEntry6()) {
-  process.exit(main6());
+if (_isCliEntry5()) {
+  process.exit(main5());
 }
 
 // src/scripts/hooks/evidence_independence.ts
 import crypto3 from "node:crypto";
-import fs7 from "node:fs";
-import path7 from "node:path";
-import { fileURLToPath as fileURLToPath7, pathToFileURL as pathToFileURL7 } from "node:url";
-var EXIT_ALLOW6 = 0;
-var EXIT_BLOCK3 = 1;
-var STATE_FILE3 = path7.join("agents", "state", "evidence-dispatch.json");
-function _isObject6(v) {
+import fs6 from "node:fs";
+import path6 from "node:path";
+import { fileURLToPath as fileURLToPath6, pathToFileURL as pathToFileURL6 } from "node:url";
+var EXIT_ALLOW5 = 0;
+var EXIT_BLOCK2 = 1;
+var STATE_FILE3 = path6.join("agents", "state", "evidence-dispatch.json");
+function _isObject5(v) {
   return typeof v === "object" && v !== null && !Array.isArray(v);
 }
 var DISPATCH_TOOLS = /* @__PURE__ */ new Set([
@@ -3372,10 +3287,10 @@ function preloadedVerdict(prompt) {
   return null;
 }
 function extractDispatch(envelope) {
-  const payload = _isObject6(envelope["payload"]) ? envelope["payload"] : envelope;
+  const payload = _isObject5(envelope["payload"]) ? envelope["payload"] : envelope;
   const toolRaw = payload["tool_name"] ?? payload["toolName"] ?? payload["tool"];
   const tool = typeof toolRaw === "string" ? toolRaw : null;
-  const input = _isObject6(payload["tool_input"]) ? payload["tool_input"] : _isObject6(payload["toolInput"]) ? payload["toolInput"] : payload;
+  const input = _isObject5(payload["tool_input"]) ? payload["tool_input"] : _isObject5(payload["toolInput"]) ? payload["toolInput"] : payload;
   for (const key of ["prompt", "instructions", "task", "description"]) {
     const v = input[key];
     if (typeof v === "string" && v.trim()) {
@@ -3386,8 +3301,8 @@ function extractDispatch(envelope) {
 }
 function _ledgerStamp(consumer_root) {
   try {
-    const raw = fs7.readFileSync(
-      path7.join(consumer_root, "agents", "state", "git-authorization.json"),
+    const raw = fs6.readFileSync(
+      path6.join(consumer_root, "agents", "state", "git-authorization.json"),
       "utf8"
     );
     const d = JSON.parse(raw);
@@ -3398,8 +3313,8 @@ function _ledgerStamp(consumer_root) {
 }
 function _load(target) {
   try {
-    const decoded = JSON.parse(fs7.readFileSync(target, "utf8"));
-    if (_isObject6(decoded) && Array.isArray(decoded["evaluations"])) {
+    const decoded = JSON.parse(fs6.readFileSync(target, "utf8"));
+    if (_isObject5(decoded) && Array.isArray(decoded["evaluations"])) {
       return decoded;
     }
   } catch {
@@ -3407,14 +3322,14 @@ function _load(target) {
   return { session_id: "", turn_started_at: "", evaluations: [] };
 }
 var WARN_TEXT = "First evaluation dispatch this turn. Two shapes fabricated a binding honest-null in the audited sessions \u2014 check your prompt for both before it goes out: (1) a verdict pre-loaded into the prompt, and (2) a scope narrowed to files you chose. A review you commissioned on your own work is admissible as gate evidence only when the prompt is recorded alongside the verdict.";
-function decide2(tool, prompt, priorEvaluations) {
+function decide(tool, prompt, priorEvaluations) {
   if (!isDispatchTool(tool) || !isEvaluationPrompt(prompt)) {
-    return { exit: EXIT_ALLOW6, stdout: "", stderr: "", evaluations: priorEvaluations };
+    return { exit: EXIT_ALLOW5, stdout: "", stderr: "", evaluations: priorEvaluations };
   }
   const preloaded = preloadedVerdict(prompt);
   if (preloaded !== null) {
     return {
-      exit: EXIT_BLOCK3,
+      exit: EXIT_BLOCK2,
       stdout: "",
       stderr: `Blocked: this evaluation prompt pre-loads its verdict ("${preloaded}"). That is the construct that produced a fabricated NO-FINDINGS committed as binding gate evidence, over a delta an unsteered pass then found a live critical in. Remove the expectation from the prompt and let the evaluator reach its own verdict.
 `,
@@ -3422,11 +3337,11 @@ function decide2(tool, prompt, priorEvaluations) {
     };
   }
   if (!isSelfScoped(prompt)) {
-    return { exit: EXIT_ALLOW6, stdout: "", stderr: "", evaluations: priorEvaluations };
+    return { exit: EXIT_ALLOW5, stdout: "", stderr: "", evaluations: priorEvaluations };
   }
   if (priorEvaluations >= 1) {
     return {
-      exit: EXIT_ALLOW6,
+      exit: EXIT_ALLOW5,
       stdout: `${JSON.stringify({
         decision: "warn",
         reason: `Second evaluation dispatch of your own work in this turn. If both passes judge the SAME subject, that is verdict shopping \u2014 commissioning another with a different prompt or scope selects the answer instead of measuring it. Report what the first pass returned, then re-plan. If this is an implementation fan-out rather than a second review, carry on: this check reads prose and cannot tell the two apart with certainty.`
@@ -3437,26 +3352,26 @@ function decide2(tool, prompt, priorEvaluations) {
     };
   }
   return {
-    exit: EXIT_ALLOW6,
+    exit: EXIT_ALLOW5,
     stdout: `${JSON.stringify({ decision: "warn", reason: WARN_TEXT })}
 `,
     stderr: "",
     evaluations: priorEvaluations + 1
   };
 }
-function run4(stdin_text, options) {
+function run3(stdin_text, options) {
   let envelope = {};
   if (stdin_text.trim()) {
     try {
       const decoded = JSON.parse(stdin_text);
-      if (_isObject6(decoded)) {
+      if (_isObject5(decoded)) {
         envelope = decoded;
       }
     } catch {
-      return EXIT_ALLOW6;
+      return EXIT_ALLOW5;
     }
   }
-  const target = path7.join(options.consumer_root, STATE_FILE3);
+  const target = path6.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)}`;
@@ -3466,7 +3381,7 @@ function run4(stdin_text, options) {
     state.evaluations = [];
   }
   const [tool, prompt] = extractDispatch(envelope);
-  const decision = decide2(tool, prompt, state.evaluations.length);
+  const decision = decide(tool, prompt, state.evaluations.length);
   if (decision.evaluations > state.evaluations.length) {
     state.evaluations.push({
       at: (/* @__PURE__ */ new Date()).toISOString(),
@@ -3475,7 +3390,11 @@ function run4(stdin_text, options) {
     });
     try {
       atomic_write_json(target, state);
-    } catch {
+    } catch (err) {
+      process.stderr.write(
+        `evidence-independence: evaluation-count write failed (${_errText3(err)}) \u2014 this turn's count did NOT advance, so a second self-scoped evaluation will not be warned about. The pre-loaded-verdict block is unaffected.
+`
+      );
     }
   }
   if (decision.stdout) {
@@ -3486,7 +3405,11 @@ function run4(stdin_text, options) {
   }
   return decision.exit;
 }
-function main7(argv) {
+function _errText3(err) {
+  const t = err instanceof Error ? err.message : String(err);
+  return t.replace(/\s+/g, " ").trim().slice(0, 200);
+}
+function main6(argv) {
   const args = argv ?? process.argv.slice(2);
   let consumer_root = process.cwd();
   for (let i = 0; i < args.length; i += 1) {
@@ -3498,35 +3421,35 @@ function main7(argv) {
       consumer_root = a.slice("--project-dir=".length);
     }
   }
-  return run4(readHookStdin(), { consumer_root });
+  return run3(readHookStdin(), { consumer_root });
 }
-function _isCliEntry7() {
+function _isCliEntry6() {
   if (true) {
     return false;
   }
   if (process.argv[1] === void 0) {
     return false;
   }
-  const argvUrl = pathToFileURL7(path7.resolve(process.argv[1])).href;
+  const argvUrl = pathToFileURL6(path6.resolve(process.argv[1])).href;
   if (import.meta.url === argvUrl) {
     return true;
   }
   try {
-    const here = fs7.realpathSync(fileURLToPath7(import.meta.url));
-    const argv = fs7.realpathSync(path7.resolve(process.argv[1]));
+    const here = fs6.realpathSync(fileURLToPath6(import.meta.url));
+    const argv = fs6.realpathSync(path6.resolve(process.argv[1]));
     return here === argv;
   } catch {
     return false;
   }
 }
-if (_isCliEntry7()) {
-  process.exit(main7());
+if (_isCliEntry6()) {
+  process.exit(main6());
 }
 
 // src/scripts/hooks/delegation_nudge_hook.ts
-import fs8 from "node:fs";
-import path8 from "node:path";
-import { fileURLToPath as fileURLToPath8, pathToFileURL as pathToFileURL8 } from "node:url";
+import fs7 from "node:fs";
+import path7 from "node:path";
+import { fileURLToPath as fileURLToPath7, pathToFileURL as pathToFileURL7 } from "node:url";
 
 // src/scripts/_lib/host_capability.ts
 import process2 from "node:process";
@@ -3855,9 +3778,9 @@ function resolveSubagentRouting(inp) {
 }
 
 // src/scripts/hooks/delegation_nudge_hook.ts
-var EXIT_ALLOW7 = 0;
+var EXIT_ALLOW6 = 0;
 var EXIT_WARN3 = 2;
-function _isObject7(v) {
+function _isObject6(v) {
   return typeof v === "object" && v !== null && !Array.isArray(v);
 }
 var FILE_TOKEN_RE = /`?\b[\w][\w.\-]{0,80}\.(ts|tsx|js|jsx|mjs|cjs|py|php|rb|go|rs|java|kt|swift|md|mdx|json|ya?ml|css|scss|less|html|vue|svelte|sql|sh|bash|c|cpp|h|hpp|cs|toml|xml)\b`?/gi;
@@ -4016,34 +3939,34 @@ function _workspaceRoot(envelope) {
   }
   return process.cwd();
 }
-function main8() {
+function main7() {
   let envelope = {};
   try {
     const raw = readHookStdin();
     envelope = raw.trim() ? JSON.parse(raw) : {};
   } catch {
-    return EXIT_ALLOW7;
+    return EXIT_ALLOW6;
   }
-  const env = _isObject7(envelope) ? envelope : {};
+  const env = _isObject6(envelope) ? envelope : {};
   const event = env["event"];
   const slot = typeof event === "string" && event !== "" ? event : "user_prompt_submit";
   if (slot !== "user_prompt_submit") {
-    return EXIT_ALLOW7;
+    return EXIT_ALLOW6;
   }
-  const payload = _isObject7(env["payload"]) ? env["payload"] : env;
+  const payload = _isObject6(env["payload"]) ? env["payload"] : env;
   const prompt = _extractPrompt2(payload);
   if (!prompt) {
-    return EXIT_ALLOW7;
+    return EXIT_ALLOW6;
   }
   if (isSyntheticPrompt(prompt)) {
-    return EXIT_ALLOW7;
+    return EXIT_ALLOW6;
   }
   const root = _workspaceRoot(env);
   const platform = env["platform"];
   const hostId = typeof platform === "string" && platform ? platform : null;
   const result = classifyPrompt(prompt, root, hostId);
   if (!result) {
-    return EXIT_ALLOW7;
+    return EXIT_ALLOW6;
   }
   process.stdout.write(
     `${JSON.stringify({
@@ -4055,31 +3978,31 @@ function main8() {
   );
   return EXIT_WARN3;
 }
-function _isCliEntry8() {
+function _isCliEntry7() {
   if (true) {
     return false;
   }
   if (process.argv[1] === void 0) {
     return false;
   }
-  const argvUrl = pathToFileURL8(path8.resolve(process.argv[1])).href;
+  const argvUrl = pathToFileURL7(path7.resolve(process.argv[1])).href;
   if (import.meta.url === argvUrl) {
     return true;
   }
   try {
-    const here = fs8.realpathSync(fileURLToPath8(import.meta.url));
-    const argv = fs8.realpathSync(path8.resolve(process.argv[1]));
+    const here = fs7.realpathSync(fileURLToPath7(import.meta.url));
+    const argv = fs7.realpathSync(path7.resolve(process.argv[1]));
     return here === argv;
   } catch {
     return false;
   }
 }
-if (_isCliEntry8()) {
-  process.exit(main8());
+if (_isCliEntry7()) {
+  process.exit(main7());
 }
 
 // src/scripts/conformance_scan.ts
-var REPO_ROOT = path9.resolve(path9.dirname(fileURLToPath9(import.meta.url)), "..", "..");
+var REPO_ROOT = path8.resolve(path8.dirname(fileURLToPath8(import.meta.url)), "..", "..");
 var OBSERVED_BAND = { low: 9.1, high: 39.2 };
 var BAND_MIN_TURNS = 1978;
 var CARRIER_CHANGES = [
@@ -4163,7 +4086,7 @@ function renderWhy(report, id) {
   }
   return lines.join("\n");
 }
-function _isObject8(v) {
+function _isObject7(v) {
   return typeof v === "object" && v !== null && !Array.isArray(v);
 }
 function userText(entry) {
@@ -4187,15 +4110,15 @@ function assistantText(entry) {
 }
 function toolUses2(entry) {
   const msg = entry["message"];
-  const content = _isObject8(msg) ? msg["content"] : void 0;
+  const content = _isObject7(msg) ? msg["content"] : void 0;
   if (!Array.isArray(content)) {
     return [];
   }
-  return content.filter((b) => _isObject8(b) && b["type"] === "tool_use").map((b) => {
+  return content.filter((b) => _isObject7(b) && b["type"] === "tool_use").map((b) => {
     const o = b;
     return {
       name: String(o["name"] ?? ""),
-      input: _isObject8(o["input"]) ? o["input"] : {}
+      input: _isObject7(o["input"]) ? o["input"] : {}
     };
   });
 }
@@ -4238,6 +4161,7 @@ function scanSession(sessionId, lines) {
   let pinned = null;
   let pendingPoll = null;
   let authorized = /* @__PURE__ */ new Set();
+  let authorizedObjects = /* @__PURE__ */ new Map();
   let sawPending = false;
   let evaluationsThisTurn = 0;
   let turnsSincePrompt = 0;
@@ -4331,7 +4255,11 @@ function scanSession(sessionId, lines) {
       if (c.language !== "und") {
         pinned = c.language;
       }
-      authorized = new Set(classifyAuthorization(ut).authorized);
+      const classified = classifyAuthorization(ut);
+      authorized = new Set(classified.authorized);
+      authorizedObjects = new Map(
+        classified.authorized.map((op) => [op, new Set(extractObjects(op, ut))])
+      );
       sawPending = false;
       evaluationsThisTurn = 0;
       pendingPoll = null;
@@ -4397,6 +4325,17 @@ function scanSession(sessionId, lines) {
             at,
             detail: `irreversible \`${op}\` with no authorization in the turn's prompt: ${cmd.slice(0, 110)}`
           });
+        } else if (op !== null && authorized.has(op) && OBJECT_REQUIRED_OPS.has(op)) {
+          const object = commandObject(op, cmd);
+          const named = authorizedObjects.get(op);
+          if (object !== null && !(named?.has(object) ?? false)) {
+            report.violations.push({
+              check: "git-authorization",
+              session: sessionId,
+              at,
+              detail: `\`${op}\` authorized, but its object \`${object}\` is not one the turn's prompt named (${named && named.size > 0 ? [...named].join(", ") : "no object named"}): ` + cmd.slice(0, 110)
+            });
+          }
         }
         if (isCiPoll(cmd)) {
           pendingPoll = { at, cmd };
@@ -4429,7 +4368,7 @@ function scanSession(sessionId, lines) {
   closeWindow();
   return report;
 }
-var DEFAULT_RATE_SERIES = path9.join(
+var DEFAULT_RATE_SERIES = path8.join(
   REPO_ROOT,
   "agents",
   "runtime",
@@ -4438,7 +4377,7 @@ var DEFAULT_RATE_SERIES = path9.join(
 );
 function defaultStore(projectDir) {
   const slug = projectStoreSlug(projectDir);
-  return path9.join(process.env["HOME"] ?? "", ".claude", "projects", slug);
+  return path8.join(process.env["HOME"] ?? "", ".claude", "projects", slug);
 }
 function _tokens(chars) {
   return Math.round(chars / 4);
@@ -4449,13 +4388,13 @@ function measureDelivered(projectRulesDir, globalRulesDir) {
   return {
     project: {
       dir: projectRulesDir,
-      present: fs9.existsSync(projectRulesDir),
+      present: fs8.existsSync(projectRulesDir),
       files: p.files,
       tokens: _tokens(p.chars)
     },
     global: {
       dir: globalRulesDir,
-      present: fs9.existsSync(globalRulesDir),
+      present: fs8.existsSync(globalRulesDir),
       files: g.files,
       tokens: _tokens(g.chars)
     },
@@ -4463,13 +4402,13 @@ function measureDelivered(projectRulesDir, globalRulesDir) {
   };
 }
 function storeKey(store) {
-  return createHash3("sha256").update(path9.resolve(store)).digest("hex").slice(0, 12);
+  return createHash3("sha256").update(path8.resolve(store)).digest("hex").slice(0, 12);
 }
 function scanStore(store, limit) {
-  const files = fs9.readdirSync(store).filter((f) => f.endsWith(".jsonl")).map((f) => ({ f, m: fs9.statSync(path9.join(store, f)).mtimeMs })).sort((a, b) => b.m - a.m).slice(0, limit).map((x) => x.f);
+  const files = fs8.readdirSync(store).filter((f) => f.endsWith(".jsonl")).map((f) => ({ f, m: fs8.statSync(path8.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 = fs9.readFileSync(path9.join(store, f), "utf8").split("\n");
+    const lines = fs8.readFileSync(path8.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);
@@ -4497,10 +4436,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(
-    path9.join(REPO_ROOT, ".claude", "rules"),
-    path9.join(process.env["HOME"] ?? os2.homedir(), ".claude", "rules")
+    path8.join(REPO_ROOT, ".claude", "rules"),
+    path8.join(process.env["HOME"] ?? os2.homedir(), ".claude", "rules")
   );
-  const ownStore = path9.resolve(store) === path9.resolve(defaultStore(REPO_ROOT));
+  const ownStore = path8.resolve(store) === path8.resolve(defaultStore(REPO_ROOT));
   return {
     scanned_at: (/* @__PURE__ */ new Date()).toISOString(),
     store,
@@ -4530,8 +4469,8 @@ function scanStore(store, limit) {
   };
 }
 function recordRate(file, scanned_at, rate) {
-  fs9.mkdirSync(path9.dirname(file), { recursive: true });
-  fs9.appendFileSync(file, `${JSON.stringify({ measured_at: scanned_at, ...rate })}
+  fs8.mkdirSync(path8.dirname(file), { recursive: true });
+  fs8.appendFileSync(file, `${JSON.stringify({ measured_at: scanned_at, ...rate })}
 `, "utf8");
 }
 function render(report) {
@@ -4630,7 +4569,7 @@ function render(report) {
   lines.push("    checkbox batching                     \u2014 measured NOWHERE. ~5 low-severity findings.");
   return lines.join("\n");
 }
-function main9(argv) {
+function main8(argv) {
   const args = argv ?? process.argv.slice(2);
   let store = null;
   let limit = 30;
@@ -4662,14 +4601,14 @@ function main9(argv) {
     return 2;
   }
   const resolved = store ?? defaultStore(process.cwd());
-  if (!fs9.existsSync(resolved)) {
+  if (!fs8.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) {
-    fs9.writeFileSync(out, `${JSON.stringify(report, null, 2)}
+    fs8.writeFileSync(out, `${JSON.stringify(report, null, 2)}
 `, "utf8");
   }
   if (record) {
@@ -4677,7 +4616,7 @@ function main9(argv) {
   }
   if (why !== null) {
     const id = why;
-    fs9.writeSync(
+    fs8.writeSync(
       1,
       json ? `${JSON.stringify(
         {
@@ -4697,48 +4636,48 @@ function main9(argv) {
     );
     return 0;
   }
-  fs9.writeSync(1, json ? `${JSON.stringify(report, null, 2)}
+  fs8.writeSync(1, json ? `${JSON.stringify(report, null, 2)}
 ` : `${render(report)}
 `);
   return 0;
 }
-function _isCliEntry9() {
+function _isCliEntry8() {
   if (true) {
     return false;
   }
   if (process.argv[1] === void 0) {
     return false;
   }
-  const argvUrl = pathToFileURL9(path9.resolve(process.argv[1])).href;
+  const argvUrl = pathToFileURL8(path8.resolve(process.argv[1])).href;
   if (import.meta.url === argvUrl) {
     return true;
   }
   try {
-    const here = fs9.realpathSync(fileURLToPath9(import.meta.url));
-    const argv = fs9.realpathSync(path9.resolve(process.argv[1]));
+    const here = fs8.realpathSync(fileURLToPath8(import.meta.url));
+    const argv = fs8.realpathSync(path8.resolve(process.argv[1]));
     return here === argv;
   } catch {
     return false;
   }
 }
-if (_isCliEntry9()) {
-  process.exit(main9());
+if (_isCliEntry8()) {
+  process.exit(main8());
 }
 
 // src/scripts/report_carrier_divergence.ts
-import * as fs10 from "node:fs";
+import * as fs9 from "node:fs";
 import * as os3 from "node:os";
-import * as path10 from "node:path";
+import * as path9 from "node:path";
 import process3 from "node:process";
-import { fileURLToPath as fileURLToPath10, pathToFileURL as pathToFileURL10 } from "node:url";
-var _HERE = fileURLToPath10(import.meta.url);
-var REPO_ROOT2 = path10.resolve(path10.dirname(_HERE), "..", "..");
-var PROJECT_RULES = path10.join(".claude", "rules");
-var PROJECTION_SOURCE = path10.join("dist", "agent-src", "rules");
-var GLOBAL_RULES = path10.join(".claude", "rules");
+import { fileURLToPath as fileURLToPath9, pathToFileURL as pathToFileURL9 } from "node:url";
+var _HERE = fileURLToPath9(import.meta.url);
+var REPO_ROOT2 = path9.resolve(path9.dirname(_HERE), "..", "..");
+var PROJECT_RULES = path9.join(".claude", "rules");
+var PROJECTION_SOURCE = path9.join("dist", "agent-src", "rules");
+var GLOBAL_RULES = path9.join(".claude", "rules");
 function _listRules(dir) {
   try {
-    return fs10.readdirSync(dir).filter((f) => f.endsWith(".md")).sort();
+    return fs9.readdirSync(dir).filter((f) => f.endsWith(".md")).sort();
   } catch {
     return [];
   }
@@ -4746,7 +4685,7 @@ function _listRules(dir) {
 function _ruleType(file) {
   let text;
   try {
-    text = fs10.readFileSync(file, "utf-8");
+    text = fs9.readFileSync(file, "utf-8");
   } catch {
     return "";
   }
@@ -4757,8 +4696,8 @@ function compareCarriers(projectDir, globalDir, sourceDir) {
   const out = {
     projectDir,
     globalDir,
-    globalPresent: fs10.existsSync(globalDir),
-    projectPresent: fs10.existsSync(projectDir),
+    globalPresent: fs9.existsSync(globalDir),
+    projectPresent: fs9.existsSync(projectDir),
     shared: 0,
     identical: [],
     provenanceOnly: [],
@@ -4781,7 +4720,7 @@ function compareCarriers(projectDir, globalDir, sourceDir) {
     }
     if (!inP && inG) {
       out.globalOnly.push(rule);
-      if (sourceDir !== void 0 && _ruleType(path10.join(sourceDir, rule)) === "manual") {
+      if (sourceDir !== void 0 && _ruleType(path9.join(sourceDir, rule)) === "manual") {
         out.manualOnlyGlobal.push(rule);
       }
       continue;
@@ -4791,8 +4730,8 @@ function compareCarriers(projectDir, globalDir, sourceDir) {
     let projectCopy;
     let globalCopy;
     try {
-      projectCopy = fs10.readFileSync(path10.join(projectDir, rule));
-      globalCopy = fs10.readFileSync(path10.join(globalDir, rule));
+      projectCopy = fs9.readFileSync(path9.join(projectDir, rule));
+      globalCopy = fs9.readFileSync(path9.join(globalDir, rule));
       verdict = comparePair(projectCopy, globalCopy);
     } catch {
       out.shared -= 1;
@@ -4937,11 +4876,11 @@ function render2(d) {
   }
   return lines.join("\n");
 }
-function main10(argv) {
+function main9(argv) {
   const args = argv ?? process3.argv.slice(2);
-  let projectDir = path10.join(REPO_ROOT2, PROJECT_RULES);
-  let globalDir = path10.join(os3.homedir(), GLOBAL_RULES);
-  let sourceDir = path10.join(REPO_ROOT2, PROJECTION_SOURCE);
+  let projectDir = path9.join(REPO_ROOT2, PROJECT_RULES);
+  let globalDir = path9.join(os3.homedir(), GLOBAL_RULES);
+  let sourceDir = path9.join(REPO_ROOT2, PROJECTION_SOURCE);
   const value = (i) => {
     const v = args[i + 1];
     return v === void 0 || v.startsWith("-") ? null : v;
@@ -4955,7 +4894,7 @@ function main10(argv) {
 `);
         return 1;
       }
-      const resolved = path10.resolve(v);
+      const resolved = path9.resolve(v);
       if (a === "--project") projectDir = resolved;
       else if (a === "--global") globalDir = resolved;
       else sourceDir = resolved;
@@ -4975,49 +4914,57 @@ function main10(argv) {
 `);
   return 0;
 }
-function _isCliEntry10() {
+function _isCliEntry9() {
   if (process3.argv[1] === void 0) return false;
-  if (import.meta.url === pathToFileURL10(path10.resolve(process3.argv[1])).href) return true;
+  if (import.meta.url === pathToFileURL9(path9.resolve(process3.argv[1])).href) return true;
   try {
-    return fs10.realpathSync(_HERE) === fs10.realpathSync(path10.resolve(process3.argv[1]));
+    return fs9.realpathSync(_HERE) === fs9.realpathSync(path9.resolve(process3.argv[1]));
   } catch {
     return false;
   }
 }
-if (_isCliEntry10()) {
-  process3.exit(main10());
+if (_isCliEntry9()) {
+  process3.exit(main9());
 }
 
 // src/scripts/report_skill_activation.ts
-import * as fs11 from "node:fs";
+import * as fs10 from "node:fs";
 import * as os4 from "node:os";
-import * as path11 from "node:path";
-import { fileURLToPath as fileURLToPath11, pathToFileURL as pathToFileURL11 } from "node:url";
-var _HERE2 = fileURLToPath11(import.meta.url);
-var REPO_ROOT3 = path11.resolve(path11.dirname(_HERE2), "..", "..");
+import * as path10 from "node:path";
+import { fileURLToPath as fileURLToPath10, pathToFileURL as pathToFileURL10 } from "node:url";
+var _HERE2 = fileURLToPath10(import.meta.url);
+var REPO_ROOT3 = path10.resolve(path10.dirname(_HERE2), "..", "..");
 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;
 function censusSkills(root) {
-  const out = { total: 0, withTriggerKey: [], withDeterministicObligation: [] };
-  if (!fs11.existsSync(root)) {
+  const out = {
+    total: 0,
+    withTriggerKey: [],
+    withTriggerCorpus: [],
+    withDeterministicObligation: []
+  };
+  if (!fs10.existsSync(root)) {
     return out;
   }
-  for (const entry of fs11.readdirSync(root, { withFileTypes: true }).sort((a, b) => a.name.localeCompare(b.name))) {
+  for (const entry of fs10.readdirSync(root, { withFileTypes: true }).sort((a, b) => a.name.localeCompare(b.name))) {
     if (!entry.isDirectory()) {
       continue;
     }
-    const file = path11.join(root, entry.name, "SKILL.md");
-    if (!fs11.existsSync(file)) {
+    const file = path10.join(root, entry.name, "SKILL.md");
+    if (!fs10.existsSync(file)) {
       continue;
     }
     out.total += 1;
-    const text = fs11.readFileSync(file, "utf8");
+    const text = fs10.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 (fs10.existsSync(path10.join(root, entry.name, "evals", "triggers.json"))) {
+      out.withTriggerCorpus.push(entry.name);
+    }
     const body = fmEnd === -1 ? text : text.slice(fmEnd + 4);
     if (DETERMINISTIC_RE.test(body)) {
       out.withDeterministicObligation.push(entry.name);
@@ -5026,17 +4973,17 @@ function censusSkills(root) {
   return out;
 }
 function defaultStore2(cwd) {
-  return path11.join(os4.homedir(), ".claude", "projects", projectStoreSlug(cwd));
+  return path10.join(os4.homedir(), ".claude", "projects", projectStoreSlug(cwd));
 }
 function measureUsage(store, limit) {
   const rep = { store, sessions: 0, assistantTurns: 0, invocations: 0, bySkill: {} };
-  if (!fs11.existsSync(store)) {
+  if (!fs10.existsSync(store)) {
     return rep;
   }
-  const files = fs11.readdirSync(store).filter((f) => f.endsWith(".jsonl")).map((f) => path11.join(store, f)).sort((a, b) => fs11.statSync(b).mtimeMs - fs11.statSync(a).mtimeMs).slice(0, limit);
+  const files = fs10.readdirSync(store).filter((f) => f.endsWith(".jsonl")).map((f) => path10.join(store, f)).sort((a, b) => fs10.statSync(b).mtimeMs - fs10.statSync(a).mtimeMs).slice(0, limit);
   rep.sessions = files.length;
   for (const file of files) {
-    for (const line of fs11.readFileSync(file, "utf8").split("\n")) {
+    for (const line of fs10.readFileSync(file, "utf8").split("\n")) {
       if (!line.trim()) {
         continue;
       }
@@ -5076,7 +5023,50 @@ function measureUsage(store, limit) {
 function _pct(n, d) {
   return d === 0 ? "n/a" : `${(100 * n / d).toFixed(1)}%`;
 }
-function render3(census, usage) {
+var RECORD_PATH = "agents/evidence/metrics/skill-activation-census.json";
+function populations(census) {
+  const corpus = new Set(census.withTriggerCorpus);
+  const both = census.withTriggerKey.filter((s) => corpus.has(s));
+  const eitherOne = /* @__PURE__ */ new Set([...census.withTriggerKey, ...census.withTriggerCorpus]);
+  return {
+    shipped: census.total,
+    triggerKey: census.withTriggerKey.length,
+    triggerCorpus: census.withTriggerCorpus.length,
+    bothKeyAndCorpus: both.length,
+    humanNamedOnly: census.total - eitherOne.size
+  };
+}
+function buildRecord(census, usage, today) {
+  const pop = populations(census);
+  const distinct = /* @__PURE__ */ new Set();
+  for (const u of usage) {
+    for (const k of Object.keys(u.bySkill)) {
+      distinct.add(k);
+    }
+  }
+  return {
+    schema_version: 1,
+    measured_at: today,
+    skills_shipped: pop.shipped,
+    with_trigger_key: pop.triggerKey,
+    with_trigger_corpus: pop.triggerCorpus,
+    trigger_key_and_corpus: pop.bothKeyAndCorpus,
+    human_named_only: pop.humanNamedOnly,
+    sessions: usage.reduce((a, u) => a + u.sessions, 0),
+    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) => path10.basename(u.store))
+  };
+}
+function readRecord(repoRoot) {
+  const file = path10.join(repoRoot, RECORD_PATH);
+  if (!fs10.existsSync(file)) {
+    return null;
+  }
+  return JSON.parse(fs10.readFileSync(file, "utf8"));
+}
+function render3(census, usage, published = null) {
   const lines = [];
   lines.push("skill activation census \u2014 advisory, gates on nothing");
   lines.push("");
@@ -5091,6 +5081,16 @@ function render3(census, usage) {
     lines.push(`      ${census.withDeterministicObligation.join(", ")}`);
   }
   lines.push("");
+  const pop = populations(census);
+  lines.push("  populations \u2014 the three ways a skill can be reached, reconciled");
+  lines.push(`    machine-matchable trigger key        ${pop.triggerKey}`);
+  lines.push(`    evals/triggers.json corpus           ${pop.triggerCorpus}  (a test fixture; no host reads it at routing time)`);
+  lines.push(`    both of the above                    ${pop.bothKeyAndCorpus}`);
+  lines.push(`    human-named only (remainder)         ${pop.humanNamedOnly}`);
+  lines.push(
+    `    reconciles                           ${pop.triggerKey} + ${pop.triggerCorpus} - ${pop.bothKeyAndCorpus} + ${pop.humanNamedOnly} = ${String(pop.triggerKey + pop.triggerCorpus - pop.bothKeyAndCorpus + pop.humanNamedOnly)} of ${pop.shipped}`
+  );
+  lines.push("");
   let totalInv = 0;
   const distinct = /* @__PURE__ */ new Set();
   for (const u of usage) {
@@ -5099,7 +5099,7 @@ function render3(census, usage) {
     }
     totalInv += u.invocations;
     lines.push(
-      `  ${path11.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)}`
+      `  ${path10.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("");
@@ -5111,6 +5111,51 @@ function render3(census, usage) {
     lines.push(`      ${[...distinct].sort().join(", ")}`);
   }
   lines.push("");
+  const sessionsRead = usage.reduce((a, u) => a + u.sessions, 0);
+  if (sessionsRead === 0) {
+    lines.push('  EMPTY STORE: 0 sessions were read, so the zero above is "no transcripts at');
+    lines.push('  this path", NOT "no activations". It is not a measurement of the surface and');
+    lines.push("  must not be published as one. Run this where the store lives, or pass --store.");
+    lines.push("");
+  }
+  if (published !== null) {
+    const live = buildRecord(census, usage, published.measured_at);
+    const REPO_FIELDS = [
+      "skills_shipped",
+      "with_trigger_key",
+      "with_trigger_corpus",
+      "trigger_key_and_corpus",
+      "human_named_only"
+    ];
+    const STORE_FIELDS = [
+      "sessions",
+      "assistant_turns",
+      "invocations",
+      "distinct_skills_invoked"
+    ];
+    const repoDrift = REPO_FIELDS.filter((k) => live[k] !== published[k]);
+    const storeDrift = STORE_FIELDS.filter((k) => live[k] !== published[k]);
+    lines.push(`  PUBLISHED RECORD (${RECORD_PATH}), measured ${published.measured_at}:`);
+    lines.push(
+      `    sessions=${String(published.sessions)} asst=${String(published.assistant_turns)} invocations=${String(published.invocations)} distinct=${String(published.distinct_skills_invoked)}`
+    );
+    if (repoDrift.length > 0) {
+      lines.push(`    STALE: the published population split no longer describes this tree \u2014`);
+      lines.push(`    ${repoDrift.join(", ")} moved. Re-take with --emit.`);
+    } else {
+      lines.push("    population split still describes this tree.");
+    }
+    if (sessionsRead === 0) {
+      lines.push("    Store reading: UNDECIDED \u2014 this run read no store, so it cannot say whether");
+      lines.push("    the published figures still hold. Re-run where the store lives.");
+    } else if (storeDrift.length === 0) {
+      lines.push("    Store reading: reproduces the published figures exactly.");
+    } else {
+      lines.push(`    Store reading: moved since the record (${storeDrift.join(", ")}). Expected \u2014`);
+      lines.push("    the store is rolling, not append-only, and a later reading can be lower.");
+    }
+    lines.push("");
+  }
   if (census.withTriggerKey.length === 0) {
     lines.push("  VERDICT: activation is not measurable as a rate. No skill declares a");
     lines.push("  machine-matchable trigger, so a missed-activation detector has nothing to");
@@ -5124,19 +5169,30 @@ function render3(census, usage) {
   lines.push("  catalogue once per session, then count descriptions against bare names.");
   return lines.join("\n");
 }
-function main11(argv) {
+var USAGE = "usage: report_skill_activation [--root DIR] [--limit N] [--store PATH]... [--emit] [--allow-empty-store]\n";
+function main10(argv) {
   let limit = 30;
+  let emit = false;
+  let allowEmpty = false;
+  const rootIdx = argv.indexOf("--root");
+  const root = rootIdx === -1 ? REPO_ROOT3 : argv[rootIdx + 1] ?? REPO_ROOT3;
   const stores = [];
   for (let i = 0; i < argv.length; i += 1) {
     const a = argv[i];
-    if (a === "--limit" && argv[i + 1] !== void 0) {
+    if (a === "--root" && argv[i + 1] !== void 0) {
+      i += 1;
+    } else if (a === "--limit" && argv[i + 1] !== void 0) {
       limit = Number.parseInt(argv[i + 1], 10);
       i += 1;
     } else if (a === "--store" && argv[i + 1] !== void 0) {
       stores.push(argv[i + 1]);
       i += 1;
+    } else if (a === "--emit") {
+      emit = true;
+    } else if (a === "--allow-empty-store") {
+      allowEmpty = true;
     } else if (a === "--help" || a === "-h") {
-      process.stdout.write("usage: report_skill_activation [--limit N] [--store PATH]...\n");
+      process.stdout.write(USAGE);
       return 0;
     }
   }
@@ -5147,24 +5203,48 @@ function main11(argv) {
   if (stores.length === 0) {
     stores.push(defaultStore2(REPO_ROOT3));
   }
-  const census = censusSkills(path11.join(REPO_ROOT3, SKILLS_ROOT));
+  const census = censusSkills(path10.join(root, SKILLS_ROOT));
   const usage = stores.map((s) => measureUsage(s, limit));
-  process.stdout.write(`${render3(census, usage)}
+  process.stdout.write(`${render3(census, usage, readRecord(root))}
+`);
+  reportScanned({
+    gate: "report_skill_activation",
+    scanned: census.total,
+    units: "SKILL.md file(s)",
+    roots: [SKILLS_ROOT]
+  });
+  if (!emit) {
+    return 0;
+  }
+  const sessionsRead = usage.reduce((a, u) => a + u.sessions, 0);
+  if (sessionsRead === 0 && !allowEmpty) {
+    process.stderr.write(
+      'report_skill_activation --emit: refusing to write a record from 0 sessions \u2014 that zero\nis "no transcripts at this path", not an activation reading. Run where the store lives,\npass --store, or pass --allow-empty-store if an empty store is genuinely the finding.\n'
+    );
+    return 1;
+  }
+  const today = (/* @__PURE__ */ new Date()).toISOString().slice(0, 10);
+  const file = path10.join(root, RECORD_PATH);
+  fs10.mkdirSync(path10.dirname(file), { recursive: true });
+  fs10.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(path11.resolve(process.argv[1])).href) {
-  process.exit(main11(process.argv.slice(2)));
+if (process.argv[1] !== void 0 && import.meta.url === pathToFileURL10(path10.resolve(process.argv[1])).href) {
+  process.exit(main10(process.argv.slice(2)));
 }
 
 // src/scripts/report_skill_obligation_violations.ts
-import * as fs12 from "node:fs";
+import * as fs11 from "node:fs";
 import * as os5 from "node:os";
-import * as path12 from "node:path";
+import * as path11 from "node:path";
 import process4 from "node:process";
-import { fileURLToPath as fileURLToPath12, pathToFileURL as pathToFileURL12 } from "node:url";
-var _HERE3 = fileURLToPath12(import.meta.url);
-var REPO_ROOT4 = path12.resolve(path12.dirname(_HERE3), "..", "..");
+import { fileURLToPath as fileURLToPath11, pathToFileURL as pathToFileURL11 } from "node:url";
+var _HERE3 = fileURLToPath11(import.meta.url);
+var REPO_ROOT4 = path11.resolve(path11.dirname(_HERE3), "..", "..");
 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;
@@ -5202,7 +5282,7 @@ function _artefacts(line) {
   return out;
 }
 function extractObligations(repoRoot) {
-  const skillsRoot = path12.join(repoRoot, SKILLS_ROOT);
+  const skillsRoot = path11.join(repoRoot, SKILLS_ROOT);
   const census = censusSkills(skillsRoot);
   const out = {
     skills: census.withDeterministicObligation,
@@ -5216,7 +5296,7 @@ function extractObligations(repoRoot) {
   for (const skill of census.withDeterministicObligation) {
     let text;
     try {
-      text = fs12.readFileSync(path12.join(skillsRoot, skill, "SKILL.md"), "utf-8");
+      text = fs11.readFileSync(path11.join(skillsRoot, skill, "SKILL.md"), "utf-8");
     } catch {
       continue;
     }
@@ -5332,7 +5412,7 @@ function scanSessionForViolations(session, lines, forbidden, parsed) {
   return flags;
 }
 function defaultStore3(cwd) {
-  return path12.join(os5.homedir(), ".claude", "projects", projectStoreSlug(cwd));
+  return path11.join(os5.homedir(), ".claude", "projects", projectStoreSlug(cwd));
 }
 function scanStore2(repoRoot, store, limit) {
   const census = extractObligations(repoRoot);
@@ -5345,14 +5425,14 @@ function scanStore2(repoRoot, store, limit) {
   };
   let files;
   try {
-    files = fs12.readdirSync(store).filter((f) => f.endsWith(".jsonl")).map((f) => ({ p: path12.join(store, f), m: fs12.statSync(path12.join(store, f)).mtimeMs })).sort((a, b) => b.m - a.m).slice(0, limit).map((x) => x.p);
+    files = fs11.readdirSync(store).filter((f) => f.endsWith(".jsonl")).map((f) => ({ p: path11.join(store, f), m: fs11.statSync(path11.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 = fs12.readFileSync(file, "utf-8").split("\n");
-    const id = path12.basename(file).replace(/\.jsonl$/, "").slice(0, 8);
+    const lines = fs11.readFileSync(file, "utf-8").split("\n");
+    const id = path11.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));
@@ -5422,7 +5502,7 @@ function render4(r) {
   lines.push("  ships as detection-only, and this one says so.");
   return lines.join("\n");
 }
-function main12(argv) {
+function main11(argv) {
   const args = argv ?? process4.argv.slice(2);
   let limit = 30;
   let json = false;
@@ -5475,35 +5555,35 @@ function main12(argv) {
   }
   return 0;
 }
-function _isCliEntry11() {
+function _isCliEntry10() {
   if (process4.argv[1] === void 0) return false;
-  if (import.meta.url === pathToFileURL12(path12.resolve(process4.argv[1])).href) return true;
+  if (import.meta.url === pathToFileURL11(path11.resolve(process4.argv[1])).href) return true;
   try {
-    return fs12.realpathSync(_HERE3) === fs12.realpathSync(path12.resolve(process4.argv[1]));
+    return fs11.realpathSync(_HERE3) === fs11.realpathSync(path11.resolve(process4.argv[1]));
   } catch {
     return false;
   }
 }
-if (_isCliEntry11()) {
-  process4.exit(main12());
+if (_isCliEntry10()) {
+  process4.exit(main11());
 }
 
 // src/scripts/report_conformance_funnel.ts
-var _HERE4 = fileURLToPath13(import.meta.url);
-var REPO_ROOT5 = path13.resolve(path13.dirname(_HERE4), "..", "..");
+var _HERE4 = fileURLToPath12(import.meta.url);
+var REPO_ROOT5 = path12.resolve(path12.dirname(_HERE4), "..", "..");
 function buildFunnel(opts = {}) {
   const repoRoot = opts.repoRoot ?? REPO_ROOT5;
-  const projectRulesDir = opts.projectRulesDir ?? path13.join(repoRoot, PROJECT_RULES);
-  const globalRulesDir = opts.globalRulesDir ?? path13.join(os6.homedir(), GLOBAL_RULES);
-  const sourceDir = opts.sourceDir ?? path13.join(repoRoot, PROJECTION_SOURCE);
+  const projectRulesDir = opts.projectRulesDir ?? path12.join(repoRoot, PROJECT_RULES);
+  const globalRulesDir = opts.globalRulesDir ?? path12.join(os6.homedir(), GLOBAL_RULES);
+  const sourceDir = opts.sourceDir ?? path12.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(path13.join(repoRoot, SKILLS_ROOT)),
+    skills: censusSkills(path12.join(repoRoot, SKILLS_ROOT)),
     usage: measureUsage(store, limit),
-    storePresent: fs13.existsSync(store),
+    storePresent: fs12.existsSync(store),
     sk2: scanStore2(repoRoot, store, limit)
   };
 }
@@ -5628,7 +5708,7 @@ function render5(r) {
   lines.push("workflow without a measured false-positive rate first (locked policy).");
   return lines.join("\n");
 }
-function main13(argv) {
+function main12(argv) {
   const args = argv ?? process5.argv.slice(2);
   const opts = {};
   const value = (i) => {
@@ -5644,7 +5724,7 @@ function main13(argv) {
 `);
         return 1;
       }
-      const resolved = path13.resolve(v);
+      const resolved = path12.resolve(v);
       if (a === "--store") opts.store = resolved;
       else if (a === "--project") opts.projectRulesDir = resolved;
       else if (a === "--global") opts.globalRulesDir = resolved;
@@ -5674,21 +5754,21 @@ function main13(argv) {
 `);
   return 0;
 }
-function _isCliEntry12() {
+function _isCliEntry11() {
   if (process5.argv[1] === void 0) return false;
-  if (import.meta.url === pathToFileURL13(path13.resolve(process5.argv[1])).href) return true;
+  if (import.meta.url === pathToFileURL12(path12.resolve(process5.argv[1])).href) return true;
   try {
-    return fs13.realpathSync(_HERE4) === fs13.realpathSync(path13.resolve(process5.argv[1]));
+    return fs12.realpathSync(_HERE4) === fs12.realpathSync(path12.resolve(process5.argv[1]));
   } catch {
     return false;
   }
 }
-if (_isCliEntry12()) {
-  process5.exit(main13());
+if (_isCliEntry11()) {
+  process5.exit(main12());
 }
 
 // src/scripts/_cli/cmd_conformance.ts
-var _HERE5 = fileURLToPath14(import.meta.url);
+var _HERE5 = fileURLToPath13(import.meta.url);
 var PACKAGE_ROOT = resolvePackageRoot(import.meta.url);
 var CONFORMANCE_CHECK_IDS = [
   "txlog-clean",
@@ -5711,17 +5791,17 @@ function conformanceLogPath() {
   if (override && override.trim().length > 0) {
     return override;
   }
-  return path14.join(os7.homedir(), ".event4u", "agent-config", "conformance-log.jsonl");
+  return path13.join(os7.homedir(), ".event4u", "agent-config", "conformance-log.jsonl");
 }
 function installLogPath() {
   const override = process6.env["AGENT_CONFIG_INSTALL_LOG"];
   if (override && override.trim().length > 0) {
     return override;
   }
-  return path14.join(os7.homedir(), ".event4u", "agent-config", "install-log.jsonl");
+  return path13.join(os7.homedir(), ".event4u", "agent-config", "install-log.jsonl");
 }
 function _check_txlog_clean(logPath = installLogPath()) {
-  if (!fs14.existsSync(logPath)) {
+  if (!fs13.existsSync(logPath)) {
     return {
       id: "txlog-clean",
       status: "ok",
@@ -5755,11 +5835,11 @@ function _check_txlog_clean(logPath = installLogPath()) {
   };
 }
 function routeTargetPaths(target) {
-  return routeTargetPathsPosix(target).map((rel) => path14.join(...rel.split("/")));
+  return routeTargetPathsPosix(target).map((rel) => path13.join(...rel.split("/")));
 }
 function _check_router_pointers(packageRoot = PACKAGE_ROOT) {
-  const routerPath = path14.join(packageRoot, "dist", "router.json");
-  if (!fs14.existsSync(routerPath)) {
+  const routerPath = path13.join(packageRoot, "dist", "router.json");
+  if (!fs13.existsSync(routerPath)) {
     return {
       id: "router-pointers",
       status: "fail",
@@ -5769,7 +5849,7 @@ function _check_router_pointers(packageRoot = PACKAGE_ROOT) {
   }
   let router;
   try {
-    router = JSON.parse(fs14.readFileSync(routerPath, "utf8"));
+    router = JSON.parse(fs13.readFileSync(routerPath, "utf8"));
   } catch (exc) {
     return {
       id: "router-pointers",
@@ -5778,13 +5858,13 @@ function _check_router_pointers(packageRoot = PACKAGE_ROOT) {
       remedy: "reinstall the package \u2014 dist/router.json is corrupt"
     };
   }
-  const rulesDir = path14.join(packageRoot, "dist", "agent-src", "rules");
+  const rulesDir = path13.join(packageRoot, "dist", "agent-src", "rules");
   const broken = [];
   let ids = 0;
   let targets = 0;
   for (const kernelId of router["kernel"] ?? []) {
     ids += 1;
-    if (!fs14.existsSync(path14.join(rulesDir, `${kernelId}.md`))) {
+    if (!fs13.existsSync(path13.join(rulesDir, `${kernelId}.md`))) {
       broken.push(`kernel:${kernelId} \u2192 rules/${kernelId}.md missing`);
     }
   }
@@ -5792,7 +5872,7 @@ function _check_router_pointers(packageRoot = PACKAGE_ROOT) {
     for (const entry of router[tier] ?? []) {
       const ruleId = String(entry["id"] ?? "");
       ids += 1;
-      if (!fs14.existsSync(path14.join(rulesDir, `${ruleId}.md`))) {
+      if (!fs13.existsSync(path13.join(rulesDir, `${ruleId}.md`))) {
         broken.push(`${tier}:${ruleId} \u2192 rules/${ruleId}.md missing`);
       }
       for (const target of entry["routes_to"] ?? []) {
@@ -5802,7 +5882,7 @@ function _check_router_pointers(packageRoot = PACKAGE_ROOT) {
           broken.push(`${ruleId} \u2192 unparseable routes_to ${JSON.stringify(target)}`);
           continue;
         }
-        if (!candidates.some((rel) => fs14.existsSync(path14.join(packageRoot, rel)))) {
+        if (!candidates.some((rel) => fs13.existsSync(path13.join(packageRoot, rel)))) {
           broken.push(`${ruleId} \u2192 ${target} (${candidates[0]} missing)`);
         }
       }
@@ -5834,9 +5914,9 @@ function detectSmokePlatform(projectRoot) {
   return "claude";
 }
 function dispatcherRunner(packageRoot) {
-  const localTsx = path14.join(packageRoot, "node_modules", ".bin", "tsx");
-  const script = path14.join(packageRoot, "src", "scripts", "hooks", "dispatch_hook.ts");
-  if (fs14.existsSync(localTsx)) {
+  const localTsx = path13.join(packageRoot, "node_modules", ".bin", "tsx");
+  const script = path13.join(packageRoot, "src", "scripts", "hooks", "dispatch_hook.ts");
+  if (fs13.existsSync(localTsx)) {
     return [localTsx, script];
   }
   return ["npx", "tsx", script];
@@ -5886,12 +5966,12 @@ function _check_hook_dispatcher(projectRoot, packageRoot = PACKAGE_ROOT, opts =
   };
 }
 function readSettingsMode(projectRoot) {
-  const settingsPath = path14.join(projectRoot, ".agent-settings.yml");
-  if (!fs14.existsSync(settingsPath)) {
+  const settingsPath = path13.join(projectRoot, ".agent-settings.yml");
+  if (!fs13.existsSync(settingsPath)) {
     return "eager-all";
   }
   try {
-    const parsed = YAML.parse(fs14.readFileSync(settingsPath, "utf8"));
+    const parsed = YAML.parse(fs13.readFileSync(settingsPath, "utf8"));
     const lean = parsed?.["lean_projection"] ?? null;
     const mode = lean?.["mode"];
     return typeof mode === "string" && mode.length > 0 ? mode : "eager-all";
@@ -5902,7 +5982,7 @@ function readSettingsMode(projectRoot) {
 function kernelIdsFromRouter(packageRoot) {
   try {
     const router = JSON.parse(
-      fs14.readFileSync(path14.join(packageRoot, "dist", "router.json"), "utf8")
+      fs13.readFileSync(path13.join(packageRoot, "dist", "router.json"), "utf8")
     );
     return new Set((router["kernel"] ?? []).map(String));
   } catch {
@@ -5919,8 +5999,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 ?? path14.join(projectRoot, ".augment", "rules");
-  if (!fs14.existsSync(rulesDir)) {
+  const rulesDir = projectedRulesDir ?? path13.join(projectRoot, ".augment", "rules");
+  if (!fs13.existsSync(rulesDir)) {
     return {
       id: "lean-projection",
       status: "skipped",
@@ -5929,7 +6009,7 @@ function _check_lean_projection(projectRoot, packageRoot = PACKAGE_ROOT, project
     };
   }
   const kernel = kernelIdsFromRouter(packageRoot);
-  const files = fs14.readdirSync(rulesDir).filter((f) => f.endsWith(".md") && f !== "INDEX.md").sort();
+  const files = fs13.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 {
@@ -5943,7 +6023,7 @@ function _check_lean_projection(projectRoot, packageRoot = PACKAGE_ROOT, project
   for (const f of nonKernel) {
     let text = "";
     try {
-      text = fs14.readFileSync(path14.join(rulesDir, f), "utf8");
+      text = fs13.readFileSync(path13.join(rulesDir, f), "utf8");
     } catch {
       continue;
     }
@@ -5974,8 +6054,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 = path14.join(projectRoot, ".agent-settings.yml");
-  if (!fs14.existsSync(settingsPath)) {
+  const settingsPath = path13.join(projectRoot, ".agent-settings.yml");
+  if (!fs13.existsSync(settingsPath)) {
     return {
       id: "host-manifest",
       status: "ok",
@@ -5985,7 +6065,7 @@ function _check_host_manifest(projectRoot) {
   }
   let parsed = null;
   try {
-    parsed = YAML.parse(fs14.readFileSync(settingsPath, "utf8"));
+    parsed = YAML.parse(fs13.readFileSync(settingsPath, "utf8"));
   } catch (exc) {
     return {
       id: "host-manifest",
@@ -6046,14 +6126,14 @@ function appendConformanceReport(checks, projectRoot, logPath = conformanceLogPa
   } catch {
   }
 }
-var USAGE = "usage: agent-config conformance [-h] [--project PROJECT] [--json]\n                                [--skip-dispatcher] [--funnel]\n";
+var USAGE2 = "usage: agent-config conformance [-h] [--project PROJECT] [--json]\n                                [--skip-dispatcher] [--funnel]\n";
 function _parse(argv) {
   const opts = { project: null, json: false, skip_dispatcher: false, funnel: false };
   let i = 0;
   while (i < argv.length) {
     const a = argv[i];
     if (a === "-h" || a === "--help") {
-      process6.stdout.write(USAGE);
+      process6.stdout.write(USAGE2);
       throw new ArgparseExit(0);
     }
     if (a === "--json") {
@@ -6067,7 +6147,7 @@ function _parse(argv) {
         opts.project = a.slice(a.indexOf("=") + 1);
       } else {
         if (i + 1 >= argv.length) {
-          process6.stderr.write(USAGE);
+          process6.stderr.write(USAGE2);
           process6.stderr.write("agent-config conformance: error: --project expects a value\n");
           throw new ArgparseExit(2);
         }
@@ -6075,7 +6155,7 @@ function _parse(argv) {
         i += 1;
       }
     } else {
-      process6.stderr.write(USAGE);
+      process6.stderr.write(USAGE2);
       process6.stderr.write(`agent-config conformance: error: unrecognized argument ${a}
 `);
       throw new ArgparseExit(2);
@@ -6084,7 +6164,7 @@ function _parse(argv) {
   }
   return opts;
 }
-function main14(argv = null) {
+function main13(argv = null) {
   const opts = _parse(argv !== null ? Array.from(argv) : process6.argv.slice(2));
   if (opts.funnel) {
     print(render5(buildFunnel()));
@@ -6155,25 +6235,25 @@ function main14(argv = null) {
   }
   return failed ? 1 : 0;
 }
-function _isCliEntry13() {
+function _isCliEntry12() {
   if (process6.argv[1] === void 0) {
     return false;
   }
-  const argvUrl = pathToFileURL14(path14.resolve(process6.argv[1])).href;
+  const argvUrl = pathToFileURL13(path13.resolve(process6.argv[1])).href;
   if (import.meta.url === argvUrl) {
     return true;
   }
   try {
-    const here = fs14.realpathSync(fileURLToPath14(import.meta.url));
-    const argv = fs14.realpathSync(path14.resolve(process6.argv[1]));
+    const here = fs13.realpathSync(fileURLToPath13(import.meta.url));
+    const argv = fs13.realpathSync(path13.resolve(process6.argv[1]));
     return here === argv;
   } catch {
     return false;
   }
 }
-if (_isCliEntry13() || process6.argv[1] === _HERE5) {
+if (_isCliEntry12() || process6.argv[1] === _HERE5) {
   try {
-    process6.exitCode = main14(process6.argv.slice(2));
+    process6.exitCode = main13(process6.argv.slice(2));
   } catch (e) {
     if (e instanceof ArgparseExit) {
       process6.exitCode = e.code;
@@ -6196,7 +6276,7 @@ export {
   conformanceLogPath,
   detectSmokePlatform,
   installLogPath,
-  main14 as main,
+  main13 as main,
   routeTargetPaths,
   runConformanceChecks
 };