@event4u/agent-config 14.12.0 → 14.13.0

package/dist/cli-delegate/{chunk-K4FFODTS.js → chunk-ILMUPLGW.js}

@@ -26,7 +26,7 @@ import {
   projectStoreSlug,
   scanTranscripts,
   weightedInputUnits
-} from "./chunk-FF7WAFMR.js";
+} from "./chunk-KPBWFOPZ.js";
 import {
   git_common_dir
 } from "./chunk-E4XIZDIB.js";
@@ -58,6 +58,7 @@ import {
   ProjectRootError,
   ROOT_OVERRIDE_ENV,
   find_project_root_with_trace,
+  iter_setting_overrides,
   project_settings_path,
   resolve_project_root
 } from "./chunk-NLP54U3J.js";
@@ -73,11 +74,11 @@ import {
 // src/scripts/_cli/cmd_doctor.ts
 var YAML2 = __toESM(require_dist(), 1);
 import * as crypto2 from "node:crypto";
-import * as fs11 from "node:fs";
+import * as fs14 from "node:fs";
 import * as os3 from "node:os";
-import * as path15 from "node:path";
-import process2 from "node:process";
-import { fileURLToPath as fileURLToPath5, pathToFileURL as pathToFileURL4 } from "node:url";
+import * as path19 from "node:path";
+import process3 from "node:process";
+import { fileURLToPath as fileURLToPath5, pathToFileURL as pathToFileURL6 } from "node:url";
 
 // src/scripts/_cli/doctor_overrides.ts
 import * as fs from "node:fs";
@@ -255,21 +256,23 @@ function censusDuplicateScope(userRulesDir, projectRulesDir) {
 var preamble_byte_census_exports = {};
 __export(preamble_byte_census_exports, {
   buildByteCensus: () => buildByteCensus,
-  buildReport: () => buildReport2,
+  buildReport: () => buildReport3,
   censusClaudeMdHierarchy: () => censusClaudeMdHierarchy,
+  censusDeliveredRulePayload: () => censusDeliveredRulePayload,
   censusGlobalProfile: () => censusGlobalProfile,
   censusRuleDir: () => censusRuleDir,
   censusSkillsCatalog: () => censusSkillsCatalog,
-  main: () => main2,
-  parseArgs: () => parseArgs2,
-  renderText: () => renderText2,
+  main: () => main4,
+  parseArgs: () => parseArgs4,
+  parseFrontmatter: () => parseFrontmatter,
+  renderText: () => renderText4,
   topRulesByCost: () => topRulesByCost
 });
 var YAML = __toESM(require_dist(), 1);
-import * as fs7 from "node:fs";
+import * as fs8 from "node:fs";
 import { homedir as homedir2 } from "node:os";
-import * as path10 from "node:path";
-import { fileURLToPath as fileURLToPath3, pathToFileURL as pathToFileURL2 } from "node:url";
+import * as path12 from "node:path";
+import { fileURLToPath as fileURLToPath3, pathToFileURL as pathToFileURL4 } from "node:url";
 
 // src/scripts/_lib/agent_user_profile.ts
 import * as path6 from "node:path";
@@ -357,14 +360,348 @@ function censusRuleDir(dir) {
 
 // src/scripts/cache_realization_report.ts
 import { execFileSync } from "node:child_process";
-import * as fs6 from "node:fs";
+import * as fs7 from "node:fs";
 import { homedir } from "node:os";
+import * as path11 from "node:path";
+import { fileURLToPath as fileURLToPath2, pathToFileURL as pathToFileURL3 } from "node:url";
+
+// src/scripts/orchestration_payload_hash_drift.ts
 import * as path9 from "node:path";
-import { fileURLToPath as fileURLToPath2, pathToFileURL } from "node:url";
+import { pathToFileURL as pathToFileURL2 } from "node:url";
 
-// src/scripts/ai_council/pricing.ts
+// src/scripts/_lib/payload_hash_drift.ts
+function emptyCohort() {
+  return { n: 0, hit_count: 0, hit_rate: null };
+}
+function aggregatePayloadHashDrift(lines) {
+  const withData = lines.filter((l) => l.payload_hash !== null && l.cache_hit !== null);
+  const byHash = /* @__PURE__ */ new Map();
+  for (const l of withData) {
+    const hash = l.payload_hash;
+    const arr = byHash.get(hash) ?? [];
+    arr.push(l.cache_hit);
+    byHash.set(hash, arr);
+  }
+  const groups = [];
+  const stable = emptyCohort();
+  const unstable = emptyCohort();
+  for (const [hash, hits] of byHash) {
+    const hitCount = hits.filter(Boolean).length;
+    groups.push({
+      payload_hash: hash,
+      occurrences: hits.length,
+      hit_count: hitCount,
+      hit_rate: hitCount / hits.length
+    });
+    if (hits.length === 1) {
+      unstable.n += 1;
+      if (hits[0] === true) unstable.hit_count += 1;
+    } else {
+      const repeats = hits.slice(1);
+      stable.n += repeats.length;
+      stable.hit_count += repeats.filter(Boolean).length;
+    }
+  }
+  groups.sort((a, b) => b.occurrences - a.occurrences || a.payload_hash.localeCompare(b.payload_hash));
+  stable.hit_rate = stable.n > 0 ? stable.hit_count / stable.n : null;
+  unstable.hit_rate = unstable.n > 0 ? unstable.hit_count / unstable.n : null;
+  const driftVisible = stable.hit_rate !== null && unstable.hit_rate !== null && stable.hit_rate > unstable.hit_rate;
+  return {
+    total_lines: lines.length,
+    lines_with_data: withData.length,
+    groups,
+    stable_cohort: stable,
+    unstable_cohort: unstable,
+    drift_visible: driftVisible
+  };
+}
+
+// src/scripts/orchestration_savings_report.ts
 import * as fs5 from "node:fs";
 import * as path8 from "node:path";
+import { pathToFileURL } from "node:url";
+
+// src/scripts/_lib/orchestration_savings.ts
+var DEFAULT_TIER_WEIGHTS = { lite: 1, medium: 5, high: 15 };
+function emptyProvenance() {
+  return { dispatches: 0, net_token_delta: 0 };
+}
+function aggregateOrchestrationSavings(lines, weights = DEFAULT_TIER_WEIGHTS) {
+  const report = {
+    dispatches: 0,
+    total_spawns: 0,
+    net_token_delta: 0,
+    tokens_saved: 0,
+    tokens_added: 0,
+    by_provenance: { measured: emptyProvenance(), estimated: emptyProvenance() },
+    by_tier: {},
+    by_task_class: {},
+    measured_share: 0,
+    modeled_cost: { covered_dispatches: 0, baseline_cost_units: 0, delegated_cost_units: 0, cost_reduction_pct: null, weights },
+    quality: {
+      quality_lines: 0,
+      first_pass_lines: 0,
+      first_pass_success_count: 0,
+      first_pass_success_rate: null,
+      escalated_lines: 0,
+      escalated_count: 0,
+      escalation_rate: null
+    },
+    notes: []
+  };
+  for (const line of lines) {
+    const o = line.orchestration;
+    if (!o) continue;
+    const spawns = o.spawn_count ?? 0;
+    if (!(spawns > 0)) continue;
+    report.dispatches += 1;
+    report.total_spawns += spawns;
+    const delta = o.token_delta ?? 0;
+    report.net_token_delta += delta;
+    if (delta < 0) report.tokens_saved += -delta;
+    else report.tokens_added += delta;
+    const prov = o.token_delta_provenance === "measured" ? "measured" : "estimated";
+    report.by_provenance[prov].dispatches += 1;
+    report.by_provenance[prov].net_token_delta += delta;
+    const tier = o.tier_chosen ?? "unknown";
+    report.by_tier[tier] = (report.by_tier[tier] ?? 0) + delta;
+    const cls = o.task_class ?? "unclassified";
+    report.by_task_class[cls] = (report.by_task_class[cls] ?? 0) + delta;
+    const dt = o.dispatch_tokens ?? 0;
+    const wChosen = o.tier_chosen != null ? weights[o.tier_chosen] : void 0;
+    const wSession = o.session_tier != null ? weights[o.session_tier] : void 0;
+    if (dt > 0 && wChosen !== void 0 && wSession !== void 0) {
+      report.modeled_cost.covered_dispatches += 1;
+      report.modeled_cost.baseline_cost_units += dt * wSession;
+      report.modeled_cost.delegated_cost_units += dt * wChosen;
+    }
+    const q2 = report.quality;
+    const fps = typeof o.first_pass_success === "boolean";
+    const esc = typeof o.escalated === "boolean";
+    if (fps || esc) q2.quality_lines += 1;
+    if (fps) {
+      q2.first_pass_lines += 1;
+      if (o.first_pass_success === true) q2.first_pass_success_count += 1;
+    }
+    if (esc) {
+      q2.escalated_lines += 1;
+      if (o.escalated === true) q2.escalated_count += 1;
+    }
+  }
+  report.measured_share = report.dispatches === 0 ? 0 : report.by_provenance.measured.dispatches / report.dispatches;
+  const mc = report.modeled_cost;
+  mc.cost_reduction_pct = mc.baseline_cost_units > 0 ? (mc.baseline_cost_units - mc.delegated_cost_units) / mc.baseline_cost_units : null;
+  const q = report.quality;
+  q.first_pass_success_rate = q.first_pass_lines > 0 ? q.first_pass_success_count / q.first_pass_lines : null;
+  q.escalation_rate = q.escalated_lines > 0 ? q.escalated_count / q.escalated_lines : null;
+  if (report.dispatches === 0) {
+    report.notes.push("No orchestration telemetry yet (0 dispatches). Data accrues as delegable slices dispatch (always-on orchestration; recorded via orchestration_record).");
+  } else {
+    report.notes.push("Token counts are MEASURED but blind to the downshift rate win (same tokens on a cheaper tier \u2248 same count). The MODELED cost-% below captures that axis.");
+    if (report.by_provenance.estimated.dispatches > 0) {
+      report.notes.push(`${report.by_provenance.estimated.dispatches}/${report.dispatches} dispatch(es) use ESTIMATED token_delta (chars/4, lossy). Prefer measured (host usage metadata).`);
+    }
+    if (mc.covered_dispatches > 0 && mc.cost_reduction_pct !== null) {
+      report.notes.push(`MODELED cost reduction ${(mc.cost_reduction_pct * 100).toFixed(0)}% over ${mc.covered_dispatches}/${report.dispatches} dispatch(es) that carry tier data \u2014 from provider-neutral tier weights ${JSON.stringify(mc.weights)} + a same-token-count assumption. A MODEL, NOT a measured $ figure; tune with --weights.`);
+    } else {
+      report.notes.push("MODELED cost-% unavailable: no dispatch yet carries dispatch_tokens + session_tier + tier_chosen. Record those (orchestration_record --dispatch-tokens/--session-tier/--tier-chosen) to populate it.");
+    }
+    if (q.quality_lines === 0) {
+      report.notes.push("QUALITY columns empty: no dispatch yet carries first_pass_success / escalated. Record them (orchestration_record --first-pass-success/--escalated) \u2014 cost and quality are reported as a PAIR, never savings alone.");
+    }
+  }
+  return report;
+}
+
+// src/scripts/orchestration_savings_report.ts
+var DEFAULT_DIR = "agents/runtime/state/audit";
+function parseWeights(spec) {
+  if (!spec) return void 0;
+  const w = {};
+  for (const pair of spec.split(",")) {
+    const [k, v] = pair.split("=");
+    const n = Number(v);
+    if (k && Number.isFinite(n)) w[k.trim()] = n;
+  }
+  return Object.keys(w).length ? w : void 0;
+}
+function parseArgs(argv) {
+  const opts = { dir: DEFAULT_DIR, format: "text", weights: DEFAULT_TIER_WEIGHTS };
+  for (let i = 0; i < argv.length; i++) {
+    const a = argv[i];
+    if (a === void 0) continue;
+    if (a === "--dir") opts.dir = argv[++i] ?? opts.dir;
+    else if (a.startsWith("--dir=")) opts.dir = a.slice("--dir=".length);
+    else if (a === "--format") opts.format = argv[++i] ?? opts.format;
+    else if (a.startsWith("--format=")) opts.format = a.slice("--format=".length);
+    else if (a === "--weights") opts.weights = parseWeights(argv[++i]) ?? opts.weights;
+    else if (a.startsWith("--weights=")) opts.weights = parseWeights(a.slice("--weights=".length)) ?? opts.weights;
+  }
+  if (opts.format !== "text" && opts.format !== "json") opts.format = "text";
+  return opts;
+}
+function readAuditLines(dir) {
+  if (!fs5.existsSync(dir)) return [];
+  const lines = [];
+  for (const entry of fs5.readdirSync(dir).sort()) {
+    if (!entry.endsWith(".jsonl")) continue;
+    const raw = fs5.readFileSync(path8.join(dir, entry), "utf8");
+    for (const ln of raw.split("\n")) {
+      const trimmed = ln.trim();
+      if (!trimmed) continue;
+      try {
+        lines.push(JSON.parse(trimmed));
+      } catch {
+      }
+    }
+  }
+  return lines;
+}
+var QUALITY_GATE_MIN_LINES = 20;
+function pct(v) {
+  return `${(v * 100).toFixed(0)}%`;
+}
+function renderPairedCostQuality(r) {
+  const q = r.quality;
+  const gated = q.quality_lines >= QUALITY_GATE_MIN_LINES;
+  const fps = gated && q.first_pass_success_rate !== null ? `${pct(q.first_pass_success_rate)} (n=${q.first_pass_lines})` : `n/a (n=${q.first_pass_lines})`;
+  const esc = gated && q.escalation_rate !== null ? `${pct(q.escalation_rate)} (n=${q.escalated_lines})` : `n/a (n=${q.escalated_lines})`;
+  return [
+    "  cost \xD7 quality (paired \u2014 never savings alone):",
+    `    net token_delta: ${r.net_token_delta} (negative = net saved)   | first_pass_success_rate: ${fps}`,
+    `    tokens saved: ${r.tokens_saved} \xB7 tokens added: ${r.tokens_added}   | escalation_rate: ${esc}`
+  ];
+}
+function renderText(r, dir) {
+  const out = [];
+  out.push("Orchestration savings report");
+  out.push(`  source: ${dir}`);
+  out.push(`  dispatches: ${r.dispatches}  (total spawns: ${r.total_spawns})`);
+  out.push(...renderPairedCostQuality(r));
+  out.push(`  provenance: measured ${r.by_provenance.measured.dispatches} (\u0394 ${r.by_provenance.measured.net_token_delta}) \xB7 estimated ${r.by_provenance.estimated.dispatches} (\u0394 ${r.by_provenance.estimated.net_token_delta})`);
+  out.push(`  measured share: ${(r.measured_share * 100).toFixed(0)}%`);
+  if (Object.keys(r.by_tier).length) {
+    out.push("  by tier (\u0394 tokens):");
+    for (const [tier, d] of Object.entries(r.by_tier).sort()) out.push(`    ${tier}: ${d}`);
+  }
+  if (Object.keys(r.by_task_class).length) {
+    out.push("  by task_class (\u0394 tokens):");
+    for (const [cls, d] of Object.entries(r.by_task_class).sort()) out.push(`    ${cls}: ${d}`);
+  }
+  const mc = r.modeled_cost;
+  if (mc.cost_reduction_pct !== null) {
+    out.push(`  MODELED cost reduction: ${(mc.cost_reduction_pct * 100).toFixed(0)}%  (over ${mc.covered_dispatches}/${r.dispatches} dispatch(es) with tier data)`);
+    out.push(`    weights ${JSON.stringify(mc.weights)} \xB7 baseline ${mc.baseline_cost_units} \u2192 delegated ${mc.delegated_cost_units} cost-units \xB7 MODEL, not measured $`);
+  } else {
+    out.push("  MODELED cost reduction: n/a (needs dispatch_tokens + session_tier + tier_chosen on a dispatch)");
+  }
+  out.push("  notes:");
+  for (const n of r.notes) out.push(`    - ${n}`);
+  return out.join("\n");
+}
+function main(argv = process.argv.slice(2)) {
+  const opts = parseArgs(argv);
+  const lines = readAuditLines(opts.dir);
+  const report = aggregateOrchestrationSavings(lines, opts.weights);
+  if (opts.format === "json") {
+    process.stdout.write(JSON.stringify({ ...report, source: opts.dir }, null, 2) + "\n");
+  } else {
+    process.stdout.write(renderText(report, opts.dir) + "\n");
+  }
+  return 0;
+}
+if (process.argv[1] !== void 0) {
+  const invokedUrl = pathToFileURL(path8.resolve(process.argv[1])).href;
+  if (import.meta.url === invokedUrl) process.exit(main());
+}
+
+// src/scripts/orchestration_payload_hash_drift.ts
+var DEFAULT_DIR2 = "agents/runtime/state/audit";
+function parseArgs2(argv) {
+  const opts = { dir: DEFAULT_DIR2, format: "text" };
+  for (let i = 0; i < argv.length; i++) {
+    const a = argv[i];
+    if (a === void 0) continue;
+    if (a === "--dir") opts.dir = argv[++i] ?? opts.dir;
+    else if (a.startsWith("--dir=")) opts.dir = a.slice("--dir=".length);
+    else if (a === "--format") opts.format = argv[++i] ?? opts.format;
+    else if (a.startsWith("--format=")) opts.format = a.slice("--format=".length);
+  }
+  if (opts.format !== "text" && opts.format !== "json") opts.format = "text";
+  return opts;
+}
+function toPayloadHashLine(raw) {
+  const line = raw ?? {};
+  if (line.input_kind !== "orchestration" || !line.orchestration) {
+    return { payload_hash: null, cache_hit: null };
+  }
+  const hash = line.orchestration.payload_hash;
+  const hit = line.orchestration.cache_hit;
+  return {
+    payload_hash: typeof hash === "string" && hash.length > 0 ? hash : null,
+    cache_hit: typeof hit === "boolean" ? hit : null
+  };
+}
+function buildReport(dir) {
+  const rawLines = readAuditLines(dir);
+  const lines = rawLines.map(toPayloadHashLine);
+  return aggregatePayloadHashDrift(lines);
+}
+function pct2(v) {
+  return `${(v * 100).toFixed(1)}%`;
+}
+function renderText2(r) {
+  const out = [];
+  out.push("Payload-hash \xD7 cache-hit drift report");
+  out.push(`  total audit-log-v1 lines seen: ${r.total_lines}`);
+  out.push(`  lines carrying BOTH payload_hash and cache_hit: ${r.lines_with_data}`);
+  out.push("");
+  if (r.lines_with_data === 0) {
+    out.push(
+      "No recorded lines carry both fields yet \u2014 this is the CURRENT expected state (both are lean-init"
+    );
+    out.push(
+      "extensions; no caller wires a real value into them today). The reader works; there is nothing to"
+    );
+    out.push("report on. This is NOT presented as a green pass \u2014 it is an honest empty state.");
+  } else {
+    out.push(
+      `stable cohort (repeat occurrences of a hash \u2014 the prior write should already be cached): n=${r.stable_cohort.n} hit_rate=${r.stable_cohort.hit_rate !== null ? pct2(r.stable_cohort.hit_rate) : "n/a"}`
+    );
+    out.push(
+      `unstable cohort (hashes seen exactly once \u2014 a payload that never repeats): n=${r.unstable_cohort.n} hit_rate=${r.unstable_cohort.hit_rate !== null ? pct2(r.unstable_cohort.hit_rate) : "n/a"}`
+    );
+    out.push(`drift_visible (stable hit_rate > unstable hit_rate): ${r.drift_visible ? "YES" : "no"}`);
+    out.push("");
+    out.push("Per-hash breakdown (most-occurrences first):");
+    for (const g of r.groups) {
+      out.push(`  ${g.payload_hash}: occurrences=${g.occurrences} hit_rate=${pct2(g.hit_rate)}`);
+    }
+  }
+  out.push("");
+  out.push("REFUSAL (report, never act): cache_hit is a proxy for host-controlled cache behaviour, not a");
+  out.push("metric this package controls. Per ADR-118 \xA71, a host-controlled proxy fails the direct-measure");
+  out.push("condition outright \u2014 this report never wires a measure\u2192adjust step off these two fields.");
+  return out.join("\n");
+}
+function main2(argv = process.argv.slice(2)) {
+  const opts = parseArgs2(argv);
+  const report = buildReport(opts.dir);
+  if (opts.format === "json") {
+    process.stdout.write(JSON.stringify(report, null, 2) + "\n");
+  } else {
+    process.stdout.write(renderText2(report) + "\n");
+  }
+  return 0;
+}
+if (process.argv[1] !== void 0) {
+  const invokedUrl = pathToFileURL2(path9.resolve(process.argv[1])).href;
+  if (import.meta.url === invokedUrl) process.exit(main2());
+}
+
+// src/scripts/ai_council/pricing.ts
+import * as fs6 from "node:fs";
+import * as path10 from "node:path";
 import { fileURLToPath } from "node:url";
 
 // src/scripts/ai_council/_default_prices.ts
@@ -409,8 +746,8 @@ function as_rows() {
 
 // src/scripts/ai_council/pricing.ts
 var _HERE = fileURLToPath(import.meta.url);
-var REPO_ROOT = path8.resolve(path8.dirname(_HERE), "..", "..", "..");
-var PRICES_FILE = path8.join(REPO_ROOT, "agents", "runtime", ".agent-prices.md");
+var REPO_ROOT = path10.resolve(path10.dirname(_HERE), "..", "..", "..");
+var PRICES_FILE = path10.join(REPO_ROOT, "agents", "runtime", ".agent-prices.md");
 function lookup(table, provider, model) {
   const exact = table.prices.get(priceKey(provider, model));
   if (exact !== void 0) {
@@ -469,16 +806,16 @@ function reprice_with_cache(provider, model, tokens, table, ttl = "5m") {
   };
 }
 function load_prices(p = PRICES_FILE) {
-  if (!fs5.existsSync(p)) {
+  if (!fs6.existsSync(p)) {
     bootstrap_from_defaults(p);
   }
-  return _parse(fs5.readFileSync(p, "utf-8"));
+  return _parse(fs6.readFileSync(p, "utf-8"));
 }
 function bootstrap_from_defaults(p = PRICES_FILE) {
-  fs5.mkdirSync(path8.dirname(p), { recursive: true });
+  fs6.mkdirSync(path10.dirname(p), { recursive: true });
   const rows = as_rows();
   const body = _render_markdown(LAST_UPDATED, "shipped-default", rows);
-  fs5.writeFileSync(p, body, "utf-8");
+  fs6.writeFileSync(p, body, "utf-8");
 }
 function _fmt62f(x) {
   const s = x.toFixed(2);
@@ -598,7 +935,7 @@ function _pyFloat(s) {
 
 // src/scripts/cache_realization_report.ts
 var _HERE2 = fileURLToPath2(import.meta.url);
-var REPO_ROOT2 = path9.resolve(path9.dirname(_HERE2), "..", "..");
+var REPO_ROOT2 = path11.resolve(path11.dirname(_HERE2), "..", "..");
 var C1_COLD_START_DOMINANCE_THRESHOLD = 0.5;
 var C2_DUPLICATE_SCOPE_THRESHOLD = 0.25;
 var C4_COUNCIL_MISPRICING_THRESHOLD = 0.05;
@@ -703,20 +1040,20 @@ function computeDuplicateScope(userRulesDir, projectRulesDir, subagentWriteVolum
   };
 }
 function findDebateRoundFiles(councilRoot) {
-  const base = path9.join(councilRoot, "agents", "runtime", "council", "responses");
-  if (!fs6.existsSync(base)) return [];
+  const base = path11.join(councilRoot, "agents", "runtime", "council", "responses");
+  if (!fs7.existsSync(base)) return [];
   const out = [];
   const stack = [base];
   while (stack.length > 0) {
     const dir = stack.pop();
     let entries;
     try {
-      entries = fs6.readdirSync(dir, { withFileTypes: true });
+      entries = fs7.readdirSync(dir, { withFileTypes: true });
     } catch {
       continue;
     }
     for (const entry of entries) {
-      const full = path9.join(dir, entry.name);
+      const full = path11.join(dir, entry.name);
       if (entry.isDirectory()) {
         stack.push(full);
         continue;
@@ -739,7 +1076,7 @@ function computeCouncilMispricing(councilRoot) {
   }
   const groups = /* @__PURE__ */ new Map();
   for (const f of files) {
-    const dir = path9.dirname(f);
+    const dir = path11.dirname(f);
     const arr = groups.get(dir) ?? [];
     arr.push(f);
     groups.set(dir, arr);
@@ -760,7 +1097,7 @@ function computeCouncilMispricing(councilRoot) {
     for (const f of groupFiles) {
       let data;
       try {
-        data = JSON.parse(fs6.readFileSync(f, "utf-8"));
+        data = JSON.parse(fs7.readFileSync(f, "utf-8"));
       } catch {
         continue;
       }
@@ -800,7 +1137,7 @@ function computeCouncilMispricing(councilRoot) {
   const status = Math.abs(deltaPct) >= C4_COUNCIL_MISPRICING_THRESHOLD ? "confirmed" : "falsified";
   return {
     status,
-    session: path9.relative(councilRoot, best.dir) || "(top-level)",
+    session: path11.relative(councilRoot, best.dir) || "(top-level)",
     rounds: best.rounds,
     recorded_cost_usd: best.recorded,
     cache_aware_cost_usd: best.cacheAware,
@@ -828,8 +1165,8 @@ function computeWorktreeFragmentation(projectsRoot, worktreePaths, maxAgeDays) {
   }
   const established = worktreePaths[0];
   const encodedEstablished = encodeProjectPath(established);
-  const worktreeDirs = worktreePaths.slice(1).map(encodeProjectPath).filter((d) => fs6.existsSync(path9.join(projectsRoot, d)));
-  if (!fs6.existsSync(path9.join(projectsRoot, encodedEstablished)) || worktreeDirs.length === 0) {
+  const worktreeDirs = worktreePaths.slice(1).map(encodeProjectPath).filter((d) => fs7.existsSync(path11.join(projectsRoot, d)));
+  if (!fs7.existsSync(path11.join(projectsRoot, encodedEstablished)) || worktreeDirs.length === 0) {
     return {
       status: "pending",
       reason: "no transcript directory found for both an established and a fresh-worktree checkout of this repo"
@@ -945,11 +1282,12 @@ function defaultOptions() {
     maxAgeDays: 14,
     repoRoot: REPO_ROOT2,
     councilRoot: REPO_ROOT2,
-    userRulesDir: path9.join(homedir(), ".claude", "rules"),
-    projectRulesDir: path9.join(REPO_ROOT2, "dist", "agent-src", "rules")
+    userRulesDir: path11.join(homedir(), ".claude", "rules"),
+    projectRulesDir: path11.join(REPO_ROOT2, "dist", "agent-src", "rules"),
+    auditDir: path11.join(REPO_ROOT2, "agents", "runtime", "state", "audit")
   };
 }
-function parseArgs(argv) {
+function parseArgs3(argv) {
   const opts = defaultOptions();
   for (let i = 0; i < argv.length; i++) {
     const a = argv[i];
@@ -968,11 +1306,44 @@ function parseArgs(argv) {
     else if (a.startsWith("--user-rules-dir=")) opts.userRulesDir = a.slice("--user-rules-dir=".length);
     else if (a === "--project-rules-dir") opts.projectRulesDir = argv[++i] ?? opts.projectRulesDir;
     else if (a.startsWith("--project-rules-dir=")) opts.projectRulesDir = a.slice("--project-rules-dir=".length);
+    else if (a === "--audit-dir") opts.auditDir = argv[++i] ?? opts.auditDir;
+    else if (a.startsWith("--audit-dir=")) opts.auditDir = a.slice("--audit-dir=".length);
   }
   if (opts.format !== "text" && opts.format !== "json") opts.format = "text";
   return opts;
 }
-function buildReport(opts) {
+function computePrefixStability(drift) {
+  const stable = { n: drift.stable_cohort.n, read_share: drift.stable_cohort.hit_rate };
+  const unstable = { n: drift.unstable_cohort.n, read_share: drift.unstable_cohort.hit_rate };
+  if (stable.read_share === null || unstable.read_share === null) {
+    const empty = [stable.read_share === null ? "stable" : null, unstable.read_share === null ? "unstable" : null].filter((x) => x !== null).join(" and ");
+    const plural = empty.includes(" and ") ? "cohorts are" : "cohort is";
+    return {
+      verdict: "insufficient-data",
+      reason: `the ${empty} ${plural} empty (${drift.lines_with_data} audit line(s) carry both payload_hash and cache_hit) \u2014 no comparison exists, and a share is not reported for one`,
+      stable_cohort: stable,
+      unstable_cohort: unstable,
+      lines_with_data: drift.lines_with_data
+    };
+  }
+  if (stable.read_share < unstable.read_share) {
+    return {
+      verdict: "inverted",
+      reason: `repeat dispatches of the same payload shape hit the cache LESS often (${(stable.read_share * 100).toFixed(1)}%) than one-off shapes (${(unstable.read_share * 100).toFixed(1)}%) \u2014 a prefix-stable surface is being rewritten between repeats`,
+      stable_cohort: stable,
+      unstable_cohort: unstable,
+      lines_with_data: drift.lines_with_data
+    };
+  }
+  return {
+    verdict: "stable-higher",
+    reason: `repeat dispatches hit the cache at ${(stable.read_share * 100).toFixed(1)}% against ${(unstable.read_share * 100).toFixed(1)}% for one-off shapes, which is the expected ordering`,
+    stable_cohort: stable,
+    unstable_cohort: unstable,
+    lines_with_data: drift.lines_with_data
+  };
+}
+function buildReport2(opts) {
   const scan = scanTranscripts({ root: opts.root, maxAgeDays: opts.maxAgeDays });
   const buckets = aggregateByBucket(scan.records);
   const subagentColdStart = computeColdStarts(scan.records);
@@ -986,6 +1357,18 @@ function buildReport(opts) {
   const councilMispricing = computeCouncilMispricing(opts.councilRoot);
   const worktreePaths = listGitWorktrees(opts.repoRoot);
   const worktreeFragmentation = computeWorktreeFragmentation(opts.root, worktreePaths, opts.maxAgeDays);
+  let prefixStability;
+  try {
+    prefixStability = computePrefixStability(buildReport(opts.auditDir));
+  } catch (err) {
+    prefixStability = {
+      verdict: "insufficient-data",
+      reason: `the audit ledger at ${opts.auditDir} could not be read: ${err.message}`,
+      stable_cohort: { n: 0, read_share: null },
+      unstable_cohort: { n: 0, read_share: null },
+      lines_with_data: 0
+    };
+  }
   const claims = buildClaims({ subagentColdStart, duplicateScope, councilMispricing, worktreeFragmentation });
   return {
     schema: "cache-realization-report/v1",
@@ -1005,13 +1388,14 @@ function buildReport(opts) {
     duplicate_scope: duplicateScope,
     council_mispricing: councilMispricing,
     worktree_fragmentation: worktreeFragmentation,
+    prefix_stability: prefixStability,
     claims
   };
 }
-function pct(v) {
+function pct3(v) {
   return `${(v * 100).toFixed(1)}%`;
 }
-function renderText(r) {
+function renderText3(r) {
   const out = [];
   out.push("Cache-realization report");
   out.push(`  host_version: ${r.host_version}`);
@@ -1019,12 +1403,21 @@ function renderText(r) {
   out.push(`  root: ${r.root}`);
   out.push(`  metric: billable_input = ${r.metric_definition.billable_input}`);
   out.push(`          ${r.metric_definition.note}`);
-  out.push(`  dedup: ${r.deduped_count}/${r.total_seen} unique records kept (dedup_ratio ${pct(r.dedup_ratio)})`);
+  out.push(`  dedup: ${r.deduped_count}/${r.total_seen} unique records kept (dedup_ratio ${pct3(r.dedup_ratio)})`);
+  out.push("");
+  const ps = r.prefix_stability;
+  const share = (v) => v === null ? "insufficient data" : pct3(v);
+  const mark = ps.verdict === "inverted" ? "\u26A0\uFE0F " : "";
+  out.push("Prefix stability (payload_hash \xD7 cache_hit):");
+  out.push(`  ${mark}verdict: ${ps.verdict}`);
+  out.push(`  stable cohort:   n=${ps.stable_cohort.n} read_share=${share(ps.stable_cohort.read_share)}`);
+  out.push(`  unstable cohort: n=${ps.unstable_cohort.n} read_share=${share(ps.unstable_cohort.read_share)}`);
+  out.push(`  ${ps.reason}`);
   out.push("");
   out.push("By bucket:");
   for (const bucket of ["main", "subagent"]) {
     const b = r.buckets[bucket];
-    out.push(`  ${bucket}: calls=${b.calls} read_share=${pct(b.read_share)} weighted_input_units=${Math.round(b.weighted_input_units)}`);
+    out.push(`  ${bucket}: calls=${b.calls} read_share=${pct3(b.read_share)} weighted_input_units=${Math.round(b.weighted_input_units)}`);
     out.push(
       `    input=${b.input_tokens} cache_read=${b.cache_read_input_tokens} cache_creation=${b.cache_creation_input_tokens} (5m=${b.ephemeral_5m_input_tokens} 1h=${b.ephemeral_1h_input_tokens}) output=${b.output_tokens}`
     );
@@ -1035,21 +1428,21 @@ function renderText(r) {
   out.push(
     `  legs=${cs.legs} median_written_or_uncached=${Math.round(cs.median_first_call_written_or_uncached)} mean=${Math.round(cs.mean_first_call_written_or_uncached)}`
   );
-  out.push(`  first_call_cache_read_share=${pct(cs.first_call_cache_read_share)}`);
-  out.push(`  cold_start_share_of_subagent_write_volume=${pct(cs.cold_start_share_of_write_volume)}`);
+  out.push(`  first_call_cache_read_share=${pct3(cs.first_call_cache_read_share)}`);
+  out.push(`  cold_start_share_of_subagent_write_volume=${pct3(cs.cold_start_share_of_write_volume)}`);
   out.push(
-    `  write_share=${pct(cs.write_share_of_billable)} read_share=${pct(cs.read_share_of_billable)} uncached_share=${pct(cs.uncached_share_of_billable)} (of billable input, all subagent records)`
+    `  write_share=${pct3(cs.write_share_of_billable)} read_share=${pct3(cs.read_share_of_billable)} uncached_share=${pct3(cs.uncached_share_of_billable)} (of billable input, all subagent records)`
   );
   out.push("");
   out.push(`Per-agent breakdown: ${r.by_agent.length} distinct subagent legs (--format json carries all; top 10 by weighted_input_units below)`);
   const top10 = [...r.by_agent].sort((a, b) => b.weighted_input_units - a.weighted_input_units).slice(0, 10);
   for (const a of top10) {
-    out.push(`  ${a.agentId}: calls=${a.calls} read_share=${pct(a.read_share)} weighted_input_units=${Math.round(a.weighted_input_units)}`);
+    out.push(`  ${a.agentId}: calls=${a.calls} read_share=${pct3(a.read_share)} weighted_input_units=${Math.round(a.weighted_input_units)}`);
   }
   out.push("");
   out.push("Pre-registered claims:");
   for (const c of r.claims) {
-    const measured = c.measured !== void 0 ? ` (measured ${pct(c.measured)})` : "";
+    const measured = c.measured !== void 0 ? ` (measured ${pct3(c.measured)})` : "";
     const reasonSuffix = c.verdict === "pending" && c.reason ? ` \u2014 ${c.reason}` : "";
     out.push(`  ${c.id} [${c.verdict}]${measured}: ${c.description}${reasonSuffix}`);
   }
@@ -1058,28 +1451,28 @@ function renderText(r) {
   out.push("  command: ./scripts-run src/scripts/cache_realization_report --format text");
   out.push(`  host_version at this run: ${r.host_version}`);
   out.push(
-    `  re-run + restamp this report if: read_share drops below ${pct(DRIFT_READ_SHARE_FLOOR)}, OR cold-start share drops below ${pct(DRIFT_COLD_START_SHARE_FLOOR)}`
+    `  re-run + restamp this report if: read_share drops below ${pct3(DRIFT_READ_SHARE_FLOOR)}, OR cold-start share drops below ${pct3(DRIFT_COLD_START_SHARE_FLOOR)}`
   );
   return out.join("\n");
 }
-function main(argv = process.argv.slice(2)) {
-  const opts = parseArgs(argv);
-  const report = buildReport(opts);
+function main3(argv = process.argv.slice(2)) {
+  const opts = parseArgs3(argv);
+  const report = buildReport2(opts);
   if (opts.format === "json") {
     process.stdout.write(JSON.stringify(report, null, 2) + "\n");
   } else {
-    process.stdout.write(renderText(report) + "\n");
+    process.stdout.write(renderText3(report) + "\n");
   }
   return 0;
 }
 if (process.argv[1] !== void 0) {
-  const invokedUrl = pathToFileURL(path9.resolve(process.argv[1])).href;
-  if (import.meta.url === invokedUrl) process.exit(main());
+  const invokedUrl = pathToFileURL3(path11.resolve(process.argv[1])).href;
+  if (import.meta.url === invokedUrl) process.exit(main3());
 }
 
 // src/scripts/preamble_byte_census.ts
 var _HERE3 = fileURLToPath3(import.meta.url);
-var REPO_ROOT3 = path10.resolve(path10.dirname(_HERE3), "..", "..");
+var REPO_ROOT3 = path12.resolve(path12.dirname(_HERE3), "..", "..");
 var CHARS_PER_TOKEN = 4;
 var SUM_TOLERANCE_PCT = 0.1;
 function tokensFromChars(chars) {
@@ -1087,19 +1480,47 @@ function tokensFromChars(chars) {
 }
 function readCharsIfExists(p) {
   try {
-    return fs7.statSync(p).size;
+    return fs8.statSync(p).size;
   } catch {
     return 0;
   }
 }
+var MAINTAINER_WORKSPACE = "agent-config-maintainer";
+function censusDeliveredRulePayload(projectionDir) {
+  const empty = () => ({ files: 0, chars: 0 });
+  const delivered = empty();
+  const packageOnly = empty();
+  let names;
+  try {
+    names = fs8.readdirSync(projectionDir).filter((f) => f.endsWith(".md"));
+  } catch {
+    return { delivered, packageOnly };
+  }
+  for (const name of names) {
+    const abs = path12.join(projectionDir, name);
+    let text;
+    try {
+      text = fs8.readFileSync(abs, "utf8");
+    } catch {
+      continue;
+    }
+    const m = /^workspaces:\s*\[([^\]]*)\]/m.exec(text);
+    const listed = m === null ? [] : m[1].split(",").map((x) => x.trim()).filter((x) => x !== "");
+    const isPackageOnly = listed.length > 0 && listed.every((w) => w === MAINTAINER_WORKSPACE);
+    const bucket = isPackageOnly ? packageOnly : delivered;
+    bucket.files += 1;
+    bucket.chars += Buffer.byteLength(text, "utf8");
+  }
+  return { delivered, packageOnly };
+}
 function topRulesByCost(dir, limit = 10) {
-  if (!fs7.existsSync(dir)) return [];
+  if (!fs8.existsSync(dir)) return [];
   const entries = [];
-  for (const name of fs7.readdirSync(dir)) {
+  for (const name of fs8.readdirSync(dir)) {
     if (!name.endsWith(".md")) continue;
     let chars;
     try {
-      chars = fs7.statSync(path10.join(dir, name)).size;
+      chars = fs8.statSync(path12.join(dir, name)).size;
     } catch {
       continue;
     }
@@ -1112,33 +1533,33 @@ var IMPORT_LINE_RE = /^@(\S+)\s*$/;
 function parseClaudeMdImports(claudeMdPath) {
   let text;
   try {
-    text = fs7.readFileSync(claudeMdPath, "utf-8");
+    text = fs8.readFileSync(claudeMdPath, "utf-8");
   } catch {
     return [];
   }
-  const base = path10.dirname(claudeMdPath);
+  const base = path12.dirname(claudeMdPath);
   const out = [];
   for (const line of text.split("\n")) {
     const m = IMPORT_LINE_RE.exec(line.trim());
     if (!m) continue;
     const rel = m[1];
-    const resolved = path10.isAbsolute(rel) ? rel : path10.join(base, rel);
+    const resolved = path12.isAbsolute(rel) ? rel : path12.join(base, rel);
     const chars = readCharsIfExists(resolved);
     if (chars > 0) out.push({ file: rel, chars });
   }
   return out;
 }
 function censusClaudeMdHierarchy(repoRoot, userHome) {
-  const projectClaudeMd = path10.join(repoRoot, "CLAUDE.md");
-  const projectClaudeLocalMd = path10.join(repoRoot, "CLAUDE.local.md");
-  const userClaudeMd = path10.join(userHome, ".claude", "CLAUDE.md");
+  const projectClaudeMd = path12.join(repoRoot, "CLAUDE.md");
+  const projectClaudeLocalMd = path12.join(repoRoot, "CLAUDE.local.md");
+  const userClaudeMd = path12.join(userHome, ".claude", "CLAUDE.md");
   return {
     project_claude_md_chars: readCharsIfExists(projectClaudeMd),
-    project_claude_md_present: fs7.existsSync(projectClaudeMd),
+    project_claude_md_present: fs8.existsSync(projectClaudeMd),
     project_claude_local_md_chars: readCharsIfExists(projectClaudeLocalMd),
-    project_claude_local_md_present: fs7.existsSync(projectClaudeLocalMd),
+    project_claude_local_md_present: fs8.existsSync(projectClaudeLocalMd),
     user_claude_md_chars: readCharsIfExists(userClaudeMd),
-    user_claude_md_present: fs7.existsSync(userClaudeMd),
+    user_claude_md_present: fs8.existsSync(userClaudeMd),
     user_imports: parseClaudeMdImports(userClaudeMd)
   };
 }
@@ -1160,15 +1581,15 @@ function parseFrontmatter(text) {
   }
 }
 function censusSkillsCatalog(skillsDir) {
-  if (!fs7.existsSync(skillsDir)) return { skills: 0, chars: 0 };
+  if (!fs8.existsSync(skillsDir)) return { skills: 0, chars: 0 };
   let skills = 0;
   let chars = 0;
-  for (const entry of fs7.readdirSync(skillsDir, { withFileTypes: true })) {
+  for (const entry of fs8.readdirSync(skillsDir, { withFileTypes: true })) {
     if (!entry.isDirectory()) continue;
-    const skillMd = path10.join(skillsDir, entry.name, "SKILL.md");
+    const skillMd = path12.join(skillsDir, entry.name, "SKILL.md");
     let text;
     try {
-      text = fs7.readFileSync(skillMd, "utf-8");
+      text = fs8.readFileSync(skillMd, "utf-8");
     } catch {
       continue;
     }
@@ -1187,14 +1608,14 @@ function defaultOptions2() {
     format: "text",
     repoRoot: REPO_ROOT3,
     userHome,
-    userRulesDir: path10.join(userHome, ".claude", "rules"),
-    projectRulesDir: path10.join(REPO_ROOT3, "dist", "agent-src", "rules"),
-    skillsDir: path10.join(REPO_ROOT3, "dist", "agent-src", "skills"),
+    userRulesDir: path12.join(userHome, ".claude", "rules"),
+    projectRulesDir: path12.join(REPO_ROOT3, "dist", "agent-src", "rules"),
+    skillsDir: path12.join(REPO_ROOT3, "dist", "agent-src", "skills"),
     root: DEFAULT_PROJECTS_ROOT,
     maxAgeDays: 14
   };
 }
-function parseArgs2(argv) {
+function parseArgs4(argv) {
   const opts = defaultOptions2();
   for (let i = 0; i < argv.length; i++) {
     const a = argv[i];
@@ -1228,7 +1649,7 @@ function buildByteCensus(opts) {
       files: opts.userRules.files,
       chars: opts.userRules.chars,
       tokens_estimate: tokensFromChars(opts.userRules.chars),
-      provenance: "measured_local_file",
+      provenance: "measured",
       basis: "\u03A3 byte size of every .md file in the user-scope rules directory, chars/4."
     },
     {
@@ -1236,7 +1657,7 @@ function buildByteCensus(opts) {
       files: opts.projectRules.files,
       chars: opts.projectRules.chars,
       tokens_estimate: tokensFromChars(opts.projectRules.chars),
-      provenance: "measured_local_file",
+      provenance: "measured",
       basis: "\u03A3 byte size of every .md file in the project-scope rules directory, chars/4."
     },
     {
@@ -1244,7 +1665,7 @@ function buildByteCensus(opts) {
       files: claudeMdFiles,
       chars: claudeMdChars,
       tokens_estimate: tokensFromChars(claudeMdChars),
-      provenance: "measured_local_file",
+      provenance: "measured",
       basis: 'Byte size of project CLAUDE.md + project CLAUDE.local.md (if present) + user ~/.claude/CLAUDE.md + every file pulled in by a top-level "@<path>" import line in the user CLAUDE.md, chars/4.'
     },
     {
@@ -1252,7 +1673,7 @@ function buildByteCensus(opts) {
       files: opts.globalProfile.present ? 1 : 0,
       chars: opts.globalProfile.chars,
       tokens_estimate: tokensFromChars(opts.globalProfile.chars),
-      provenance: "measured_local_file",
+      provenance: "measured",
       basis: opts.globalProfile.present ? `Byte size of ${opts.globalProfile.path}, chars/4.` : "Layer not written yet on this machine (resolveGlobalProfilePath() returned null) \u2014 treated as 0, per the roadmap's own honesty caveat."
     },
     {
@@ -1260,7 +1681,7 @@ function buildByteCensus(opts) {
       files: opts.skillsCatalog.skills,
       chars: opts.skillsCatalog.chars,
       tokens_estimate: tokensFromChars(opts.skillsCatalog.chars),
-      provenance: "measured_local_file",
+      provenance: "measured",
       basis: `\u03A3 "- <name>: <description>\\n" over every SKILL.md frontmatter, chars/4 \u2014 the description-text component only; the host's exact on-wire catalog format is not independently file-measurable.`
     }
   ];
@@ -1273,7 +1694,7 @@ function buildByteCensus(opts) {
       files: 0,
       chars: 0,
       tokens_estimate: residualTokens,
-      provenance: "residual",
+      provenance: "estimated",
       basis: "measured_cold_start_median minus the sum of the file-measurable buckets above. No local transcript or file carries the request's raw tool-definition JSON or the per-spawn dispatch-prompt text (verified: ~/.claude/projects/**/*.jsonl records only message.usage counts and response content, never the request system/tool payload) \u2014 this bucket exists so the gap is named rather than silently dropped."
     });
   }
@@ -1296,6 +1717,15 @@ function buildByteCensus(opts) {
   }
   return {
     sources,
+    derived_user_scope: {
+      delivered_files: opts.deliveredRules.delivered.files,
+      delivered_chars: opts.deliveredRules.delivered.chars,
+      delivered_tokens: tokensFromChars(opts.deliveredRules.delivered.chars),
+      package_only_files: opts.deliveredRules.packageOnly.files,
+      package_only_chars: opts.deliveredRules.packageOnly.chars,
+      package_only_tokens: tokensFromChars(opts.deliveredRules.packageOnly.chars),
+      basis: `\u03A3 byte size of every dist/agent-src/rules/*.md whose \`workspaces:\` does not restrict it to the ${MAINTAINER_WORKSPACE} workspace, chars/4 \u2014 computed without reading ~/.claude at all. This is the bucket src/config/preamble-payload-budget.json excludes as "machine-dependent, not CI-checkable", and computing it here is what falsifies that reason. A gap against the measured user-scope row is INSTALL DRIFT (the machine carries an older release), never a defect in either number.`
+    },
     measurable_tokens_total: measurableTokensTotal,
     grand_total_tokens: grandTotal,
     measured_cold_start_median: median3,
@@ -1317,7 +1747,7 @@ function buildByteCensus(opts) {
     }
   };
 }
-function buildReport2(opts) {
+function buildReport3(opts) {
   const userRules = censusRuleDir(opts.userRulesDir);
   const projectRules = censusRuleDir(opts.projectRulesDir);
   const claudeMd = censusClaudeMdHierarchy(opts.repoRoot, opts.userHome);
@@ -1325,6 +1755,7 @@ function buildReport2(opts) {
   const skillsCatalog = censusSkillsCatalog(opts.skillsDir);
   const topRules = topRulesByCost(opts.projectRulesDir, 10);
   const duplicateScope = censusDuplicateScope(opts.userRulesDir, opts.projectRulesDir);
+  const deliveredRules = censusDeliveredRulePayload(opts.projectRulesDir);
   const scan = scanTranscripts({ root: opts.root, maxAgeDays: opts.maxAgeDays });
   const coldStart = computeColdStarts(scan.records);
   const measuredColdStartMedian = coldStart.legs > 0 ? coldStart.median_first_call_written_or_uncached : null;
@@ -1336,14 +1767,15 @@ function buildReport2(opts) {
     skillsCatalog,
     topRules,
     duplicateScope,
+    deliveredRules,
     measuredColdStartMedian,
     coldStartLegs: coldStart.legs
   });
 }
-function pct2(v) {
+function pct4(v) {
   return `${(v * 100).toFixed(1)}%`;
 }
-function renderText2(r) {
+function renderText4(r) {
   const out = [];
   out.push("Preamble byte census (road-to-cache-economy Phase 3, steps 1-2)");
   out.push("");
@@ -1354,11 +1786,22 @@ function renderText2(r) {
     out.push(`    basis: ${s.basis}`);
   }
   out.push("");
+  const d = r.derived_user_scope;
+  out.push("");
+  out.push("User-scope bucket, DERIVED from the projection (NOT summed \u2014 a second view of a row above):");
+  out.push(
+    `  delivered to the global layer: files=${String(d.delivered_files)} chars=${String(d.delivered_chars)} tokens_estimate=${String(d.delivered_tokens)}`
+  );
+  out.push(
+    `  package-only (never delivered): files=${String(d.package_only_files)} chars=${String(d.package_only_chars)} tokens_estimate=${String(d.package_only_tokens)}`
+  );
+  out.push(`  basis: ${d.basis}`);
+  out.push("");
   out.push(`measurable_tokens_total (excludes residual): ${Math.round(r.measurable_tokens_total)}`);
   out.push(`grand_total_tokens (includes residual): ${Math.round(r.grand_total_tokens)}`);
   if (r.measured_cold_start_median !== null) {
     out.push(`measured_cold_start_median: ${Math.round(r.measured_cold_start_median)} (${r.cold_start_legs} legs, this window)`);
-    out.push(`measurable_share_of_median: ${pct2(r.measurable_share_of_median)} (the honest, non-tautological number)`);
+    out.push(`measurable_share_of_median: ${pct4(r.measurable_share_of_median)} (the honest, non-tautological number)`);
     out.push(
       `sum check (grand_total vs median, \xB110%): ${r.within_tolerance ? "PASS" : "FAIL"} \u2014 trivially PASS by construction once the residual bucket exists; see the module doc comment for why.`
     );
@@ -1383,7 +1826,7 @@ function renderText2(r) {
   out.push("Modelled duplicate-copy removal (MODELLED, not measured):");
   if (r.modelled_duplicate_removal.applicable) {
     out.push(`  modelled_new_median: ${Math.round(r.modelled_duplicate_removal.modelled_new_median)}`);
-    out.push(`  modelled_reduction_pct: ${pct2(r.modelled_duplicate_removal.modelled_reduction_pct)}`);
+    out.push(`  modelled_reduction_pct: ${pct4(r.modelled_duplicate_removal.modelled_reduction_pct)}`);
   } else {
     out.push(`  not applicable \u2014 ${r.modelled_duplicate_removal.reason ?? "unknown reason"}`);
   }
@@ -1393,20 +1836,20 @@ function renderText2(r) {
   out.push("docs/contracts/load-context-budget-model.md. This report does NOT enforce it.");
   return out.join("\n");
 }
-function main2(argv = process.argv.slice(2)) {
-  const opts = parseArgs2(argv);
-  const report = buildReport2(opts);
+function main4(argv = process.argv.slice(2)) {
+  const opts = parseArgs4(argv);
+  const report = buildReport3(opts);
   if (opts.format === "json") {
     process.stdout.write(JSON.stringify(report, null, 2) + "\n");
   } else {
-    process.stdout.write(renderText2(report) + "\n");
+    process.stdout.write(renderText4(report) + "\n");
   }
   return 0;
 }
 var _isBundled = true;
 if (!_isBundled && process.argv[1] !== void 0) {
-  const invokedUrl = pathToFileURL2(path10.resolve(process.argv[1])).href;
-  if (import.meta.url === invokedUrl) process.exit(main2());
+  const invokedUrl = pathToFileURL4(path12.resolve(process.argv[1])).href;
+  if (import.meta.url === invokedUrl) process.exit(main4());
 }
 
 // src/scripts/dispatch_economy_report.ts
@@ -1414,20 +1857,20 @@ var dispatch_economy_report_exports = {};
 __export(dispatch_economy_report_exports, {
   DEFAULT_AUDIT_DIR: () => DEFAULT_AUDIT_DIR,
   DEFAULT_PROJECTS_ROOT: () => DEFAULT_PROJECTS_ROOT,
-  buildReport: () => buildReport3,
+  buildReport: () => buildReport4,
   computeLegs: () => computeLegs,
-  main: () => main3,
+  main: () => main5,
   median: () => median2,
   readAuditOrchestrations: () => readAuditOrchestrations,
-  renderText: () => renderText3
+  renderText: () => renderText5
 });
-import * as fs8 from "node:fs";
-import * as path11 from "node:path";
-import { fileURLToPath as fileURLToPath4, pathToFileURL as pathToFileURL3 } from "node:url";
+import * as fs9 from "node:fs";
+import * as path13 from "node:path";
+import { fileURLToPath as fileURLToPath4, pathToFileURL as pathToFileURL5 } from "node:url";
 var _HERE4 = fileURLToPath4(import.meta.url);
-var REPO_ROOT4 = path11.resolve(path11.dirname(_HERE4), "..", "..");
-var REGISTRATION_FILE = path11.join(REPO_ROOT4, "src", "config", "dispatch-economy-metrics.json");
-var DEFAULT_AUDIT_DIR = path11.join("agents", "runtime", "state", "audit");
+var REPO_ROOT4 = path13.resolve(path13.dirname(_HERE4), "..", "..");
+var REGISTRATION_FILE = path13.join(REPO_ROOT4, "src", "config", "dispatch-economy-metrics.json");
+var DEFAULT_AUDIT_DIR = path13.join("agents", "runtime", "state", "audit");
 var REVIEWER_TYPE_RE = /review|judge|validator/i;
 function median2(values) {
   if (values.length === 0) return null;
@@ -1473,19 +1916,19 @@ function isFiniteNonNegInt(v) {
   return typeof v === "number" && Number.isInteger(v) && v >= 0;
 }
 function readAuditOrchestrations(auditDir, opts = {}) {
-  if (!fs8.existsSync(auditDir)) return [];
+  if (!fs9.existsSync(auditDir)) return [];
   const out = [];
   const cutoffMs = opts.maxAgeDays !== void 0 ? (opts.now ?? /* @__PURE__ */ new Date()).getTime() - opts.maxAgeDays * 24 * 60 * 60 * 1e3 : null;
   let entries;
   try {
-    entries = fs8.readdirSync(auditDir).filter((f) => f.endsWith(".jsonl")).sort();
+    entries = fs9.readdirSync(auditDir).filter((f) => f.endsWith(".jsonl")).sort();
   } catch {
     return [];
   }
   if (cutoffMs !== null) {
     entries = entries.filter((f) => {
       try {
-        return fs8.statSync(path11.join(auditDir, f)).mtimeMs >= cutoffMs;
+        return fs9.statSync(path13.join(auditDir, f)).mtimeMs >= cutoffMs;
       } catch {
         return false;
       }
@@ -1494,7 +1937,7 @@ function readAuditOrchestrations(auditDir, opts = {}) {
   for (const f of entries) {
     let text;
     try {
-      text = fs8.readFileSync(path11.join(auditDir, f), "utf8");
+      text = fs9.readFileSync(path13.join(auditDir, f), "utf8");
     } catch {
       continue;
     }
@@ -1515,8 +1958,8 @@ function readAuditOrchestrations(auditDir, opts = {}) {
   }
   return out;
 }
-function buildReport3(opts) {
-  const registrationRaw = fs8.readFileSync(REGISTRATION_FILE, "utf8");
+function buildReport4(opts) {
+  const registrationRaw = fs9.readFileSync(REGISTRATION_FILE, "utf8");
   const registration = JSON.parse(registrationRaw);
   const scanOpts = {
     root: opts.root,
@@ -1617,7 +2060,7 @@ function fmtTokens(n) {
   if (n === null) return "\u2014";
   return n >= 1e3 ? `${(n / 1e3).toFixed(1)}k` : String(Math.round(n));
 }
-function renderText3(r) {
+function renderText5(r) {
   const lines = [];
   lines.push("dispatch-economy report (registered: " + r.registration.registered_at + " \xB7 review by: " + r.registration.review_by + ")");
   lines.push(`window: ${r.window.max_age_days}d \xB7 ${r.window.transcript_records} deduped records \xB7 ${r.window.legs} legs`);
@@ -1651,10 +2094,10 @@ function renderText3(r) {
   for (const n of r.notes) lines.push(`note: ${n}`);
   return lines.join("\n") + "\n";
 }
-function main3(argv) {
+function main5(argv) {
   let format = "text";
   let root = DEFAULT_PROJECTS_ROOT;
-  let auditDir = path11.join(process.cwd(), DEFAULT_AUDIT_DIR);
+  let auditDir = path13.join(process.cwd(), DEFAULT_AUDIT_DIR);
   let maxAgeDays = 14;
   for (let i = 0; i < argv.length; i++) {
     const a = argv[i];
@@ -1665,38 +2108,572 @@ function main3(argv) {
   }
   let report;
   try {
-    report = buildReport3({ root, auditDir, maxAgeDays });
+    report = buildReport4({ root, auditDir, maxAgeDays });
   } catch (err) {
     process.stderr.write(`dispatch_economy_report: ${err instanceof Error ? err.message : String(err)}
 `);
     return 2;
   }
-  process.stdout.write(format === "json" ? JSON.stringify(report, null, 2) + "\n" : renderText3(report));
+  process.stdout.write(format === "json" ? JSON.stringify(report, null, 2) + "\n" : renderText5(report));
   return 0;
 }
 function _isCliEntry() {
   if (true) return false;
   if (process.argv[1] === void 0) return false;
-  const argvUrl = pathToFileURL3(path11.resolve(process.argv[1])).href;
+  const argvUrl = pathToFileURL5(path13.resolve(process.argv[1])).href;
   if (import.meta.url === argvUrl) return true;
   try {
-    return fs8.realpathSync(fileURLToPath4(import.meta.url)) === fs8.realpathSync(path11.resolve(process.argv[1]));
+    return fs9.realpathSync(fileURLToPath4(import.meta.url)) === fs9.realpathSync(path13.resolve(process.argv[1]));
+  } catch {
+    return false;
+  }
+}
+if (_isCliEntry()) process.exit(main5(process.argv.slice(2)));
+
+// src/scripts/_lib/runtime_wiring_checks.ts
+var import_yaml = __toESM(require_dist(), 1);
+import * as fs10 from "node:fs";
+import * as path14 from "node:path";
+import process2 from "node:process";
+
+// src/scripts/_lib/repo_root.ts
+var GIT_DISCOVERY_OVERRIDES = [
+  "GIT_DIR",
+  "GIT_WORK_TREE",
+  "GIT_INDEX_FILE",
+  "GIT_COMMON_DIR"
+];
+function inheritedGitOverrides(env = process.env) {
+  const out = [];
+  for (const name of GIT_DISCOVERY_OVERRIDES) {
+    const value = env[name];
+    if (typeof value === "string" && value !== "") out.push({ name, value });
+  }
+  return out;
+}
+
+// src/scripts/_lib/runtime_wiring_checks.ts
+function checkSettingsResolution(iterOverrides) {
+  let pairs;
+  try {
+    pairs = [...iterOverrides()];
+  } catch (e) {
+    return {
+      id: "settings-resolution",
+      status: "fail",
+      message: `settings cascade did not resolve: ${e instanceof Error ? e.message : String(e)}`,
+      remedy: "check the YAML in every layer `agent-config settings:get <key>` reports"
+    };
+  }
+  if (pairs.length === 0) {
+    return {
+      id: "settings-resolution",
+      // `skipped`, not `ok`: the cascade RESOLVED and there was nothing
+      // in it, which is a check that had nothing to inspect rather than a
+      // check that passed. Reporting `ok` here would read as "settings
+      // resolved fine" on a tree where no setting exists at all — the
+      // same conflation the reach check exists to remove elsewhere.
+      status: "skipped",
+      message: "settings cascade resolves, and NO layer sets any key \u2014 every read falls to the template default. That is a valid state, not a failure: a fresh project has no settings.",
+      remedy: ""
+    };
+  }
+  const winner = /* @__PURE__ */ new Map();
+  for (const [key, , file] of pairs) winner.set(key, file);
+  const byFile = /* @__PURE__ */ new Map();
+  for (const file of winner.values()) byFile.set(file, (byFile.get(file) ?? 0) + 1);
+  const summary = [...byFile.entries()].sort((a, b) => b[1] - a[1]).map(([f, n]) => `${path14.basename(f)}=${String(n)}`).join(" \xB7 ");
+  return {
+    id: "settings-resolution",
+    status: "ok",
+    message: `${String(winner.size)} key(s) resolved across ${String(byFile.size)} layer(s) \u2014 ${summary}`,
+    remedy: ""
+  };
+}
+function checkRouterArtifact(repoRoot, rel = "dist/router.json") {
+  const abs = path14.join(repoRoot, rel);
+  if (!fs10.existsSync(abs)) {
+    return {
+      id: "router-artifact",
+      status: "warn",
+      message: `${rel} is absent \u2014 no rule router is deployed`,
+      remedy: "task generate-tools"
+    };
+  }
+  let doc;
+  try {
+    doc = JSON.parse(fs10.readFileSync(abs, "utf8"));
+  } catch (e) {
+    return {
+      id: "router-artifact",
+      status: "fail",
+      message: `${rel} exists but does NOT parse: ${e instanceof Error ? e.message : String(e)}`,
+      remedy: "task generate-tools (a present-but-unparseable router loads as zero rules)"
+    };
+  }
+  const rules = _routerRuleCount(doc);
+  if (rules === 0) {
+    return {
+      id: "router-artifact",
+      status: "warn",
+      message: `${rel} parses and carries ZERO rules \u2014 a router with no rules routes nothing`,
+      remedy: "task generate-tools"
+    };
+  }
+  return { id: "router-artifact", status: "ok", message: `${rel} parses \xB7 ${String(rules)} rule(s)`, remedy: "" };
+}
+function _routerRuleCount(doc) {
+  if (doc === null || typeof doc !== "object") return 0;
+  const d = doc;
+  if (Array.isArray(d["rules"])) return d["rules"].length;
+  let n = 0;
+  for (const v of Object.values(d)) {
+    if (Array.isArray(v)) n += v.length;
+    else if (v !== null && typeof v === "object") n += _routerRuleCount(v);
+  }
+  return n;
+}
+function checkHookResolution(repoRoot, manifestRel = "src/scripts/hook_manifest.yaml", probe = null) {
+  const abs = path14.join(repoRoot, manifestRel);
+  if (!fs10.existsSync(abs)) {
+    return {
+      check: {
+        id: "hook-resolution",
+        status: "fail",
+        message: `${manifestRel} is absent \u2014 the hook estate cannot be enumerated`,
+        remedy: "restore the manifest; every hook is registered from it"
+      },
+      probes: []
+    };
+  }
+  let concerns;
+  try {
+    const doc = (0, import_yaml.parse)(fs10.readFileSync(abs, "utf8"));
+    concerns = doc.concerns ?? {};
+  } catch (e) {
+    return {
+      check: {
+        id: "hook-resolution",
+        status: "fail",
+        message: `${manifestRel} does not parse: ${e instanceof Error ? e.message : String(e)}`,
+        remedy: "fix the manifest YAML"
+      },
+      probes: []
+    };
+  }
+  const probes = [];
+  for (const [id, c] of Object.entries(concerns)) {
+    const script = typeof c.script === "string" ? c.script : "";
+    const resolves = script !== "" && fs10.existsSync(path14.join(repoRoot, script));
+    probes.push({ id, script, resolves, ms: resolves && probe !== null ? probe(script) : null });
+  }
+  const broken = probes.filter((p) => !p.resolves);
+  if (broken.length > 0) {
+    return {
+      check: {
+        id: "hook-resolution",
+        status: "fail",
+        message: `${String(broken.length)} of ${String(probes.length)} registered hook(s) do NOT resolve to a file: ` + broken.map((b) => b.id).join(", "),
+        remedy: "a registered hook with no script silently no-ops every session \u2014 fix the path or drop the entry"
+      },
+      probes
+    };
+  }
+  const timed = probes.filter((p) => p.ms !== null).sort((a, b) => (b.ms ?? 0) - (a.ms ?? 0));
+  const slowest = timed.length > 0 ? ` \xB7 slowest ${timed[0].id} ${String(timed[0].ms)}ms` : "";
+  return {
+    check: {
+      id: "hook-resolution",
+      status: "ok",
+      message: `${String(probes.length)} registered hook(s), all resolving${slowest}`,
+      remedy: ""
+    },
+    probes
+  };
+}
+function checkInheritedGitEnv(env = process2.env) {
+  const found = inheritedGitOverrides(env);
+  if (found.length === 0) {
+    return {
+      id: "inherited-git-env",
+      status: "ok",
+      message: "no git discovery override in the environment \u2014 git resolves from the working directory",
+      remedy: ""
+    };
+  }
+  return {
+    id: "inherited-git-env",
+    status: "warn",
+    message: `${String(found.length)} git discovery override(s) inherited: ` + found.map((f) => `${f.name}=${f.value}`).join(" \xB7 ") + " \u2014 every git call in this process answers for THAT repository, not the working directory",
+    remedy: "unset them before running a gate from inside a git hook (`env -u GIT_DIR -u GIT_WORK_TREE \u2026`), or resolve the root with _lib/repo_root.ts, which refuses instead of guessing"
+  };
+}
+var WIRING_CHECK_IDS = ["settings-resolution", "router-artifact", "hook-resolution", "inherited-git-env", "hooks-kill-switch"];
+function checkHooksDisabled(env = process2.env) {
+  const raw = env["AGENT_CONFIG_DISABLE_HOOKS"];
+  if (raw !== "1") {
+    return {
+      id: "hooks-kill-switch",
+      status: "ok",
+      message: raw === void 0 || raw === "" ? "AGENT_CONFIG_DISABLE_HOOKS is not set \u2014 the hook estate is armed" : `AGENT_CONFIG_DISABLE_HOOKS=${raw} \u2014 only the exact value "1" disarms, so the estate is armed`,
+      remedy: ""
+    };
+  }
+  return {
+    id: "hooks-kill-switch",
+    status: "warn",
+    message: "AGENT_CONFIG_DISABLE_HOOKS=1 \u2014 EVERY hook and shim in this environment is disabled. A run under this flag enforces nothing, and without this line it would look identical to one with the whole estate armed.",
+    remedy: "unset AGENT_CONFIG_DISABLE_HOOKS (it is intended for one command, not a session)"
+  };
+}
+function wiringRunners(opts) {
+  return {
+    "settings-resolution": () => checkSettingsResolution(opts.iterOverrides),
+    "router-artifact": () => checkRouterArtifact(opts.packageRoot),
+    // Per-hook COST is not probed on the default path: it spawns one process
+    // per registered concern (53 today), turning a read-only diagnostic into
+    // a multi-second one. `probeHookCost` is exported for a caller that wants it.
+    "hook-resolution": () => checkHookResolution(opts.packageRoot).check,
+    "inherited-git-env": () => checkInheritedGitEnv(),
+    "hooks-kill-switch": () => checkHooksDisabled()
+  };
+}
+function checkHookWiring(deps) {
+  const claude = deps.which("claude");
+  if (claude === null) {
+    return {
+      id: "hook-wiring",
+      status: "skipped",
+      message: "Claude Code CLI not on PATH \u2014 hook-wiring check not applicable",
+      remedy: ""
+    };
+  }
+  const settings_path = path14.join(deps.homeDir, ".claude", "settings.json");
+  let missing;
+  try {
+    const matrix = deps.buildMatrix(path14.join(deps.packageRoot, "src", "scripts", "hook_manifest.yaml"));
+    const settings = fs10.existsSync(settings_path) ? JSON.parse(fs10.readFileSync(settings_path, "utf8")) : {};
+    const hooks = (settings["hooks"] ?? {}) || {};
+    missing = Object.keys(matrix).filter((ev) => {
+      const groups = hooks[ev];
+      if (!Array.isArray(groups)) return true;
+      return !JSON.stringify(groups).includes(deps.managedSignature);
+    });
+  } catch (e) {
+    return {
+      id: "hook-wiring",
+      status: "fail",
+      message: `cannot evaluate managed hooks: ${String(e)}`,
+      remedy: "fix ~/.claude/settings.json (invalid JSON?), then agent-config refresh --global"
+    };
+  }
+  const binary_ok = deps.which("agent-config") !== null;
+  if (missing.length === 0 && binary_ok) {
+    return {
+      id: "hook-wiring",
+      status: "ok",
+      message: "managed hooks registered in ~/.claude/settings.json; dispatch binary on PATH",
+      remedy: ""
+    };
+  }
+  if (missing.length > 0 && deps.pluginInstalled()) {
+    return {
+      id: "hook-wiring",
+      status: "warn",
+      message: `managed hooks missing for: ${missing.join(", ")} \u2014 currently carried by the installed plugin (deprecated surface)`,
+      remedy: "agent-config refresh --global (writes the managed settings.json block)"
+    };
+  }
+  const parts = [];
+  if (missing.length > 0) parts.push(`managed hooks missing for: ${missing.join(", ")}`);
+  if (!binary_ok) parts.push("`agent-config` not on PATH (hooks would silently no-op)");
+  if (parts.length === 0) {
+    parts.push("`agent-config` not on PATH");
+  }
+  return {
+    id: "hook-wiring",
+    status: "fail",
+    message: parts.join("; "),
+    remedy: binary_ok ? "agent-config refresh --global" : "npm install -g @event4u/agent-config, then agent-config refresh --global"
+  };
+}
+
+// src/scripts/_lib/install_reach_checks.ts
+import * as fs11 from "node:fs";
+import * as path15 from "node:path";
+var ROOT_INSTRUCTION_FILES = [
+  "AGENTS.md",
+  "CLAUDE.md",
+  "GEMINI.md",
+  ".github/copilot-instructions.md"
+];
+var UNRESOLVABLE_REASONS = [
+  { test: (s) => /^[a-z][a-z0-9+.-]*:\/\//i.test(s), reason: "a URL, not a repository path" },
+  { test: (s) => s.startsWith("/"), reason: "absolute \u2014 outside the repository root this checker resolves against" },
+  { test: (s) => s.startsWith("~"), reason: "home-relative \u2014 resolves per machine, not per repository" },
+  { test: (s) => s.includes("*") || s.includes("?") || s.includes("["), reason: "a glob, which names a set rather than a path" },
+  { test: (s) => s.includes("<") || s.includes(">") || s.includes("{"), reason: "carries a placeholder, so no single path is named" },
+  { test: (s) => s.startsWith(".."), reason: "escapes the repository root" },
+  {
+    // `archive/`, `skipped/` — written inside prose that already established
+    // a parent directory. Read from the repository root they are wrong, and
+    // reporting them dangling would blame the tree for the checker's missing
+    // context. Their parent is knowable to a reader and not to this parser.
+    test: (s) => /^[^/]+\/$/.test(s),
+    reason: "a bare directory reference \u2014 the prose around it names the parent, this parser does not"
+  }
+];
+var BACKTICKED = /`([^`\n]+)`/g;
+var LINK_TARGET = /\]\(([^)\s]+)\)/g;
+var EXTENSION = /\.[A-Za-z0-9]{1,8}$/;
+function _isAnchored(projectRoot, token) {
+  if (token.startsWith("./") || token.startsWith("../") || token.startsWith("/") || token.startsWith(".")) return true;
+  if (token.endsWith("/")) return true;
+  if (EXTENSION.test(token)) return true;
+  const first = token.split("/")[0];
+  if (first === void 0 || first === "" || first === token) return false;
+  try {
+    return fs11.statSync(path15.join(projectRoot, first)).isDirectory();
   } catch {
     return false;
   }
 }
-if (_isCliEntry()) process.exit(main3(process.argv.slice(2)));
+function _looksLikePath(projectRoot, token) {
+  const t = token.trim();
+  if (t === "") return false;
+  if (/\s/.test(t)) return false;
+  if (t.startsWith("-")) return false;
+  if (!t.includes("/")) return false;
+  return _isAnchored(projectRoot, t);
+}
+function extractNamedPaths(projectRoot, source, text) {
+  const seen = /* @__PURE__ */ new Set();
+  const out = [];
+  for (const re of [BACKTICKED, LINK_TARGET]) {
+    re.lastIndex = 0;
+    let m;
+    while ((m = re.exec(text)) !== null) {
+      if (re === BACKTICKED && text.slice(m.index + m[0].length, m.index + m[0].length + 2) === "](") continue;
+      const raw = (m[1] ?? "").trim();
+      if (!_looksLikePath(projectRoot, raw) || seen.has(raw)) continue;
+      seen.add(raw);
+      out.push({ source, raw, normalised: null, outcome: "unresolvable" });
+    }
+  }
+  return out;
+}
+function classifyNamedPath(projectRoot, entry) {
+  for (const { test, reason } of UNRESOLVABLE_REASONS) {
+    if (test(entry.raw)) return { ...entry, normalised: null, outcome: "unresolvable", reason };
+  }
+  const rel = entry.raw.replace(/^\.\//, "").replace(/\/$/, "");
+  if (rel === "") {
+    return { ...entry, normalised: null, outcome: "unresolvable", reason: "empty after normalisation" };
+  }
+  const abs = path15.join(projectRoot, rel);
+  if (!path15.resolve(abs).startsWith(path15.resolve(projectRoot))) {
+    return { ...entry, normalised: rel, outcome: "unresolvable", reason: "escapes the repository root" };
+  }
+  return { ...entry, normalised: rel, outcome: fs11.existsSync(abs) ? "present" : "dangling" };
+}
+function resolveInstructionPaths(projectRoot) {
+  const out = [];
+  for (const rel of ROOT_INSTRUCTION_FILES) {
+    const abs = path15.join(projectRoot, rel);
+    let text;
+    try {
+      text = fs11.readFileSync(abs, "utf8");
+    } catch {
+      continue;
+    }
+    for (const entry of extractNamedPaths(projectRoot, rel, text)) {
+      out.push(classifyNamedPath(projectRoot, entry));
+    }
+  }
+  return out;
+}
+function checkInstructionPaths(projectRoot) {
+  const id = "instruction-path-reach";
+  const named = resolveInstructionPaths(projectRoot);
+  if (named.length === 0) {
+    return {
+      id,
+      status: "skipped",
+      message: "no root instruction file names a repository path \u2014 nothing to resolve",
+      remedy: ""
+    };
+  }
+  const dangling = named.filter((n) => n.outcome === "dangling");
+  const unresolvable = named.filter((n) => n.outcome === "unresolvable");
+  const present = named.length - dangling.length - unresolvable.length;
+  const tail = unresolvable.length === 0 ? "" : ` ${unresolvable.length} path(s) THIS CHECKER could not interpret, which is not the same as absent: ` + unresolvable.map((n) => `${n.source} \u2192 ${n.raw} (${n.reason ?? "no reason recorded"})`).join("; ");
+  if (dangling.length === 0) {
+    return {
+      id,
+      status: "ok",
+      message: `${present} instruction-file path(s) resolve.${tail}`,
+      remedy: ""
+    };
+  }
+  return {
+    id,
+    status: "fail",
+    message: `${dangling.length} path(s) named by a root instruction file do NOT exist: ` + dangling.map((n) => `${n.source} \u2192 ${n.raw}`).join("; ") + `. ${present} resolved.${tail} An instruction file that over-reports is read as fact: every routing decision downstream of a dangling path is made against a layer that is not there. See rule \`instruction-path-verification\`.`,
+    remedy: "install the missing layer, or delete the claim from the instruction file \u2014 a path named is a promise"
+  };
+}
+var SETTINGS_PIN_FILES = [
+  { rel: path15.join("agents", "settings", ".agent-settings.yml"), legacy: false },
+  { rel: ".agent-settings.yml", legacy: true },
+  { rel: ".agent-project-settings.yml", legacy: true },
+  { rel: "agent-settings.yml", legacy: true }
+];
+var PIN_RE = /^\s*(?:agent_config_version|version)\s*:\s*"?([^"'\s]+)"?\s*$/m;
+var LOCK_VERSION_RE = /^\s*agent_config_version\s*:\s*"?([^"\s]+)"?\s*$/m;
+function readVersionPins(projectRoot) {
+  const out = [];
+  for (const { rel, legacy } of SETTINGS_PIN_FILES) {
+    let text;
+    try {
+      text = fs11.readFileSync(path15.join(projectRoot, rel), "utf8");
+    } catch {
+      continue;
+    }
+    const m = PIN_RE.exec(text);
+    if (m?.[1] !== void 0) out.push({ file: rel, legacy, version: m[1] });
+  }
+  return out;
+}
+function readInstalledVersion(projectRoot) {
+  try {
+    const text = fs11.readFileSync(path15.join(projectRoot, "agents", "installed-tools.lock"), "utf8");
+    return LOCK_VERSION_RE.exec(text)?.[1] ?? null;
+  } catch {
+    return null;
+  }
+}
+function checkVersionAxis(projectRoot, resolvableNow) {
+  const id = "version-axis";
+  const pins = readVersionPins(projectRoot);
+  const installed = readInstalledVersion(projectRoot);
+  if (pins.length === 0 && installed === null) {
+    return { id, status: "skipped", message: "no version pin and no install lockfile in this tree", remedy: "" };
+  }
+  const pinText = pins.length === 0 ? "pinned: none" : `pinned: ${pins.map((p) => `${p.version} (${p.file}${p.legacy ? ", LEGACY filename" : ""})`).join(" \xB7 ")}`;
+  const line = `${pinText} \xB7 installed: ${installed ?? "unknown"} \xB7 resolvable now: ${resolvableNow ?? "unknown"}`;
+  const divergent = pins.filter((p) => installed !== null && p.version !== installed);
+  if (divergent.length === 0) {
+    return { id, status: "ok", message: line, remedy: "" };
+  }
+  return {
+    id,
+    status: "warn",
+    message: `${line} \u2014 ${divergent.length} pin(s) disagree with the installed projection. A pin behind the installed tree is ordinary manifest-versus-lockfile drift, and it is only visible as a comparison: each number alone reads as correct.`,
+    remedy: "reconcile the pin with the installed version, or migrate a legacy settings file into the canonical location"
+  };
+}
+var OVERRIDE_LAYERS = [
+  path15.join("agents", "overrides"),
+  path15.join(".agent", "overrides")
+];
+var KIND_DIRS = [
+  { dir: "rules", kind: "rule" },
+  { dir: "skills", kind: "skill" },
+  { dir: "commands", kind: "command" }
+];
+function collectOverrideSet(projectRoot) {
+  const counts = /* @__PURE__ */ new Map();
+  for (const layer of OVERRIDE_LAYERS) {
+    for (const { dir, kind } of KIND_DIRS) {
+      let entries;
+      try {
+        entries = fs11.readdirSync(path15.join(projectRoot, layer, dir));
+      } catch {
+        continue;
+      }
+      for (const entry of entries) {
+        const name = entry.replace(/\.md$/, "");
+        if (name === "" || name.startsWith(".")) continue;
+        const key = `${kind}:${name}`;
+        const prev = counts.get(key);
+        counts.set(key, { kind, name, layers: (prev?.layers ?? 0) + 1 });
+      }
+    }
+  }
+  return [...counts.values()].sort((a, b) => `${a.kind}:${a.name}`.localeCompare(`${b.kind}:${b.name}`));
+}
+function repeatedOverrides(set) {
+  return set.filter((s) => s.layers > 1);
+}
+function checkOverrideSet(projectRoot) {
+  const id = "override-set";
+  const set = collectOverrideSet(projectRoot);
+  if (set.length === 0) {
+    return { id, status: "skipped", message: "no shipped artifact is overridden in this tree", remedy: "" };
+  }
+  const repeated = repeatedOverrides(set);
+  const names = set.map((s) => `${s.kind}:${s.name}\xD7${s.layers}`).join(" \xB7 ");
+  if (repeated.length === 0) {
+    return {
+      id,
+      status: "ok",
+      message: `${set.length} shipped artifact(s) overridden locally, each once: ${names}`,
+      remedy: ""
+    };
+  }
+  return {
+    id,
+    status: "warn",
+    message: `${repeated.length} shipped artifact(s) overridden in more than one layer: ${names}. A repeatedly overridden default is a candidate for an upstream proposal \u2014 but ONE tree is not evidence about a default. It is one input to an aggregate across independent consumers.`,
+    remedy: "route it through the upstream-contribution path, never by changing a shipped default on one install"
+  };
+}
+var REACH_CHECK_IDS = ["instruction-path-reach", "version-axis", "override-set"];
+function reachRunners(opts) {
+  return {
+    "instruction-path-reach": () => checkInstructionPaths(opts.projectRoot),
+    "version-axis": () => checkVersionAxis(opts.projectRoot, opts.resolvableVersion),
+    "override-set": () => checkOverrideSet(opts.projectRoot)
+  };
+}
+
+// src/scripts/_lib/doctor_runtime_checks.ts
+function checkPythonRuntime() {
+  return {
+    id: "python-runtime",
+    status: "ok",
+    message: "python3 is not a runtime dependency (TS runtime via tsx)",
+    remedy: ""
+  };
+}
+function checkHumanizerRuntime(which) {
+  const node = which("node");
+  if (node === null) {
+    return {
+      id: "humanizer-runtime",
+      status: "ok",
+      message: "no Node runtime on PATH \u2014 write-engine step 4b uses the prose-only humanize audit (graceful fallback)",
+      remedy: "install Node to enable the mechanical detect_ai_tells.ts pass; the prose audit runs regardless"
+    };
+  }
+  return {
+    id: "humanizer-runtime",
+    status: "ok",
+    message: `Node runtime present (${node}) \u2014 step 4b runs the mechanical detect_ai_tells.ts pass`,
+    remedy: ""
+  };
+}
 
 // src/scripts/_lib/environment_detector.ts
 import { spawnSync } from "node:child_process";
-import * as fs9 from "node:fs";
+import * as fs12 from "node:fs";
 import * as os from "node:os";
-import * as path12 from "node:path";
+import * as path16 from "node:path";
 
 // src/install/toolDetection.ts
-import { existsSync as existsSync6 } from "node:fs";
+import { existsSync as existsSync9 } from "node:fs";
 import { homedir as homedir3 } from "node:os";
-import { delimiter, join as join12 } from "node:path";
+import { delimiter, join as join15 } from "node:path";
 var TOOL_SIGNALS = {
   "claude-code": { bins: ["claude"], homePaths: [".claude", ".claude.json", ".config/claude"] },
   "claude-desktop": { absPaths: ["/Applications/Claude.app"], homePaths: ["Library/Application Support/Claude", ".config/Claude"] },
@@ -1741,8 +2718,8 @@ function resolveBinaryPath(name, pathEnv) {
   for (const dir of pathEnv.split(delimiter)) {
     if (dir.length === 0) continue;
     for (const candidate of [name, `${name}.exe`, `${name}.cmd`]) {
-      const full = join12(dir, candidate);
-      if (existsSync6(full)) return full;
+      const full = join15(dir, candidate);
+      if (existsSync9(full)) return full;
     }
   }
   return null;
@@ -1752,10 +2729,10 @@ function binOnPath(name, pathEnv) {
 }
 function isToolInstalled(signal, home, pathEnv) {
   for (const rel of signal.homePaths ?? []) {
-    if (existsSync6(join12(home, rel))) return true;
+    if (existsSync9(join15(home, rel))) return true;
   }
   for (const abs of signal.absPaths ?? []) {
-    if (existsSync6(abs)) return true;
+    if (existsSync9(abs)) return true;
   }
   for (const bin of signal.bins ?? []) {
     if (binOnPath(bin, pathEnv)) return true;
@@ -1814,7 +2791,7 @@ function classifyBilling(provider, source) {
 function codexHome(env) {
   const map = env ?? process.env;
   const override = (map["CODEX_HOME"] ?? "").trim();
-  return override !== "" ? override : path12.join(homeOf(env), ".codex");
+  return override !== "" ? override : path16.join(homeOf(env), ".codex");
 }
 function homeOf(env) {
   const map = env ?? process.env;
@@ -1855,14 +2832,14 @@ ${res.stderr ?? ""}`;
 }
 function isFile3(p) {
   try {
-    return fs9.statSync(p).isFile();
+    return fs12.statSync(p).isFile();
   } catch {
     return false;
   }
 }
 function exists(p) {
   try {
-    return fs9.existsSync(p);
+    return fs12.existsSync(p);
   } catch {
     return false;
   }
@@ -1870,7 +2847,7 @@ function exists(p) {
 function classifyCodexAuth(authPath) {
   let data;
   try {
-    data = JSON.parse(fs9.readFileSync(authPath, "utf-8"));
+    data = JSON.parse(fs12.readFileSync(authPath, "utf-8"));
   } catch {
     return "cli-api-key";
   }
@@ -1887,7 +2864,7 @@ function cliSubscriptionEvidence(provider, home, env, claudeConfigDir, probeKeyc
   if (provider === "anthropic") {
     const configDir = claudeConfigDir;
     for (const rel of [".credentials.json", "credentials.json"]) {
-      const p = path12.join(configDir, rel);
+      const p = path16.join(configDir, rel);
       if (isFile3(p)) return { source: "cli-subscription", evidence: p };
     }
     if (probeKeychain(CLAUDE_KEYCHAIN_SERVICE)) {
@@ -1896,12 +2873,12 @@ function cliSubscriptionEvidence(provider, home, env, claudeConfigDir, probeKeyc
     return null;
   }
   if (provider === "openai") {
-    const p = path12.join(codexHome(env), "auth.json");
+    const p = path16.join(codexHome(env), "auth.json");
     if (isFile3(p)) return { source: classifyCodexAuth(p), evidence: p };
     return null;
   }
   if (provider === "gemini") {
-    const p = path12.join(home, ".gemini", "oauth_creds.json");
+    const p = path16.join(home, ".gemini", "oauth_creds.json");
     if (isFile3(p)) return { source: "cli-subscription", evidence: p };
     return null;
   }
@@ -1933,7 +2910,7 @@ function detectHosts(opts) {
 function detectAuth(opts) {
   const env = opts.env ?? process.env;
   const home = opts.home ?? homeOf(opts.env);
-  const claudeConfigDir = opts.home === void 0 && opts.env === void 0 ? claude_config_dir() : (env["CLAUDE_CONFIG_DIR"] ?? "").trim() || path12.join(home, ".claude");
+  const claudeConfigDir = opts.home === void 0 && opts.env === void 0 ? claude_config_dir() : (env["CLAUDE_CONFIG_DIR"] ?? "").trim() || path16.join(home, ".claude");
   const probeKeychain = opts.probeKeychain ?? defaultProbeKeychain;
   const auth = [];
   const keys = [];
@@ -1988,7 +2965,7 @@ function detectEnvironment(opts = {}) {
 }
 
 // src/scripts/_cli/detection_report.ts
-import * as path13 from "node:path";
+import * as path17 from "node:path";
 
 // src/scripts/ai_council/transport_resolver.ts
 var VALID_TRANSPORT_MODES = /* @__PURE__ */ new Set([
@@ -2007,11 +2984,11 @@ function cliBinary(report, provider) {
   if (meta === void 0) return null;
   const binaryName = meta[0];
   const host = report.hosts.find(
-    (h) => h.binary !== null && stripExeSuffix(basename(h.binary)) === binaryName
+    (h) => h.binary !== null && stripExeSuffix(basename2(h.binary)) === binaryName
   );
   return host?.binary ?? null;
 }
-function basename(p) {
+function basename2(p) {
   const parts = p.split(/[/\\]/);
   return parts[parts.length - 1] ?? p;
 }
@@ -2190,7 +3167,7 @@ function cliBinaryPresent(environment, provider, binaryOverride) {
   const expected = PROVIDER_CLI_META[provider]?.[0];
   if (expected === void 0) return false;
   return environment.hosts.some(
-    (h) => h.binary !== null && stripExe(path13.basename(h.binary)) === expected
+    (h) => h.binary !== null && stripExe(path17.basename(h.binary)) === expected
   );
 }
 function stripExe(name) {
@@ -2351,9 +3328,9 @@ function absentCouncilFacts(configPath) {
 
 // src/scripts/ai_team/review_gate.ts
 import * as crypto from "node:crypto";
-import * as fs10 from "node:fs";
+import * as fs13 from "node:fs";
 import * as os2 from "node:os";
-import * as path14 from "node:path";
+import * as path18 from "node:path";
 
 // src/scripts/ai_team/config.ts
 var AI_TEAM_REVIEW_GATE_DEFAULTS = Object.freeze({
@@ -2369,16 +3346,16 @@ var AI_TEAM_DEFAULTS = Object.freeze({
 });
 
 // src/scripts/ai_team/review_gate.ts
-var GATE_LEDGER_RELPATH = path14.join("agents", "runtime", "team", "events.log");
+var GATE_LEDGER_RELPATH = path18.join("agents", "runtime", "team", "events.log");
 var _CODEX_PLUGIN_DATA_DIRNAME = `${CODEX_PLUGIN_ID}-${CODEX_MARKETPLACE_NAME}`;
 function _workspace_state_segment(workspace_root) {
   let canonical = workspace_root;
   try {
-    canonical = fs10.realpathSync.native(workspace_root);
+    canonical = fs13.realpathSync.native(workspace_root);
   } catch {
     canonical = workspace_root;
   }
-  const slug_source = path14.basename(workspace_root) || "workspace";
+  const slug_source = path18.basename(workspace_root) || "workspace";
   const slug = slug_source.replace(/[^a-zA-Z0-9._-]+/g, "-").replace(/^-+|-+$/g, "") || "workspace";
   const hash = crypto.createHash("sha256").update(canonical).digest("hex").slice(0, 16);
   return `${slug}-${hash}`;
@@ -2388,19 +3365,19 @@ function upstream_state_dir_candidates(workspace_root) {
   const candidates = [];
   const env = (process.env["CLAUDE_PLUGIN_DATA"] ?? "").trim();
   if (env !== "") {
-    candidates.push(path14.join(env, "state", segment));
+    candidates.push(path18.join(env, "state", segment));
   }
   candidates.push(
-    path14.join(claude_config_dir(), "plugins", "data", _CODEX_PLUGIN_DATA_DIRNAME, "state", segment)
+    path18.join(claude_config_dir(), "plugins", "data", _CODEX_PLUGIN_DATA_DIRNAME, "state", segment)
   );
-  candidates.push(path14.join(os2.tmpdir(), "codex-companion", segment));
+  candidates.push(path18.join(os2.tmpdir(), "codex-companion", segment));
   return candidates;
 }
 function upstream_gate_enabled(workspace_root) {
   for (const dir of upstream_state_dir_candidates(workspace_root)) {
     let parsed;
     try {
-      parsed = JSON.parse(fs10.readFileSync(path14.join(dir, "state.json"), "utf-8"));
+      parsed = JSON.parse(fs13.readFileSync(path18.join(dir, "state.json"), "utf-8"));
     } catch {
       continue;
     }
@@ -2460,13 +3437,13 @@ var ArgparseExit = class extends Error {
 function expanduser(p) {
   if (p === "~") return os3.homedir();
   if (p.startsWith("~/") || p.startsWith("~\\")) {
-    return path15.join(os3.homedir(), p.slice(2));
+    return path19.join(os3.homedir(), p.slice(2));
   }
   return p;
 }
 function pathExists(p) {
   try {
-    fs11.statSync(p);
+    fs14.statSync(p);
     return true;
   } catch {
     return false;
@@ -2474,27 +3451,27 @@ function pathExists(p) {
 }
 function isFile4(p) {
   try {
-    return fs11.statSync(p).isFile();
+    return fs14.statSync(p).isFile();
   } catch {
     return false;
   }
 }
 function isDir3(p) {
   try {
-    return fs11.statSync(p).isDirectory();
+    return fs14.statSync(p).isDirectory();
   } catch {
     return false;
   }
 }
 function resolvePath(p) {
   try {
-    return fs11.realpathSync(path15.resolve(p));
+    return fs14.realpathSync(path19.resolve(p));
   } catch {
-    return path15.resolve(p);
+    return path19.resolve(p);
   }
 }
 function readText(p) {
-  return fs11.readFileSync(p, "utf-8");
+  return fs14.readFileSync(p, "utf-8");
 }
 function _jsonStrAscii(s) {
   let out = '"';
@@ -2592,10 +3569,10 @@ function yamlSafeLoad(text) {
   }
 }
 function print(line = "") {
-  process2.stdout.write(line + "\n");
+  process3.stdout.write(line + "\n");
 }
 function eprint(line = "") {
-  process2.stderr.write(line + "\n");
+  process3.stderr.write(line + "\n");
 }
 var _Sentinel = class {
 };
@@ -2605,7 +3582,7 @@ function _resolve_project_root(arg) {
 }
 var _INSTALL_MODE_MARKER_REL = "agents/.agent-state/install-mode.txt";
 function _detect_install_mode(project_root) {
-  const marker = path15.join(project_root, _INSTALL_MODE_MARKER_REL);
+  const marker = path19.join(project_root, _INSTALL_MODE_MARKER_REL);
   if (isFile4(marker)) {
     let value;
     try {
@@ -2617,9 +3594,9 @@ function _detect_install_mode(project_root) {
       return [value, "marker-file"];
     }
   }
-  const has_agents_md = pathExists(path15.join(project_root, "AGENTS.md"));
+  const has_agents_md = pathExists(path19.join(project_root, "AGENTS.md"));
   const has_copilot = pathExists(
-    path15.join(project_root, ".github", "copilot-instructions.md")
+    path19.join(project_root, ".github", "copilot-instructions.md")
   );
   if (has_agents_md && has_copilot) {
     return ["full", "heuristic"];
@@ -2639,7 +3616,7 @@ function _settings_layer_chain(project_root) {
   return layers;
 }
 function _detect_wrapper(project_root) {
-  const wrapper = path15.join(project_root, "agent-config");
+  const wrapper = path19.join(project_root, "agent-config");
   if (!pathExists(wrapper)) {
     return { path: String(wrapper), exists: false, embedded_root: null };
   }
@@ -2650,7 +3627,7 @@ function _detect_wrapper(project_root) {
   };
 }
 function _emit_trace_text(root, anchor, trace, origin) {
-  print(`  \u{1F4CD}  start: ${process2.cwd()}`);
+  print(`  \u{1F4CD}  start: ${process3.cwd()}`);
   print(`  \u{1F4CD}  origin: ${origin}`);
   if (trace.length > 0) {
     print("  trace:");
@@ -2670,7 +3647,7 @@ function _emit_trace_text(root, anchor, trace, origin) {
 }
 function _emit_trace_json(root, anchor, trace, origin) {
   const payload = {
-    start: process2.cwd(),
+    start: process3.cwd(),
     origin,
     resolved_root: root !== null ? String(root) : null,
     anchor,
@@ -2706,14 +3683,14 @@ function _emit_context_text(ctx) {
 }
 function _resolve_path(project_root, raw) {
   let p = expanduser(raw);
-  if (!path15.isAbsolute(p)) {
-    p = path15.join(project_root, p);
+  if (!path19.isAbsolute(p)) {
+    p = path19.join(project_root, p);
   }
   return p;
 }
 function _sha256(p) {
   try {
-    const data = fs11.readFileSync(p);
+    const data = fs14.readFileSync(p);
     return crypto2.createHash("sha256").update(data).digest("hex");
   } catch {
     return null;
@@ -2722,7 +3699,7 @@ function _sha256(p) {
 var PACKAGE_TAG_ID = "event4u/agent-config";
 var _FRONTMATTER_PACKAGE_RE = /^package:\s*(.+?)\s*$/m;
 function _read_inline_package_tag(p) {
-  if (path15.extname(p) !== ".md") {
+  if (path19.extname(p) !== ".md") {
     return NO_FRONTMATTER;
   }
   let text;
@@ -2851,13 +3828,13 @@ function rglob(root) {
   const walk = (dir) => {
     let entries;
     try {
-      entries = fs11.readdirSync(dir, { withFileTypes: true });
+      entries = fs14.readdirSync(dir, { withFileTypes: true });
     } catch {
       return;
     }
     entries.sort((a, b) => a.name < b.name ? -1 : a.name > b.name ? 1 : 0);
     for (const ent of entries) {
-      const full = path15.join(dir, ent.name);
+      const full = path19.join(dir, ent.name);
       out.push(full);
       let dirLike = ent.isDirectory();
       if (ent.isSymbolicLink()) {
@@ -2932,9 +3909,9 @@ function _foreign_records(project_root, foreign) {
   return out;
 }
 function relativeTo(p, base) {
-  const rel = path15.relative(base, p);
+  const rel = path19.relative(base, p);
   if (rel === "") return rel;
-  if (rel.startsWith("..") || path15.isAbsolute(rel)) {
+  if (rel.startsWith("..") || path19.isAbsolute(rel)) {
     return null;
   }
   return rel;
@@ -2947,6 +3924,8 @@ var CHECK_IDS = [
   "claude-command-wrappers",
   "surface-state",
   "hook-wiring",
+  ...WIRING_CHECK_IDS,
+  ...REACH_CHECK_IDS,
   "stale-orphans",
   "overrides",
   "rule-scope-drift",
@@ -2976,6 +3955,8 @@ var GLOBAL_CHECK_IDS = /* @__PURE__ */ new Set([
   "claude-command-wrappers",
   "surface-state",
   "hook-wiring",
+  ...WIRING_CHECK_IDS,
+  ...REACH_CHECK_IDS,
   "stale-orphans",
   "overrides",
   "rule-scope-drift",
@@ -3016,7 +3997,7 @@ var STATUS_SYMBOLS = {
 var MIN_PYTHON = [3, 10];
 function _check_scope(project_root) {
   for (const marker of ["pnpm-workspace.yaml", "lerna.json"]) {
-    if (pathExists(path15.join(project_root, marker))) {
+    if (pathExists(path19.join(project_root, marker))) {
       return {
         id: "scope",
         status: "warn",
@@ -3025,7 +4006,7 @@ function _check_scope(project_root) {
       };
     }
   }
-  const pkg = path15.join(project_root, "package.json");
+  const pkg = path19.join(project_root, "package.json");
   if (pathExists(pkg)) {
     try {
       const data = JSON.parse(readText(pkg));
@@ -3051,7 +4032,7 @@ var _PLACEHOLDER_EMAIL_RE = /^(t@t\.t|.*@example\.(com|org)|.*@localhost)$/i;
 var _PLACEHOLDER_NAME_RE = /^(t|test|user|nobody|x)$/i;
 function _git_config_path(project_root) {
   const common = git_common_dir(project_root);
-  return common === null ? null : path15.join(common, "config");
+  return common === null ? null : path19.join(common, "config");
 }
 function _parse_git_user(configText) {
   let inUser = false;
@@ -3081,7 +4062,7 @@ function _check_git_identity(project_root) {
   }
   let ident = _parse_git_user(readText(cfgPath));
   if (ident.name === null && ident.email === null) {
-    const globalCfg = path15.join(os3.homedir(), ".gitconfig");
+    const globalCfg = path19.join(os3.homedir(), ".gitconfig");
     if (pathExists(globalCfg)) {
       ident = _parse_git_user(readText(globalCfg));
     }
@@ -3142,7 +4123,7 @@ function _package_root() {
 }
 function _current_package_version() {
   try {
-    const data = JSON.parse(readText(path15.join(_package_root(), "package.json")));
+    const data = JSON.parse(readText(path19.join(_package_root(), "package.json")));
     const v = data["version"];
     if (typeof v === "string" && v.trim()) {
       return v.trim();
@@ -3186,25 +4167,25 @@ function _check_lockfile_freshness(manifest) {
   };
 }
 function shutilWhich(name) {
-  if (path15.dirname(name) !== "." && (name.includes("/") || name.includes("\\"))) {
+  if (path19.dirname(name) !== "." && (name.includes("/") || name.includes("\\"))) {
     return isExecutableFile(name) ? name : null;
   }
-  const pathEnv = process2.env["PATH"] || "";
-  const sep2 = process2.platform === "win32" ? ";" : ":";
+  const pathEnv = process3.env["PATH"] || "";
+  const sep2 = process3.platform === "win32" ? ";" : ":";
   const dirs = pathEnv.split(sep2);
-  const exts = process2.platform === "win32" ? (process2.env["PATHEXT"] || ".COM;.EXE;.BAT;.CMD").split(";") : [""];
+  const exts = process3.platform === "win32" ? (process3.env["PATHEXT"] || ".COM;.EXE;.BAT;.CMD").split(";") : [""];
   const seenDirs = /* @__PURE__ */ new Set();
   for (const dir of dirs) {
     const d = dir === "" ? "." : dir;
     if (seenDirs.has(d)) continue;
     seenDirs.add(d);
     for (const ext of exts) {
-      const candidate = path15.join(d, name + (ext === "" ? "" : ext.toLowerCase() === ext ? ext : ext));
+      const candidate = path19.join(d, name + (ext === "" ? "" : ext.toLowerCase() === ext ? ext : ext));
       if (isExecutableFile(candidate)) {
         return candidate;
       }
       if (ext !== "") {
-        const upper = path15.join(d, name + ext);
+        const upper = path19.join(d, name + ext);
         if (isExecutableFile(upper)) return upper;
       }
     }
@@ -3213,10 +4194,10 @@ function shutilWhich(name) {
 }
 function isExecutableFile(p) {
   try {
-    const st = fs11.statSync(p);
+    const st = fs14.statSync(p);
     if (!st.isFile()) return false;
-    if (process2.platform === "win32") return true;
-    fs11.accessSync(p, fs11.constants.X_OK);
+    if (process3.platform === "win32") return true;
+    fs14.accessSync(p, fs14.constants.X_OK);
     return true;
   } catch {
     return false;
@@ -3280,7 +4261,7 @@ function _check_claude_plugin() {
       remedy: ""
     };
   }
-  const projection = path15.join(os3.homedir(), ".claude", "skills");
+  const projection = path19.join(os3.homedir(), ".claude", "skills");
   const projection_present = isDir3(projection);
   if (projection_present) {
     return {
@@ -3317,8 +4298,8 @@ function _check_claude_command_wrappers() {
       remedy: ""
     };
   }
-  const anchor = path15.join(os3.homedir(), ".claude");
-  const commands_dir = path15.join(anchor, "commands");
+  const anchor = path19.join(os3.homedir(), ".claude");
+  const commands_dir = path19.join(anchor, "commands");
   if (!isDir3(commands_dir)) {
     return {
       id: "claude-command-wrappers",
@@ -3327,8 +4308,8 @@ function _check_claude_command_wrappers() {
       remedy: ""
     };
   }
-  const flat_probe = fs11.existsSync(path15.join(commands_dir, "commit.md"));
-  const wrapper_probe = fs11.existsSync(path15.join(anchor, "skills", "commit", "SKILL.md"));
+  const flat_probe = fs14.existsSync(path19.join(commands_dir, "commit.md"));
+  const wrapper_probe = fs14.existsSync(path19.join(anchor, "skills", "commit", "SKILL.md"));
   if (wrapper_probe) {
     return {
       id: "claude-command-wrappers",
@@ -3353,7 +4334,7 @@ function _check_claude_command_wrappers() {
   };
 }
 function _check_surface_state() {
-  const matrix_path = path15.join(_package_root(), "src", "config", "surface-matrix.yml");
+  const matrix_path = path19.join(_package_root(), "src", "config", "surface-matrix.yml");
   if (!isFile4(matrix_path)) {
     return {
       id: "surface-state",
@@ -3377,7 +4358,7 @@ function _check_surface_state() {
       remedy: "agent-config upgrade (reinstalls the package data files)"
     };
   }
-  const _expand = (p) => p.startsWith("~/") ? path15.join(os3.homedir(), p.slice(2)) : path15.join(_package_root(), p);
+  const _expand = (p) => p.startsWith("~/") ? path19.join(os3.homedir(), p.slice(2)) : path19.join(_package_root(), p);
   const violations = [];
   const remedies = [];
   let checked = 0;
@@ -3419,72 +4400,21 @@ function _check_surface_state() {
 }
 function pathExistsAny(p) {
   try {
-    fs11.statSync(p);
+    fs14.statSync(p);
     return true;
   } catch {
     return false;
   }
 }
 function _check_hook_wiring() {
-  const claude = shutilWhich("claude");
-  if (claude === null) {
-    return {
-      id: "hook-wiring",
-      status: "skipped",
-      message: "Claude Code CLI not on PATH \u2014 hook-wiring check not applicable",
-      remedy: ""
-    };
-  }
-  const settings_path = path15.join(os3.homedir(), ".claude", "settings.json");
-  let missing;
-  try {
-    const matrix = build_claude_hook_matrix(
-      path15.join(_package_root(), "src", "scripts", "hook_manifest.yaml")
-    );
-    const settings = pathExists(settings_path) ? JSON.parse(fs11.readFileSync(settings_path, "utf8")) : {};
-    const hooks = (settings["hooks"] ?? {}) || {};
-    missing = Object.keys(matrix).filter((ev) => {
-      const groups = hooks[ev];
-      if (!Array.isArray(groups)) return true;
-      return !JSON.stringify(groups).includes(MANAGED_SIGNATURE);
-    });
-  } catch (e) {
-    return {
-      id: "hook-wiring",
-      status: "fail",
-      message: `cannot evaluate managed hooks: ${String(e)}`,
-      remedy: "fix ~/.claude/settings.json (invalid JSON?), then agent-config refresh --global"
-    };
-  }
-  const binary_ok = shutilWhich("agent-config") !== null;
-  if (missing.length === 0 && binary_ok) {
-    return {
-      id: "hook-wiring",
-      status: "ok",
-      message: "managed hooks registered in ~/.claude/settings.json; dispatch binary on PATH",
-      remedy: ""
-    };
-  }
-  if (missing.length > 0 && claude_plugin_installed()) {
-    return {
-      id: "hook-wiring",
-      status: "warn",
-      message: `managed hooks missing for: ${missing.join(", ")} \u2014 currently carried by the installed plugin (deprecated surface)`,
-      remedy: "agent-config refresh --global (writes the managed settings.json block)"
-    };
-  }
-  const parts = [];
-  if (missing.length > 0) parts.push(`managed hooks missing for: ${missing.join(", ")}`);
-  if (!binary_ok) parts.push("`agent-config` not on PATH (hooks would silently no-op)");
-  if (parts.length === 0) {
-    parts.push("`agent-config` not on PATH");
-  }
-  return {
-    id: "hook-wiring",
-    status: "fail",
-    message: parts.join("; "),
-    remedy: binary_ok ? "agent-config refresh --global" : "npm install -g @event4u/agent-config, then agent-config refresh --global"
-  };
+  return checkHookWiring({
+    which: shutilWhich,
+    packageRoot: _package_root(),
+    homeDir: os3.homedir(),
+    buildMatrix: (mp) => build_claude_hook_matrix(mp),
+    managedSignature: MANAGED_SIGNATURE,
+    pluginInstalled: () => claude_plugin_installed()
+  });
 }
 function _check_bridge_drift(missing, modified, foreign, tag_drift) {
   const total = missing.length + modified.length + foreign.length + tag_drift.length;
@@ -3516,7 +4446,7 @@ function _check_mcp_mode(project_root) {
   ];
   const found = [];
   for (const [rel, label] of candidates) {
-    const p = path15.join(project_root, rel);
+    const p = path19.join(project_root, rel);
     if (!pathExists(p)) {
       continue;
     }
@@ -3548,7 +4478,7 @@ function _check_mcp_mode(project_root) {
   };
 }
 function _check_offline_readiness() {
-  const script = path15.join(_package_root(), "src", "scripts", "hermetic-install.sh");
+  const script = path19.join(_package_root(), "src", "scripts", "hermetic-install.sh");
   if (!pathExists(script)) {
     return {
       id: "offline-readiness",
@@ -3606,7 +4536,7 @@ function _check_stale_orphans() {
       (a, b) => a < b ? -1 : a > b ? 1 : 0
     );
     for (const root_name of ownedSorted) {
-      const root = path15.join(anchor, root_name);
+      const root = path19.join(anchor, root_name);
       if (!isDir3(root)) {
         continue;
       }
@@ -3621,7 +4551,7 @@ function _check_stale_orphans() {
         if (rel === null) {
           continue;
         }
-        const relPosix = rel.split(path15.sep).join("/");
+        const relPosix = rel.split(path19.sep).join("/");
         if (recorded_set.has(relPosix)) {
           continue;
         }
@@ -3676,14 +4606,14 @@ function _check_rule_scope_drift(project_root) {
   let rules_dir = null;
   let found = 0;
   for (const rel of _RULE_PROJECTION_DIRS) {
-    const cand = path15.join(project_root, rel);
+    const cand = path19.join(project_root, rel);
     if (!isDir3(cand)) {
       continue;
     }
     let count = 0;
     try {
-      for (const name of fs11.readdirSync(cand)) {
-        if (name.endsWith(".md") && isFile4(path15.join(cand, name))) {
+      for (const name of fs14.readdirSync(cand)) {
+        if (name.endsWith(".md") && isFile4(path19.join(cand, name))) {
           count += 1;
         }
       }
@@ -3737,14 +4667,14 @@ function _check_rule_scope_drift(project_root) {
   };
 }
 function _check_duplicate_scope_rules(project_root, userRulesDirOverride) {
-  const user_rules_dir = userRulesDirOverride ?? path15.join(os3.homedir(), ".claude", "rules");
+  const user_rules_dir = userRulesDirOverride ?? path19.join(os3.homedir(), ".claude", "rules");
   let project_rules_dir = null;
   if (_is_source_repo(project_root)) {
-    const cand = path15.join(project_root, "dist", "agent-src", "rules");
+    const cand = path19.join(project_root, "dist", "agent-src", "rules");
     if (isDir3(cand)) project_rules_dir = cand;
   } else {
     for (const rel of _RULE_PROJECTION_DIRS) {
-      const cand = path15.join(project_root, rel);
+      const cand = path19.join(project_root, rel);
       if (isDir3(cand)) {
         project_rules_dir = cand;
         break;
@@ -3777,31 +4707,8 @@ function _check_duplicate_scope_rules(project_root, userRulesDirOverride) {
     remedy: "detection only \u2014 no file is modified. If the duplication is unwanted, refresh the user-scope copy (e.g. `agent-config global`) to re-sync it with the project-scope version."
   };
 }
-function _check_python_runtime() {
-  return {
-    id: "python-runtime",
-    status: "ok",
-    message: "python3 is not a runtime dependency (TS runtime via tsx)",
-    remedy: ""
-  };
-}
-function _check_humanizer_runtime() {
-  const node = shutilWhich("node");
-  if (node === null) {
-    return {
-      id: "humanizer-runtime",
-      status: "ok",
-      message: "no Node runtime on PATH \u2014 write-engine step 4b uses the prose-only humanize audit (graceful fallback)",
-      remedy: "install Node to enable the mechanical detect_ai_tells.ts pass; the prose audit runs regardless"
-    };
-  }
-  return {
-    id: "humanizer-runtime",
-    status: "ok",
-    message: `Node runtime present (${node}) \u2014 step 4b runs the mechanical detect_ai_tells.ts pass`,
-    remedy: ""
-  };
-}
+var _check_python_runtime = () => checkPythonRuntime();
+var _check_humanizer_runtime = () => checkHumanizerRuntime(shutilWhich);
 function _check_mcp_beta_readiness(project_root) {
   if (!_is_source_repo(project_root)) {
     return {
@@ -3813,7 +4720,7 @@ function _check_mcp_beta_readiness(project_root) {
   }
   const pending = [];
   for (const [gate_id, rel] of MCP_BETA_GATES) {
-    if (!pathExists(path15.join(project_root, rel))) {
+    if (!pathExists(path19.join(project_root, rel))) {
       pending.push(`${gate_id} (${rel})`);
     }
   }
@@ -3834,7 +4741,7 @@ function _check_mcp_beta_readiness(project_root) {
 }
 function _check_tier_usage_readiness(project_root) {
   const settings_file = project_settings_path(project_root);
-  let log_path = path15.join(project_root, ".agent-tier-usage.jsonl");
+  let log_path = path19.join(project_root, ".agent-tier-usage.jsonl");
   let enabled = false;
   if (isFile4(settings_file)) {
     let raw;
@@ -3853,7 +4760,7 @@ function _check_tier_usage_readiness(project_root) {
         const outputRaw = tu["output"];
         const output = typeof outputRaw === "object" && outputRaw !== null && !Array.isArray(outputRaw) ? outputRaw : {};
         if (typeof output["path"] === "string" && output["path"].trim()) {
-          log_path = path15.join(project_root, output["path"].trim());
+          log_path = path19.join(project_root, output["path"].trim());
         }
         const val = tu["enabled"];
         if (typeof val === "boolean") {
@@ -3878,7 +4785,7 @@ function _check_tier_usage_readiness(project_root) {
     return {
       id: "tier-usage-readiness",
       status: "warn",
-      message: `tier-usage telemetry on but ${path15.basename(log_path)} not yet written \u2014 no signal accumulated`,
+      message: `tier-usage telemetry on but ${path19.basename(log_path)} not yet written \u2014 no signal accumulated`,
       remedy: "run any tracked command to seed the log; the dispatcher writes one record per invocation"
     };
   }
@@ -3893,7 +4800,7 @@ function _check_tier_usage_readiness(project_root) {
     return {
       id: "tier-usage-readiness",
       status: "fail",
-      message: `cannot read ${path15.basename(log_path)}: ${osErrorStr(exc)}`,
+      message: `cannot read ${path19.basename(log_path)}: ${osErrorStr(exc)}`,
       remedy: "fix permissions on the tier-usage log"
     };
   }
@@ -3924,7 +4831,7 @@ function _check_tier_usage_readiness(project_root) {
     return {
       id: "tier-usage-readiness",
       status: "fail",
-      message: `${total} record(s) in ${path15.basename(log_path)} but 0 passed the privacy floor \u2014 report would refuse to render`,
+      message: `${total} record(s) in ${path19.basename(log_path)} but 0 passed the privacy floor \u2014 report would refuse to render`,
       remedy: "inspect the log; the dispatcher is writing records the contract forbids (paths, argv, message bodies)"
     };
   }
@@ -3932,19 +4839,19 @@ function _check_tier_usage_readiness(project_root) {
     return {
       id: "tier-usage-readiness",
       status: "warn",
-      message: `${path15.basename(log_path)} present but empty \u2014 no signal yet`,
+      message: `${path19.basename(log_path)} present but empty \u2014 no signal yet`,
       remedy: "run any tracked command to seed the log"
     };
   }
   return {
     id: "tier-usage-readiness",
     status: "ok",
-    message: `${valid} record(s) past the privacy floor in ${path15.basename(log_path)} \u2014 retiering signal available`,
+    message: `${valid} record(s) past the privacy floor in ${path19.basename(log_path)} \u2014 retiering signal available`,
     remedy: ""
   };
 }
 function readText0(p) {
-  return fs11.readFileSync(p, "utf-8");
+  return fs14.readFileSync(p, "utf-8");
 }
 function osErrorStr(exc) {
   if (exc && typeof exc === "object" && "message" in exc) {
@@ -4117,7 +5024,7 @@ function _epoch_seconds(value) {
 function _codex_auth_expiry(auth_path) {
   let data;
   try {
-    data = JSON.parse(fs11.readFileSync(auth_path, "utf-8"));
+    data = JSON.parse(fs14.readFileSync(auth_path, "utf-8"));
   } catch {
     return null;
   }
@@ -4263,7 +5170,7 @@ function _check_team(project_root) {
   if (binary_missing) {
     remedies.push("install the codex CLI: `npm install -g @openai/codex`");
   }
-  const auth_path = path15.join(_codex_home(), "auth.json");
+  const auth_path = path19.join(_codex_home(), "auth.json");
   const authed = pathExists(auth_path);
   let auth_str;
   if (!authed) {
@@ -4351,7 +5258,7 @@ function _check_unsupported_combos(manifest) {
   };
 }
 function _wizard_state_path() {
-  return path15.join(event4u_root(), "state", "wizard-state.json");
+  return path19.join(event4u_root(), "state", "wizard-state.json");
 }
 function _check_wizard_state() {
   const state_pth = _wizard_state_path();
@@ -4431,7 +5338,7 @@ function _check_wizard_state() {
   };
 }
 function _check_settings_review_pending() {
-  const delta_pth = path15.join(event4u_root(), "state", "settings-delta.json");
+  const delta_pth = path19.join(event4u_root(), "state", "settings-delta.json");
   if (!pathExists(delta_pth)) {
     return {
       id: "settings-review-pending",
@@ -4457,7 +5364,7 @@ function _check_settings_review_pending() {
 }
 function _check_memory_merge_union(project_root) {
   const remedy = "run: npx tsx src/scripts/sync_gitattributes.ts (or `agent-config refresh --project`)";
-  const target = path15.join(project_root, DEFAULT_GITATTRIBUTES);
+  const target = path19.join(project_root, DEFAULT_GITATTRIBUTES);
   if (!pathExists(target)) {
     return {
       id: "memory-merge-union",
@@ -4574,6 +5481,8 @@ function _run_checks(project_root, manifest, drift, only = null) {
     "claude-command-wrappers": _check_claude_command_wrappers,
     "surface-state": _check_surface_state,
     "hook-wiring": _check_hook_wiring,
+    ...wiringRunners({ packageRoot: _package_root(), iterOverrides: () => iter_setting_overrides({ cwd: project_root }) }),
+    ...reachRunners({ projectRoot: project_root, resolvableVersion: _current_package_version() }),
     "stale-orphans": _check_stale_orphans,
     overrides: () => _check_overrides(project_root),
     "rule-scope-drift": () => _check_rule_scope_drift(project_root),
@@ -4642,6 +5551,8 @@ function _run_checks_no_manifest(project_root, bridge_present, only = null) {
     "claude-command-wrappers": _check_claude_command_wrappers,
     "surface-state": _check_surface_state,
     "hook-wiring": _check_hook_wiring,
+    ...wiringRunners({ packageRoot: _package_root(), iterOverrides: () => iter_setting_overrides({ cwd: project_root }) }),
+    ...reachRunners({ projectRoot: project_root, resolvableVersion: _current_package_version() }),
     "stale-orphans": _check_stale_orphans,
     // BOTH registries need the id. Registering only the first one crashed with
     // `runners[cid] is not a function` on a global-only consumer, which is the
@@ -4806,8 +5717,8 @@ var _VALUE_FLAGS = {
   "--repair": "repair"
 };
 function _argError(msg) {
-  process2.stderr.write(USAGE);
-  process2.stderr.write(`${PROG}: error: ${msg}
+  process3.stderr.write(USAGE);
+  process3.stderr.write(`${PROG}: error: ${msg}
 `);
   throw new ArgparseExit(2);
 }
@@ -4827,7 +5738,7 @@ function _parse2(argv) {
   while (i < argv.length) {
     const a = argv[i];
     if (a === "-h" || a === "--help") {
-      process2.stdout.write(USAGE);
+      process3.stdout.write(USAGE);
       throw new ArgparseExit(0);
     }
     const eq = a.startsWith("--") ? a.indexOf("=") : -1;
@@ -4885,14 +5796,14 @@ function argMetaName(flag) {
   return flag;
 }
 function _run_trace_root(opts) {
-  const start = process2.cwd();
+  const start = process3.cwd();
   const [root, anchor, trace] = find_project_root_with_trace(start);
   let origin;
-  if (process2.env[ROOT_OVERRIDE_ENV] === "1" && process2.env[PROJECT_ROOT_ENV]) {
+  if (process3.env[ROOT_OVERRIDE_ENV] === "1" && process3.env[PROJECT_ROOT_ENV]) {
     origin = "root-flag";
   } else if (opts.project) {
     origin = "explicit";
-  } else if (process2.env[PROJECT_ROOT_ENV]) {
+  } else if (process3.env[PROJECT_ROOT_ENV]) {
     origin = "env";
   } else if (root !== null) {
     origin = anchor || "unknown";
@@ -4924,8 +5835,8 @@ function _run_context(opts) {
     origin,
     install_mode: mode,
     install_mode_source: mode_source,
-    env_pin: process2.env[PROJECT_ROOT_ENV] || null,
-    root_override: process2.env[ROOT_OVERRIDE_ENV] === "1",
+    env_pin: process3.env[PROJECT_ROOT_ENV] || null,
+    root_override: process3.env[ROOT_OVERRIDE_ENV] === "1",
     settings_layers: _settings_layer_chain(project_root),
     wrapper: _detect_wrapper(project_root)
   };
@@ -4945,7 +5856,7 @@ function _run_anatomy(opts) {
   try {
     economyReport = economy.buildReport({
       root: economy.DEFAULT_PROJECTS_ROOT,
-      auditDir: path15.join(process2.cwd(), economy.DEFAULT_AUDIT_DIR),
+      auditDir: path19.join(process3.cwd(), economy.DEFAULT_AUDIT_DIR),
       maxAgeDays: 14
     });
   } catch (err) {
@@ -4984,7 +5895,7 @@ function _run_repair(opts) {
     };
     if (exists2) {
       try {
-        fs11.unlinkSync(state_pth);
+        fs14.unlinkSync(state_pth);
       } catch (exc) {
         payload["action"] = "error";
         payload["error"] = osErrorStr(exc);
@@ -5010,8 +5921,8 @@ function _run_repair(opts) {
   eprint(`\u274C  doctor: unknown repair target ${pyRepr(target)}`);
   return 2;
 }
-function main4(argv = null) {
-  const opts = _parse2(argv !== null ? Array.from(argv) : process2.argv.slice(2));
+function main6(argv = null) {
+  const opts = _parse2(argv !== null ? Array.from(argv) : process3.argv.slice(2));
   if (opts.ci) {
     opts.json = true;
   }
@@ -5084,32 +5995,32 @@ function _isCliEntry2() {
   if (bundled && !cliDelegate) {
     return false;
   }
-  if (process2.argv[1] === void 0) {
+  if (process3.argv[1] === void 0) {
     return false;
   }
   if (cliDelegate) {
-    if (path15.basename(process2.argv[1], ".js") === "cmd_doctor") {
+    if (path19.basename(process3.argv[1], ".js") === "cmd_doctor") {
       return true;
     }
   }
-  const argvUrl = pathToFileURL4(path15.resolve(process2.argv[1])).href;
+  const argvUrl = pathToFileURL6(path19.resolve(process3.argv[1])).href;
   if (import.meta.url === argvUrl) {
     return true;
   }
   try {
-    const here = fs11.realpathSync(fileURLToPath5(import.meta.url));
-    const argv = fs11.realpathSync(path15.resolve(process2.argv[1]));
+    const here = fs14.realpathSync(fileURLToPath5(import.meta.url));
+    const argv = fs14.realpathSync(path19.resolve(process3.argv[1]));
     return here === argv;
   } catch {
     return false;
   }
 }
-if (_isCliEntry2() || process2.argv[1] === _HERE5) {
+if (_isCliEntry2() || process3.argv[1] === _HERE5) {
   try {
-    process2.exitCode = main4(process2.argv.slice(2));
+    process3.exitCode = main6(process3.argv.slice(2));
   } catch (e) {
     if (e instanceof ArgparseExit) {
-      process2.exitCode = e.code;
+      process3.exitCode = e.code;
     } else {
       throw e;
     }
@@ -5186,5 +6097,5 @@ export {
   _run_trace_root,
   _run_context,
   _run_repair,
-  main4 as main
+  main6 as main
 };