@event4u/agent-config 9.29.0 → 9.30.0

package/dist/cli-delegate/cmd_conformance.js

@@ -1,4 +1,7 @@
 import { createRequire as __acCreateRequire } from 'node:module'; const require = globalThis.require ?? __acCreateRequire(import.meta.url);
+import {
+  readHookStdin
+} from "./chunk-MMJL4TIX.js";
 import {
   ArgparseExit,
   STATUS_SYMBOLS,
@@ -11,8 +14,11 @@ import {
   _run_checks,
   _run_checks_no_manifest,
   _scan_foreign
-} from "./chunk-RCIA67XN.js";
+} from "./chunk-IYTGIG2Y.js";
 import "./chunk-FTAISGDQ.js";
+import {
+  atomic_write_json
+} from "./chunk-O3CO5BFB.js";
 import "./chunk-LVRYBKTI.js";
 import "./chunk-736JCWLM.js";
 import {
@@ -39,73 +45,2764 @@ import {
 
 // src/scripts/_cli/cmd_conformance.ts
 var YAML = __toESM(require_dist(), 1);
+import * as fs12 from "node:fs";
+import * as os6 from "node:os";
+import * as path12 from "node:path";
+import process5 from "node:process";
+import { spawnSync } from "node:child_process";
+import { fileURLToPath as fileURLToPath11, pathToFileURL as pathToFileURL11 } from "node:url";
+
+// src/install/txlog.ts
+import { createReadStream, createWriteStream, existsSync, readFileSync, renameSync, statSync, unlinkSync } from "node:fs";
+var ROTATION_MAX_BYTES = 10 * 1024 * 1024;
+var ROTATION_MAX_AGE_MS = 30 * 24 * 60 * 60 * 1e3;
+var RECOVERY_DEPTH_CAP = 500;
+function readRecentEntries(logPath) {
+  if (!existsSync(logPath)) {
+    return [];
+  }
+  const raw = readFileSync(logPath, "utf8");
+  const lines = raw.split("\n").filter((l) => l.length > 0);
+  const tail = lines.slice(-RECOVERY_DEPTH_CAP);
+  const out = [];
+  for (const line of tail) {
+    const parsed = tryParseEntry(line);
+    if (parsed !== null) {
+      out.push(parsed);
+    }
+  }
+  return out;
+}
+function tryParseEntry(line) {
+  try {
+    const obj = JSON.parse(line);
+    if (typeof obj.ts !== "string" || typeof obj.kind !== "string" || typeof obj.path !== "string") {
+      return null;
+    }
+    return obj;
+  } catch {
+    return null;
+  }
+}
+
+// src/scripts/router_target_paths.mjs
+var ROUTE_TARGET_TEMPLATES = Object.freeze({
+  skill: Object.freeze(["dist/agent-src/skills/{id}/SKILL.md"]),
+  command: Object.freeze(["dist/agent-src/commands/{id}.md"]),
+  guideline: Object.freeze(["docs/guidelines/{id}.md"]),
+  contract: Object.freeze([
+    "docs/contracts/{id}.md",
+    "dist/agent-src/contexts/contracts/{id}.md"
+  ])
+});
+function parseRouteTarget(target) {
+  const sep = target.indexOf(":");
+  if (sep <= 0) return null;
+  const kind = target.slice(0, sep);
+  const id = target.slice(sep + 1);
+  if (!id) return null;
+  if (!Object.prototype.hasOwnProperty.call(ROUTE_TARGET_TEMPLATES, kind)) return null;
+  return { kind, id };
+}
+function routeTargetPathsPosix(target) {
+  const parsed = parseRouteTarget(target);
+  if (parsed === null) return [];
+  return ROUTE_TARGET_TEMPLATES[parsed.kind].map((tpl) => tpl.replace("{id}", parsed.id));
+}
+
+// src/scripts/report_conformance_funnel.ts
+import * as fs11 from "node:fs";
+import * as os5 from "node:os";
+import * as path11 from "node:path";
+import process4 from "node:process";
+import { fileURLToPath as fileURLToPath10, pathToFileURL as pathToFileURL10 } from "node:url";
+
+// src/scripts/conformance_scan.ts
+import { createHash } from "node:crypto";
+import fs7 from "node:fs";
+import os from "node:os";
+import path7 from "node:path";
+import { fileURLToPath as fileURLToPath6, pathToFileURL as pathToFileURL6 } from "node:url";
+
+// src/scripts/_lib/carrier_divergence.ts
 import * as fs from "node:fs";
-import * as os from "node:os";
 import * as path from "node:path";
-import process from "node:process";
-import { spawnSync } from "node:child_process";
+var OWNERSHIP_KEYS = ["package", "source_path"];
+function stripOwnershipKeys(text) {
+  return text.split("\n").filter((line) => !OWNERSHIP_KEYS.some((k) => line.startsWith(`${k}:`))).join("\n");
+}
+function comparePair(a, b) {
+  if (a.equals(b)) {
+    return "identical";
+  }
+  if (stripOwnershipKeys(a.toString("utf-8")) === stripOwnershipKeys(b.toString("utf-8"))) {
+    return "provenance-only";
+  }
+  return "body-diff";
+}
+function censusRuleDir(dir) {
+  let files = 0;
+  let chars = 0;
+  let entries;
+  try {
+    entries = fs.readdirSync(dir);
+  } catch {
+    return { files: 0, chars: 0 };
+  }
+  for (const name of entries) {
+    if (!name.endsWith(".md")) continue;
+    try {
+      chars += fs.statSync(path.join(dir, name)).size;
+      files += 1;
+    } catch {
+    }
+  }
+  return { files, chars };
+}
+
+// src/scripts/_lib/transcript_entry.ts
+function _isObject(v) {
+  return typeof v === "object" && v !== null && !Array.isArray(v);
+}
+function isSidechain(entry) {
+  return entry["isSidechain"] === true;
+}
+function entryText(entry) {
+  const msg = entry["message"];
+  const content = _isObject(msg) ? msg["content"] : void 0;
+  if (typeof content === "string") {
+    return content;
+  }
+  if (!Array.isArray(content)) {
+    return "";
+  }
+  return content.filter((b) => _isObject(b) && b["type"] === "text").map((b) => String(b["text"] ?? "")).join("\n");
+}
+function toolUses(entry) {
+  const msg = entry["message"];
+  const content = _isObject(msg) ? msg["content"] : void 0;
+  if (!Array.isArray(content)) {
+    return [];
+  }
+  const out = [];
+  for (const part of content) {
+    if (!_isObject(part) || part["type"] !== "tool_use") {
+      continue;
+    }
+    out.push({
+      name: typeof part["name"] === "string" ? part["name"] : "",
+      input: _isObject(part["input"]) ? part["input"] : {}
+    });
+  }
+  return out;
+}
+
+// src/scripts/language_mirror_hook.ts
+import fs2 from "node:fs";
+import path2 from "node:path";
 import { fileURLToPath, pathToFileURL } from "node:url";
 
-// src/install/txlog.ts
-import { createReadStream, createWriteStream, existsSync, readFileSync, renameSync, statSync, unlinkSync } from "node:fs";
-var ROTATION_MAX_BYTES = 10 * 1024 * 1024;
-var ROTATION_MAX_AGE_MS = 30 * 24 * 60 * 60 * 1e3;
-var RECOVERY_DEPTH_CAP = 500;
-function readRecentEntries(logPath) {
-  if (!existsSync(logPath)) {
+// src/scripts/_lib/prompt_shape.ts
+function isSyntheticPrompt(prompt) {
+  const head = prompt.trimStart().slice(0, 400);
+  return head.startsWith("[SYSTEM NOTIFICATION - NOT USER INPUT]") || head.startsWith("<task-notification>") || head.startsWith("<system-reminder>") || head.startsWith("<local-command-caveat>") || /^\[SYSTEM NOTIFICATION\b/.test(head);
+}
+var DOCUMENT_HEAD = /^\s*(#{1,6}\s|-{3,}\s*$|={3,}\s*$|<[A-Za-z][\w-]*>\s*$)/;
+function humanAuthoredLead(text) {
+  const kept = [];
+  for (const line of text.split("\n")) {
+    if (DOCUMENT_HEAD.test(line)) {
+      break;
+    }
+    kept.push(line);
+  }
+  return kept.join("\n");
+}
+
+// src/scripts/language_mirror_hook.ts
+var EXIT_ALLOW = 0;
+var EXIT_WARN = 2;
+var STATE_FILE = path2.join("agents", "state", "language-mirror.json");
+var PIN_LOST_MARKER = path2.join("agents", "state", "language-mirror.pin-lost");
+function _isObject2(v) {
+  return typeof v === "object" && v !== null && !Array.isArray(v);
+}
+var DE_MARKERS = /\b(der|die|das|den|dem|und|ist|sind|nicht|kein|keine|mach|mache|bitte|warum|wieso|weshalb|weiter|kannst|sollst|soll|musst|muss|hast|habe|haben|wir|ich|du|dann|noch|auch|schon|wenn|aber|alle|mit|ohne|damit|dass|wurde|werden|gibt|nochmal|erstell|erstelle|erstelle|fehler|regeln|arbeite|analysiere|fixe|nimm|lege|prüfe|pruefe|schau|zeig|mir|dir|sich|eine|einen|einem|einer|vom|zum|zur|beim|im)\b|[äöüÄÖÜß]/gi;
+var EN_MARKERS = /\b(the|and|is|are|was|were|not|please|why|because|should|would|could|there|these|those|with|from|about|which|that|this|will|have|has|been|they|them|their|your|our|what|when|where|make|need|want|does|doesn't|don't|it's|let's)\b/gi;
+var MIN_MARKERS = 2;
+function instructionText(prompt) {
+  const OUTPUT_HEAD = /^\s*(To\s+\S+|remote:|error:|fatal:|hint:|warning:|npm ERR!|Error:|Traceback|Exception|[A-Za-z]*Error\b|at\s+\S+:\d+|\s{4,}\S|[-+]{3}\s|@@\s|\$\s|>\s|\||\d+\s*\|)/i;
+  const kept = [];
+  let inPaste = false;
+  for (const line of prompt.replace(/```[\s\S]*?```/g, "\n\n").split("\n")) {
+    if (!line.trim()) {
+      inPaste = false;
+      kept.push(line);
+      continue;
+    }
+    if (OUTPUT_HEAD.test(line)) {
+      inPaste = true;
+      continue;
+    }
+    if (inPaste) {
+      continue;
+    }
+    kept.push(line);
+  }
+  return kept.join("\n");
+}
+function classify(prompt) {
+  const text = instructionText(prompt);
+  const lead = humanAuthoredLead(text);
+  const leadVerdict = _score(lead);
+  if (leadVerdict.language !== "und") {
+    return leadVerdict;
+  }
+  return _score(text);
+}
+function _score(text) {
+  const de = (text.match(DE_MARKERS) ?? []).length;
+  const en = (text.match(EN_MARKERS) ?? []).length;
+  if (de < MIN_MARKERS && en < MIN_MARKERS) {
+    return { language: "und", de_markers: de, en_markers: en };
+  }
+  return { language: de >= en ? "de" : "en", de_markers: de, en_markers: en };
+}
+var LANGUAGE_NAME = {
+  de: "German (Deutsch)",
+  en: "English"
+};
+var LOCALE_ENV_KEYS = ["LC_ALL", "LC_MESSAGES", "LANG", "LANGUAGE"];
+function systemLocaleVerdict(env = process.env) {
+  for (const key of LOCALE_ENV_KEYS) {
+    const raw = (env[key] ?? "").trim();
+    if (!raw) {
+      continue;
+    }
+    const first = raw.split(":")[0] ?? "";
+    const primary = (first.split(/[._@-]/)[0] ?? "").toLowerCase();
+    if (primary === "c" || primary === "posix" || !primary) {
+      continue;
+    }
+    if (primary === "de") {
+      return "de";
+    }
+    if (primary === "en") {
+      return "en";
+    }
+    return "und";
+  }
+  return "und";
+}
+function noticeText(language, source) {
+  const name = LANGUAGE_NAME[language];
+  if (source === "system-locale") {
+    return `Reply language for this turn: ${name} \u2014 the prompt carried no language markers, so this fell back to the system locale. Write in another language and the next turn follows the prompt instead.`;
+  }
+  return `Reply language for this turn: ${name}.`;
+}
+function pinText(language, source = "prompt") {
+  const name = LANGUAGE_NAME[language];
+  if (source === "system-locale") {
+    return `<language-pin>
+No language markers were found in this turn's prompt and no language was pinned yet, so the mirror target falls back to the environment's locale: ${name}. Use it for EVERY user-visible token this turn.
+
+This is the WEAKER of the two provenances \u2014 it reflects the machine, not the user's own words. The first prompt that carries real markers replaces it. Do not treat it as a standing preference, and do not argue with the user about it if they write in something else.
+</language-pin>`;
+  }
+  return `<language-pin>
+The user submitted this turn's prompt in ${name}. That is the mirror target for EVERY user-visible token of your replies this turn \u2014 including the short inter-tool lines between tool calls, headings, table cells, bullets, status lines, and the recommendation label under any numbered-options block.
+
+This pin exists because the trigger is not observable from the transcript alone: slash-command and skill bodies arrive in the user role and can be long and English, which is what drove the 626 wrong-language turns measured in the 30-session audit this hook was built from. Tool output, file contents, and an injected skill body are NOT the trigger \u2014 this pin is.
+</language-pin>`;
+}
+function _loadState(target) {
+  try {
+    const raw = fs2.readFileSync(target, "utf8");
+    const decoded = JSON.parse(raw);
+    return _isObject2(decoded) ? decoded : {};
+  } catch {
+    return {};
+  }
+}
+function nextState(previous, classification, prompt_chars, session_id, now, locale = "und") {
+  if (classification.language === "und") {
+    if (previous.language === "de" || previous.language === "en") {
+      return null;
+    }
+    if (locale === "und") {
+      return null;
+    }
+    return {
+      language: locale,
+      source: "system-locale",
+      detected_at: now,
+      prompt_chars,
+      de_markers: classification.de_markers,
+      en_markers: classification.en_markers,
+      session_id
+    };
+  }
+  return {
+    language: classification.language,
+    source: "prompt",
+    detected_at: now,
+    prompt_chars,
+    de_markers: classification.de_markers,
+    en_markers: classification.en_markers,
+    session_id
+  };
+}
+function _extractPrompt(payload) {
+  for (const key of ["prompt", "userPrompt", "user_prompt", "message", "text"]) {
+    const v = payload[key];
+    if (typeof v === "string" && v.trim()) {
+      return v;
+    }
+  }
+  return "";
+}
+function _setPinLost(consumer_root) {
+  try {
+    const target = path2.join(consumer_root, PIN_LOST_MARKER);
+    fs2.mkdirSync(path2.dirname(target), { recursive: true });
+    fs2.writeFileSync(target, (/* @__PURE__ */ new Date()).toISOString());
+  } catch {
+  }
+}
+function _pinLost(consumer_root) {
+  try {
+    return fs2.existsSync(path2.join(consumer_root, PIN_LOST_MARKER));
+  } catch {
+    return false;
+  }
+}
+function _clearPinLost(consumer_root) {
+  try {
+    fs2.rmSync(path2.join(consumer_root, PIN_LOST_MARKER), { force: true });
+  } catch {
+  }
+}
+function _reEmitAfterCompaction(consumer_root) {
+  if (!_pinLost(consumer_root)) {
+    return EXIT_ALLOW;
+  }
+  const previous = _loadState(path2.join(consumer_root, STATE_FILE));
+  const language = previous.language;
+  const source = previous.source === "system-locale" ? "system-locale" : "prompt";
+  _clearPinLost(consumer_root);
+  if (language !== "de" && language !== "en") {
+    return EXIT_ALLOW;
+  }
+  process.stdout.write(
+    `${JSON.stringify({
+      decision: "warn",
+      reason: noticeText(language, source),
+      additional_context: pinText(language, source)
+    })}
+`
+  );
+  return EXIT_WARN;
+}
+function run(stdin_text, options) {
+  let envelope = {};
+  if (stdin_text.trim()) {
+    try {
+      const decoded = JSON.parse(stdin_text);
+      if (_isObject2(decoded)) {
+        envelope = decoded;
+      }
+    } catch {
+      return EXIT_ALLOW;
+    }
+  }
+  const payload = _isObject2(envelope["payload"]) ? envelope["payload"] : envelope;
+  const event = typeof envelope["event"] === "string" ? envelope["event"] : "";
+  if (event === "pre_compact") {
+    _setPinLost(options.consumer_root);
+    return EXIT_ALLOW;
+  }
+  if (event === "post_tool_use") {
+    return _reEmitAfterCompaction(options.consumer_root);
+  }
+  const prompt = _extractPrompt(payload);
+  if (!prompt) {
+    return EXIT_ALLOW;
+  }
+  if (isSyntheticPrompt(prompt)) {
+    return EXIT_ALLOW;
+  }
+  const session_id = typeof envelope["session_id"] === "string" ? envelope["session_id"] : "";
+  const target = path2.join(options.consumer_root, STATE_FILE);
+  const previous = _loadState(target);
+  const classification = classify(prompt);
+  const next = nextState(
+    previous,
+    classification,
+    prompt.length,
+    session_id,
+    (/* @__PURE__ */ new Date()).toISOString(),
+    // Injectable so the suite can pin a locale instead of inheriting the
+    // machine's — a test whose verdict depends on the developer's `LANG` is a
+    // test that passes here and fails in CI for reasons unrelated to the diff.
+    systemLocaleVerdict(options.env ?? process.env)
+  );
+  const effective = next?.language ?? previous.language;
+  const effectiveSource = next?.source ?? (previous.source === "system-locale" ? "system-locale" : "prompt");
+  if (next) {
+    try {
+      atomic_write_json(target, next);
+    } catch {
+    }
+  }
+  if (effective === "de" || effective === "en") {
+    process.stdout.write(
+      `${JSON.stringify({ decision: "warn", reason: noticeText(effective, effectiveSource), additional_context: pinText(effective, effectiveSource) })}
+`
+    );
+    return EXIT_WARN;
+  }
+  return EXIT_ALLOW;
+}
+function main(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 run(readHookStdin(), { consumer_root });
+}
+function _isCliEntry() {
+  if (true) {
+    return false;
+  }
+  if (process.argv[1] === void 0) {
+    return false;
+  }
+  const argvUrl = pathToFileURL(path2.resolve(process.argv[1])).href;
+  if (import.meta.url === argvUrl) {
+    return true;
+  }
+  try {
+    const here = fs2.realpathSync(fileURLToPath(import.meta.url));
+    const argv = fs2.realpathSync(path2.resolve(process.argv[1]));
+    return here === argv;
+  } catch {
+    return false;
+  }
+}
+if (_isCliEntry()) {
+  process.exit(main());
+}
+
+// src/scripts/git_authorization_hook.ts
+import fs3 from "node:fs";
+import path3 from "node:path";
+import { fileURLToPath as fileURLToPath2, pathToFileURL as pathToFileURL2 } from "node:url";
+var EXIT_ALLOW2 = 0;
+var STATE_FILE2 = path3.join("agents", "state", "git-authorization.json");
+function _isObject3(v) {
+  return typeof v === "object" && v !== null && !Array.isArray(v);
+}
+var PHRASES = [
+  { op: "commit", re: /\b(commit(e|et|te|ten)?|committe|einchecken)\b/i },
+  { op: "push", re: /\b(push(e|en|t)?|hochladen|hochschieben|raufschieben)\b/i },
+  { op: "branch", re: /\b(branch|feature-branch|zweig)\b/i },
+  // A creation verb is required — "schau dir den PR an" is not "open a PR".
+  {
+    op: "pr-create",
+    re: /\b(erstell(e|en)?|mach(e|en)?|leg(e|en)?\s+an|(er)?(ö|oe)ffne|open|create|raise|aufmachen)\b[^.\n]{0,30}\b(pr|pull[- ]request)\b|\b(pr|pull[- ]request)\b[^.\n]{0,20}\b(erstellen|aufmachen|anlegen|(er)?(ö|oe)ffnen)\b/i
+  },
+  // `merge` as an ACTION, never as the noun in "merge conflict" / "merge commit".
+  { op: "pr-merge", re: /\b(merge|merg(e|en|st|t)|zusammenf(ü|ue)hren|reinmergen)\b(?!\s*[- ]?(conflict|konflikt|commit|base|queue|state|status))/i },
+  // A tag is an ACTION here — bare "Tag" is the German word for day, and
+  // "Version" is an ordinary noun. Both authorized a BLOCK op before this.
+  { op: "tag", re: /\b(tagge(n|st)?|tag\s+(setzen|anlegen|erstellen)|git\s+tag|--tags|--follow-tags)\b/i },
+  // "die release notes sind falsch" is a noun phrase, not an authorization.
+  {
+    op: "release",
+    re: /\b(releasen?|ver(ö|oe)ffentlich(e|en))\b(?!\s*[- ]?(notes?|branch|candidate|pr\b|datum|date|zweig))/i
+  },
+  { op: "publish", re: /\b(publish(e|en)?|publiziere[n]?)\b/i }
+];
+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) {
+  const t = prose.trim();
+  if (!t) {
+    return false;
+  }
+  const hasImperative = /\b(mach|mache|bitte|leg|lege|erstell|erstelle|f(ü|ue)hr|f(ü|ue)hre|setz|setze|starte|los|jetzt|go ahead|do it|ja[,.]?\s|ok[,.]?\s)\b/i.test(
+    t
+  );
+  if (hasImperative) {
+    return false;
+  }
+  return /\?\s*$/.test(t) || /^(was|wie|warum|wieso|weshalb|wann|wer|welche[rs]?|wo|ist|sind|kann|kannst|k(ö|oe)nnen|soll|sollen|darf|d(ü|ue)rfen|why|what|how|when|which|who|is|are|can|could|should|does|do)\b/i.test(
+    t
+  );
+}
+var PASTED_COMMANDS = [
+  { op: "publish", re: /\bnpm\s+publish\b/i },
+  { op: "tag", re: /\bgit\s+push\s+[^\n]*--tags\b|\bgit\s+tag\s+-a\b/i },
+  { op: "release", re: /\bgh\s+release\s+create\b/i },
+  { op: "pr-merge", re: /\bgh\s+pr\s+merge\b/i },
+  { op: "pr-create", re: /\bgh\s+pr\s+create\b/i },
+  { op: "push", re: /\bgit\s+push\b/i },
+  { op: "commit", re: /\bgit\s+commit\b/i },
+  { op: "branch", re: /\bgit\s+(checkout\s+-b|switch\s+-c|branch)\b/i }
+];
+function splitFences(prompt) {
+  const fences = [];
+  const prose = prompt.replace(/```[^\n]*\n([\s\S]*?)```/g, (_m, body) => {
+    fences.push(body);
+    return " ";
+  });
+  return { prose, fences };
+}
+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 classifyAuthorization(prompt) {
+  const { prose, fences } = splitFences(prompt);
+  const authorized = /* @__PURE__ */ new Set();
+  const evidence = {};
+  const instruction = prose.split("\n").filter((l) => !OUTPUT_LINE.test(l)).join("\n");
+  for (const { op, re } of isInterrogative(instruction) ? [] : PHRASES) {
+    const m = re.exec(instruction);
+    if (m) {
+      authorized.add(op);
+      evidence[op] = `prose: "${m[0]}"`;
+    }
+  }
+  for (const fence of fences) {
+    if (fence.split("\n").some((l) => OUTPUT_LINE.test(l))) {
+      continue;
+    }
+    for (const line of _commandLines(fence)) {
+      for (const { op, re } of PASTED_COMMANDS) {
+        if (re.test(line)) {
+          authorized.add(op);
+          evidence[op] = `pasted command: "${line.slice(0, 80)}"`;
+        }
+      }
+    }
+  }
+  return { authorized: [...authorized], evidence };
+}
+function run2(stdin_text, options) {
+  let envelope = {};
+  if (stdin_text.trim()) {
+    try {
+      const decoded = JSON.parse(stdin_text);
+      if (_isObject3(decoded)) {
+        envelope = decoded;
+      }
+    } catch {
+      return EXIT_ALLOW2;
+    }
+  }
+  const payload = _isObject3(envelope["payload"]) ? envelope["payload"] : envelope;
+  let prompt = "";
+  for (const key of ["prompt", "userPrompt", "user_prompt", "message", "text"]) {
+    const v = payload[key];
+    if (typeof v === "string" && v.trim()) {
+      prompt = v;
+      break;
+    }
+  }
+  if (!prompt) {
+    return EXIT_ALLOW2;
+  }
+  const { authorized, evidence } = classifyAuthorization(prompt);
+  const ledger = {
+    session_id: typeof envelope["session_id"] === "string" ? envelope["session_id"] : "",
+    detected_at: (/* @__PURE__ */ new Date()).toISOString(),
+    authorized,
+    evidence,
+    prompt_chars: prompt.length
+  };
+  try {
+    atomic_write_json(path3.join(options.consumer_root, STATE_FILE2), ledger);
+  } catch {
+  }
+  return EXIT_ALLOW2;
+}
+function main2(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 run2(readHookStdin(), { consumer_root });
+}
+function _isCliEntry2() {
+  if (true) {
+    return false;
+  }
+  if (process.argv[1] === void 0) {
+    return false;
+  }
+  const argvUrl = pathToFileURL2(path3.resolve(process.argv[1])).href;
+  if (import.meta.url === argvUrl) {
+    return true;
+  }
+  try {
+    const here = fs3.realpathSync(fileURLToPath2(import.meta.url));
+    const argv = fs3.realpathSync(path3.resolve(process.argv[1]));
+    return here === argv;
+  } catch {
+    return false;
+  }
+}
+if (_isCliEntry2()) {
+  process.exit(main2());
+}
+
+// src/scripts/hooks/block_unauthorized_git.ts
+import fs4 from "node:fs";
+import path4 from "node:path";
+import { fileURLToPath as fileURLToPath3, pathToFileURL as pathToFileURL3 } from "node:url";
+var EXIT_ALLOW3 = 0;
+var EXIT_BLOCK = 1;
+function _isObject4(v) {
+  return typeof v === "object" && v !== null && !Array.isArray(v);
+}
+var BLOCK_OPS = /* @__PURE__ */ new Set([
+  "publish",
+  "tag",
+  "release",
+  "pr-merge"
+]);
+var WARN_OPS = /* @__PURE__ */ new Set([
+  "commit",
+  "push",
+  "pr-create",
+  "branch"
+]);
+var G = "(?:-[A-Za-z-]+(?:=\\S+)?(?:\\s+\\S+)?\\s+)*";
+var COMMAND_OPS = [
+  { op: "publish", re: new RegExp(`\\b(npm|pnpm|yarn)\\s+${G}publish\\b`, "i") },
+  { op: "release", re: /\bgh\s+release\s+create\b|\bgh\s+api\b[^\n]*\/releases\b/i },
+  {
+    op: "tag",
+    re: new RegExp(
+      `\\bgit\\s+${G}push\\b[^\\n;|&]*(--tags|--follow-tags|refs\\/tags\\/)`,
+      "i"
+    )
+  },
+  { op: "pr-merge", re: /\bgh\s+pr\s+merge\b|\bgh\s+api\b[^\n]*\/pulls\/\d+\/merge\b/i },
+  { op: "pr-create", re: /\bgh\s+pr\s+create\b|\bgh\s+api\b[^\n]*-X\s+POST[^\n]*\/pulls\b/i },
+  { op: "push", re: new RegExp(`\\bgit\\s+${G}push\\b`, "i") },
+  { op: "commit", re: new RegExp(`\\bgit\\s+${G}commit\\b`, "i") },
+  { op: "branch", re: new RegExp(`\\bgit\\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 = "";
+  let quote = null;
+  for (let i = 0; i < command.length; i += 1) {
+    const ch = command[i];
+    if (quote !== null) {
+      if (quote === "$'" && ch === "\\" && i + 1 < command.length) {
+        cur += ch + command[i + 1];
+        i += 1;
+        continue;
+      }
+      cur += ch;
+      if (ch === (quote === "$'" ? "'" : quote)) {
+        quote = null;
+      } else if (ch === "\\" && quote === '"' && i + 1 < command.length) {
+        cur += command[i + 1];
+        i += 1;
+      }
+      continue;
+    }
+    if (ch === "$" && (command[i + 1] === "'" || command[i + 1] === '"')) {
+      quote = command[i + 1] === "'" ? "$'" : '"';
+      cur += ch + command[i + 1];
+      i += 1;
+      continue;
+    }
+    if (ch === '"' || ch === "'") {
+      quote = ch;
+      cur += ch;
+      continue;
+    }
+    if (ch === "\\" && i + 1 < command.length) {
+      cur += ch + command[i + 1];
+      i += 1;
+      continue;
+    }
+    if (ch === "\n" || ch === ";" || ch === "|" || ch === "&") {
+      if ((ch === "|" || ch === "&") && command[i + 1] === ch) {
+        i += 1;
+      }
+      parts.push(cur);
+      cur = "";
+      continue;
+    }
+    cur += ch;
+  }
+  if (quote !== null) {
+    parts.push(...splitIgnoringQuotes(cur));
+    return parts;
+  }
+  parts.push(cur);
+  return parts;
+}
+function splitIgnoringQuotes(fragment) {
+  const parts = [];
+  let cur = "";
+  for (let i = 0; i < fragment.length; i += 1) {
+    const ch = fragment[i];
+    if (ch === "\\" && i + 1 < fragment.length) {
+      cur += ch + fragment[i + 1];
+      i += 1;
+      continue;
+    }
+    if (ch === "\n" || ch === ";" || ch === "|" || ch === "&") {
+      if ((ch === "|" || ch === "&") && fragment[i + 1] === ch) {
+        i += 1;
+      }
+      parts.push(cur);
+      cur = "";
+      continue;
+    }
+    cur += ch;
+  }
+  parts.push(cur);
+  return parts;
+}
+function substitutionPayloads(segment) {
+  const out = [];
+  for (let i = 0; i < segment.length; i += 1) {
+    const ch = segment[i];
+    if (ch === "\\") {
+      i += 1;
+      continue;
+    }
+    if ((ch === "$" || ch === "<" || ch === ">") && segment[i + 1] === "(") {
+      let open = 1;
+      let j = i + 2;
+      const start = j;
+      for (; j < segment.length && open > 0; j += 1) {
+        const c = segment[j];
+        if (c === "\\") {
+          j += 1;
+        } else if (c === "(") {
+          open += 1;
+        } else if (c === ")") {
+          open -= 1;
+        }
+      }
+      out.push(segment.slice(start, open === 0 ? j - 1 : segment.length));
+      i = j - 1;
+      continue;
+    }
+    if (ch === "`") {
+      const end = segment.indexOf("`", i + 1);
+      out.push(segment.slice(i + 1, end === -1 ? segment.length : end));
+      i = end === -1 ? segment.length : end;
+    }
+  }
+  return out;
+}
+function invokedSegments(command, depth = 0) {
+  if (depth > 3) {
+    return [];
+  }
+  const out = [];
+  const withoutHeredocs = command.replace(
+    /<<-?\s*(['"]?)([A-Za-z_][A-Za-z0-9_]*)\1[\s\S]*?^\s*\2\s*$/gm,
+    "<<HEREDOC"
+  );
+  for (const raw of splitOutsideQuotes(withoutHeredocs)) {
+    let seg = raw.trim();
+    if (!seg) {
+      continue;
+    }
+    seg = seg.replace(/^(?:[A-Za-z_][A-Za-z0-9_]*=(?:"[^"]*"|'[^']*'|\S*)\s+)+/, "");
+    for (const payload of substitutionPayloads(seg)) {
+      out.push(...invokedSegments(payload, depth + 1));
+    }
+    const wrapped = /^(?:\S*\/)?(?:ba|z|k)?sh\s+-[a-z]*c\s+(?:"([^"]*)"|'([^']*)'|(\S+))/.exec(seg);
+    if (wrapped) {
+      out.push(...invokedSegments(wrapped[1] ?? wrapped[2] ?? wrapped[3] ?? "", depth + 1));
+      continue;
+    }
+    const evaled = /^eval\s+(?:"([^"]*)"|'([^']*)'|(.+))$/.exec(seg);
+    if (evaled) {
+      out.push(...invokedSegments(evaled[1] ?? evaled[2] ?? evaled[3] ?? "", depth + 1));
+      continue;
+    }
+    out.push(seg.replace(/^(\S+)/, (w) => w.replace(/['"]/g, "")));
+  }
+  return out;
+}
+function commandOp(command) {
+  let found = null;
+  for (const seg of invokedSegments(command)) {
+    if (!/^(?:\S*\/)?(git|gh|npm|pnpm|yarn)\b/.test(seg)) {
+      continue;
+    }
+    for (const { op, re } of COMMAND_OPS) {
+      if (re.test(seg)) {
+        if (BLOCK_OPS.has(op)) {
+          return op;
+        }
+        found ??= op;
+        break;
+      }
+    }
+  }
+  return found;
+}
+var LEDGER_MAX_AGE_MS = 30 * 60 * 1e3;
+function _loadLedger(consumer_root, session_id, now) {
+  try {
+    const raw = fs4.readFileSync(path4.join(consumer_root, STATE_FILE2), "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 { authorized: /* @__PURE__ */ new Set(), present: false };
+      }
+      const at = Date.parse(String(decoded["detected_at"] ?? ""));
+      if (Number.isFinite(at) && now - at > LEDGER_MAX_AGE_MS) {
+        return { authorized: /* @__PURE__ */ new Set(), present: false };
+      }
+      return {
+        authorized: new Set(decoded["authorized"].filter(Boolean)),
+        present: true
+      };
+    }
+  } catch {
+  }
+  return { authorized: /* @__PURE__ */ new Set(), present: false };
+}
+function decide(command, ledger) {
+  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 shown = command.length > 120 ? `${command.slice(0, 117)}\u2026` : command;
+  if (BLOCK_OPS.has(op)) {
+    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}. Ask the user, in one numbered-options block, and run it only after they answer this turn.`;
+    return { exit: EXIT_BLOCK, stdout: "", stderr: `${reason}
+` };
+  }
+  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 decision = decide(
+    extractCommand(envelope),
+    _loadLedger(options.consumer_root, session_id, Date.now())
+  );
+  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(path4.resolve(process.argv[1])).href;
+  if (import.meta.url === argvUrl) {
+    return true;
+  }
+  try {
+    const here = fs4.realpathSync(fileURLToPath3(import.meta.url));
+    const argv = fs4.realpathSync(path4.resolve(process.argv[1]));
+    return here === argv;
+  } catch {
+    return false;
+  }
+}
+if (_isCliEntry3()) {
+  process.exit(main3());
+}
+
+// src/scripts/before_complete_hook.ts
+import fs5 from "node:fs";
+import path5 from "node:path";
+import { fileURLToPath as fileURLToPath4, pathToFileURL as pathToFileURL4 } from "node:url";
+var STATE_FILE3 = path5.join("agents", "state", "verify-before-complete.json");
+var COMMAND_TOOLS2 = /* @__PURE__ */ new Set([
+  "launch-process",
+  "launch_process",
+  // Augment
+  "Bash",
+  "BashTool",
+  // Claude Code
+  "run-process",
+  "runProcess",
+  // variants
+  "shell",
+  "execute_shell",
+  // generic / Cline
+  "RunShellCommand"
+  // Cursor
+]);
+var _VERIFICATION_RE = new RegExp(
+  "(?:^|[\\s;&|`(])(task\\s+(?:ci|test|tests|lint|check|qa|phpstan|rector|ecs|pest|pytest)|(?:\\./|\\.venv/bin/|vendor/bin/)?(?:pest|phpunit|phpstan|psalm|rector|ecs)\\b|(?:python3?|\\.venv/bin/python3?)\\s+-m\\s+pytest|pytest\\b|(?:npm|pnpm|yarn|bun)\\s+(?:run\\s+)?(?:test|check|lint|typecheck|tsc)|cargo\\s+(?:test|check|clippy)|go\\s+test|make\\s+(?:test|check|lint)|composer\\s+(?:test|check|lint|phpstan)|(?:php\\s+)?artisan\\s+test)",
+  "i"
+);
+function _now() {
+  return (/* @__PURE__ */ new Date()).toISOString().replace(/\.\d{3}Z$/, "+00:00");
+}
+function _empty_state() {
+  return {
+    schema_version: 1,
+    session_id: "",
+    turn_started_at: null,
+    last_verification: null,
+    verifications_this_turn: 0,
+    verifications_this_session: 0,
+    last_stop_at: null,
+    verified_this_turn: false,
+    ci_saw_pending: false,
+    nonevidence_this_turn: 0,
+    checked_at: _now()
+  };
+}
+function _load_state(target) {
+  let isFile = false;
+  try {
+    isFile = fs5.statSync(target).isFile();
+  } catch {
+    isFile = false;
+  }
+  if (!isFile) {
+    return _empty_state();
+  }
+  try {
+    const decoded = JSON.parse(fs5.readFileSync(target, "utf-8"));
+    if (typeof decoded === "object" && decoded !== null && !Array.isArray(decoded)) {
+      return { ..._empty_state(), ...decoded };
+    }
+  } catch {
+  }
+  return _empty_state();
+}
+function _extract_command(payload) {
+  const toolRaw = payload["tool_name"] || payload["toolName"] || payload["tool"];
+  if (!(typeof toolRaw === "string" && COMMAND_TOOLS2.has(toolRaw))) {
+    return [typeof toolRaw === "string" ? toolRaw : null, null];
+  }
+  const tool = toolRaw;
+  const ti = payload["tool_input"];
+  if (typeof ti === "object" && ti !== null && !Array.isArray(ti)) {
+    for (const key of ["command", "cmd", "shell_command"]) {
+      const v = ti[key];
+      if (typeof v === "string" && v) {
+        return [tool, v];
+      }
+    }
+  }
+  for (const key of ["command", "cmd"]) {
+    const v = payload[key];
+    if (typeof v === "string" && v) {
+      return [tool, v];
+    }
+  }
+  return [tool, null];
+}
+function _is_verification(command) {
+  return _VERIFICATION_RE.test(command) || isCiPoll(command);
+}
+var _VACUOUS_PATTERNS = [
+  // gh pr checks / gh run — no checks registered at all.
+  /\b0\s+(?:checks?|runs?)\b/i,
+  // Test runners reporting an empty run.
+  /\bno tests? (?:ran|found|to run|were run)\b/i,
+  /\bNo test files found\b/i,
+  /\b0\s+pass(?:ed|ing)?\b[\s,|·]*\b0\s+fail(?:ed|ing|ures)?\b/i,
+  /\bTests?\s+0\s+passed\b/i,
+  /\bRan 0 tests?\b/i,
+  // Linters / scanners with an empty target set.
+  /\bno files? (?:matched|to (?:lint|check|scan)|found)\b/i,
+  /\b0\s+files?\s+(?:checked|scanned|linted)\b/i,
+  /\bnothing to check\b/i
+];
+function isVacuousOutput(output) {
+  const text = output.trim();
+  if (!text) {
+    return false;
+  }
+  const lines = text.split("\n").filter((l) => l.trim());
+  return lines.every((l) => _VACUOUS_PATTERNS.some((re) => re.test(l)));
+}
+var _CI_POLL_RE = /\bgh\s+(?:pr\s+checks|run\s+(?:watch|list|view))\b/i;
+function isCiPoll(command) {
+  return _CI_POLL_RE.test(command);
+}
+function pendingCount(output) {
+  const m = /(\d+)\s+(?:checks? )?pending\b/i.exec(output) ?? /\bpending[:=]\s*(\d+)/i.exec(output);
+  if (m?.[1] !== void 0) {
+    return Number(m[1]);
+  }
+  const rows = output.match(/^\S.*\b(pending|in_progress|queued)\b/gim);
+  if (rows) {
+    return rows.length;
+  }
+  if (/\bno checks reported\b/i.test(output)) {
+    return null;
+  }
+  if (/^\S+\s+(pass|fail|skipping|successful|failing)\b/im.test(output)) {
+    return 0;
+  }
+  return null;
+}
+function _extract_output(payload) {
+  for (const key of ["tool_response", "toolResponse", "output", "stdout", "result"]) {
+    const v = payload[key];
+    if (typeof v === "string") {
+      return v;
+    }
+    if (v !== null && typeof v === "object") {
+      return JSON.stringify(v);
+    }
+  }
+  return null;
+}
+function _reset_turn(state, session_id) {
+  state["session_id"] = session_id || state["session_id"] || "";
+  state["turn_started_at"] = _now();
+  state["verifications_this_turn"] = 0;
+  state["verified_this_turn"] = false;
+  state["ci_saw_pending"] = false;
+  state["nonevidence_this_turn"] = 0;
+  return state;
+}
+function _asInt(v) {
+  if (!v) {
+    return 0;
+  }
+  if (typeof v === "number") {
+    return Math.trunc(v);
+  }
+  const n = Number(v);
+  return Number.isFinite(n) ? Math.trunc(n) : 0;
+}
+function _update(state, event, envelope) {
+  const session_id = envelope["session_id"] || state["session_id"] || "";
+  if (session_id && session_id !== state["session_id"]) {
+    state["session_id"] = session_id;
+    state["verifications_this_session"] = 0;
+    state = _reset_turn(state, session_id);
+  }
+  let payload = envelope["payload"];
+  if (!(typeof payload === "object" && payload !== null && !Array.isArray(payload))) {
+    payload = {};
+  }
+  const pl = payload;
+  if (event === "session_start" || event === "user_prompt_submit") {
+    state = _reset_turn(state, session_id);
+  } else if (event === "post_tool_use") {
+    const [tool, cmd] = _extract_command(pl);
+    if (cmd && _is_verification(cmd)) {
+      const output = _extract_output(pl);
+      const vacuous = output !== null && isVacuousOutput(output);
+      let counts = !vacuous;
+      if (isCiPoll(cmd)) {
+        const pending = output === null ? null : pendingCount(output);
+        if (pending !== null && pending > 0) {
+          state["ci_saw_pending"] = true;
+          counts = false;
+        } else if (pending === 0) {
+          counts = !vacuous && state["ci_saw_pending"] === true;
+        } else {
+          counts = false;
+        }
+      }
+      state["last_verification"] = {
+        command: cmd.slice(0, 512),
+        tool,
+        at: _now(),
+        platform: envelope["platform"] || "",
+        vacuous,
+        counted: counts
+      };
+      if (counts) {
+        state["verifications_this_turn"] = _asInt(state["verifications_this_turn"]) + 1;
+        state["verifications_this_session"] = _asInt(state["verifications_this_session"]) + 1;
+        state["verified_this_turn"] = true;
+      } else {
+        state["nonevidence_this_turn"] = _asInt(state["nonevidence_this_turn"]) + 1;
+      }
+    }
+  } else if (event === "stop") {
+    state["last_stop_at"] = _now();
+  }
+  state["checked_at"] = _now();
+  return state;
+}
+function run4(stdin_text, options) {
+  const { consumer_root } = options;
+  const verbose = options.verbose ?? false;
+  let envelope = {};
+  if (stdin_text.trim()) {
+    try {
+      const decoded = JSON.parse(stdin_text);
+      if (typeof decoded === "object" && decoded !== null && !Array.isArray(decoded)) {
+        envelope = decoded;
+      }
+    } catch {
+      envelope = {};
+    }
+  }
+  const event = envelope["event"] || "";
+  const target = path5.join(consumer_root, STATE_FILE3);
+  let state = _load_state(target);
+  state = _update(state, event, envelope);
+  try {
+    atomic_write_json(target, state);
+  } catch {
+    if (verbose) {
+      process.stderr.write("verify-before-complete-hook: state write failed\n");
+    }
+    return 0;
+  }
+  if (verbose) {
+    process.stderr.write(
+      `verify-before-complete-hook: event=${event} verified_this_turn=${pyRepr(state["verified_this_turn"])} verifications_this_turn=${pyRepr(state["verifications_this_turn"])}
+`
+    );
+  }
+  return 0;
+}
+function pyRepr(value) {
+  if (value === null || value === void 0) {
+    return "None";
+  }
+  if (typeof value === "boolean") {
+    return value ? "True" : "False";
+  }
+  return String(value);
+}
+function parse_args(argv) {
+  let platform = "generic";
+  let verbose = false;
+  for (let i = 0; i < argv.length; i += 1) {
+    const arg = argv[i];
+    if (arg === "--platform") {
+      platform = argv[i + 1] ?? "generic";
+      i += 1;
+    } else if (arg !== void 0 && arg.startsWith("--platform=")) {
+      platform = arg.slice("--platform=".length);
+    } else if (arg === "--verbose") {
+      verbose = true;
+    }
+  }
+  return { platform, verbose };
+}
+function _readStdin() {
+  return readHookStdin();
+}
+function main4(argv) {
+  const args = parse_args(argv ?? process.argv.slice(2));
+  return run4(_readStdin(), { consumer_root: process.cwd(), verbose: args.verbose });
+}
+function _isCliEntry4() {
+  if (true) {
+    return false;
+  }
+  if (process.argv[1] === void 0) {
+    return false;
+  }
+  const argvUrl = pathToFileURL4(path5.resolve(process.argv[1])).href;
+  if (import.meta.url === argvUrl) {
+    return true;
+  }
+  try {
+    const here = fs5.realpathSync(fileURLToPath4(import.meta.url));
+    const argv = fs5.realpathSync(path5.resolve(process.argv[1]));
+    return here === argv;
+  } catch {
+    return false;
+  }
+}
+var isCliEntry = _isCliEntry4();
+if (isCliEntry) {
+  process.exit(main4(process.argv.slice(2)));
+}
+
+// src/scripts/hooks/evidence_independence.ts
+import crypto from "node:crypto";
+import fs6 from "node:fs";
+import path6 from "node:path";
+import { fileURLToPath as fileURLToPath5, pathToFileURL as pathToFileURL5 } from "node:url";
+var EXIT_ALLOW4 = 0;
+var EXIT_BLOCK2 = 1;
+var STATE_FILE4 = 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([
+  "Agent",
+  "Task",
+  "task",
+  "dispatch_agent",
+  "dispatchAgent",
+  "launch_agent",
+  "run_subagent",
+  "Subagent"
+]);
+var EVALUATION_RE = /\b(review|reviewer|audit|auditor|judge|verdict|blind[- ]pass|blind review|adversarial|critique|assess(ment)?|verify (my|the) (work|change|diff|implementation)|find (any )?(bugs|issues|defects|problems) in (my|the)|pr(ü|ue)f(e|ung)?|begutachte|gutachten|bewerte|(gegen)?check(e)?|durchsicht|review(e|iere))\b/i;
+var PRELOADED_VERDICT_RE = [
+  // German — the operator writes German, and an English-only list meant no
+  // German dispatch was ever screened at all.
+  /\bich erwarte (hier )?(keine|nichts)\b/i,
+  /\b(du )?(wirst|solltest) (hier )?nichts finden\b/i,
+  /\bbest(ä|ae)tige (nur|kurz)\b/i,
+  /\b(ist|sollte) (wahrscheinlich|vermutlich|sicher) (sauber|korrekt|in ordnung|fine)\b/i,
+  /\bkeine findings? (erwartet|zu erwarten)\b/i,
+  // English paraphrases of the audited construct.
+  /\bi am confident there is nothing\b/i,
+  /\ba clean pass is the likely\b/i,
+  /\bno[- ]findings? (is|are) (expected|welcome|fine|acceptable|the likely)/i,
+  /\b(you )?(should|will|probably) find (nothing|no (issues|problems|bugs|findings))/i,
+  /\bconfirm (that )?there (are|is) no\b/i,
+  /\bi (believe|think|expect) (this|it) is (clean|correct|fine)\b/i,
+  /\bexpect(ed)? (to be )?(clean|green|no findings)\b/i,
+  /\bjust confirm\b/i,
+  /\bit('s| is) (probably|likely) fine\b/i
+];
+function isDispatchTool(tool) {
+  return tool !== null && DISPATCH_TOOLS.has(tool);
+}
+function isEvaluationPrompt(prompt) {
+  return EVALUATION_RE.test(prompt);
+}
+var SELF_SCOPE_RE = /\b(my (work|change|diff|implementation|code|fix|patch|branch|pr)|this (diff|change|branch|pr|delta|implementation|patch)|the delta|the change i|what i (wrote|built|changed|implemented)|i just (wrote|built|changed|implemented))\b/i;
+function isSelfScoped(prompt) {
+  return SELF_SCOPE_RE.test(prompt);
+}
+function preloadedVerdict(prompt) {
+  for (const re of PRELOADED_VERDICT_RE) {
+    const m = re.exec(prompt);
+    if (m) {
+      return m[0];
+    }
+  }
+  return null;
+}
+function extractDispatch(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 = _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()) {
+      return [tool, v];
+    }
+  }
+  return [tool, ""];
+}
+function _ledgerStamp(consumer_root) {
+  try {
+    const raw = fs6.readFileSync(
+      path6.join(consumer_root, "agents", "state", "git-authorization.json"),
+      "utf8"
+    );
+    const d = JSON.parse(raw);
+    return typeof d["detected_at"] === "string" ? d["detected_at"] : "";
+  } catch {
+    return "";
+  }
+}
+function _load(target) {
+  try {
+    const decoded = JSON.parse(fs6.readFileSync(target, "utf8"));
+    if (_isObject5(decoded) && Array.isArray(decoded["evaluations"])) {
+      return decoded;
+    }
+  } catch {
+  }
+  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) {
+  if (!isDispatchTool(tool) || !isEvaluationPrompt(prompt)) {
+    return { exit: EXIT_ALLOW4, stdout: "", stderr: "", evaluations: priorEvaluations };
+  }
+  const preloaded = preloadedVerdict(prompt);
+  if (preloaded !== null) {
+    return {
+      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.
+`,
+      evaluations: priorEvaluations
+    };
+  }
+  if (!isSelfScoped(prompt)) {
+    return { exit: EXIT_ALLOW4, stdout: "", stderr: "", evaluations: priorEvaluations };
+  }
+  if (priorEvaluations >= 1) {
+    return {
+      exit: EXIT_BLOCK2,
+      stdout: "",
+      stderr: `Blocked: second evaluation dispatch of your own work in this turn (verdict shopping). One evaluation has already run; commissioning another with a different prompt or scope selects the answer instead of measuring it. Report what the first pass returned, then re-plan.
+`,
+      evaluations: priorEvaluations
+    };
+  }
+  return {
+    exit: EXIT_ALLOW4,
+    stdout: `${JSON.stringify({ decision: "warn", reason: WARN_TEXT })}
+`,
+    stderr: "",
+    evaluations: priorEvaluations + 1
+  };
+}
+function run5(stdin_text, options) {
+  let envelope = {};
+  if (stdin_text.trim()) {
+    try {
+      const decoded = JSON.parse(stdin_text);
+      if (_isObject5(decoded)) {
+        envelope = decoded;
+      }
+    } catch {
+      return EXIT_ALLOW4;
+    }
+  }
+  const target = path6.join(options.consumer_root, STATE_FILE4);
+  const state = _load(target);
+  const session_id = typeof envelope["session_id"] === "string" ? envelope["session_id"] : "";
+  const turnMarker = `${session_id}:${_ledgerStamp(options.consumer_root)}`;
+  if (state.session_id !== turnMarker) {
+    state.session_id = turnMarker;
+    state.turn_started_at = (/* @__PURE__ */ new Date()).toISOString();
+    state.evaluations = [];
+  }
+  const [tool, prompt] = extractDispatch(envelope);
+  const decision = decide2(tool, prompt, state.evaluations.length);
+  if (decision.evaluations > state.evaluations.length) {
+    state.evaluations.push({
+      at: (/* @__PURE__ */ new Date()).toISOString(),
+      digest: crypto.createHash("sha256").update(prompt).digest("hex").slice(0, 16),
+      prompt_chars: prompt.length
+    });
+    try {
+      atomic_write_json(target, state);
+    } catch {
+    }
+  }
+  if (decision.stdout) {
+    process.stdout.write(decision.stdout);
+  }
+  if (decision.stderr) {
+    process.stderr.write(decision.stderr);
+  }
+  return decision.exit;
+}
+function main5(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 run5(readHookStdin(), { consumer_root });
+}
+function _isCliEntry5() {
+  if (true) {
+    return false;
+  }
+  if (process.argv[1] === void 0) {
+    return false;
+  }
+  const argvUrl = pathToFileURL5(path6.resolve(process.argv[1])).href;
+  if (import.meta.url === argvUrl) {
+    return true;
+  }
+  try {
+    const here = fs6.realpathSync(fileURLToPath5(import.meta.url));
+    const argv = fs6.realpathSync(path6.resolve(process.argv[1]));
+    return here === argv;
+  } catch {
+    return false;
+  }
+}
+if (_isCliEntry5()) {
+  process.exit(main5());
+}
+
+// src/scripts/conformance_scan.ts
+var REPO_ROOT = path7.resolve(path7.dirname(fileURLToPath6(import.meta.url)), "..", "..");
+var OBSERVED_BAND = { low: 9.1, high: 39.2 };
+var BAND_MIN_TURNS = 1978;
+function bandVerdict(rate_pct, assistant_turns) {
+  if (assistant_turns < BAND_MIN_TURNS) {
+    return "corpus-too-small";
+  }
+  return rate_pct >= OBSERVED_BAND.low && rate_pct <= OBSERVED_BAND.high ? "inside" : "outside";
+}
+function _isObject6(v) {
+  return typeof v === "object" && v !== null && !Array.isArray(v);
+}
+function userText(entry) {
+  if (entry["type"] !== "user" || isSidechain(entry)) {
+    return null;
+  }
+  const text = entryText(entry);
+  if (!text.trim()) {
+    return null;
+  }
+  if (text.includes("<system-reminder>") || text.startsWith("<local-command-stdout>")) {
+    return null;
+  }
+  return text;
+}
+function assistantText(entry) {
+  if (entry["type"] !== "assistant" || isSidechain(entry)) {
+    return null;
+  }
+  return entryText(entry).trim() || null;
+}
+function toolUses2(entry) {
+  const msg = entry["message"];
+  const content = _isObject6(msg) ? msg["content"] : void 0;
+  if (!Array.isArray(content)) {
+    return [];
+  }
+  return content.filter((b) => _isObject6(b) && b["type"] === "tool_use").map((b) => {
+    const o = b;
+    return {
+      name: String(o["name"] ?? ""),
+      input: _isObject6(o["input"]) ? o["input"] : {}
+    };
+  });
+}
+function isInjectedBody(text) {
+  if (/^(Base directory for this skill|<command-message>|<command-name>|<local-command)/.test(text)) {
+    return true;
+  }
+  return text.length > 2500 && classify(text).language === "en";
+}
+var HARNESS_TEXT = /^(API Error:|Request (timed out|was aborted)|\[Request interrupted|Error: |Credit balance is too low|You've hit your|Prompt is too long)/i;
+var EN_OPENER = /^(let me|i'?ll |i'?m |found it|ok[,. ]|okay|alright|here'?s|now[,. ]|looking|checking|reading|running|the |this |that |there |we |you |good |right[,. ]|perfect|done[.,]|all |confirmed|correct)/i;
+function scanSession(sessionId, lines) {
+  const report = {
+    session: sessionId,
+    user_turns: 0,
+    assistant_turns: 0,
+    violations: []
+  };
+  let pinned = null;
+  let pendingPoll = null;
+  let authorized = /* @__PURE__ */ new Set();
+  let sawPending = false;
+  let evaluationsThisTurn = 0;
+  let turnsSincePrompt = 0;
+  let compactionSincePrompt = false;
+  for (const line of lines) {
+    if (!line.trim()) {
+      continue;
+    }
+    let entry;
+    try {
+      entry = JSON.parse(line);
+    } catch {
+      continue;
+    }
+    if (entry["type"] === "user" && entry["toolUseResult"] !== void 0 && pendingPoll !== null) {
+      const raw = entry["toolUseResult"];
+      const out = typeof raw === "string" ? raw : JSON.stringify(raw);
+      const pending = pendingCount(out);
+      if (pending !== null && pending > 0) {
+        sawPending = true;
+      } else if (isVacuousOutput(out) || pending === 0 && !sawPending) {
+        report.violations.push({
+          check: "vacuous-evidence",
+          session: sessionId,
+          at: pendingPoll.at,
+          detail: `CI poll read as settled without an in-flight observation: ${out.slice(0, 90)}`
+        });
+      }
+      pendingPoll = null;
+      continue;
+    }
+    if (entry["type"] === "system" && entry["subtype"] === "compact_boundary") {
+      compactionSincePrompt = true;
+      continue;
+    }
+    const ut = userText(entry);
+    if (ut !== null) {
+      if (entry["isCompactSummary"] === true) {
+        continue;
+      }
+      if (isSyntheticPrompt(ut)) {
+        continue;
+      }
+      if (isInjectedBody(ut)) {
+        continue;
+      }
+      report.user_turns += 1;
+      turnsSincePrompt = 0;
+      compactionSincePrompt = false;
+      const c = classify(ut);
+      if (c.language !== "und") {
+        pinned = c.language;
+      }
+      authorized = new Set(classifyAuthorization(ut).authorized);
+      sawPending = false;
+      evaluationsThisTurn = 0;
+      pendingPoll = null;
+      continue;
+    }
+    if (entry["type"] !== "assistant" || entry["isSidechain"] === true) {
+      continue;
+    }
+    const at = String(entry["timestamp"] ?? "");
+    const prose = assistantText(entry);
+    if (prose !== null) {
+      report.assistant_turns += 1;
+      turnsSincePrompt += 1;
+      if (pinned === "de") {
+        const first = prose.split("\n").find((l) => l.trim()) ?? "";
+        if (HARNESS_TEXT.test(first.trim())) {
+          continue;
+        }
+        const c = classify(first);
+        if (first.length > 12 && (c.language === "en" || EN_OPENER.test(first.trim()))) {
+          report.violations.push({
+            check: "language-pin",
+            session: sessionId,
+            at,
+            detail: `German pin, English reply opener: "${first.slice(0, 110)}"`,
+            turns_since_prompt: turnsSincePrompt,
+            compaction_since_prompt: compactionSincePrompt
+          });
+        }
+      }
+    }
+    for (const tu of toolUses2(entry)) {
+      const cmd = typeof tu.input["command"] === "string" ? tu.input["command"] : null;
+      if (cmd !== null) {
+        const op = commandOp(cmd);
+        if (op !== null && !authorized.has(op) && BLOCK_OPS.has(op)) {
+          report.violations.push({
+            check: "git-authorization",
+            session: sessionId,
+            at,
+            detail: `irreversible \`${op}\` with no authorization in the turn's prompt: ${cmd.slice(0, 110)}`
+          });
+        }
+        if (isCiPoll(cmd)) {
+          pendingPoll = { at, cmd };
+        }
+      }
+      const prompt = typeof tu.input["prompt"] === "string" ? tu.input["prompt"] : null;
+      if (prompt !== null && isEvaluationPrompt(prompt)) {
+        const preloaded = preloadedVerdict(prompt);
+        if (preloaded !== null) {
+          report.violations.push({
+            check: "evidence-steering",
+            session: sessionId,
+            at,
+            detail: `evaluation prompt pre-loads its verdict: "${preloaded}"`
+          });
+        } else if (isSelfScoped(prompt)) {
+          if (evaluationsThisTurn >= 1) {
+            report.violations.push({
+              check: "evidence-steering",
+              session: sessionId,
+              at,
+              detail: "second self-review dispatch in one turn (verdict shopping)"
+            });
+          }
+          evaluationsThisTurn += 1;
+        }
+      }
+    }
+  }
+  return report;
+}
+var DEFAULT_RATE_SERIES = path7.join(
+  REPO_ROOT,
+  "agents",
+  "runtime",
+  "state",
+  "conformance-rates.jsonl"
+);
+function defaultStore(projectDir) {
+  const slug = projectDir.replace(/[/.]/g, "-");
+  return path7.join(process.env["HOME"] ?? "", ".claude", "projects", slug);
+}
+function _tokens(chars) {
+  return Math.round(chars / 4);
+}
+function measureDelivered(projectRulesDir, globalRulesDir) {
+  const p = censusRuleDir(projectRulesDir);
+  const g = censusRuleDir(globalRulesDir);
+  return {
+    project: {
+      dir: projectRulesDir,
+      present: fs7.existsSync(projectRulesDir),
+      files: p.files,
+      tokens: _tokens(p.chars)
+    },
+    global: {
+      dir: globalRulesDir,
+      present: fs7.existsSync(globalRulesDir),
+      files: g.files,
+      tokens: _tokens(g.chars)
+    },
+    union_tokens: _tokens(p.chars + g.chars)
+  };
+}
+function storeKey(store) {
+  return createHash("sha256").update(path7.resolve(store)).digest("hex").slice(0, 12);
+}
+function scanStore(store, limit) {
+  const files = fs7.readdirSync(store).filter((f) => f.endsWith(".jsonl")).map((f) => ({ f, m: fs7.statSync(path7.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 = fs7.readFileSync(path7.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);
+    }
+  }
+  const totals = {
+    "language-pin": 0,
+    "git-authorization": 0,
+    "vacuous-evidence": 0,
+    "evidence-steering": 0
+  };
+  for (const s of per_session) {
+    for (const v of s.violations) {
+      totals[v.check] = (totals[v.check] ?? 0) + 1;
+    }
+  }
+  const assistant_turns = per_session.reduce((n, s) => n + s.assistant_turns, 0);
+  const language_pin = totals["language-pin"] ?? 0;
+  const rate_pct = assistant_turns === 0 ? 0 : Number((100 * language_pin / assistant_turns).toFixed(1));
+  const delivered = measureDelivered(
+    path7.join(REPO_ROOT, ".claude", "rules"),
+    path7.join(process.env["HOME"] ?? os.homedir(), ".claude", "rules")
+  );
+  const ownStore = path7.resolve(store) === path7.resolve(defaultStore(REPO_ROOT));
+  return {
+    scanned_at: (/* @__PURE__ */ new Date()).toISOString(),
+    store,
+    sessions: per_session.length,
+    totals,
+    per_session,
+    delivered,
+    rate: {
+      store_key: storeKey(store),
+      sessions: per_session.length,
+      assistant_turns,
+      language_pin,
+      rate_pct,
+      band: bandVerdict(rate_pct, assistant_turns),
+      // Only attach the carrier figures when the rate and the carriers describe
+      // the same project.
+      delivered_project_tokens: ownStore ? delivered.project.tokens : null,
+      delivered_global_tokens: ownStore ? delivered.global.tokens : null
+    }
+  };
+}
+function recordRate(file, scanned_at, rate) {
+  fs7.mkdirSync(path7.dirname(file), { recursive: true });
+  fs7.appendFileSync(file, `${JSON.stringify({ measured_at: scanned_at, ...rate })}
+`, "utf8");
+}
+function render(report) {
+  const lines = [];
+  lines.push(`conformance:behavior \xB7 ${report.sessions} session(s) \xB7 ${report.store}`);
+  for (const [k, v] of Object.entries(report.totals)) {
+    lines.push(`  ${v === 0 ? "\u2705" : "\u26A0\uFE0F "} ${k.padEnd(18)} ${v}`);
+  }
+  const worst = [...report.per_session].filter((s) => s.violations.length > 0).sort((a, b) => b.violations.length - a.violations.length).slice(0, 5);
+  if (worst.length > 0) {
+    lines.push("");
+    lines.push("  Highest-violation sessions:");
+    for (const s of worst) {
+      lines.push(`    ${s.session}  ${s.violations.length} across ${s.assistant_turns} turns`);
+    }
+  }
+  const d = report.delivered;
+  lines.push("");
+  lines.push("  Delivered rule text (chars/4, carriers as they stand NOW \u2014 not per-session):");
+  const carrier = (label, c) => c.present ? `    ${label}  ${String(c.files).padStart(4)} rules  ${String(c.tokens).padStart(7)} tok` : `    ${label}  ABSENT \u2014 not a measured zero, this carrier does not exist here`;
+  lines.push(carrier("project", d.project));
+  lines.push(carrier("global ", d.global));
+  lines.push(`    union                  ${String(d.union_tokens).padStart(7)} tok`);
+  lines.push("    A session's own payload is NOT recoverable: the transcript records no system");
+  lines.push("    or tools field, and the carriers change under the sessions. This is one");
+  lines.push("    reading; the series below is what makes it interpretable over time.");
+  lines.push("");
+  lines.push(
+    `  language-pin rate  ${report.rate.rate_pct.toFixed(1)}%  (${report.rate.language_pin} of ${report.rate.assistant_turns} assistant turns)`
+  );
+  if (report.rate.band === "corpus-too-small") {
+    lines.push(
+      `    Not compared: ${report.rate.assistant_turns} turns is below the ${BAND_MIN_TURNS} of the`
+    );
+    lines.push("    smallest corpus the band was derived from, so a verdict here would be about");
+    lines.push("    corpus size, not behaviour.");
+  } else if (report.rate.band === "inside") {
+    lines.push(
+      `    Inside the observed ${OBSERVED_BAND.low}-${OBSERVED_BAND.high}% band (M5, n=3).`
+    );
+  } else {
+    lines.push(
+      `    \u26A0\uFE0F  OUTSIDE the observed ${OBSERVED_BAND.low}-${OBSERVED_BAND.high}% band (M5, n=3).`
+    );
+    lines.push("    This is the falsifier both council members named when the volume test was");
+    lines.push("    cancelled: a project outside the band is the signal that the cancellation");
+    lines.push("    was wrong. It is a reason to look, not a defect in this run.");
+    lines.push("    CHECK FIRST that this is a different PROJECT: a git worktree gets its own");
+    lines.push("    transcript store under the same project, so a store-keyed series counts it");
+    lines.push("    as new. Store novelty is not project novelty.");
+  }
+  lines.push("");
+  lines.push("  Scanned checks are exactly the mechanised ones. Ask-shape, session-canary,");
+  lines.push("  promissory closings and checkbox batching are left as prose and NOT measured.");
+  return lines.join("\n");
+}
+function main6(argv) {
+  const args = argv ?? process.argv.slice(2);
+  let store = null;
+  let limit = 30;
+  let json = false;
+  let out = null;
+  let record = null;
+  for (let i = 0; i < args.length; i += 1) {
+    const a = args[i];
+    if (a === "--store" && args[i + 1] !== void 0) {
+      store = args[++i];
+    } else if (a === "--limit" && args[i + 1] !== void 0) {
+      limit = Number(args[++i]);
+    } else if (a === "--json") {
+      json = true;
+    } else if (a === "--output" && args[i + 1] !== void 0) {
+      out = args[++i];
+    } else if (a === "--record") {
+      record = args[i + 1] !== void 0 && !args[i + 1].startsWith("-") ? args[++i] : DEFAULT_RATE_SERIES;
+    }
+  }
+  const resolved = store ?? defaultStore(process.cwd());
+  if (!fs7.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) {
+    fs7.writeFileSync(out, `${JSON.stringify(report, null, 2)}
+`, "utf8");
+  }
+  if (record) {
+    recordRate(record, report.scanned_at, report.rate);
+  }
+  fs7.writeSync(1, json ? `${JSON.stringify(report, null, 2)}
+` : `${render(report)}
+`);
+  return 0;
+}
+function _isCliEntry6() {
+  if (true) {
+    return false;
+  }
+  if (process.argv[1] === void 0) {
+    return false;
+  }
+  const argvUrl = pathToFileURL6(path7.resolve(process.argv[1])).href;
+  if (import.meta.url === argvUrl) {
+    return true;
+  }
+  try {
+    const here = fs7.realpathSync(fileURLToPath6(import.meta.url));
+    const argv = fs7.realpathSync(path7.resolve(process.argv[1]));
+    return here === argv;
+  } catch {
+    return false;
+  }
+}
+if (_isCliEntry6()) {
+  process.exit(main6());
+}
+
+// src/scripts/report_carrier_divergence.ts
+import * as fs8 from "node:fs";
+import * as os2 from "node:os";
+import * as path8 from "node:path";
+import process2 from "node:process";
+import { fileURLToPath as fileURLToPath7, pathToFileURL as pathToFileURL7 } from "node:url";
+var _HERE = fileURLToPath7(import.meta.url);
+var REPO_ROOT2 = path8.resolve(path8.dirname(_HERE), "..", "..");
+var PROJECT_RULES = path8.join(".claude", "rules");
+var PROJECTION_SOURCE = path8.join("dist", "agent-src", "rules");
+var GLOBAL_RULES = path8.join(".claude", "rules");
+function _listRules(dir) {
+  try {
+    return fs8.readdirSync(dir).filter((f) => f.endsWith(".md")).sort();
+  } catch {
     return [];
   }
-  const raw = readFileSync(logPath, "utf8");
-  const lines = raw.split("\n").filter((l) => l.length > 0);
-  const tail = lines.slice(-RECOVERY_DEPTH_CAP);
-  const out = [];
-  for (const line of tail) {
-    const parsed = tryParseEntry(line);
-    if (parsed !== null) {
-      out.push(parsed);
+}
+function _ruleType(file) {
+  let text;
+  try {
+    text = fs8.readFileSync(file, "utf-8");
+  } catch {
+    return "";
+  }
+  if (!text.startsWith("---")) return "";
+  const end = text.indexOf("\n---", 3);
+  const fm = end === -1 ? text : text.slice(0, end);
+  const m = /^type:\s*"?([a-z]+)"?/m.exec(fm);
+  return m === null ? "" : m[1];
+}
+function compareCarriers(projectDir, globalDir, sourceDir) {
+  const out = {
+    projectDir,
+    globalDir,
+    globalPresent: fs8.existsSync(globalDir),
+    projectPresent: fs8.existsSync(projectDir),
+    shared: 0,
+    identical: [],
+    provenanceOnly: [],
+    bodyDiff: [],
+    projectOnly: [],
+    globalOnly: [],
+    unreadable: [],
+    manualOnlyGlobal: []
+  };
+  const project = new Set(_listRules(projectDir));
+  const global = new Set(_listRules(globalDir));
+  for (const rule of [.../* @__PURE__ */ new Set([...project, ...global])].sort()) {
+    const inP = project.has(rule);
+    const inG = global.has(rule);
+    if (inP && !inG) {
+      out.projectOnly.push(rule);
+      continue;
+    }
+    if (!inP && inG) {
+      out.globalOnly.push(rule);
+      if (sourceDir !== void 0 && _ruleType(path8.join(sourceDir, rule)) === "manual") {
+        out.manualOnlyGlobal.push(rule);
+      }
+      continue;
+    }
+    out.shared += 1;
+    let verdict;
+    try {
+      verdict = comparePair(
+        fs8.readFileSync(path8.join(projectDir, rule)),
+        fs8.readFileSync(path8.join(globalDir, rule))
+      );
+    } catch {
+      out.shared -= 1;
+      out.unreadable.push(rule);
+      continue;
     }
+    if (verdict === "identical") out.identical.push(rule);
+    else if (verdict === "provenance-only") out.provenanceOnly.push(rule);
+    else out.bodyDiff.push(rule);
   }
   return out;
 }
-function tryParseEntry(line) {
+function render2(d) {
+  const lines = [];
+  lines.push("cross-carrier rule divergence \u2014 advisory, gates on nothing");
+  lines.push(`  project carrier: ${d.projectDir}`);
+  lines.push(`  global carrier:  ${d.globalDir}`);
+  lines.push("");
+  if (!d.globalPresent) {
+    lines.push("  The global carrier is absent \u2014 this machine loads the project projection");
+    lines.push("  only, so there is no second copy to diverge from. Nothing to report, and");
+    lines.push("  that is a real answer rather than a skipped check.");
+    return lines.join("\n");
+  }
+  if (!d.projectPresent) {
+    lines.push("  The project rule tree does not exist in this checkout \u2014 it is generated and");
+    lines.push("  gitignored, so a fresh clone has none, and `agents/.agent-tools.yml` may");
+    lines.push("  select zero tools deliberately. Run `task generate-tools` and re-run this");
+    lines.push("  report. Reported rather than silently substituted with the projection");
+    lines.push("  source: dist/ holds rules the project tree omits by design, so reading it");
+    lines.push("  as the project carrier would answer a different question than the one asked.");
+    return lines.join("\n");
+  }
+  lines.push(`  shared rule names                    ${d.shared}`);
+  lines.push(`    byte-identical                     ${d.identical.length}`);
+  lines.push(`    differ ONLY in the install stamp   ${d.provenanceOnly.length}`);
+  lines.push(`    differ in BODY                     ${d.bodyDiff.length}`);
+  if (d.unreadable.length > 0) {
+    lines.push(`    unreadable on one side             ${d.unreadable.length}  (${d.unreadable.join(", ")})`);
+    lines.push("      Not counted as shared and NOT a body difference \u2014 a dangling entry is");
+    lines.push("      a broken install, not a disagreement about content.");
+  }
+  lines.push(`  present at project scope only        ${d.projectOnly.length}`);
+  lines.push(`  present at global scope only         ${d.globalOnly.length}`);
+  lines.push("");
+  if (d.bodyDiff.length > 0) {
+    lines.push("  BODY DIVERGENCE \u2014 the two carriers deliver different text for these rules.");
+    lines.push("  Both copies reach the model, with no precedence marker between them, so a");
+    lines.push("  claim one copy retracts can be re-asserted by the other. PRECEDENCE: the");
+    lines.push("  project projection is generated from src/ at this commit and wins; the");
+    lines.push("  global install is a release snapshot. Close it by reinstalling the global");
+    lines.push("  copy, or by reading the project copy as authoritative.");
+    for (const r of d.bodyDiff) lines.push(`    - ${r}`);
+    lines.push("");
+  }
+  if (d.provenanceOnly.length > 0) {
+    lines.push(`  ${String(d.provenanceOnly.length)} pair(s) differ only by the installer's package:/source_path: stamp.`);
+    lines.push("  Not a content difference and NOT a defect: install.ts stamps every installed");
+    lines.push("  rule, the in-repo projection stamps nothing. Closing it was decided against");
+    lines.push("  on 2026-07-31 \u2014 agents/settings/contexts/dedup-reachability-refusal.md holds");
+    lines.push("  the analysis and the five reopen conditions. Reported as a count on purpose:");
+    lines.push("  naming every expected pair would bury the class above.");
+    lines.push("");
+  }
+  if (d.projectOnly.length > 0) {
+    lines.push(`  project-scope only (${String(d.projectOnly.length)}) \u2014 newer than the installed release:`);
+    lines.push(`    ${d.projectOnly.join(", ")}`);
+  }
+  const driftGlobalOnly = d.globalOnly.filter((r) => !d.manualOnlyGlobal.includes(r));
+  if (driftGlobalOnly.length > 0) {
+    lines.push(`  global-scope only (${String(driftGlobalOnly.length)}) \u2014 the release carries these, this checkout does not project them:`);
+    lines.push(`    ${driftGlobalOnly.join(", ")}`);
+  }
+  if (d.manualOnlyGlobal.length > 0) {
+    lines.push(
+      `  delivered by the global carrier ONLY, by design (${String(d.manualOnlyGlobal.length)}, ADR-004 \`type: manual\`):`
+    );
+    lines.push(`    ${d.manualOnlyGlobal.join(", ")}`);
+    lines.push("    The project projection filters these out and the global installer does not.");
+    lines.push("    Two writers, different filters \u2014 so on a machine with both carriers these");
+    lines.push("    rules reach the model, and on a project-only machine they do not. Expected,");
+    lines.push("    and worth knowing before citing any project-scope reach figure.");
+  }
+  if (d.projectOnly.length > 0 || d.globalOnly.length > 0) {
+    lines.push("");
+    lines.push("  Asymmetric reach is why a project-scope conformance figure does not transfer");
+    lines.push("  to another machine: the rule set the model was told differs by carrier.");
+  }
+  if (d.bodyDiff.length === 0) {
+    lines.push("");
+    lines.push("  No body divergence. The condition is transient \u2014 it returns whenever the");
+    lines.push("  checkout moves ahead of the installed release \u2014 so this is a reading of");
+    lines.push("  right now, not a property of the repo. Re-run it, do not cite it.");
+  }
+  return lines.join("\n");
+}
+function main7(argv) {
+  const args = argv ?? process2.argv.slice(2);
+  let projectDir = path8.join(REPO_ROOT2, PROJECT_RULES);
+  let globalDir = path8.join(os2.homedir(), GLOBAL_RULES);
+  let sourceDir = path8.join(REPO_ROOT2, PROJECTION_SOURCE);
+  const value = (i) => {
+    const v = args[i + 1];
+    return v === void 0 || v.startsWith("-") ? null : v;
+  };
+  for (let i = 0; i < args.length; i += 1) {
+    const a = args[i];
+    if (a === "--project" || a === "--global" || a === "--source") {
+      const v = value(i);
+      if (v === null) {
+        process2.stderr.write(`report_carrier_divergence: ${a} needs a directory
+`);
+        return 1;
+      }
+      const resolved = path8.resolve(v);
+      if (a === "--project") projectDir = resolved;
+      else if (a === "--global") globalDir = resolved;
+      else sourceDir = resolved;
+      i += 1;
+    } else if (a === "--help" || a === "-h") {
+      process2.stdout.write(
+        "usage: report_carrier_divergence [--project DIR] [--global DIR] [--source DIR]\n"
+      );
+      return 0;
+    } else if (a !== void 0 && a.startsWith("--") && a !== "--quiet") {
+      process2.stderr.write(`report_carrier_divergence: unknown flag ${a}
+`);
+      return 1;
+    }
+  }
+  process2.stdout.write(`${render2(compareCarriers(projectDir, globalDir, sourceDir))}
+`);
+  return 0;
+}
+function _isCliEntry7() {
+  if (process2.argv[1] === void 0) return false;
+  if (import.meta.url === pathToFileURL7(path8.resolve(process2.argv[1])).href) return true;
   try {
-    const obj = JSON.parse(line);
-    if (typeof obj.ts !== "string" || typeof obj.kind !== "string" || typeof obj.path !== "string") {
+    return fs8.realpathSync(_HERE) === fs8.realpathSync(path8.resolve(process2.argv[1]));
+  } catch {
+    return false;
+  }
+}
+if (_isCliEntry7()) {
+  process2.exit(main7());
+}
+
+// src/scripts/report_skill_activation.ts
+import * as fs9 from "node:fs";
+import * as os3 from "node:os";
+import * as path9 from "node:path";
+import { fileURLToPath as fileURLToPath8, pathToFileURL as pathToFileURL8 } from "node:url";
+var _HERE2 = fileURLToPath8(import.meta.url);
+var REPO_ROOT3 = path9.resolve(path9.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 (!fs9.existsSync(root)) {
+    return out;
+  }
+  for (const entry of fs9.readdirSync(root, { withFileTypes: true }).sort((a, b) => a.name.localeCompare(b.name))) {
+    if (!entry.isDirectory()) {
+      continue;
+    }
+    const file = path9.join(root, entry.name, "SKILL.md");
+    if (!fs9.existsSync(file)) {
+      continue;
+    }
+    out.total += 1;
+    const text = fs9.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);
+    }
+    const body = fmEnd === -1 ? text : text.slice(fmEnd + 4);
+    if (DETERMINISTIC_RE.test(body)) {
+      out.withDeterministicObligation.push(entry.name);
+    }
+  }
+  return out;
+}
+function defaultStore2(cwd) {
+  return path9.join(os3.homedir(), ".claude", "projects", cwd.replace(/\//g, "-"));
+}
+function measureUsage(store, limit) {
+  const rep = { store, sessions: 0, assistantTurns: 0, invocations: 0, bySkill: {} };
+  if (!fs9.existsSync(store)) {
+    return rep;
+  }
+  const files = fs9.readdirSync(store).filter((f) => f.endsWith(".jsonl")).map((f) => path9.join(store, f)).sort((a, b) => fs9.statSync(b).mtimeMs - fs9.statSync(a).mtimeMs).slice(0, limit);
+  rep.sessions = files.length;
+  for (const file of files) {
+    for (const line of fs9.readFileSync(file, "utf8").split("\n")) {
+      if (!line.trim()) {
+        continue;
+      }
+      let entry;
+      try {
+        entry = JSON.parse(line);
+      } catch {
+        continue;
+      }
+      if (entry["type"] !== "assistant") {
+        continue;
+      }
+      rep.assistantTurns += 1;
+      const msg = entry["message"];
+      const content = msg !== null && typeof msg === "object" ? msg["content"] : null;
+      if (!Array.isArray(content)) {
+        continue;
+      }
+      for (const part of content) {
+        if (part === null || typeof part !== "object") {
+          continue;
+        }
+        const p = part;
+        if (p["type"] !== "tool_use" || p["name"] !== "Skill") {
+          continue;
+        }
+        rep.invocations += 1;
+        const input = p["input"];
+        const name = input !== null && typeof input === "object" ? input["skill"] : null;
+        const key = typeof name === "string" && name !== "" ? name : "<unnamed>";
+        rep.bySkill[key] = (rep.bySkill[key] ?? 0) + 1;
+      }
+    }
+  }
+  return rep;
+}
+function _pct(n, d) {
+  return d === 0 ? "n/a" : `${(100 * n / d).toFixed(1)}%`;
+}
+function render3(census, usage) {
+  const lines = [];
+  lines.push("skill activation census \u2014 advisory, gates on nothing");
+  lines.push("");
+  lines.push(`  skills shipped                         ${census.total}`);
+  lines.push(
+    `  with a machine-matchable trigger key   ${census.withTriggerKey.length} (${_pct(census.withTriggerKey.length, census.total)})`
+  );
+  lines.push(
+    `  with a deterministic obligation        ${census.withDeterministicObligation.length} (${_pct(census.withDeterministicObligation.length, census.total)})`
+  );
+  if (census.withDeterministicObligation.length > 0) {
+    lines.push(`      ${census.withDeterministicObligation.join(", ")}`);
+  }
+  lines.push("");
+  let totalInv = 0;
+  const distinct = /* @__PURE__ */ new Set();
+  for (const u of usage) {
+    for (const k of Object.keys(u.bySkill)) {
+      distinct.add(k);
+    }
+    totalInv += u.invocations;
+    lines.push(
+      `  ${path9.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("");
+  lines.push(`  invocations total                      ${totalInv}`);
+  lines.push(
+    `  distinct skills invoked                ${distinct.size} of ${census.total} (${_pct(distinct.size, census.total)})`
+  );
+  if (distinct.size > 0) {
+    lines.push(`      ${[...distinct].sort().join(", ")}`);
+  }
+  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");
+    lines.push("  match against, and matching the description prose is the class this suite");
+    lines.push("  excludes. The counts above are the finding, not an input to a percentage.");
+  }
+  lines.push("");
+  lines.push("  NOT MEASURED: whether each skill reached the model WITH its description.");
+  lines.push("  The host's injected catalogue is not persisted in the transcript, so the");
+  lines.push("  bare-name hypothesis is a single-session observation. Falsifier: log the");
+  lines.push("  catalogue once per session, then count descriptions against bare names.");
+  return lines.join("\n");
+}
+function main8(argv) {
+  let limit = 30;
+  const stores = [];
+  for (let i = 0; i < argv.length; i += 1) {
+    const a = argv[i];
+    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 === "--help" || a === "-h") {
+      process.stdout.write("usage: report_skill_activation [--limit N] [--store PATH]...\n");
+      return 0;
+    }
+  }
+  if (!Number.isFinite(limit) || limit <= 0) {
+    process.stderr.write("report_skill_activation: --limit must be a positive integer\n");
+    return 1;
+  }
+  if (stores.length === 0) {
+    stores.push(defaultStore2(REPO_ROOT3));
+  }
+  const census = censusSkills(path9.join(REPO_ROOT3, SKILLS_ROOT));
+  const usage = stores.map((s) => measureUsage(s, limit));
+  process.stdout.write(`${render3(census, usage)}
+`);
+  return 0;
+}
+if (process.argv[1] !== void 0 && import.meta.url === pathToFileURL8(path9.resolve(process.argv[1])).href) {
+  process.exit(main8(process.argv.slice(2)));
+}
+
+// src/scripts/report_skill_obligation_violations.ts
+import * as fs10 from "node:fs";
+import * as os4 from "node:os";
+import * as path10 from "node:path";
+import process3 from "node:process";
+import { fileURLToPath as fileURLToPath9, pathToFileURL as pathToFileURL9 } from "node:url";
+var _HERE3 = fileURLToPath9(import.meta.url);
+var REPO_ROOT4 = path10.resolve(path10.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;
+var CMD_HEADS = /* @__PURE__ */ new Set([
+  "cargo",
+  "npm",
+  "pnpm",
+  "yarn",
+  "git",
+  "php",
+  "composer",
+  "task",
+  "make",
+  "npx",
+  "gh",
+  "python3",
+  "docker"
+]);
+var PIVOT_RE = /\s—\s|\s–\s|→|;\s|\s—use\b|\buse instead\b/;
+function _verb(line) {
+  const m = /\b(NEVER|MUST|ALWAYS)\b/.exec(line);
+  return m?.[1] ?? "NEVER";
+}
+function _artefacts(line) {
+  const out = [];
+  for (const m of line.matchAll(PATH_RE)) {
+    out.push({ artefact: m[1], kind: "path" });
+  }
+  for (const m of line.matchAll(CMD_RE)) {
+    const cmd = m[1];
+    if (CMD_HEADS.has(cmd.split(" ")[0])) {
+      out.push({ artefact: cmd, kind: "command" });
+    }
+  }
+  return out;
+}
+function extractObligations(repoRoot) {
+  const skillsRoot = path10.join(repoRoot, SKILLS_ROOT);
+  const census = censusSkills(skillsRoot);
+  const out = {
+    skills: census.withDeterministicObligation,
+    totalLines: 0,
+    withArtefact: [],
+    linesWithArtefact: 0,
+    forbidden: [],
+    prescribed: [],
+    required: []
+  };
+  for (const skill of census.withDeterministicObligation) {
+    let text;
+    try {
+      text = fs10.readFileSync(path10.join(skillsRoot, skill, "SKILL.md"), "utf-8");
+    } catch {
+      continue;
+    }
+    const fmEnd = text.startsWith("---") ? text.indexOf("\n---", 3) : -1;
+    const body = fmEnd === -1 ? text : text.slice(fmEnd + 4);
+    for (const raw of body.match(OBLIGATION_LINE_RE) ?? []) {
+      const line = raw.trim();
+      out.totalLines += 1;
+      const verb = _verb(line);
+      const pivot = PIVOT_RE.exec(line);
+      const head = pivot === null ? line : line.slice(0, pivot.index);
+      const found = _artefacts(line);
+      if (found.length > 0) {
+        out.linesWithArtefact += 1;
+      }
+      for (const a of found) {
+        const polarity = verb === "NEVER" ? head.includes(`\`${a.artefact}\``) ? "forbidden" : "prescribed" : "required";
+        const ob = { skill, line, verb, artefact: a.artefact, kind: a.kind, polarity };
+        out.withArtefact.push(ob);
+        if (polarity === "forbidden") out.forbidden.push(ob);
+        else if (polarity === "prescribed") out.prescribed.push(ob);
+        else out.required.push(ob);
+      }
+    }
+  }
+  return out;
+}
+function _parseSession(lines) {
+  return lines.map((line) => {
+    if (!line.trim()) return null;
+    try {
+      return JSON.parse(line);
+    } catch {
       return null;
     }
-    return obj;
+  });
+}
+var WRITE_TOOLS = /* @__PURE__ */ new Set([
+  "Edit",
+  "Write",
+  "NotebookEdit",
+  "MultiEdit",
+  "str-replace-editor",
+  "str_replace_editor",
+  "save-file",
+  "save_file"
+]);
+var SHELL_TOOLS = /* @__PURE__ */ new Set(["Bash", "BashTool", "launch-process", "launch_process"]);
+var SKILL_BODY_RE = /Base directory for this skill:\s*\S*?\/skills\/([A-Za-z0-9_-]+)/;
+function loadedSkillsFrom(entries) {
+  const first = /* @__PURE__ */ new Map();
+  const note = (name, at) => {
+    const key = name.replace(/:/g, "-");
+    if (!first.has(key)) first.set(key, at);
+  };
+  entries.forEach((entry, i) => {
+    if (entry === null || isSidechain(entry)) return;
+    if (entry["type"] === "user") {
+      const m = SKILL_BODY_RE.exec(entryText(entry));
+      if (m !== null) note(m[1], i);
+      return;
+    }
+    if (entry["type"] !== "assistant") return;
+    for (const t of toolUses(entry)) {
+      if (t.name !== "Skill") continue;
+      const s = t.input["skill"];
+      if (typeof s === "string" && s !== "") note(s, i);
+    }
+  });
+  return first;
+}
+var PATH_FIELDS = ["file_path", "path", "filePath", "notebook_path", "target_file"];
+var COMMAND_FIELDS = ["command", "cmd"];
+function _targetText(input, kind) {
+  const fields = kind === "path" ? PATH_FIELDS : COMMAND_FIELDS;
+  return fields.map((f) => input[f]).filter((v) => typeof v === "string").join("\n");
+}
+function scanSessionForViolations(session, lines, forbidden, parsed) {
+  const entries = parsed ?? _parseSession(lines);
+  const loaded = loadedSkillsFrom(entries);
+  if (loaded.size === 0) return [];
+  const relevant = forbidden.filter((o) => loaded.has(o.skill));
+  if (relevant.length === 0) return [];
+  const flags = [];
+  entries.forEach((entry, i) => {
+    if (entry === null || isSidechain(entry)) return;
+    if (entry["type"] !== "assistant") return;
+    for (const t of toolUses(entry)) {
+      const isWrite = WRITE_TOOLS.has(t.name);
+      const isShell = SHELL_TOOLS.has(t.name);
+      if (!isWrite && !isShell) continue;
+      for (const o of relevant) {
+        const loadedAt = loaded.get(o.skill);
+        if (i <= loadedAt) continue;
+        if (o.kind === "path" && !isWrite) continue;
+        if (o.kind === "command" && !isShell) continue;
+        const text = _targetText(t.input, o.kind);
+        if (!text.includes(o.artefact)) continue;
+        const at = text.indexOf(o.artefact);
+        flags.push({
+          session,
+          skill: o.skill,
+          artefact: o.artefact,
+          kind: o.kind,
+          at: i,
+          loadedAt,
+          tool: t.name,
+          evidence: text.slice(Math.max(0, at - 40), at + o.artefact.length + 40).replace(/\n/g, " ")
+        });
+      }
+    }
+  });
+  return flags;
+}
+function defaultStore3(cwd) {
+  return path10.join(os4.homedir(), ".claude", "projects", cwd.replace(/[/.]/g, "-"));
+}
+function scanStore2(repoRoot, store, limit) {
+  const census = extractObligations(repoRoot);
+  const report = {
+    store,
+    sessions: 0,
+    sessionsWithASkill: 0,
+    census,
+    flags: []
+  };
+  let files;
+  try {
+    files = fs10.readdirSync(store).filter((f) => f.endsWith(".jsonl")).map((f) => ({ p: path10.join(store, f), m: fs10.statSync(path10.join(store, f)).mtimeMs })).sort((a, b) => b.m - a.m).slice(0, limit).map((x) => x.p);
   } catch {
-    return null;
+    return report;
+  }
+  report.sessions = files.length;
+  for (const file of files) {
+    const lines = fs10.readFileSync(file, "utf-8").split("\n");
+    const id = path10.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));
+  }
+  return report;
+}
+function _pct2(n, d) {
+  return d === 0 ? "n/a" : `${(100 * n / d).toFixed(1)}%`;
+}
+function render4(r) {
+  const c = r.census;
+  const lines = [];
+  lines.push("SK-2 loaded-but-violated \u2014 advisory, gates on nothing");
+  lines.push("");
+  lines.push("  COVERAGE (the headline \u2014 read this before any violation count)");
+  lines.push(`    skills with a deterministic obligation   ${c.skills.length}`);
+  lines.push(`    obligation lines in them                 ${c.totalLines}`);
+  lines.push(
+    `    \u2026LINES naming a concrete artefact        ${c.linesWithArtefact} (${_pct2(c.linesWithArtefact, c.totalLines)})`
+  );
+  lines.push(`    \u2026artefacts named across those lines      ${c.withArtefact.length}`);
+  lines.push(`    \u2026of those, the FORBIDDEN artefact        ${c.forbidden.length}`);
+  lines.push(`    \u2026the PRESCRIBED alternative (excluded)   ${c.prescribed.length}`);
+  lines.push(`    \u2026REQUIRED by a MUST/ALWAYS (excluded)    ${c.required.length}`);
+  lines.push(
+    `    testable without judgement               ${c.forbidden.length} artefact(s) over ${c.totalLines} obligation line(s)`
+  );
+  lines.push("");
+  lines.push("  The other lines are deterministic in wording and need a reading to test");
+  lines.push('  ("NEVER return `clean` out of politeness"). That is the FC-8 class this suite');
+  lines.push("  excludes, so it is reported as uncovered rather than approximated.");
+  lines.push("");
+  if (c.forbidden.length > 0) {
+    lines.push("  Mechanised obligations:");
+    for (const o of c.forbidden) {
+      lines.push(`    [${o.skill}] ${o.kind}: ${o.artefact}`);
+    }
+    lines.push("");
+  }
+  if (c.prescribed.length > 0) {
+    lines.push("  Excluded as prescriptive (the artefact is the remedy, not the offence):");
+    for (const o of c.prescribed) {
+      lines.push(`    [${o.skill}] ${o.artefact}`);
+    }
+    lines.push("");
+  }
+  if (c.required.length > 0) {
+    lines.push("  Excluded as REQUIRED \u2014 a MUST/ALWAYS line, so its violation is the");
+    lines.push("  artefact being ABSENT, and a transcript cannot show that something never");
+    lines.push("  happened without also knowing it was due:");
+    for (const o of c.required) {
+      lines.push(`    [${o.skill}] ${o.verb} ${o.artefact}`);
+    }
+    lines.push("");
+  }
+  lines.push(
+    `  Scanned ${r.sessions} session(s); ${r.sessionsWithASkill} had a skill in context.`
+  );
+  lines.push(`  Flags: ${r.flags.length}`);
+  for (const f of r.flags) {
+    lines.push(`    ${f.session}  [${f.skill}] ${f.artefact} via ${f.tool} (entry ${f.at}, loaded ${f.loadedAt})`);
+    lines.push(`        \u2026${f.evidence}\u2026`);
+  }
+  lines.push("");
+  lines.push("  PRECISION: every flag above is hand-read before any number from this script");
+  lines.push("  is cited (Phase 3.3). A detector that cannot state its false-positive rate");
+  lines.push("  ships as detection-only, and this one says so.");
+  return lines.join("\n");
+}
+function main9(argv) {
+  const args = argv ?? process3.argv.slice(2);
+  let limit = 30;
+  let json = false;
+  const stores = [];
+  for (let i = 0; i < args.length; i += 1) {
+    const a = args[i];
+    const value = (at) => {
+      const v = args[at + 1];
+      return v === void 0 || v.startsWith("-") ? null : v;
+    };
+    if (a === "--limit") {
+      const v = value(i);
+      if (v === null) {
+        process3.stderr.write("report_skill_obligation_violations: --limit needs a number\n");
+        return 1;
+      }
+      limit = Number.parseInt(v, 10);
+      i += 1;
+    } else if (a === "--store") {
+      const v = value(i);
+      if (v === null) {
+        process3.stderr.write("report_skill_obligation_violations: --store needs a path\n");
+        return 1;
+      }
+      stores.push(v);
+      i += 1;
+    } else if (a === "--json") {
+      json = true;
+    } else if (a === "--help" || a === "-h") {
+      process3.stdout.write(
+        "usage: report_skill_obligation_violations [--limit N] [--store PATH]... [--json]\n"
+      );
+      return 0;
+    } else if (a !== void 0 && a.startsWith("--") && a !== "--quiet") {
+      process3.stderr.write(`report_skill_obligation_violations: unknown flag ${a}
+`);
+      return 1;
+    }
+  }
+  if (!Number.isFinite(limit) || limit <= 0) {
+    process3.stderr.write("report_skill_obligation_violations: --limit must be a positive integer\n");
+    return 1;
+  }
+  if (stores.length === 0) stores.push(defaultStore3(REPO_ROOT4));
+  for (const store of stores) {
+    const r = scanStore2(REPO_ROOT4, store, limit);
+    process3.stdout.write(json ? `${JSON.stringify(r, null, 2)}
+` : `${render4(r)}
+`);
+  }
+  return 0;
+}
+function _isCliEntry8() {
+  if (process3.argv[1] === void 0) return false;
+  if (import.meta.url === pathToFileURL9(path10.resolve(process3.argv[1])).href) return true;
+  try {
+    return fs10.realpathSync(_HERE3) === fs10.realpathSync(path10.resolve(process3.argv[1]));
+  } catch {
+    return false;
   }
 }
+if (_isCliEntry8()) {
+  process3.exit(main9());
+}
 
-// src/scripts/router_target_paths.mjs
-var ROUTE_TARGET_TEMPLATES = Object.freeze({
-  skill: Object.freeze(["dist/agent-src/skills/{id}/SKILL.md"]),
-  command: Object.freeze(["dist/agent-src/commands/{id}.md"]),
-  guideline: Object.freeze(["docs/guidelines/{id}.md"]),
-  contract: Object.freeze([
-    "docs/contracts/{id}.md",
-    "dist/agent-src/contexts/contracts/{id}.md"
-  ])
-});
-function parseRouteTarget(target) {
-  const sep = target.indexOf(":");
-  if (sep <= 0) return null;
-  const kind = target.slice(0, sep);
-  const id = target.slice(sep + 1);
-  if (!id) return null;
-  if (!Object.prototype.hasOwnProperty.call(ROUTE_TARGET_TEMPLATES, kind)) return null;
-  return { kind, id };
+// src/scripts/report_conformance_funnel.ts
+var _HERE4 = fileURLToPath10(import.meta.url);
+var REPO_ROOT5 = path11.resolve(path11.dirname(_HERE4), "..", "..");
+function buildFunnel(opts = {}) {
+  const repoRoot = opts.repoRoot ?? REPO_ROOT5;
+  const projectRulesDir = opts.projectRulesDir ?? path11.join(repoRoot, PROJECT_RULES);
+  const globalRulesDir = opts.globalRulesDir ?? path11.join(os5.homedir(), GLOBAL_RULES);
+  const sourceDir = opts.sourceDir ?? path11.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(path11.join(repoRoot, SKILLS_ROOT)),
+    usage: measureUsage(store, limit),
+    storePresent: fs11.existsSync(store),
+    sk2: scanStore2(repoRoot, store, limit)
+  };
 }
-function routeTargetPathsPosix(target) {
-  const parsed = parseRouteTarget(target);
-  if (parsed === null) return [];
-  return ROUTE_TARGET_TEMPLATES[parsed.kind].map((tpl) => tpl.replace("{id}", parsed.id));
+function _pct3(n, d) {
+  return d === 0 ? "n/a" : `${(100 * n / d).toFixed(1)}%`;
+}
+function _carrierLine(label, c) {
+  return c.present ? `    ${label}  ${String(c.files).padStart(4)} rules  ${String(c.tokens).padStart(7)} tok` : `    ${label}  ABSENT \u2014 not a measured zero, this carrier does not exist here`;
+}
+function render5(r) {
+  const lines = [];
+  lines.push("conformance funnel \u2014 delivery \u2192 activation \u2192 compliance (report, not a gate)");
+  lines.push("");
+  lines.push("DELIVERY \u2014 rule text the carriers put in front of the model");
+  lines.push(_carrierLine("project", r.delivered.project));
+  lines.push(_carrierLine("global ", r.delivered.global));
+  lines.push(`    union                  ${String(r.delivered.union_tokens).padStart(7)} tok`);
+  lines.push("    Carriers as they stand NOW \u2014 a session's own payload is NOT recoverable:");
+  lines.push("    the transcript records no system or tools field (conformance_scan).");
+  const d = r.divergence;
+  if (!d.globalPresent) {
+    lines.push("    Divergence: the global carrier is absent \u2014 this machine loads the project");
+    lines.push("    projection only, so there is no second copy to diverge from. A real");
+    lines.push("    answer, not a skipped check.");
+  } else if (!d.projectPresent) {
+    lines.push("    Divergence: the project rule tree does not exist in this checkout \u2014 it is");
+    lines.push("    generated and gitignored. Run `task generate-tools`, then re-run. Not");
+    lines.push("    substituted with dist/, which would answer a different question.");
+  } else {
+    lines.push(
+      `    Divergence: ${d.shared} shared \xB7 ${d.bodyDiff.length} body-diff \xB7 ${d.provenanceOnly.length} provenance-only \xB7 ${d.projectOnly.length} project-only \xB7 ${d.globalOnly.length} global-only` + (d.manualOnlyGlobal.length > 0 ? ` (${d.manualOnlyGlobal.length} by design, ADR-004 manual)` : "")
+    );
+    if (d.bodyDiff.length > 0) {
+      lines.push(`    BODY DIVERGENCE \u2014 both copies reach the model: ${d.bodyDiff.join(", ")}`);
+      lines.push("    Precedence: the project projection is generated from src/ at this commit");
+      lines.push("    and wins; the global install is a release snapshot.");
+    }
+    if (d.unreadable.length > 0) {
+      lines.push(`    Unreadable on one side (${d.unreadable.length}) \u2014 a broken install, not a disagreement.`);
+    }
+  }
+  lines.push("");
+  lines.push("ACTIVATION \u2014 are the delivered skills invoked?");
+  lines.push(`    skills shipped                        ${r.skills.total}`);
+  lines.push(
+    `    with a machine-matchable trigger key  ${r.skills.withTriggerKey.length} (${_pct3(r.skills.withTriggerKey.length, r.skills.total)})`
+  );
+  if (!r.storePresent) {
+    lines.push(`    NO DATA: no transcript store at ${r.usage.store} \u2014 usage is not`);
+    lines.push("    measurable here. An absent store is an answer, not a zero.");
+  } else {
+    const distinct = Object.keys(r.usage.bySkill).length;
+    lines.push(
+      `    sessions=${r.usage.sessions} assistant turns=${r.usage.assistantTurns} Skill invocations=${r.usage.invocations} distinct skills=${distinct} of ${r.skills.total} (${_pct3(distinct, r.skills.total)})`
+    );
+  }
+  if (r.skills.withTriggerKey.length === 0) {
+    lines.push("    Honest scope: activation is NOT measurable as a rate \u2014 no skill declares");
+    lines.push("    a machine-matchable trigger, and matching description prose is the class");
+    lines.push("    this suite excludes (report_skill_activation).");
+  }
+  lines.push("    NOT MEASURED: whether each skill reached the model WITH its description \u2014");
+  lines.push("    the host's injected catalogue is not persisted in the transcript, so the");
+  lines.push("    bare-name (truncation) hypothesis stays a single-session observation.");
+  lines.push("");
+  const c = r.sk2.census;
+  lines.push("COMPLIANCE \u2014 SK-2 loaded-but-violated (coverage is the headline)");
+  lines.push(`    skills with a deterministic obligation  ${c.skills.length}`);
+  lines.push(
+    `    testable without judgement              ${c.forbidden.length} artefact(s) over ${c.totalLines} obligation line(s)`
+  );
+  lines.push("    The rest are deterministic in WORDING and need a reading to test \u2014 the");
+  lines.push("    FC-8 class this suite excludes, reported as uncovered, not approximated");
+  lines.push("    (report_skill_obligation_violations).");
+  if (!r.storePresent) {
+    lines.push("    NO DATA: no transcript store \u2014 loaded-but-violated cannot be observed");
+    lines.push("    here. The coverage census above is static and still holds.");
+  } else {
+    lines.push(
+      `    sessions scanned=${r.sk2.sessions} with a skill in context=${r.sk2.sessionsWithASkill} flags=${r.sk2.flags.length}`
+    );
+    for (const f of r.sk2.flags) {
+      lines.push(`      ${f.session}  [${f.skill}] ${f.artefact} via ${f.tool}`);
+    }
+  }
+  lines.push("    PRECISION: every flag is hand-read before any number here is cited \u2014 the");
+  lines.push("    detector cannot state its false-positive rate, so it ships detection-only.");
+  lines.push("");
+  lines.push("This is a REPORT. It gates on nothing and must never be wired into a CI");
+  lines.push("workflow without a measured false-positive rate first (locked policy).");
+  return lines.join("\n");
+}
+function main10(argv) {
+  const args = argv ?? process4.argv.slice(2);
+  const opts = {};
+  const value = (i) => {
+    const v = args[i + 1];
+    return v === void 0 || v.startsWith("-") ? null : v;
+  };
+  for (let i = 0; i < args.length; i += 1) {
+    const a = args[i];
+    if (a === "--store" || a === "--project" || a === "--global" || a === "--source") {
+      const v = value(i);
+      if (v === null) {
+        process4.stderr.write(`report_conformance_funnel: ${a} needs a value
+`);
+        return 1;
+      }
+      const resolved = path11.resolve(v);
+      if (a === "--store") opts.store = resolved;
+      else if (a === "--project") opts.projectRulesDir = resolved;
+      else if (a === "--global") opts.globalRulesDir = resolved;
+      else opts.sourceDir = resolved;
+      i += 1;
+    } else if (a === "--limit") {
+      const v = value(i);
+      const n = v === null ? Number.NaN : Number.parseInt(v, 10);
+      if (!Number.isFinite(n) || n <= 0) {
+        process4.stderr.write("report_conformance_funnel: --limit must be a positive integer\n");
+        return 1;
+      }
+      opts.limit = n;
+      i += 1;
+    } else if (a === "--help" || a === "-h") {
+      process4.stdout.write(
+        "usage: report_conformance_funnel [--store PATH] [--limit N]\n                                 [--project DIR] [--global DIR] [--source DIR]\n"
+      );
+      return 0;
+    } else if (a !== void 0 && a.startsWith("--") && a !== "--quiet") {
+      process4.stderr.write(`report_conformance_funnel: unknown flag ${a}
+`);
+      return 1;
+    }
+  }
+  process4.stdout.write(`${render5(buildFunnel(opts))}
+`);
+  return 0;
+}
+function _isCliEntry9() {
+  if (process4.argv[1] === void 0) return false;
+  if (import.meta.url === pathToFileURL10(path11.resolve(process4.argv[1])).href) return true;
+  try {
+    return fs11.realpathSync(_HERE4) === fs11.realpathSync(path11.resolve(process4.argv[1]));
+  } catch {
+    return false;
+  }
+}
+if (_isCliEntry9()) {
+  process4.exit(main10());
 }
 
 // src/scripts/_cli/cmd_conformance.ts
-var _HERE = fileURLToPath(import.meta.url);
+var _HERE5 = fileURLToPath11(import.meta.url);
 var PACKAGE_ROOT = resolvePackageRoot(import.meta.url);
 var CONFORMANCE_CHECK_IDS = [
   "txlog-clean",
@@ -116,29 +2813,29 @@ var CONFORMANCE_CHECK_IDS = [
 ];
 var THIN_STUB_MARKER = "Routed rule \u2014 load the body on trigger-match";
 function print(s = "") {
-  process.stdout.write(`${s}
+  process5.stdout.write(`${s}
 `);
 }
 function eprint(s = "") {
-  process.stderr.write(`${s}
+  process5.stderr.write(`${s}
 `);
 }
 function conformanceLogPath() {
-  const override = process.env["AGENT_CONFIG_CONFORMANCE_LOG"];
+  const override = process5.env["AGENT_CONFIG_CONFORMANCE_LOG"];
   if (override && override.trim().length > 0) {
     return override;
   }
-  return path.join(os.homedir(), ".event4u", "agent-config", "conformance-log.jsonl");
+  return path12.join(os6.homedir(), ".event4u", "agent-config", "conformance-log.jsonl");
 }
 function installLogPath() {
-  const override = process.env["AGENT_CONFIG_INSTALL_LOG"];
+  const override = process5.env["AGENT_CONFIG_INSTALL_LOG"];
   if (override && override.trim().length > 0) {
     return override;
   }
-  return path.join(os.homedir(), ".event4u", "agent-config", "install-log.jsonl");
+  return path12.join(os6.homedir(), ".event4u", "agent-config", "install-log.jsonl");
 }
 function _check_txlog_clean(logPath = installLogPath()) {
-  if (!fs.existsSync(logPath)) {
+  if (!fs12.existsSync(logPath)) {
     return {
       id: "txlog-clean",
       status: "ok",
@@ -172,11 +2869,11 @@ function _check_txlog_clean(logPath = installLogPath()) {
   };
 }
 function routeTargetPaths(target) {
-  return routeTargetPathsPosix(target).map((rel) => path.join(...rel.split("/")));
+  return routeTargetPathsPosix(target).map((rel) => path12.join(...rel.split("/")));
 }
 function _check_router_pointers(packageRoot = PACKAGE_ROOT) {
-  const routerPath = path.join(packageRoot, "dist", "router.json");
-  if (!fs.existsSync(routerPath)) {
+  const routerPath = path12.join(packageRoot, "dist", "router.json");
+  if (!fs12.existsSync(routerPath)) {
     return {
       id: "router-pointers",
       status: "fail",
@@ -186,7 +2883,7 @@ function _check_router_pointers(packageRoot = PACKAGE_ROOT) {
   }
   let router;
   try {
-    router = JSON.parse(fs.readFileSync(routerPath, "utf8"));
+    router = JSON.parse(fs12.readFileSync(routerPath, "utf8"));
   } catch (exc) {
     return {
       id: "router-pointers",
@@ -195,13 +2892,13 @@ function _check_router_pointers(packageRoot = PACKAGE_ROOT) {
       remedy: "reinstall the package \u2014 dist/router.json is corrupt"
     };
   }
-  const rulesDir = path.join(packageRoot, "dist", "agent-src", "rules");
+  const rulesDir = path12.join(packageRoot, "dist", "agent-src", "rules");
   const broken = [];
   let ids = 0;
   let targets = 0;
   for (const kernelId of router["kernel"] ?? []) {
     ids += 1;
-    if (!fs.existsSync(path.join(rulesDir, `${kernelId}.md`))) {
+    if (!fs12.existsSync(path12.join(rulesDir, `${kernelId}.md`))) {
       broken.push(`kernel:${kernelId} \u2192 rules/${kernelId}.md missing`);
     }
   }
@@ -209,7 +2906,7 @@ function _check_router_pointers(packageRoot = PACKAGE_ROOT) {
     for (const entry of router[tier] ?? []) {
       const ruleId = String(entry["id"] ?? "");
       ids += 1;
-      if (!fs.existsSync(path.join(rulesDir, `${ruleId}.md`))) {
+      if (!fs12.existsSync(path12.join(rulesDir, `${ruleId}.md`))) {
         broken.push(`${tier}:${ruleId} \u2192 rules/${ruleId}.md missing`);
       }
       for (const target of entry["routes_to"] ?? []) {
@@ -219,7 +2916,7 @@ function _check_router_pointers(packageRoot = PACKAGE_ROOT) {
           broken.push(`${ruleId} \u2192 unparseable routes_to ${JSON.stringify(target)}`);
           continue;
         }
-        if (!candidates.some((rel) => fs.existsSync(path.join(packageRoot, rel)))) {
+        if (!candidates.some((rel) => fs12.existsSync(path12.join(packageRoot, rel)))) {
           broken.push(`${ruleId} \u2192 ${target} (${candidates[0]} missing)`);
         }
       }
@@ -251,9 +2948,9 @@ function detectSmokePlatform(projectRoot) {
   return "claude";
 }
 function dispatcherRunner(packageRoot) {
-  const localTsx = path.join(packageRoot, "node_modules", ".bin", "tsx");
-  const script = path.join(packageRoot, "src", "scripts", "hooks", "dispatch_hook.ts");
-  if (fs.existsSync(localTsx)) {
+  const localTsx = path12.join(packageRoot, "node_modules", ".bin", "tsx");
+  const script = path12.join(packageRoot, "src", "scripts", "hooks", "dispatch_hook.ts");
+  if (fs12.existsSync(localTsx)) {
     return [localTsx, script];
   }
   return ["npx", "tsx", script];
@@ -303,12 +3000,12 @@ function _check_hook_dispatcher(projectRoot, packageRoot = PACKAGE_ROOT, opts =
   };
 }
 function readSettingsMode(projectRoot) {
-  const settingsPath = path.join(projectRoot, ".agent-settings.yml");
-  if (!fs.existsSync(settingsPath)) {
+  const settingsPath = path12.join(projectRoot, ".agent-settings.yml");
+  if (!fs12.existsSync(settingsPath)) {
     return "eager-all";
   }
   try {
-    const parsed = YAML.parse(fs.readFileSync(settingsPath, "utf8"));
+    const parsed = YAML.parse(fs12.readFileSync(settingsPath, "utf8"));
     const lean = parsed?.["lean_projection"] ?? null;
     const mode = lean?.["mode"];
     return typeof mode === "string" && mode.length > 0 ? mode : "eager-all";
@@ -319,7 +3016,7 @@ function readSettingsMode(projectRoot) {
 function kernelIdsFromRouter(packageRoot) {
   try {
     const router = JSON.parse(
-      fs.readFileSync(path.join(packageRoot, "dist", "router.json"), "utf8")
+      fs12.readFileSync(path12.join(packageRoot, "dist", "router.json"), "utf8")
     );
     return new Set((router["kernel"] ?? []).map(String));
   } catch {
@@ -336,8 +3033,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 ?? path.join(projectRoot, ".augment", "rules");
-  if (!fs.existsSync(rulesDir)) {
+  const rulesDir = projectedRulesDir ?? path12.join(projectRoot, ".augment", "rules");
+  if (!fs12.existsSync(rulesDir)) {
     return {
       id: "lean-projection",
       status: "skipped",
@@ -346,7 +3043,7 @@ function _check_lean_projection(projectRoot, packageRoot = PACKAGE_ROOT, project
     };
   }
   const kernel = kernelIdsFromRouter(packageRoot);
-  const files = fs.readdirSync(rulesDir).filter((f) => f.endsWith(".md") && f !== "INDEX.md").sort();
+  const files = fs12.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 {
@@ -360,7 +3057,7 @@ function _check_lean_projection(projectRoot, packageRoot = PACKAGE_ROOT, project
   for (const f of nonKernel) {
     let text = "";
     try {
-      text = fs.readFileSync(path.join(rulesDir, f), "utf8");
+      text = fs12.readFileSync(path12.join(rulesDir, f), "utf8");
     } catch {
       continue;
     }
@@ -391,8 +3088,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 = path.join(projectRoot, ".agent-settings.yml");
-  if (!fs.existsSync(settingsPath)) {
+  const settingsPath = path12.join(projectRoot, ".agent-settings.yml");
+  if (!fs12.existsSync(settingsPath)) {
     return {
       id: "host-manifest",
       status: "ok",
@@ -402,7 +3099,7 @@ function _check_host_manifest(projectRoot) {
   }
   let parsed = null;
   try {
-    parsed = YAML.parse(fs.readFileSync(settingsPath, "utf8"));
+    parsed = YAML.parse(fs12.readFileSync(settingsPath, "utf8"));
   } catch (exc) {
     return {
       id: "host-manifest",
@@ -429,7 +3126,7 @@ function _check_host_manifest(projectRoot) {
   };
 }
 function runConformanceChecks(opts = {}) {
-  const projectRoot = opts.projectRoot ?? process.cwd();
+  const projectRoot = opts.projectRoot ?? process5.cwd();
   const packageRoot = opts.packageRoot ?? PACKAGE_ROOT;
   const checks = [];
   checks.push(_check_txlog_clean());
@@ -463,18 +3160,20 @@ function appendConformanceReport(checks, projectRoot, logPath = conformanceLogPa
   } catch {
   }
 }
-var USAGE = "usage: agent-config conformance [-h] [--project PROJECT] [--json]\n                                [--skip-dispatcher]\n";
+var USAGE = "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 };
+  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") {
-      process.stdout.write(USAGE);
+      process5.stdout.write(USAGE);
       throw new ArgparseExit(0);
     }
     if (a === "--json") {
       opts.json = true;
+    } else if (a === "--funnel") {
+      opts.funnel = true;
     } else if (a === "--skip-dispatcher") {
       opts.skip_dispatcher = true;
     } else if (a === "--project" || a.startsWith("--project=")) {
@@ -482,16 +3181,16 @@ function _parse(argv) {
         opts.project = a.slice(a.indexOf("=") + 1);
       } else {
         if (i + 1 >= argv.length) {
-          process.stderr.write(USAGE);
-          process.stderr.write("agent-config conformance: error: --project expects a value\n");
+          process5.stderr.write(USAGE);
+          process5.stderr.write("agent-config conformance: error: --project expects a value\n");
           throw new ArgparseExit(2);
         }
         opts.project = argv[i + 1];
         i += 1;
       }
     } else {
-      process.stderr.write(USAGE);
-      process.stderr.write(`agent-config conformance: error: unrecognized argument ${a}
+      process5.stderr.write(USAGE);
+      process5.stderr.write(`agent-config conformance: error: unrecognized argument ${a}
 `);
       throw new ArgparseExit(2);
     }
@@ -499,8 +3198,12 @@ function _parse(argv) {
   }
   return opts;
 }
-function main(argv = null) {
-  const opts = _parse(argv !== null ? Array.from(argv) : process.argv.slice(2));
+function main11(argv = null) {
+  const opts = _parse(argv !== null ? Array.from(argv) : process5.argv.slice(2));
+  if (opts.funnel) {
+    print(render5(buildFunnel()));
+    return 0;
+  }
   let project_root;
   try {
     [project_root] = _resolve_project_root(opts.project);
@@ -566,28 +3269,28 @@ function main(argv = null) {
   }
   return failed ? 1 : 0;
 }
-function _isCliEntry() {
-  if (process.argv[1] === void 0) {
+function _isCliEntry10() {
+  if (process5.argv[1] === void 0) {
     return false;
   }
-  const argvUrl = pathToFileURL(path.resolve(process.argv[1])).href;
+  const argvUrl = pathToFileURL11(path12.resolve(process5.argv[1])).href;
   if (import.meta.url === argvUrl) {
     return true;
   }
   try {
-    const here = fs.realpathSync(fileURLToPath(import.meta.url));
-    const argv = fs.realpathSync(path.resolve(process.argv[1]));
+    const here = fs12.realpathSync(fileURLToPath11(import.meta.url));
+    const argv = fs12.realpathSync(path12.resolve(process5.argv[1]));
     return here === argv;
   } catch {
     return false;
   }
 }
-if (_isCliEntry() || process.argv[1] === _HERE) {
+if (_isCliEntry10() || process5.argv[1] === _HERE5) {
   try {
-    process.exitCode = main(process.argv.slice(2));
+    process5.exitCode = main11(process5.argv.slice(2));
   } catch (e) {
     if (e instanceof ArgparseExit) {
-      process.exitCode = e.code;
+      process5.exitCode = e.code;
     } else {
       throw e;
     }
@@ -607,7 +3310,7 @@ export {
   conformanceLogPath,
   detectSmokePlatform,
   installLogPath,
-  main,
+  main11 as main,
   routeTargetPaths,
   runConformanceChecks
 };