@event4u/agent-config 9.32.0 → 9.33.0

package/dist/cli-delegate/{chunk-542DZR4P.js → chunk-PMQ6Z3T3.js}

@@ -11,9 +11,14 @@ import {
   codex_plugin_identity
 } from "./chunk-FTAISGDQ.js";
 import {
+  DEFAULT_PROJECTS_ROOT,
+  aggregateByBucket,
+  billableInputTokens,
   config_exports,
-  hardenedSpawnEnv
-} from "./chunk-LVRYBKTI.js";
+  hardenedSpawnEnv,
+  scanTranscripts,
+  weightedInputUnits
+} from "./chunk-YPAWXXXR.js";
 import {
   git_common_dir
 } from "./chunk-PZWRPRWP.js";
@@ -65,13 +70,13 @@ import {
 } from "./chunk-J55WI3RR.js";
 
 // src/scripts/_cli/cmd_doctor.ts
-var YAML = __toESM(require_dist(), 1);
+var YAML2 = __toESM(require_dist(), 1);
 import * as crypto3 from "node:crypto";
-import * as fs6 from "node:fs";
+import * as fs11 from "node:fs";
 import * as os3 from "node:os";
-import * as path7 from "node:path";
+import * as path15 from "node:path";
 import process2 from "node:process";
-import { fileURLToPath as fileURLToPath2, pathToFileURL } from "node:url";
+import { fileURLToPath as fileURLToPath6, pathToFileURL as pathToFileURL4 } from "node:url";
 
 // src/scripts/_lib/duplicate_scope_census.ts
 import * as fs from "node:fs";
@@ -112,6 +117,1442 @@ function censusDuplicateScope(userRulesDir, projectRulesDir) {
   };
 }
 
+// src/scripts/preamble_byte_census.ts
+var preamble_byte_census_exports = {};
+__export(preamble_byte_census_exports, {
+  buildByteCensus: () => buildByteCensus,
+  buildReport: () => buildReport2,
+  censusClaudeMdHierarchy: () => censusClaudeMdHierarchy,
+  censusGlobalProfile: () => censusGlobalProfile,
+  censusRuleDir: () => censusRuleDir,
+  censusSkillsCatalog: () => censusSkillsCatalog,
+  main: () => main2,
+  parseArgs: () => parseArgs2,
+  renderText: () => renderText2,
+  topRulesByCost: () => topRulesByCost
+});
+var YAML = __toESM(require_dist(), 1);
+import * as fs5 from "node:fs";
+import { homedir as homedir2 } from "node:os";
+import * as path8 from "node:path";
+import { fileURLToPath as fileURLToPath3, pathToFileURL as pathToFileURL2 } from "node:url";
+
+// src/scripts/_lib/agent_user_profile.ts
+import * as path4 from "node:path";
+
+// src/scripts/_lib/user_global_revocations.ts
+import * as path2 from "node:path";
+var REVOCATIONS_RELATIVE = path2.join("user", ".revocations.jsonl");
+
+// src/scripts/_lib/user_memory_gate_counters.ts
+import * as path3 from "node:path";
+var GATE_COUNTERS_RELATIVE = path3.join("user", "promotion-gate-counters.json");
+
+// src/scripts/_lib/agent_user_profile.ts
+var GLOBAL_PROFILE_RELATIVE = path4.join("user", "profile.md");
+function resolveGlobalProfilePath(env) {
+  return resolve_with_fallback(GLOBAL_PROFILE_RELATIVE, { env: env ?? null });
+}
+
+// src/scripts/_lib/carrier_divergence.ts
+import * as fs2 from "node:fs";
+import * as path5 from "node:path";
+var OWNERSHIP_KEYS = ["package", "source_path"];
+function stripOwnershipKeys(text) {
+  return text.split("\n").filter((line) => !OWNERSHIP_KEYS.some((k) => line.startsWith(`${k}:`))).join("\n");
+}
+function comparePair(a, b) {
+  if (a.equals(b)) {
+    return "identical";
+  }
+  if (stripOwnershipKeys(a.toString("utf-8")) === stripOwnershipKeys(b.toString("utf-8"))) {
+    return "provenance-only";
+  }
+  return "body-diff";
+}
+function splitFrontmatter(text) {
+  if (!text.startsWith("---")) return { hadFrontmatter: false, frontmatter: "", body: text };
+  const end = text.indexOf("\n---", 3);
+  if (end === -1) return { hadFrontmatter: false, frontmatter: "", body: text };
+  const afterFence = text.indexOf("\n", end + 1);
+  return {
+    hadFrontmatter: true,
+    frontmatter: text.slice(3, end),
+    body: afterFence === -1 ? "" : text.slice(afterFence + 1)
+  };
+}
+function proseEqual(a, b) {
+  const sa = splitFrontmatter(a);
+  const sb = splitFrontmatter(b);
+  if (!sa.hadFrontmatter && !sb.hadFrontmatter) return false;
+  const leading = /^\n+/;
+  return sa.body.replace(leading, "") === sb.body.replace(leading, "");
+}
+function frontmatterPaths(text) {
+  const { hadFrontmatter, frontmatter } = splitFrontmatter(text);
+  if (!hadFrontmatter) return null;
+  const lines = frontmatter.split("\n");
+  const start = lines.findIndex((l) => /^paths:/.test(l));
+  if (start === -1) return null;
+  const block = [lines[start]];
+  for (const line of lines.slice(start + 1)) {
+    if (/^\s/.test(line) && line.trim() !== "") block.push(line);
+    else break;
+  }
+  return block.map((l) => l.trim()).join(" ");
+}
+function censusRuleDir(dir) {
+  let files = 0;
+  let chars = 0;
+  let entries;
+  try {
+    entries = fs2.readdirSync(dir);
+  } catch {
+    return { files: 0, chars: 0 };
+  }
+  for (const name of entries) {
+    if (!name.endsWith(".md")) continue;
+    try {
+      chars += fs2.statSync(path5.join(dir, name)).size;
+      files += 1;
+    } catch {
+    }
+  }
+  return { files, chars };
+}
+
+// src/scripts/cache_realization_report.ts
+import { execFileSync } from "node:child_process";
+import * as fs4 from "node:fs";
+import { homedir } from "node:os";
+import * as path7 from "node:path";
+import { fileURLToPath as fileURLToPath2, pathToFileURL } from "node:url";
+
+// src/scripts/ai_council/pricing.ts
+import * as fs3 from "node:fs";
+import * as path6 from "node:path";
+import { fileURLToPath } from "node:url";
+
+// src/scripts/ai_council/_default_prices.ts
+var LAST_UPDATED = "2026-05-14";
+var DEFAULT_PRICES_ENTRIES = [
+  // ── Anthropic ────────────────────────────────────────────────────
+  ["anthropic", "claude-sonnet-4-5", 3, 15],
+  ["anthropic", "claude-opus-4-1", 15, 75],
+  ["anthropic", "claude-haiku-4-5", 1, 5],
+  // ── OpenAI ───────────────────────────────────────────────────────
+  ["openai", "gpt-4o", 2.5, 10],
+  ["openai", "gpt-4o-mini", 0.15, 0.6],
+  ["openai", "o1", 15, 60],
+  ["openai", "o3-mini", 1.1, 4.4],
+  // ── Google Gemini ────────────────────────────────────────────────
+  ["gemini", "gemini-2.5-pro", 1.25, 10],
+  ["gemini", "gemini-2.5-flash", 0.3, 2.5],
+  // ── xAI Grok ─────────────────────────────────────────────────────
+  ["xai", "grok-4", 3, 15],
+  ["xai", "grok-3-mini", 0.3, 0.5],
+  // ── Perplexity ───────────────────────────────────────────────────
+  ["perplexity", "sonar-pro", 3, 15],
+  ["perplexity", "sonar", 1, 1]
+];
+function priceKey(provider, model) {
+  return `${provider} ${model}`;
+}
+var DEFAULT_PRICES = new Map(
+  DEFAULT_PRICES_ENTRIES.map(([p, m, i, o]) => [priceKey(p, m), [i, o]])
+);
+function as_rows() {
+  return [...DEFAULT_PRICES_ENTRIES].map(([p, m, i, o]) => [p, m, i, o]).sort((a, b) => {
+    if (a[0] !== b[0]) {
+      return a[0] < b[0] ? -1 : 1;
+    }
+    if (a[1] !== b[1]) {
+      return a[1] < b[1] ? -1 : 1;
+    }
+    return 0;
+  });
+}
+
+// src/scripts/ai_council/pricing.ts
+var _HERE = fileURLToPath(import.meta.url);
+var REPO_ROOT = path6.resolve(path6.dirname(_HERE), "..", "..", "..");
+var PRICES_FILE = path6.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) {
+    return exact;
+  }
+  const prefix = priceKey(provider, "");
+  let best = null;
+  let bestLen = -1;
+  for (const [key, price] of table.prices) {
+    if (!key.startsWith(prefix)) {
+      continue;
+    }
+    const candidate = key.slice(prefix.length);
+    if (!candidate || !model.startsWith(candidate)) {
+      continue;
+    }
+    const next = model.charAt(candidate.length);
+    if (next !== "" && next !== "-" && next !== "." && next !== ":" && next !== "@") {
+      continue;
+    }
+    if (candidate.length > bestLen) {
+      best = price;
+      bestLen = candidate.length;
+    }
+  }
+  return best;
+}
+var CACHE_READ_MULTIPLIER = 0.1;
+var CACHE_WRITE_MULTIPLIER_5M = 1.25;
+var CACHE_WRITE_MULTIPLIER_1H = 2;
+function reprice_with_cache(provider, model, tokens, table, ttl = "5m") {
+  const price = lookup(table, provider, model);
+  const read = tokens.cache_read_input_tokens ?? 0;
+  const write = tokens.cache_creation_input_tokens ?? 0;
+  const totalInput = tokens.input_tokens + read + write;
+  if (price === null) {
+    return {
+      provider,
+      model,
+      input_tokens: totalInput,
+      output_tokens: tokens.output_tokens,
+      input_usd: 0,
+      output_usd: 0
+    };
+  }
+  const writeMult = ttl === "1h" ? CACHE_WRITE_MULTIPLIER_1H : CACHE_WRITE_MULTIPLIER_5M;
+  const inputUsd = tokens.input_tokens / 1e6 * price.input_per_1m_usd + read / 1e6 * price.input_per_1m_usd * CACHE_READ_MULTIPLIER + write / 1e6 * price.input_per_1m_usd * writeMult;
+  const outputUsd = tokens.output_tokens / 1e6 * price.output_per_1m_usd;
+  return {
+    provider,
+    model,
+    input_tokens: totalInput,
+    output_tokens: tokens.output_tokens,
+    input_usd: inputUsd,
+    output_usd: outputUsd
+  };
+}
+function load_prices(p = PRICES_FILE) {
+  if (!fs3.existsSync(p)) {
+    bootstrap_from_defaults(p);
+  }
+  return _parse(fs3.readFileSync(p, "utf-8"));
+}
+function bootstrap_from_defaults(p = PRICES_FILE) {
+  fs3.mkdirSync(path6.dirname(p), { recursive: true });
+  const rows = as_rows();
+  const body = _render_markdown(LAST_UPDATED, "shipped-default", rows);
+  fs3.writeFileSync(p, body, "utf-8");
+}
+function _fmt62f(x) {
+  const s = x.toFixed(2);
+  return s.length >= 6 ? s : " ".repeat(6 - s.length) + s;
+}
+function _ljust(s, width) {
+  return s.length >= width ? s : s + " ".repeat(width - s.length);
+}
+function _render_markdown(lastUpdated, source, rows) {
+  const lines = [
+    "---",
+    `last_updated: ${lastUpdated}`,
+    "currency: USD",
+    "unit: per_1M_tokens",
+    `source: ${source}`,
+    "---",
+    "",
+    "# Agent prices",
+    "",
+    "| provider  | model               | input  | output |",
+    "|-----------|---------------------|--------|--------|"
+  ];
+  for (const [provider, model, inp, outp] of rows) {
+    lines.push(`| ${_ljust(provider, 9)} | ${_ljust(model, 19)} | ${_fmt62f(inp)} | ${_fmt62f(outp)} |`);
+  }
+  lines.push("");
+  return lines.join("\n");
+}
+function _parse(text) {
+  const [front, body] = _split_frontmatter(text);
+  const meta = _parse_frontmatter(front);
+  const prices = _parse_table(body);
+  return {
+    last_updated: meta.last_updated ?? "1970-01-01",
+    currency: meta.currency ?? "USD",
+    unit: meta.unit ?? "per_1M_tokens",
+    source: meta.source ?? "unknown",
+    prices
+  };
+}
+function _split_frontmatter(text) {
+  if (!text.startsWith("---")) {
+    return ["", text];
+  }
+  const parts = _pySplit(text, "---", 2);
+  if (parts.length < 3) {
+    return ["", text];
+  }
+  return [parts[1], parts[2]];
+}
+function _pySplit(s, sep3, maxsplit) {
+  const out = [];
+  let rest = s;
+  let n = 0;
+  while (n < maxsplit) {
+    const idx = rest.indexOf(sep3);
+    if (idx === -1) {
+      break;
+    }
+    out.push(rest.slice(0, idx));
+    rest = rest.slice(idx + sep3.length);
+    n++;
+  }
+  out.push(rest);
+  return out;
+}
+function _parse_frontmatter(front) {
+  const out = {};
+  for (let line of front.split("\n")) {
+    line = line.trim();
+    if (!line || !line.includes(":")) {
+      continue;
+    }
+    const idx = line.indexOf(":");
+    out[line.slice(0, idx).trim()] = line.slice(idx + 1).trim();
+  }
+  return out;
+}
+function _parse_table(body) {
+  const out = /* @__PURE__ */ new Map();
+  for (let line of body.split("\n")) {
+    line = line.trim();
+    if (!line.startsWith("|") || line.startsWith("|--") || line.startsWith("|-")) {
+      continue;
+    }
+    const stripped = line.replace(/^\|+/, "").replace(/\|+$/, "");
+    const cells = stripped.split("|").map((c) => c.trim());
+    if (cells.length !== 4) {
+      continue;
+    }
+    const [provider, model, inp, outp] = cells;
+    if (provider === "provider") {
+      continue;
+    }
+    const inV = _pyFloat(inp);
+    const outV = _pyFloat(outp);
+    if (inV === null || outV === null) {
+      continue;
+    }
+    out.set(priceKey(provider, model), {
+      provider,
+      model,
+      input_per_1m_usd: inV,
+      output_per_1m_usd: outV
+    });
+  }
+  return out;
+}
+function _pyFloat(s) {
+  const t = s.trim();
+  if (t === "") {
+    return null;
+  }
+  const n = Number(t);
+  return Number.isNaN(n) ? null : n;
+}
+
+// src/scripts/cache_realization_report.ts
+var _HERE2 = fileURLToPath2(import.meta.url);
+var REPO_ROOT2 = path7.resolve(path7.dirname(_HERE2), "..", "..");
+var C1_COLD_START_DOMINANCE_THRESHOLD = 0.5;
+var C2_DUPLICATE_SCOPE_THRESHOLD = 0.25;
+var C4_COUNCIL_MISPRICING_THRESHOLD = 0.05;
+var C5_CONFIRM_RATIO = 0.1;
+var C5_FALSIFY_RATIO = 0.5;
+var DRIFT_READ_SHARE_FLOOR = 0.9;
+var DRIFT_COLD_START_SHARE_FLOOR = 0.5;
+function median(nums) {
+  if (nums.length === 0) return 0;
+  const sorted = [...nums].sort((a, b) => a - b);
+  const mid = Math.floor(sorted.length / 2);
+  return sorted.length % 2 === 0 ? (sorted[mid - 1] + sorted[mid]) / 2 : sorted[mid];
+}
+function mean(nums) {
+  if (nums.length === 0) return 0;
+  return nums.reduce((a, b) => a + b, 0) / nums.length;
+}
+function firstCallsByLeg(records) {
+  const byAgent = /* @__PURE__ */ new Map();
+  for (const r of records) {
+    if (r.bucket !== "subagent" || r.agentId === null) continue;
+    const arr = byAgent.get(r.agentId) ?? [];
+    arr.push(r);
+    byAgent.set(r.agentId, arr);
+  }
+  const firstCalls = [];
+  for (const arr of byAgent.values()) {
+    const sorted = arr.map((r, idx) => ({ r, idx })).sort((a, b) => {
+      const ta = a.r.timestamp;
+      const tb = b.r.timestamp;
+      if (ta !== null && tb !== null && ta !== tb) return ta < tb ? -1 : 1;
+      if (ta !== null && tb === null) return -1;
+      if (ta === null && tb !== null) return 1;
+      return a.idx - b.idx;
+    }).map((x) => x.r);
+    firstCalls.push(sorted[0]);
+  }
+  return firstCalls;
+}
+function computeColdStarts(records) {
+  const subagentRecords = records.filter((r) => r.bucket === "subagent");
+  const totalWriteVolume = subagentRecords.reduce((s, r) => s + r.usage.cache_creation_input_tokens, 0);
+  const firstCalls = firstCallsByLeg(records);
+  const writtenOrUncached = firstCalls.map((r) => r.usage.cache_creation_input_tokens + r.usage.input_tokens);
+  const sumFirstCallRead = firstCalls.reduce((s, r) => s + r.usage.cache_read_input_tokens, 0);
+  const sumFirstCallBillable = firstCalls.reduce((s, r) => s + billableInputTokens(r.usage), 0);
+  const sumFirstCallWrite = firstCalls.reduce((s, r) => s + r.usage.cache_creation_input_tokens, 0);
+  const sumBillable = subagentRecords.reduce((s, r) => s + billableInputTokens(r.usage), 0);
+  const sumWrite = totalWriteVolume;
+  const sumRead = subagentRecords.reduce((s, r) => s + r.usage.cache_read_input_tokens, 0);
+  const sumUncached = subagentRecords.reduce((s, r) => s + r.usage.input_tokens, 0);
+  return {
+    legs: firstCalls.length,
+    median_first_call_written_or_uncached: median(writtenOrUncached),
+    mean_first_call_written_or_uncached: mean(writtenOrUncached),
+    first_call_cache_read_share: sumFirstCallBillable > 0 ? sumFirstCallRead / sumFirstCallBillable : 0,
+    cold_start_share_of_write_volume: totalWriteVolume > 0 ? sumFirstCallWrite / totalWriteVolume : 0,
+    write_share_of_billable: sumBillable > 0 ? sumWrite / sumBillable : 0,
+    read_share_of_billable: sumBillable > 0 ? sumRead / sumBillable : 0,
+    uncached_share_of_billable: sumBillable > 0 ? sumUncached / sumBillable : 0
+  };
+}
+function aggregateByAgent(records) {
+  const byAgent = /* @__PURE__ */ new Map();
+  for (const r of records) {
+    if (r.bucket !== "subagent" || r.agentId === null) continue;
+    const arr = byAgent.get(r.agentId) ?? [];
+    arr.push(r);
+    byAgent.set(r.agentId, arr);
+  }
+  const out = [];
+  for (const [agentId, recs] of byAgent) {
+    const agg = aggregateByBucket(recs).subagent;
+    out.push({ ...agg, agentId });
+  }
+  return out;
+}
+function computeDuplicateScope(userRulesDir, projectRulesDir, subagentWriteVolume, spawnCount) {
+  const census = censusDuplicateScope(userRulesDir, projectRulesDir);
+  if (!census.evaluable) {
+    return {
+      evaluable: false,
+      reason: census.reason,
+      shared_filenames: census.shared_filenames.length,
+      duplicate_tokens_per_spawn: 0,
+      spawn_count: spawnCount,
+      duplicate_token_estimate_total: 0,
+      share_of_subagent_write_volume: 0
+    };
+  }
+  const duplicateTokensPerSpawn = census.duplicate_chars / 4;
+  const totalEstimate = duplicateTokensPerSpawn * spawnCount;
+  const evaluable = spawnCount > 0 && subagentWriteVolume > 0;
+  return {
+    evaluable,
+    reason: evaluable ? void 0 : "no subagent legs or no subagent write volume observed in the window",
+    shared_filenames: census.shared_filenames.length,
+    duplicate_tokens_per_spawn: duplicateTokensPerSpawn,
+    spawn_count: spawnCount,
+    duplicate_token_estimate_total: totalEstimate,
+    share_of_subagent_write_volume: subagentWriteVolume > 0 ? totalEstimate / subagentWriteVolume : 0
+  };
+}
+function findDebateRoundFiles(councilRoot) {
+  const base = path7.join(councilRoot, "agents", "runtime", "council", "responses");
+  if (!fs4.existsSync(base)) return [];
+  const out = [];
+  const stack = [base];
+  while (stack.length > 0) {
+    const dir = stack.pop();
+    let entries;
+    try {
+      entries = fs4.readdirSync(dir, { withFileTypes: true });
+    } catch {
+      continue;
+    }
+    for (const entry of entries) {
+      const full = path7.join(dir, entry.name);
+      if (entry.isDirectory()) {
+        stack.push(full);
+        continue;
+      }
+      if (entry.isFile() && /^debate-round-\d+\.json$/.test(entry.name)) out.push(full);
+    }
+  }
+  return out;
+}
+function numOrUndef(v) {
+  return typeof v === "number" && Number.isFinite(v) ? v : void 0;
+}
+function computeCouncilMispricing(councilRoot) {
+  const files = findDebateRoundFiles(councilRoot);
+  if (files.length === 0) {
+    return {
+      status: "pending",
+      reason: "no agents/runtime/council/responses/**/debate-round-*.json artefact found under this root"
+    };
+  }
+  const groups = /* @__PURE__ */ new Map();
+  for (const f of files) {
+    const dir = path7.dirname(f);
+    const arr = groups.get(dir) ?? [];
+    arr.push(f);
+    groups.set(dir, arr);
+  }
+  let table;
+  try {
+    table = load_prices();
+  } catch {
+    return { status: "pending", reason: "could not load the local price table (.agent-prices.md)" };
+  }
+  let best = null;
+  for (const [dir, groupFiles] of groups) {
+    let rounds = 0;
+    let recorded = 0;
+    let cacheAware = 0;
+    let tokens = 0;
+    let cacheVolume = 0;
+    for (const f of groupFiles) {
+      let data;
+      try {
+        data = JSON.parse(fs4.readFileSync(f, "utf-8"));
+      } catch {
+        continue;
+      }
+      rounds = Math.max(rounds, numOrUndef(data.debate_total_rounds) ?? 0);
+      recorded += numOrUndef(data.cost_usd_actual) ?? 0;
+      for (const r of data.responses ?? []) {
+        if (r.error) continue;
+        const input = numOrUndef(r.input_tokens) ?? 0;
+        const output = numOrUndef(r.output_tokens) ?? 0;
+        const read = numOrUndef(r.cache_read_input_tokens) ?? 0;
+        const write = numOrUndef(r.cache_creation_input_tokens) ?? 0;
+        tokens += input + read + write;
+        cacheVolume += read + write;
+        if (typeof r.provider !== "string" || typeof r.model !== "string") continue;
+        const est = reprice_with_cache(
+          r.provider,
+          r.model,
+          { input_tokens: input, cache_read_input_tokens: read, cache_creation_input_tokens: write, output_tokens: output },
+          table,
+          "5m"
+        );
+        cacheAware += est.input_usd + est.output_usd;
+      }
+    }
+    if (rounds < 2 || tokens === 0 || recorded === 0) continue;
+    if (best === null || cacheVolume > best.cacheVolume || cacheVolume === best.cacheVolume && rounds > best.rounds || cacheVolume === best.cacheVolume && rounds === best.rounds && tokens > best.tokens) {
+      best = { dir, rounds, recorded, cacheAware, tokens, cacheVolume };
+    }
+  }
+  if (best === null) {
+    return {
+      status: "pending",
+      reason: "found debate-round artefacts, but none had \u22652 recorded rounds with non-error usage and a non-zero recorded cost"
+    };
+  }
+  const deltaPct = (best.cacheAware - best.recorded) / best.recorded;
+  const status = Math.abs(deltaPct) >= C4_COUNCIL_MISPRICING_THRESHOLD ? "confirmed" : "falsified";
+  return {
+    status,
+    session: path7.relative(councilRoot, best.dir) || "(top-level)",
+    rounds: best.rounds,
+    recorded_cost_usd: best.recorded,
+    cache_aware_cost_usd: best.cacheAware,
+    delta_pct: deltaPct
+  };
+}
+function encodeProjectPath(cwd) {
+  return cwd.replace(/[/.]/g, "-");
+}
+function listGitWorktrees(cwd) {
+  try {
+    const out = execFileSync("git", ["worktree", "list", "--porcelain"], { cwd, encoding: "utf-8", timeout: 1e4 });
+    const paths = [];
+    for (const line of out.split("\n")) {
+      if (line.startsWith("worktree ")) paths.push(line.slice("worktree ".length).trim());
+    }
+    return paths;
+  } catch {
+    return [];
+  }
+}
+function computeWorktreeFragmentation(projectsRoot, worktreePaths, maxAgeDays) {
+  if (worktreePaths.length < 2) {
+    return { status: "pending", reason: "fewer than 2 git worktrees found for this repo \u2014 nothing to compare" };
+  }
+  const established = worktreePaths[0];
+  const encodedEstablished = encodeProjectPath(established);
+  const worktreeDirs = worktreePaths.slice(1).map(encodeProjectPath).filter((d) => fs4.existsSync(path7.join(projectsRoot, d)));
+  if (!fs4.existsSync(path7.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"
+    };
+  }
+  const establishedScan = scanTranscripts({ root: projectsRoot, projectDir: encodedEstablished, maxAgeDays });
+  const establishedColdStart = computeColdStarts(establishedScan.records);
+  let worktreeRecords = [];
+  for (const d of worktreeDirs) {
+    worktreeRecords = worktreeRecords.concat(scanTranscripts({ root: projectsRoot, projectDir: d, maxAgeDays }).records);
+  }
+  const worktreeColdStart = computeColdStarts(worktreeRecords);
+  if (establishedColdStart.legs === 0 || worktreeColdStart.legs === 0) {
+    return {
+      status: "pending",
+      reason: `insufficient subagent legs in the ${maxAgeDays}-day window (established: ${establishedColdStart.legs}, worktrees: ${worktreeColdStart.legs})`,
+      established_project_dir: encodedEstablished,
+      worktree_project_dirs: worktreeDirs
+    };
+  }
+  const establishedShare = establishedColdStart.first_call_cache_read_share;
+  const worktreeShare = worktreeColdStart.first_call_cache_read_share;
+  const ratio = establishedShare > 0 ? worktreeShare / establishedShare : worktreeShare === 0 ? 0 : Number.POSITIVE_INFINITY;
+  if (!Number.isFinite(ratio)) {
+    return {
+      status: "pending",
+      reason: "established directory shows a zero first-call cache-read share \u2014 the comparison ratio is undefined",
+      established_project_dir: encodedEstablished,
+      worktree_project_dirs: worktreeDirs,
+      established_first_call_read_share: establishedShare,
+      worktree_first_call_read_share: worktreeShare
+    };
+  }
+  let status;
+  let reason;
+  if (ratio >= C5_FALSIFY_RATIO) {
+    status = "falsified";
+  } else if (ratio < C5_CONFIRM_RATIO) {
+    status = "confirmed";
+  } else {
+    status = "pending";
+    reason = `ratio ${(ratio * 100).toFixed(1)}% falls between the confirm (<10%) and falsify (>=50%) thresholds`;
+  }
+  return {
+    status,
+    reason,
+    established_project_dir: encodedEstablished,
+    worktree_project_dirs: worktreeDirs,
+    established_first_call_read_share: establishedShare,
+    worktree_first_call_read_share: worktreeShare,
+    ratio
+  };
+}
+function hostVersion() {
+  try {
+    const out = execFileSync("claude", ["--version"], { encoding: "utf-8", timeout: 5e3 }).trim();
+    return out.length > 0 ? out : "unknown";
+  } catch {
+    return "unknown";
+  }
+}
+function buildClaims(opts) {
+  const claims = [];
+  const c1Value = opts.subagentColdStart.cold_start_share_of_write_volume;
+  claims.push({
+    id: "C-1",
+    description: "cold-start dominance: cold starts are \u226550% of subagent write volume (baseline 69.4%)",
+    threshold: ">= 0.50",
+    verdict: opts.subagentColdStart.legs === 0 ? "pending" : c1Value >= C1_COLD_START_DOMINANCE_THRESHOLD ? "confirmed" : "falsified",
+    measured: opts.subagentColdStart.legs === 0 ? void 0 : c1Value,
+    reason: opts.subagentColdStart.legs === 0 ? "no subagent legs observed in the window" : void 0
+  });
+  const d = opts.duplicateScope;
+  claims.push({
+    id: "C-2",
+    description: "duplicate-scope share: the redundant rule-set copy is \u226525% of subagent write volume (baseline \u224837%)",
+    threshold: ">= 0.25",
+    verdict: !d.evaluable ? "pending" : d.share_of_subagent_write_volume >= C2_DUPLICATE_SCOPE_THRESHOLD ? "confirmed" : "falsified",
+    measured: d.evaluable ? d.share_of_subagent_write_volume : void 0,
+    reason: !d.evaluable ? d.reason : void 0
+  });
+  claims.push({
+    id: "C-3",
+    description: "preamble reducibility: a shipped reduction moves median cold-start tokens by \u226515% with no eval regression",
+    threshold: ">= 0.15",
+    verdict: "pending",
+    reason: "requires an implemented preamble-reduction intervention (Phase 3) \u2014 none has landed yet"
+  });
+  const c = opts.councilMispricing;
+  claims.push({
+    id: "C-4",
+    description: "council mispricing magnitude: cache-aware repricing changes a real multi-round debate\u2019s realized cost by \u22655%",
+    threshold: ">= 0.05 (absolute delta)",
+    verdict: c.status,
+    measured: c.delta_pct,
+    reason: c.reason
+  });
+  const w = opts.worktreeFragmentation;
+  claims.push({
+    id: "C-5",
+    description: "worktree fragmentation: a fresh worktree's first-call cache_read share is <10% of an established directory's (falsified at >=50%)",
+    threshold: "< 0.10 confirmed / >= 0.50 falsified",
+    verdict: w.status,
+    measured: w.ratio,
+    reason: w.reason
+  });
+  return claims;
+}
+function defaultOptions() {
+  return {
+    format: "text",
+    root: DEFAULT_PROJECTS_ROOT,
+    maxAgeDays: 14,
+    repoRoot: REPO_ROOT2,
+    councilRoot: REPO_ROOT2,
+    userRulesDir: path7.join(homedir(), ".claude", "rules"),
+    projectRulesDir: path7.join(REPO_ROOT2, "dist", "agent-src", "rules")
+  };
+}
+function parseArgs(argv) {
+  const opts = defaultOptions();
+  for (let i = 0; i < argv.length; i++) {
+    const a = argv[i];
+    if (a === void 0) continue;
+    if (a === "--format") opts.format = argv[++i] ?? opts.format;
+    else if (a.startsWith("--format=")) opts.format = a.slice("--format=".length);
+    else if (a === "--root") opts.root = argv[++i] ?? opts.root;
+    else if (a.startsWith("--root=")) opts.root = a.slice("--root=".length);
+    else if (a === "--max-age-days") opts.maxAgeDays = Number(argv[++i]) || opts.maxAgeDays;
+    else if (a.startsWith("--max-age-days=")) opts.maxAgeDays = Number(a.slice("--max-age-days=".length)) || opts.maxAgeDays;
+    else if (a === "--repo-root") opts.repoRoot = argv[++i] ?? opts.repoRoot;
+    else if (a.startsWith("--repo-root=")) opts.repoRoot = a.slice("--repo-root=".length);
+    else if (a === "--council-root") opts.councilRoot = argv[++i] ?? opts.councilRoot;
+    else if (a.startsWith("--council-root=")) opts.councilRoot = a.slice("--council-root=".length);
+    else if (a === "--user-rules-dir") opts.userRulesDir = argv[++i] ?? opts.userRulesDir;
+    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);
+  }
+  if (opts.format !== "text" && opts.format !== "json") opts.format = "text";
+  return opts;
+}
+function buildReport(opts) {
+  const scan = scanTranscripts({ root: opts.root, maxAgeDays: opts.maxAgeDays });
+  const buckets = aggregateByBucket(scan.records);
+  const subagentColdStart = computeColdStarts(scan.records);
+  const byAgent = aggregateByAgent(scan.records);
+  const duplicateScope = computeDuplicateScope(
+    opts.userRulesDir,
+    opts.projectRulesDir,
+    buckets.subagent.cache_creation_input_tokens,
+    subagentColdStart.legs
+  );
+  const councilMispricing = computeCouncilMispricing(opts.councilRoot);
+  const worktreePaths = listGitWorktrees(opts.repoRoot);
+  const worktreeFragmentation = computeWorktreeFragmentation(opts.root, worktreePaths, opts.maxAgeDays);
+  const claims = buildClaims({ subagentColdStart, duplicateScope, councilMispricing, worktreeFragmentation });
+  return {
+    schema: "cache-realization-report/v1",
+    host_version: hostVersion(),
+    window_days: opts.maxAgeDays,
+    root: opts.root,
+    metric_definition: {
+      billable_input: "input_tokens + cache_read_input_tokens + cache_creation_input_tokens",
+      note: "Anthropic's usage.input_tokens EXCLUDES cache tokens \u2014 it is only the uncached portion of the prompt."
+    },
+    dedup_ratio: scan.dedup_ratio,
+    total_seen: scan.totalSeen,
+    deduped_count: scan.dedupedCount,
+    buckets,
+    subagent_cold_start: subagentColdStart,
+    by_agent: byAgent,
+    duplicate_scope: duplicateScope,
+    council_mispricing: councilMispricing,
+    worktree_fragmentation: worktreeFragmentation,
+    claims
+  };
+}
+function pct(v) {
+  return `${(v * 100).toFixed(1)}%`;
+}
+function renderText(r) {
+  const out = [];
+  out.push("Cache-realization report");
+  out.push(`  host_version: ${r.host_version}`);
+  out.push(`  window: last ${r.window_days} days`);
+  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("");
+  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(
+      `    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}`
+    );
+  }
+  out.push("");
+  const cs = r.subagent_cold_start;
+  out.push("Subagent cold start (first call per leg):");
+  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(
+    `  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)`
+  );
+  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("");
+  out.push("Pre-registered claims:");
+  for (const c of r.claims) {
+    const measured = c.measured !== void 0 ? ` (measured ${pct(c.measured)})` : "";
+    const reasonSuffix = c.verdict === "pending" && c.reason ? ` \u2014 ${c.reason}` : "";
+    out.push(`  ${c.id} [${c.verdict}]${measured}: ${c.description}${reasonSuffix}`);
+  }
+  out.push("");
+  out.push("Re-verification:");
+  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)}`
+  );
+  return out.join("\n");
+}
+function main(argv = process.argv.slice(2)) {
+  const opts = parseArgs(argv);
+  const report = buildReport(opts);
+  if (opts.format === "json") {
+    process.stdout.write(JSON.stringify(report, null, 2) + "\n");
+  } else {
+    process.stdout.write(renderText(report) + "\n");
+  }
+  return 0;
+}
+if (process.argv[1] !== void 0) {
+  const invokedUrl = pathToFileURL(path7.resolve(process.argv[1])).href;
+  if (import.meta.url === invokedUrl) process.exit(main());
+}
+
+// src/scripts/preamble_byte_census.ts
+var _HERE3 = fileURLToPath3(import.meta.url);
+var REPO_ROOT3 = path8.resolve(path8.dirname(_HERE3), "..", "..");
+var CHARS_PER_TOKEN = 4;
+var SUM_TOLERANCE_PCT = 0.1;
+function tokensFromChars(chars) {
+  return chars / CHARS_PER_TOKEN;
+}
+function readCharsIfExists(p) {
+  try {
+    return fs5.statSync(p).size;
+  } catch {
+    return 0;
+  }
+}
+function topRulesByCost(dir, limit = 10) {
+  if (!fs5.existsSync(dir)) return [];
+  const entries = [];
+  for (const name of fs5.readdirSync(dir)) {
+    if (!name.endsWith(".md")) continue;
+    let chars;
+    try {
+      chars = fs5.statSync(path8.join(dir, name)).size;
+    } catch {
+      continue;
+    }
+    entries.push({ file: name, chars, tokens_estimate: tokensFromChars(chars) });
+  }
+  entries.sort((a, b) => b.chars - a.chars || a.file.localeCompare(b.file));
+  return entries.slice(0, limit);
+}
+var IMPORT_LINE_RE = /^@(\S+)\s*$/;
+function parseClaudeMdImports(claudeMdPath) {
+  let text;
+  try {
+    text = fs5.readFileSync(claudeMdPath, "utf-8");
+  } catch {
+    return [];
+  }
+  const base = path8.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 = path8.isAbsolute(rel) ? rel : path8.join(base, rel);
+    const chars = readCharsIfExists(resolved);
+    if (chars > 0) out.push({ file: rel, chars });
+  }
+  return out;
+}
+function censusClaudeMdHierarchy(repoRoot, userHome) {
+  const projectClaudeMd = path8.join(repoRoot, "CLAUDE.md");
+  const projectClaudeLocalMd = path8.join(repoRoot, "CLAUDE.local.md");
+  const userClaudeMd = path8.join(userHome, ".claude", "CLAUDE.md");
+  return {
+    project_claude_md_chars: readCharsIfExists(projectClaudeMd),
+    project_claude_md_present: fs5.existsSync(projectClaudeMd),
+    project_claude_local_md_chars: readCharsIfExists(projectClaudeLocalMd),
+    project_claude_local_md_present: fs5.existsSync(projectClaudeLocalMd),
+    user_claude_md_chars: readCharsIfExists(userClaudeMd),
+    user_claude_md_present: fs5.existsSync(userClaudeMd),
+    user_imports: parseClaudeMdImports(userClaudeMd)
+  };
+}
+function censusGlobalProfile(env) {
+  const p = resolveGlobalProfilePath(env);
+  if (p === null) return { present: false, chars: 0, path: null };
+  return { present: true, chars: readCharsIfExists(p), path: p };
+}
+function parseFrontmatter(text) {
+  if (!text.startsWith("---")) return {};
+  const end = text.indexOf("\n---", 3);
+  if (end === -1) return {};
+  const block = text.slice(3, end);
+  try {
+    const parsed = YAML.parse(block);
+    return typeof parsed === "object" && parsed !== null ? parsed : {};
+  } catch {
+    return {};
+  }
+}
+function censusSkillsCatalog(skillsDir) {
+  if (!fs5.existsSync(skillsDir)) return { skills: 0, chars: 0 };
+  let skills = 0;
+  let chars = 0;
+  for (const entry of fs5.readdirSync(skillsDir, { withFileTypes: true })) {
+    if (!entry.isDirectory()) continue;
+    const skillMd = path8.join(skillsDir, entry.name, "SKILL.md");
+    let text;
+    try {
+      text = fs5.readFileSync(skillMd, "utf-8");
+    } catch {
+      continue;
+    }
+    const fm = parseFrontmatter(text);
+    const name = typeof fm.name === "string" && fm.name.length > 0 ? fm.name : entry.name;
+    const description = typeof fm.description === "string" ? fm.description : "";
+    chars += `- ${name}: ${description}
+`.length;
+    skills += 1;
+  }
+  return { skills, chars };
+}
+function defaultOptions2() {
+  const userHome = homedir2();
+  return {
+    format: "text",
+    repoRoot: REPO_ROOT3,
+    userHome,
+    userRulesDir: path8.join(userHome, ".claude", "rules"),
+    projectRulesDir: path8.join(REPO_ROOT3, "dist", "agent-src", "rules"),
+    skillsDir: path8.join(REPO_ROOT3, "dist", "agent-src", "skills"),
+    root: DEFAULT_PROJECTS_ROOT,
+    maxAgeDays: 14
+  };
+}
+function parseArgs2(argv) {
+  const opts = defaultOptions2();
+  for (let i = 0; i < argv.length; i++) {
+    const a = argv[i];
+    if (a === void 0) continue;
+    if (a === "--format") opts.format = argv[++i] ?? opts.format;
+    else if (a.startsWith("--format=")) opts.format = a.slice("--format=".length);
+    else if (a === "--repo-root") opts.repoRoot = argv[++i] ?? opts.repoRoot;
+    else if (a.startsWith("--repo-root=")) opts.repoRoot = a.slice("--repo-root=".length);
+    else if (a === "--user-home") opts.userHome = argv[++i] ?? opts.userHome;
+    else if (a.startsWith("--user-home=")) opts.userHome = a.slice("--user-home=".length);
+    else if (a === "--user-rules-dir") opts.userRulesDir = argv[++i] ?? opts.userRulesDir;
+    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 === "--skills-dir") opts.skillsDir = argv[++i] ?? opts.skillsDir;
+    else if (a.startsWith("--skills-dir=")) opts.skillsDir = a.slice("--skills-dir=".length);
+    else if (a === "--root") opts.root = argv[++i] ?? opts.root;
+    else if (a.startsWith("--root=")) opts.root = a.slice("--root=".length);
+    else if (a === "--max-age-days") opts.maxAgeDays = Number(argv[++i]) || opts.maxAgeDays;
+    else if (a.startsWith("--max-age-days=")) opts.maxAgeDays = Number(a.slice("--max-age-days=".length)) || opts.maxAgeDays;
+  }
+  if (opts.format !== "text" && opts.format !== "json") opts.format = "text";
+  return opts;
+}
+function buildByteCensus(opts) {
+  const claudeMdChars = opts.claudeMd.project_claude_md_chars + opts.claudeMd.project_claude_local_md_chars + opts.claudeMd.user_claude_md_chars + opts.claudeMd.user_imports.reduce((s, i) => s + i.chars, 0);
+  const claudeMdFiles = (opts.claudeMd.project_claude_md_present ? 1 : 0) + (opts.claudeMd.project_claude_local_md_present ? 1 : 0) + (opts.claudeMd.user_claude_md_present ? 1 : 0) + opts.claudeMd.user_imports.length;
+  const sources = [
+    {
+      name: "user-scope rules (~/.claude/rules/*.md)",
+      files: opts.userRules.files,
+      chars: opts.userRules.chars,
+      tokens_estimate: tokensFromChars(opts.userRules.chars),
+      provenance: "measured_local_file",
+      basis: "\u03A3 byte size of every .md file in the user-scope rules directory, chars/4."
+    },
+    {
+      name: "project-scope rules (dist/agent-src/rules/*.md)",
+      files: opts.projectRules.files,
+      chars: opts.projectRules.chars,
+      tokens_estimate: tokensFromChars(opts.projectRules.chars),
+      provenance: "measured_local_file",
+      basis: "\u03A3 byte size of every .md file in the project-scope rules directory, chars/4."
+    },
+    {
+      name: "CLAUDE.md hierarchy (project + project-local + user + user @-imports)",
+      files: claudeMdFiles,
+      chars: claudeMdChars,
+      tokens_estimate: tokensFromChars(claudeMdChars),
+      provenance: "measured_local_file",
+      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.'
+    },
+    {
+      name: "global user profile.md (road-to-global-user-memory)",
+      files: opts.globalProfile.present ? 1 : 0,
+      chars: opts.globalProfile.chars,
+      tokens_estimate: tokensFromChars(opts.globalProfile.chars),
+      provenance: "measured_local_file",
+      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."
+    },
+    {
+      name: "preloaded skills catalog (name + description, dist/agent-src/skills)",
+      files: opts.skillsCatalog.skills,
+      chars: opts.skillsCatalog.chars,
+      tokens_estimate: tokensFromChars(opts.skillsCatalog.chars),
+      provenance: "measured_local_file",
+      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.`
+    }
+  ];
+  const measurableTokensTotal = sources.reduce((s, src) => s + src.tokens_estimate, 0);
+  const median3 = opts.measuredColdStartMedian;
+  const residualTokens = median3 !== null ? Math.max(0, median3 - measurableTokensTotal) : null;
+  if (residualTokens !== null) {
+    sources.push({
+      name: "tool definitions + dispatch prompt (residual)",
+      files: 0,
+      chars: 0,
+      tokens_estimate: residualTokens,
+      provenance: "residual",
+      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."
+    });
+  }
+  const grandTotal = sources.reduce((s, src) => s + src.tokens_estimate, 0);
+  const measurableShare = median3 !== null && median3 > 0 ? measurableTokensTotal / median3 : null;
+  const withinTolerance = median3 !== null ? Math.abs(grandTotal - median3) / Math.max(1, median3) <= SUM_TOLERANCE_PCT : null;
+  const dup = opts.duplicateScope;
+  let modelledNewMedian = null;
+  let modelledReductionPct = null;
+  let modelledApplicable = false;
+  let modelledReason;
+  if (median3 === null) {
+    modelledReason = "no measured cold-start median available in this window";
+  } else if (!dup.evaluable) {
+    modelledReason = dup.reason ?? "duplicate-scope census not evaluable";
+  } else {
+    modelledApplicable = true;
+    modelledNewMedian = Math.max(0, median3 - dup.duplicate_chars / CHARS_PER_TOKEN);
+    modelledReductionPct = median3 > 0 ? (median3 - modelledNewMedian) / median3 : 0;
+  }
+  return {
+    sources,
+    measurable_tokens_total: measurableTokensTotal,
+    grand_total_tokens: grandTotal,
+    measured_cold_start_median: median3,
+    cold_start_legs: opts.coldStartLegs,
+    measurable_share_of_median: measurableShare,
+    within_tolerance: withinTolerance,
+    top_rules_by_cost: opts.topRules,
+    duplicate_scope: {
+      evaluable: dup.evaluable,
+      reason: dup.reason,
+      shared_filenames: dup.shared_filenames.length,
+      duplicate_tokens_per_spawn: dup.evaluable ? dup.duplicate_chars / CHARS_PER_TOKEN : 0
+    },
+    modelled_duplicate_removal: {
+      applicable: modelledApplicable,
+      reason: modelledReason,
+      modelled_new_median: modelledNewMedian,
+      modelled_reduction_pct: modelledReductionPct
+    }
+  };
+}
+function buildReport2(opts) {
+  const userRules = censusRuleDir(opts.userRulesDir);
+  const projectRules = censusRuleDir(opts.projectRulesDir);
+  const claudeMd = censusClaudeMdHierarchy(opts.repoRoot, opts.userHome);
+  const globalProfile = censusGlobalProfile();
+  const skillsCatalog = censusSkillsCatalog(opts.skillsDir);
+  const topRules = topRulesByCost(opts.projectRulesDir, 10);
+  const duplicateScope = censusDuplicateScope(opts.userRulesDir, 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;
+  return buildByteCensus({
+    userRules,
+    projectRules,
+    claudeMd,
+    globalProfile,
+    skillsCatalog,
+    topRules,
+    duplicateScope,
+    measuredColdStartMedian,
+    coldStartLegs: coldStart.legs
+  });
+}
+function pct2(v) {
+  return `${(v * 100).toFixed(1)}%`;
+}
+function renderText2(r) {
+  const out = [];
+  out.push("Preamble byte census (road-to-cache-economy Phase 3, steps 1-2)");
+  out.push("");
+  out.push("Sources:");
+  for (const s of r.sources) {
+    out.push(`  ${s.name}`);
+    out.push(`    files=${s.files} chars=${s.chars} tokens_estimate=${Math.round(s.tokens_estimate)} [${s.provenance}]`);
+    out.push(`    basis: ${s.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(
+      `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.`
+    );
+  } else {
+    out.push("measured_cold_start_median: pending \u2014 no subagent legs observed in this window; no residual computed.");
+  }
+  out.push("");
+  out.push("Top-10 project-scope rules by per-spawn token cost:");
+  for (const rule of r.top_rules_by_cost) {
+    out.push(`  ${rule.file}: chars=${rule.chars} tokens_estimate=${Math.round(rule.tokens_estimate)}`);
+  }
+  out.push("");
+  out.push("Duplicate-scope census (C-2):");
+  if (r.duplicate_scope.evaluable) {
+    out.push(
+      `  ${r.duplicate_scope.shared_filenames} shared filename(s), ${Math.round(r.duplicate_scope.duplicate_tokens_per_spawn)} redundant tokens per spawn.`
+    );
+  } else {
+    out.push(`  not evaluable \u2014 ${r.duplicate_scope.reason ?? "unknown reason"}`);
+  }
+  out.push("");
+  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)}`);
+  } else {
+    out.push(`  not applicable \u2014 ${r.modelled_duplicate_removal.reason ?? "unknown reason"}`);
+  }
+  out.push("");
+  out.push("The per-spawn payload ceiling (median \u2264 40k / p95 \u2264 50k) is a DOCUMENTED CANDIDATE, gated on C-3");
+  out.push("(preamble reducibility, still pending \u2014 no reduction intervention has landed). See");
+  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);
+  if (opts.format === "json") {
+    process.stdout.write(JSON.stringify(report, null, 2) + "\n");
+  } else {
+    process.stdout.write(renderText2(report) + "\n");
+  }
+  return 0;
+}
+var _isBundled = true;
+if (!_isBundled && process.argv[1] !== void 0) {
+  const invokedUrl = pathToFileURL2(path8.resolve(process.argv[1])).href;
+  if (import.meta.url === invokedUrl) process.exit(main2());
+}
+
+// src/scripts/dispatch_economy_report.ts
+var dispatch_economy_report_exports = {};
+__export(dispatch_economy_report_exports, {
+  DEFAULT_AUDIT_DIR: () => DEFAULT_AUDIT_DIR,
+  DEFAULT_PROJECTS_ROOT: () => DEFAULT_PROJECTS_ROOT,
+  buildReport: () => buildReport3,
+  computeLegs: () => computeLegs,
+  main: () => main3,
+  median: () => median2,
+  readAuditOrchestrations: () => readAuditOrchestrations,
+  renderText: () => renderText3
+});
+import * as fs6 from "node:fs";
+import * as path9 from "node:path";
+import { fileURLToPath as fileURLToPath4, pathToFileURL as pathToFileURL3 } from "node:url";
+var _HERE4 = fileURLToPath4(import.meta.url);
+var REPO_ROOT4 = path9.resolve(path9.dirname(_HERE4), "..", "..");
+var REGISTRATION_FILE = path9.join(REPO_ROOT4, "src", "config", "dispatch-economy-metrics.json");
+var DEFAULT_AUDIT_DIR = path9.join("agents", "runtime", "state", "audit");
+var REVIEWER_TYPE_RE = /review|judge|validator/i;
+function median2(values) {
+  if (values.length === 0) return null;
+  const s = [...values].sort((a, b) => a - b);
+  const mid = Math.floor(s.length / 2);
+  const lo = s[mid - 1];
+  const hi = s[mid];
+  if (s.length % 2 === 1) return hi ?? null;
+  return lo !== void 0 && hi !== void 0 ? (lo + hi) / 2 : null;
+}
+function computeLegs(records) {
+  const byAgent = /* @__PURE__ */ new Map();
+  for (const r of records) {
+    if (r.bucket !== "subagent" || r.agentId === null) continue;
+    const list = byAgent.get(r.agentId) ?? [];
+    list.push(r);
+    byAgent.set(r.agentId, list);
+  }
+  const legs = [];
+  for (const [agentId, recs] of byAgent) {
+    const sorted = [...recs].sort((a, b) => {
+      if (a.timestamp === null || b.timestamp === null) return 0;
+      return a.timestamp < b.timestamp ? -1 : a.timestamp > b.timestamp ? 1 : 0;
+    });
+    const first = sorted[0];
+    if (first === void 0) continue;
+    const init = billableInputTokens(first.usage);
+    const total = sorted.reduce((acc, r) => acc + billableInputTokens(r.usage), 0);
+    const work = total - init;
+    const initUnits = weightedInputUnits(first.usage);
+    const workUnits = sorted.slice(1).reduce((acc, r) => acc + weightedInputUnits(r.usage), 0);
+    legs.push({
+      agentId,
+      calls: sorted.length,
+      init_tokens: init,
+      work_tokens: work,
+      ratio: workUnits > 0 ? initUnits / workUnits : null
+    });
+  }
+  return legs.sort((a, b) => a.agentId < b.agentId ? -1 : 1);
+}
+function isFiniteNonNegInt(v) {
+  return typeof v === "number" && Number.isInteger(v) && v >= 0;
+}
+function readAuditOrchestrations(auditDir, opts = {}) {
+  if (!fs6.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 = fs6.readdirSync(auditDir).filter((f) => f.endsWith(".jsonl")).sort();
+  } catch {
+    return [];
+  }
+  if (cutoffMs !== null) {
+    entries = entries.filter((f) => {
+      try {
+        return fs6.statSync(path9.join(auditDir, f)).mtimeMs >= cutoffMs;
+      } catch {
+        return false;
+      }
+    });
+  }
+  for (const f of entries) {
+    let text;
+    try {
+      text = fs6.readFileSync(path9.join(auditDir, f), "utf8");
+    } catch {
+      continue;
+    }
+    for (const line of text.split("\n")) {
+      if (line.trim().length === 0) continue;
+      try {
+        const parsed = JSON.parse(line);
+        if (!parsed.orchestration || typeof parsed.orchestration !== "object") continue;
+        if (cutoffMs !== null && typeof parsed.ts === "string") {
+          const t = Date.parse(parsed.ts);
+          if (Number.isFinite(t) && t < cutoffMs) continue;
+        }
+        out.push(parsed.orchestration);
+      } catch {
+        continue;
+      }
+    }
+  }
+  return out;
+}
+function buildReport3(opts) {
+  const registrationRaw = fs6.readFileSync(REGISTRATION_FILE, "utf8");
+  const registration = JSON.parse(registrationRaw);
+  const scanOpts = {
+    root: opts.root,
+    maxAgeDays: opts.maxAgeDays,
+    ...opts.now !== void 0 ? { now: opts.now } : {}
+  };
+  const scan = scanTranscripts(scanOpts);
+  const legs = computeLegs(scan.records);
+  const finiteRatios = legs.map((l) => l.ratio).filter((r) => r !== null);
+  const singleCall = legs.filter((l) => l.ratio === null).length;
+  const orchestrations = readAuditOrchestrations(opts.auditDir, {
+    maxAgeDays: opts.maxAgeDays,
+    ...opts.now !== void 0 ? { now: opts.now } : {}
+  });
+  const reviewerMeasured = [];
+  const quotas = [];
+  let askLines = 0;
+  let askAdopted = 0;
+  let askEscalated = 0;
+  const returnChars = [];
+  for (const o of orchestrations) {
+    if (o.route_taken === "ask") {
+      askLines += 1;
+      if (o.outcome === "DONE") askAdopted += 1;
+    }
+    if (o.route_taken === "subagent" && o.escalated === true && o.origin === "dispatch-economy-2026") {
+      askEscalated += 1;
+    }
+    if (isFiniteNonNegInt(o.return_channel_chars)) {
+      returnChars.push(o.return_channel_chars);
+    }
+    if (isFiniteNonNegInt(o.rules_carried) && isFiniteNonNegInt(o.rules_used) && o.rules_carried > 0) {
+      quotas.push(o.rules_used / o.rules_carried);
+    }
+    const isReviewer = Array.isArray(o.agent_combo) && o.agent_combo.some((t2) => typeof t2 === "string" && REVIEWER_TYPE_RE.test(t2));
+    if (isReviewer && o.floor_provenance === "measured" && isFiniteNonNegInt(o.init_tokens) && isFiniteNonNegInt(o.work_tokens)) {
+      reviewerMeasured.push({ init: o.init_tokens, work: o.work_tokens });
+    }
+  }
+  const workerFloor = {
+    role: "worker",
+    attribution: "transcript-leg (role axis not shipped \u2014 all legs report as worker)",
+    legs: legs.length,
+    single_call_legs: singleCall,
+    median_init_tokens: median2(legs.map((l) => l.init_tokens)),
+    median_ratio_finite: median2(finiteRatios)
+  };
+  const reviewerRatios = reviewerMeasured.filter((p) => p.work > 0).map((p) => p.init / p.work);
+  const reviewerFloor = {
+    role: "reviewer",
+    attribution: "audit-line agent_combo",
+    legs: reviewerMeasured.length,
+    single_call_legs: reviewerMeasured.filter((p) => p.work === 0).length,
+    median_init_tokens: median2(reviewerMeasured.map((p) => p.init)),
+    median_ratio_finite: median2(reviewerRatios)
+  };
+  const t = registration.metrics.dispatch_floor.thresholds;
+  const lowQuota = registration.metrics.rules_efficiency.thresholds.low_quota_signal;
+  const medianQuota = median2(quotas);
+  const medianWorkerRatio = workerFloor.median_ratio_finite;
+  const notes = [
+    `dedup: ${scan.totalSeen} raw assistant records \u2192 ${scan.dedupedCount} (replay inflation removed)`,
+    "single_call_legs are floor-only legs (all init, zero work) \u2014 they are excluded from the finite-ratio median and support, never dilute, the projection-mandatory reading",
+    "projection_mandatory_signal is a single-run reading; the registered verdict is a sustained-window call at review date (dispatch-economy-metrics.json)"
+  ];
+  return {
+    schema: "dispatch-economy-report/v1",
+    registration: { registered_at: registration.registered_at, review_by: registration.review_by },
+    window: { max_age_days: opts.maxAgeDays, transcript_records: scan.dedupedCount, legs: legs.length },
+    dispatch_floor: {
+      roles: [workerFloor, reviewerFloor],
+      thresholds: t,
+      projection_mandatory_signal: medianWorkerRatio === null ? null : medianWorkerRatio > t.projection_mandatory_ratio
+    },
+    rules_efficiency: {
+      envelopes_with_pair: quotas.length,
+      median_quota: medianQuota,
+      threshold_low_quota: lowQuota,
+      low_quota_signal: medianQuota === null ? null : medianQuota < lowQuota
+    },
+    ask_economy: {
+      ask_lines: askLines,
+      adopted: askAdopted,
+      escalated: askEscalated,
+      threshold_escalation_kill: registration.metrics.ask_economy.thresholds.escalation_kill,
+      escalation_kill_signal: askLines === 0 ? null : askEscalated / askLines > registration.metrics.ask_economy.thresholds.escalation_kill
+    },
+    return_channel: {
+      lines_with_field: returnChars.length,
+      median_chars: median2(returnChars),
+      envelope_cap_chars: registration.metrics.return_channel.thresholds.envelope_cap_chars,
+      cap_breach_signal: returnChars.length === 0 ? null : (median2(returnChars) ?? 0) > registration.metrics.return_channel.thresholds.envelope_cap_chars
+    },
+    notes
+  };
+}
+function fmtTokens(n) {
+  if (n === null) return "\u2014";
+  return n >= 1e3 ? `${(n / 1e3).toFixed(1)}k` : String(Math.round(n));
+}
+function renderText3(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`);
+  lines.push("");
+  lines.push("dispatch_floor:");
+  for (const role of r.dispatch_floor.roles) {
+    lines.push(
+      `  ${role.role.padEnd(8)} legs=${role.legs} (single-call: ${role.single_call_legs}) \xB7 median init=${fmtTokens(role.median_init_tokens)} \xB7 median init/work=${role.median_ratio_finite === null ? "\u2014" : role.median_ratio_finite.toFixed(2)}`
+    );
+    lines.push(`           attribution: ${role.attribution}`);
+  }
+  lines.push(
+    `  projection-mandatory signal (ratio > ${r.dispatch_floor.thresholds.projection_mandatory_ratio}): ${r.dispatch_floor.projection_mandatory_signal === null ? "no data" : String(r.dispatch_floor.projection_mandatory_signal)}`
+  );
+  lines.push("");
+  lines.push("rules_efficiency:");
+  lines.push(
+    `  envelopes with pair=${r.rules_efficiency.envelopes_with_pair} \xB7 median quota=${r.rules_efficiency.median_quota === null ? "\u2014" : r.rules_efficiency.median_quota.toFixed(2)} \xB7 low-quota signal (< ${r.rules_efficiency.threshold_low_quota}): ${r.rules_efficiency.low_quota_signal === null ? "no data" : String(r.rules_efficiency.low_quota_signal)}`
+  );
+  lines.push("");
+  lines.push("return_channel:");
+  lines.push(
+    `  lines=${r.return_channel.lines_with_field} \xB7 median chars=${r.return_channel.median_chars === null ? "\u2014" : Math.round(r.return_channel.median_chars)} \xB7 cap-breach signal (> ${r.return_channel.envelope_cap_chars}): ${r.return_channel.cap_breach_signal === null ? "no data" : String(r.return_channel.cap_breach_signal)}`
+  );
+  lines.push("");
+  lines.push("ask_economy:");
+  lines.push(
+    `  ask lines=${r.ask_economy.ask_lines} \xB7 adopted=${r.ask_economy.adopted} \xB7 escalated=${r.ask_economy.escalated} \xB7 escalation-kill signal (> ${r.ask_economy.threshold_escalation_kill}): ${r.ask_economy.escalation_kill_signal === null ? "no data" : String(r.ask_economy.escalation_kill_signal)}`
+  );
+  lines.push("");
+  for (const n of r.notes) lines.push(`note: ${n}`);
+  return lines.join("\n") + "\n";
+}
+function main3(argv) {
+  let format = "text";
+  let root = DEFAULT_PROJECTS_ROOT;
+  let auditDir = path9.join(process.cwd(), DEFAULT_AUDIT_DIR);
+  let maxAgeDays = 14;
+  for (let i = 0; i < argv.length; i++) {
+    const a = argv[i];
+    if (a === "--format") format = argv[++i] === "json" ? "json" : "text";
+    else if (a === "--root") root = argv[++i] ?? root;
+    else if (a === "--audit-dir") auditDir = argv[++i] ?? auditDir;
+    else if (a === "--max-age-days") maxAgeDays = Number(argv[++i] ?? maxAgeDays) || maxAgeDays;
+  }
+  let report;
+  try {
+    report = buildReport3({ 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));
+  return 0;
+}
+function _isCliEntry() {
+  if (true) return false;
+  if (process.argv[1] === void 0) return false;
+  const argvUrl = pathToFileURL3(path9.resolve(process.argv[1])).href;
+  if (import.meta.url === argvUrl) return true;
+  try {
+    return fs6.realpathSync(fileURLToPath4(import.meta.url)) === fs6.realpathSync(path9.resolve(process.argv[1]));
+  } catch {
+    return false;
+  }
+}
+if (_isCliEntry()) process.exit(main3(process.argv.slice(2)));
+
 // src/scripts/ai_council/clients.ts
 var clients_exports = {};
 __export(clients_exports, {
@@ -170,27 +1611,28 @@ __export(clients_exports, {
   reset_cli_call_counts: () => reset_cli_call_counts
 });
 import { spawnSync } from "node:child_process";
-import * as fs3 from "node:fs";
-import * as path3 from "node:path";
+import * as fs8 from "node:fs";
+import * as path11 from "node:path";
 
 // src/scripts/_lib/session_role.ts
 var SESSION_ROLE_ENV = "AGENT_CONFIG_SESSION_ROLE";
 
 // src/scripts/ai_council/events_log.ts
 import * as crypto from "node:crypto";
-import * as fs2 from "node:fs";
-import * as path2 from "node:path";
-import { fileURLToPath } from "node:url";
-var SCHEMA_VERSION = 1;
+import * as fs7 from "node:fs";
+import * as path10 from "node:path";
+import { fileURLToPath as fileURLToPath5 } from "node:url";
+var SCHEMA_VERSION = 2;
 var _VALID_ACTIONS = /* @__PURE__ */ new Set([
   "proceed",
   "skip_necessity",
-  "block_quota"
+  "block_quota",
+  "quorum_result"
 ]);
 var _KILL_SWITCH_ENV = "AGENT_CONFIG_NO_EVENTS_LOG";
-var _HERE = fileURLToPath(import.meta.url);
-var _REPO_ROOT = path2.resolve(path2.dirname(_HERE), "..", "..", "..");
-var _DEFAULT_LOG_PATH = path2.join(
+var _HERE5 = fileURLToPath5(import.meta.url);
+var _REPO_ROOT = path10.resolve(path10.dirname(_HERE5), "..", "..", "..");
+var _DEFAULT_LOG_PATH = path10.join(
   _REPO_ROOT,
   "agents",
   "runtime",
@@ -291,9 +1733,9 @@ function appendEvent(event, opts = {}) {
     }
   }
   const target = opts.logPath != null ? opts.logPath : _DEFAULT_LOG_PATH;
-  fs2.mkdirSync(path2.dirname(target), { recursive: true });
+  fs7.mkdirSync(path10.dirname(target), { recursive: true });
   const line = _pyJsonDumpsCompact(record);
-  fs2.appendFileSync(target, line + "\n", { encoding: "utf-8" });
+  fs7.appendFileSync(target, line + "\n", { encoding: "utf-8" });
   return true;
 }
 function _isoSecondsZ(d) {
@@ -453,9 +1895,21 @@ function assertCacheBreakpointOrder(ttls) {
     }
   }
 }
+function _servedModel(response, field = "model") {
+  const value = _getattr(response, field, "");
+  return typeof value === "string" ? value : "";
+}
 var CouncilResponse = class {
   provider;
   model;
+  // The model id the provider reported serving, when it reports one. NEVER
+  // overwrites `model`: that is the REQUESTED id, and it is what the tier
+  // decision was made against — keeping both is what makes a silent alias or
+  // provider substitution detectable at all. Attribution-only; no consumer
+  // may route on it. Defaults to '' (the honest value for a transport that
+  // reports no served id, e.g. every CLI client) so existing callers and the
+  // persisted response JSON stay backward-compatible.
+  model_served;
   text;
   input_tokens;
   output_tokens;
@@ -471,6 +1925,7 @@ var CouncilResponse = class {
   constructor(opts) {
     this.provider = opts.provider;
     this.model = opts.model;
+    this.model_served = opts.model_served ?? "";
     this.text = opts.text;
     this.input_tokens = opts.input_tokens ?? 0;
     this.output_tokens = opts.output_tokens ?? 0;
@@ -496,13 +1951,13 @@ function _setMonotonicSource(fn) {
   return prev;
 }
 function _loadKey(p, prefix, installScript) {
-  if (!fs3.existsSync(p)) {
+  if (!fs8.existsSync(p)) {
     throw new KeyGateError(
       `Key not found at ${p}.
     Install it with: bash ${installScript}`
     );
   }
-  const st = fs3.statSync(p);
+  const st = fs8.statSync(p);
   const mode = st.mode & 511;
   if (mode !== 384) {
     throw new KeyGateError(
@@ -510,7 +1965,7 @@ function _loadKey(p, prefix, installScript) {
     Fix:  chmod 600 ${p}`
     );
   }
-  const key = fs3.readFileSync(p, { encoding: "utf-8" }).trim();
+  const key = fs8.readFileSync(p, { encoding: "utf-8" }).trim();
   if (!key) {
     throw new KeyGateError(`${p} is empty.`);
   }
@@ -717,6 +2172,7 @@ var AnthropicClient = class extends ExternalAIClient {
     return new CouncilResponse({
       provider: this.name,
       model: this.model,
+      model_served: _servedModel(response),
       text,
       input_tokens: usage ? _getattr(usage, "input_tokens", 0) : 0,
       output_tokens: usage ? _getattr(usage, "output_tokens", 0) : 0,
@@ -804,6 +2260,7 @@ ${user_prompt}` }
     return new CouncilResponse({
       provider: this.name,
       model: this.model,
+      model_served: _servedModel(response),
       text: text || "",
       input_tokens: usage ? _getattr(usage, "prompt_tokens", 0) : 0,
       output_tokens: usage ? _getattr(usage, "completion_tokens", 0) : 0,
@@ -864,6 +2321,8 @@ ${user_prompt}`;
     return new CouncilResponse({
       provider: this.name,
       model: this.model,
+      // Gemini names it `model_version`, not `model`.
+      model_served: _servedModel(response, "model_version"),
       text,
       input_tokens: usage ? _getattr(usage, "prompt_token_count", 0) : 0,
       output_tokens: usage ? _getattr(usage, "candidates_token_count", 0) : 0,
@@ -929,6 +2388,7 @@ var _OpenAICompatibleClient = class extends ExternalAIClient {
     return new CouncilResponse({
       provider: this.name,
       model: this.model,
+      model_served: _servedModel(response),
       text: text || "",
       input_tokens: usage ? _getattr(usage, "prompt_tokens", 0) : 0,
       output_tokens: usage ? _getattr(usage, "completion_tokens", 0) : 0,
@@ -968,12 +2428,12 @@ function _today_utc_iso() {
 }
 function load_cli_call_counts(p = null) {
   const target = p !== null ? p : _cliCallsStatePath();
-  if (!fs3.existsSync(target)) {
+  if (!fs8.existsSync(target)) {
     return {};
   }
   let data;
   try {
-    data = JSON.parse(fs3.readFileSync(target, { encoding: "utf-8" }));
+    data = JSON.parse(fs8.readFileSync(target, { encoding: "utf-8" }));
   } catch {
     return {};
   }
@@ -1000,8 +2460,8 @@ function record_cli_call(provider, p = null) {
   const target = p !== null ? p : _cliCallsStatePath();
   const counts = load_cli_call_counts(target);
   counts[provider] = (counts[provider] ?? 0) + 1;
-  fs3.mkdirSync(path3.dirname(target), { recursive: true });
-  fs3.writeFileSync(
+  fs8.mkdirSync(path11.dirname(target), { recursive: true });
+  fs8.writeFileSync(
     target,
     _jsonDumpsIndent2({ date: _today_utc_iso(), counts }),
     { encoding: "utf-8" }
@@ -1016,8 +2476,8 @@ function reset_cli_call_counts(provider = null, p = null) {
   } else {
     delete counts[provider];
   }
-  fs3.mkdirSync(path3.dirname(target), { recursive: true });
-  fs3.writeFileSync(
+  fs8.mkdirSync(path11.dirname(target), { recursive: true });
+  fs8.writeFileSync(
     target,
     _jsonDumpsIndent2({ date: _today_utc_iso(), counts }),
     { encoding: "utf-8" }
@@ -2085,7 +3545,7 @@ function _pyJsonStringAscii(s) {
   return out + '"';
 }
 function _which(name) {
-  if (name.includes(path3.sep) || path3.sep !== "/" && name.includes("/")) {
+  if (name.includes(path11.sep) || path11.sep !== "/" && name.includes("/")) {
     return _isExecutable(name) ? name : null;
   }
   const pathEnv = process.env.PATH ?? "";
@@ -2093,12 +3553,12 @@ function _which(name) {
     return null;
   }
   const exts = process.platform === "win32" ? (process.env.PATHEXT ?? ".COM;.EXE;.BAT;.CMD").split(";").filter(Boolean) : [""];
-  for (const dir of pathEnv.split(path3.delimiter)) {
+  for (const dir of pathEnv.split(path11.delimiter)) {
     if (!dir) {
       continue;
     }
     for (const ext of exts) {
-      const candidate = path3.join(dir, name + ext);
+      const candidate = path11.join(dir, name + ext);
       if (_isExecutable(candidate)) {
         return candidate;
       }
@@ -2108,7 +3568,7 @@ function _which(name) {
 }
 function _isExecutable(p) {
   try {
-    const st = fs3.statSync(p);
+    const st = fs8.statSync(p);
     if (!st.isFile()) {
       return false;
     }
@@ -2135,7 +3595,7 @@ function _defaultStdin() {
   function ensure() {
     if (buffer === null) {
       try {
-        buffer = fs3.readFileSync(0, { encoding: "utf-8" });
+        buffer = fs8.readFileSync(0, { encoding: "utf-8" });
       } catch {
         buffer = "";
       }
@@ -2177,14 +3637,14 @@ function _defaultStdin() {
 
 // src/scripts/_lib/environment_detector.ts
 import { spawnSync as spawnSync2 } from "node:child_process";
-import * as fs4 from "node:fs";
+import * as fs9 from "node:fs";
 import * as os from "node:os";
-import * as path4 from "node:path";
+import * as path12 from "node:path";
 
 // src/install/toolDetection.ts
-import { existsSync as existsSync3 } from "node:fs";
-import { homedir } from "node:os";
-import { delimiter as delimiter2, join as join4 } from "node:path";
+import { existsSync as existsSync7 } from "node:fs";
+import { homedir as homedir3 } from "node:os";
+import { delimiter as delimiter2, join as join12 } 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"] },
@@ -2229,8 +3689,8 @@ function resolveBinaryPath(name, pathEnv) {
   for (const dir of pathEnv.split(delimiter2)) {
     if (dir.length === 0) continue;
     for (const candidate of [name, `${name}.exe`, `${name}.cmd`]) {
-      const full = join4(dir, candidate);
-      if (existsSync3(full)) return full;
+      const full = join12(dir, candidate);
+      if (existsSync7(full)) return full;
     }
   }
   return null;
@@ -2240,10 +3700,10 @@ function binOnPath(name, pathEnv) {
 }
 function isToolInstalled(signal, home, pathEnv) {
   for (const rel of signal.homePaths ?? []) {
-    if (existsSync3(join4(home, rel))) return true;
+    if (existsSync7(join12(home, rel))) return true;
   }
   for (const abs of signal.absPaths ?? []) {
-    if (existsSync3(abs)) return true;
+    if (existsSync7(abs)) return true;
   }
   for (const bin of signal.bins ?? []) {
     if (binOnPath(bin, pathEnv)) return true;
@@ -2251,7 +3711,7 @@ function isToolInstalled(signal, home, pathEnv) {
   return false;
 }
 function detectInstalledTools(opts = {}) {
-  const home = opts.home ?? homedir();
+  const home = opts.home ?? homedir3();
   const pathEnv = opts.pathEnv ?? process.env["PATH"] ?? "";
   const out = {};
   for (const [id, signal] of Object.entries(TOOL_SIGNALS)) {
@@ -2302,7 +3762,7 @@ function classifyBilling(provider, source) {
 function codexHome(env) {
   const map = env ?? process.env;
   const override = (map["CODEX_HOME"] ?? "").trim();
-  return override !== "" ? override : path4.join(homeOf(env), ".codex");
+  return override !== "" ? override : path12.join(homeOf(env), ".codex");
 }
 function homeOf(env) {
   const map = env ?? process.env;
@@ -2327,14 +3787,14 @@ ${res.stderr ?? ""}`;
 }
 function isFile(p) {
   try {
-    return fs4.statSync(p).isFile();
+    return fs9.statSync(p).isFile();
   } catch {
     return false;
   }
 }
 function exists(p) {
   try {
-    return fs4.existsSync(p);
+    return fs9.existsSync(p);
   } catch {
     return false;
   }
@@ -2342,7 +3802,7 @@ function exists(p) {
 function classifyCodexAuth(authPath) {
   let data;
   try {
-    data = JSON.parse(fs4.readFileSync(authPath, "utf-8"));
+    data = JSON.parse(fs9.readFileSync(authPath, "utf-8"));
   } catch {
     return "cli-api-key";
   }
@@ -2359,18 +3819,18 @@ function cliSubscriptionEvidence(provider, home, env, claudeConfigDir) {
   if (provider === "anthropic") {
     const configDir = claudeConfigDir;
     for (const rel of [".credentials.json", "credentials.json"]) {
-      const p = path4.join(configDir, rel);
+      const p = path12.join(configDir, rel);
       if (isFile(p)) return { source: "cli-subscription", evidence: p };
     }
     return null;
   }
   if (provider === "openai") {
-    const p = path4.join(codexHome(env), "auth.json");
+    const p = path12.join(codexHome(env), "auth.json");
     if (isFile(p)) return { source: classifyCodexAuth(p), evidence: p };
     return null;
   }
   if (provider === "gemini") {
-    const p = path4.join(home, ".gemini", "oauth_creds.json");
+    const p = path12.join(home, ".gemini", "oauth_creds.json");
     if (isFile(p)) return { source: "cli-subscription", evidence: p };
     return null;
   }
@@ -2402,7 +3862,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() || path4.join(home, ".claude");
+  const claudeConfigDir = opts.home === void 0 && opts.env === void 0 ? claude_config_dir() : (env["CLAUDE_CONFIG_DIR"] ?? "").trim() || path12.join(home, ".claude");
   const auth = [];
   const keys = [];
   for (const provider of knownProviders()) {
@@ -2456,7 +3916,7 @@ function detectEnvironment(opts = {}) {
 }
 
 // src/scripts/_cli/detection_report.ts
-import * as path5 from "node:path";
+import * as path13 from "node:path";
 
 // src/scripts/ai_council/transport_resolver.ts
 var VALID_TRANSPORT_MODES = /* @__PURE__ */ new Set([
@@ -2658,7 +4118,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(path5.basename(h.binary)) === expected
+    (h) => h.binary !== null && stripExe(path13.basename(h.binary)) === expected
   );
 }
 function stripExe(name) {
@@ -2819,9 +4279,9 @@ function absentCouncilFacts(configPath) {
 
 // src/scripts/ai_team/review_gate.ts
 import * as crypto2 from "node:crypto";
-import * as fs5 from "node:fs";
+import * as fs10 from "node:fs";
 import * as os2 from "node:os";
-import * as path6 from "node:path";
+import * as path14 from "node:path";
 
 // src/scripts/ai_team/config.ts
 var AI_TEAM_REVIEW_GATE_DEFAULTS = Object.freeze({
@@ -2837,16 +4297,16 @@ var AI_TEAM_DEFAULTS = Object.freeze({
 });
 
 // src/scripts/ai_team/review_gate.ts
-var GATE_LEDGER_RELPATH = path6.join("agents", "runtime", "team", "events.log");
+var GATE_LEDGER_RELPATH = path14.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 = fs5.realpathSync.native(workspace_root);
+    canonical = fs10.realpathSync.native(workspace_root);
   } catch {
     canonical = workspace_root;
   }
-  const slug_source = path6.basename(workspace_root) || "workspace";
+  const slug_source = path14.basename(workspace_root) || "workspace";
   const slug = slug_source.replace(/[^a-zA-Z0-9._-]+/g, "-").replace(/^-+|-+$/g, "") || "workspace";
   const hash = crypto2.createHash("sha256").update(canonical).digest("hex").slice(0, 16);
   return `${slug}-${hash}`;
@@ -2856,19 +4316,19 @@ function upstream_state_dir_candidates(workspace_root) {
   const candidates = [];
   const env = (process.env["CLAUDE_PLUGIN_DATA"] ?? "").trim();
   if (env !== "") {
-    candidates.push(path6.join(env, "state", segment));
+    candidates.push(path14.join(env, "state", segment));
   }
   candidates.push(
-    path6.join(claude_config_dir(), "plugins", "data", _CODEX_PLUGIN_DATA_DIRNAME, "state", segment)
+    path14.join(claude_config_dir(), "plugins", "data", _CODEX_PLUGIN_DATA_DIRNAME, "state", segment)
   );
-  candidates.push(path6.join(os2.tmpdir(), "codex-companion", segment));
+  candidates.push(path14.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(fs5.readFileSync(path6.join(dir, "state.json"), "utf-8"));
+      parsed = JSON.parse(fs10.readFileSync(path14.join(dir, "state.json"), "utf-8"));
     } catch {
       continue;
     }
@@ -2917,7 +4377,7 @@ function review_gate_doctor_signal(project_root, gate_raw) {
 }
 
 // src/scripts/_cli/cmd_doctor.ts
-var _HERE2 = fileURLToPath2(import.meta.url);
+var _HERE6 = fileURLToPath6(import.meta.url);
 var ArgparseExit = class extends Error {
   constructor(code) {
     super(`argparse-exit-${code}`);
@@ -2928,13 +4388,13 @@ var ArgparseExit = class extends Error {
 function expanduser(p) {
   if (p === "~") return os3.homedir();
   if (p.startsWith("~/") || p.startsWith("~\\")) {
-    return path7.join(os3.homedir(), p.slice(2));
+    return path15.join(os3.homedir(), p.slice(2));
   }
   return p;
 }
 function pathExists(p) {
   try {
-    fs6.statSync(p);
+    fs11.statSync(p);
     return true;
   } catch {
     return false;
@@ -2942,27 +4402,27 @@ function pathExists(p) {
 }
 function isFile2(p) {
   try {
-    return fs6.statSync(p).isFile();
+    return fs11.statSync(p).isFile();
   } catch {
     return false;
   }
 }
 function isDir(p) {
   try {
-    return fs6.statSync(p).isDirectory();
+    return fs11.statSync(p).isDirectory();
   } catch {
     return false;
   }
 }
 function resolvePath(p) {
   try {
-    return fs6.realpathSync(path7.resolve(p));
+    return fs11.realpathSync(path15.resolve(p));
   } catch {
-    return path7.resolve(p);
+    return path15.resolve(p);
   }
 }
 function readText(p) {
-  return fs6.readFileSync(p, "utf-8");
+  return fs11.readFileSync(p, "utf-8");
 }
 function _jsonStrAscii(s) {
   let out = '"';
@@ -3050,11 +4510,11 @@ function _jsonDumpsIndentAscii(value, indent) {
   return _dumpIndentAscii(value, indent, 0);
 }
 function yamlSafeLoad(text) {
-  if (YAML === void 0 || YAML === null) {
+  if (YAML2 === void 0 || YAML2 === null) {
     return null;
   }
   try {
-    return YAML.parse(text, { version: "1.1" });
+    return YAML2.parse(text, { version: "1.1" });
   } catch {
     return void 0;
   }
@@ -3073,7 +4533,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 = path7.join(project_root, _INSTALL_MODE_MARKER_REL);
+  const marker = path15.join(project_root, _INSTALL_MODE_MARKER_REL);
   if (isFile2(marker)) {
     let value;
     try {
@@ -3085,9 +4545,9 @@ function _detect_install_mode(project_root) {
       return [value, "marker-file"];
     }
   }
-  const has_agents_md = pathExists(path7.join(project_root, "AGENTS.md"));
+  const has_agents_md = pathExists(path15.join(project_root, "AGENTS.md"));
   const has_copilot = pathExists(
-    path7.join(project_root, ".github", "copilot-instructions.md")
+    path15.join(project_root, ".github", "copilot-instructions.md")
   );
   if (has_agents_md && has_copilot) {
     return ["full", "heuristic"];
@@ -3107,7 +4567,7 @@ function _settings_layer_chain(project_root) {
   return layers;
 }
 function _detect_wrapper(project_root) {
-  const wrapper = path7.join(project_root, "agent-config");
+  const wrapper = path15.join(project_root, "agent-config");
   if (!pathExists(wrapper)) {
     return { path: String(wrapper), exists: false, embedded_root: null };
   }
@@ -3174,14 +4634,14 @@ function _emit_context_text(ctx) {
 }
 function _resolve_path(project_root, raw) {
   let p = expanduser(raw);
-  if (!path7.isAbsolute(p)) {
-    p = path7.join(project_root, p);
+  if (!path15.isAbsolute(p)) {
+    p = path15.join(project_root, p);
   }
   return p;
 }
 function _sha256(p) {
   try {
-    const data = fs6.readFileSync(p);
+    const data = fs11.readFileSync(p);
     return crypto3.createHash("sha256").update(data).digest("hex");
   } catch {
     return null;
@@ -3190,7 +4650,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 (path7.extname(p) !== ".md") {
+  if (path15.extname(p) !== ".md") {
     return NO_FRONTMATTER;
   }
   let text;
@@ -3319,13 +4779,13 @@ function rglob(root) {
   const walk = (dir) => {
     let entries;
     try {
-      entries = fs6.readdirSync(dir, { withFileTypes: true });
+      entries = fs11.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 = path7.join(dir, ent.name);
+      const full = path15.join(dir, ent.name);
       out.push(full);
       let dirLike = ent.isDirectory();
       if (ent.isSymbolicLink()) {
@@ -3400,9 +4860,9 @@ function _foreign_records(project_root, foreign) {
   return out;
 }
 function relativeTo(p, base) {
-  const rel = path7.relative(base, p);
+  const rel = path15.relative(base, p);
   if (rel === "") return rel;
-  if (rel.startsWith("..") || path7.isAbsolute(rel)) {
+  if (rel.startsWith("..") || path15.isAbsolute(rel)) {
     return null;
   }
   return rel;
@@ -3466,7 +4926,7 @@ var MANIFEST_REQUIRED_CHECK_IDS = /* @__PURE__ */ new Set([
 ]);
 var INSTALL_MODE_MARKER_RELATIVE = "agents/.agent-state/install-mode.txt";
 function _is_global_only_consumer(project_root) {
-  return isFile2(path7.join(project_root, INSTALL_MODE_MARKER_RELATIVE)) || isDir(path7.join(project_root, "agents", "overrides"));
+  return isFile2(path15.join(project_root, INSTALL_MODE_MARKER_RELATIVE)) || isDir(path15.join(project_root, "agents", "overrides"));
 }
 var REPAIR_IDS = ["wizard-state"];
 var MCP_BETA_GATES = [
@@ -3486,7 +4946,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(path7.join(project_root, marker))) {
+    if (pathExists(path15.join(project_root, marker))) {
       return {
         id: "scope",
         status: "warn",
@@ -3495,7 +4955,7 @@ function _check_scope(project_root) {
       };
     }
   }
-  const pkg = path7.join(project_root, "package.json");
+  const pkg = path15.join(project_root, "package.json");
   if (pathExists(pkg)) {
     try {
       const data = JSON.parse(readText(pkg));
@@ -3521,7 +4981,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 : path7.join(common, "config");
+  return common === null ? null : path15.join(common, "config");
 }
 function _parse_git_user(configText) {
   let inUser = false;
@@ -3551,7 +5011,7 @@ function _check_git_identity(project_root) {
   }
   let ident = _parse_git_user(readText(cfgPath));
   if (ident.name === null && ident.email === null) {
-    const globalCfg = path7.join(os3.homedir(), ".gitconfig");
+    const globalCfg = path15.join(os3.homedir(), ".gitconfig");
     if (pathExists(globalCfg)) {
       ident = _parse_git_user(readText(globalCfg));
     }
@@ -3612,7 +5072,7 @@ function _package_root() {
 }
 function _current_package_version() {
   try {
-    const data = JSON.parse(readText(path7.join(_package_root(), "package.json")));
+    const data = JSON.parse(readText(path15.join(_package_root(), "package.json")));
     const v = data["version"];
     if (typeof v === "string" && v.trim()) {
       return v.trim();
@@ -3656,7 +5116,7 @@ function _check_lockfile_freshness(manifest) {
   };
 }
 function shutilWhich(name) {
-  if (path7.dirname(name) !== "." && (name.includes("/") || name.includes("\\"))) {
+  if (path15.dirname(name) !== "." && (name.includes("/") || name.includes("\\"))) {
     return isExecutableFile(name) ? name : null;
   }
   const pathEnv = process2.env["PATH"] || "";
@@ -3669,12 +5129,12 @@ function shutilWhich(name) {
     if (seenDirs.has(d)) continue;
     seenDirs.add(d);
     for (const ext of exts) {
-      const candidate = path7.join(d, name + (ext === "" ? "" : ext.toLowerCase() === ext ? ext : ext));
+      const candidate = path15.join(d, name + (ext === "" ? "" : ext.toLowerCase() === ext ? ext : ext));
       if (isExecutableFile(candidate)) {
         return candidate;
       }
       if (ext !== "") {
-        const upper = path7.join(d, name + ext);
+        const upper = path15.join(d, name + ext);
         if (isExecutableFile(upper)) return upper;
       }
     }
@@ -3683,10 +5143,10 @@ function shutilWhich(name) {
 }
 function isExecutableFile(p) {
   try {
-    const st = fs6.statSync(p);
+    const st = fs11.statSync(p);
     if (!st.isFile()) return false;
     if (process2.platform === "win32") return true;
-    fs6.accessSync(p, fs6.constants.X_OK);
+    fs11.accessSync(p, fs11.constants.X_OK);
     return true;
   } catch {
     return false;
@@ -3750,7 +5210,7 @@ function _check_claude_plugin() {
       remedy: ""
     };
   }
-  const projection = path7.join(os3.homedir(), ".claude", "skills");
+  const projection = path15.join(os3.homedir(), ".claude", "skills");
   const projection_present = isDir(projection);
   if (projection_present) {
     return {
@@ -3787,8 +5247,8 @@ function _check_claude_command_wrappers() {
       remedy: ""
     };
   }
-  const anchor = path7.join(os3.homedir(), ".claude");
-  const commands_dir = path7.join(anchor, "commands");
+  const anchor = path15.join(os3.homedir(), ".claude");
+  const commands_dir = path15.join(anchor, "commands");
   if (!isDir(commands_dir)) {
     return {
       id: "claude-command-wrappers",
@@ -3797,8 +5257,8 @@ function _check_claude_command_wrappers() {
       remedy: ""
     };
   }
-  const flat_probe = fs6.existsSync(path7.join(commands_dir, "commit.md"));
-  const wrapper_probe = fs6.existsSync(path7.join(anchor, "skills", "commit", "SKILL.md"));
+  const flat_probe = fs11.existsSync(path15.join(commands_dir, "commit.md"));
+  const wrapper_probe = fs11.existsSync(path15.join(anchor, "skills", "commit", "SKILL.md"));
   if (wrapper_probe) {
     return {
       id: "claude-command-wrappers",
@@ -3823,7 +5283,7 @@ function _check_claude_command_wrappers() {
   };
 }
 function _check_surface_state() {
-  const matrix_path = path7.join(_package_root(), "src", "config", "surface-matrix.yml");
+  const matrix_path = path15.join(_package_root(), "src", "config", "surface-matrix.yml");
   if (!isFile2(matrix_path)) {
     return {
       id: "surface-state",
@@ -3834,7 +5294,7 @@ function _check_surface_state() {
   }
   let tools = {};
   try {
-    const raw = YAML.parse(readText(matrix_path), { version: "1.1" });
+    const raw = YAML2.parse(readText(matrix_path), { version: "1.1" });
     const t = raw["tools"];
     if (t && typeof t === "object" && !Array.isArray(t)) {
       tools = t;
@@ -3847,7 +5307,7 @@ function _check_surface_state() {
       remedy: "agent-config upgrade (reinstalls the package data files)"
     };
   }
-  const _expand = (p) => p.startsWith("~/") ? path7.join(os3.homedir(), p.slice(2)) : path7.join(_package_root(), p);
+  const _expand = (p) => p.startsWith("~/") ? path15.join(os3.homedir(), p.slice(2)) : path15.join(_package_root(), p);
   const violations = [];
   const remedies = [];
   let checked = 0;
@@ -3889,7 +5349,7 @@ function _check_surface_state() {
 }
 function pathExistsAny(p) {
   try {
-    fs6.statSync(p);
+    fs11.statSync(p);
     return true;
   } catch {
     return false;
@@ -3905,13 +5365,13 @@ function _check_hook_wiring() {
       remedy: ""
     };
   }
-  const settings_path = path7.join(os3.homedir(), ".claude", "settings.json");
+  const settings_path = path15.join(os3.homedir(), ".claude", "settings.json");
   let missing;
   try {
     const matrix = build_claude_hook_matrix(
-      path7.join(_package_root(), "src", "scripts", "hook_manifest.yaml")
+      path15.join(_package_root(), "src", "scripts", "hook_manifest.yaml")
     );
-    const settings = pathExists(settings_path) ? JSON.parse(fs6.readFileSync(settings_path, "utf8")) : {};
+    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];
@@ -3986,7 +5446,7 @@ function _check_mcp_mode(project_root) {
   ];
   const found = [];
   for (const [rel, label] of candidates) {
-    const p = path7.join(project_root, rel);
+    const p = path15.join(project_root, rel);
     if (!pathExists(p)) {
       continue;
     }
@@ -4018,7 +5478,7 @@ function _check_mcp_mode(project_root) {
   };
 }
 function _check_offline_readiness() {
-  const script = path7.join(_package_root(), "src", "scripts", "hermetic-install.sh");
+  const script = path15.join(_package_root(), "src", "scripts", "hermetic-install.sh");
   if (!pathExists(script)) {
     return {
       id: "offline-readiness",
@@ -4076,7 +5536,7 @@ function _check_stale_orphans() {
       (a, b) => a < b ? -1 : a > b ? 1 : 0
     );
     for (const root_name of ownedSorted) {
-      const root = path7.join(anchor, root_name);
+      const root = path15.join(anchor, root_name);
       if (!isDir(root)) {
         continue;
       }
@@ -4091,7 +5551,7 @@ function _check_stale_orphans() {
         if (rel === null) {
           continue;
         }
-        const relPosix = rel.split(path7.sep).join("/");
+        const relPosix = rel.split(path15.sep).join("/");
         if (recorded_set.has(relPosix)) {
           continue;
         }
@@ -4146,14 +5606,14 @@ function _check_rule_scope_drift(project_root) {
   let rules_dir = null;
   let found = 0;
   for (const rel of _RULE_PROJECTION_DIRS) {
-    const cand = path7.join(project_root, rel);
+    const cand = path15.join(project_root, rel);
     if (!isDir(cand)) {
       continue;
     }
     let count = 0;
     try {
-      for (const name of fs6.readdirSync(cand)) {
-        if (name.endsWith(".md") && isFile2(path7.join(cand, name))) {
+      for (const name of fs11.readdirSync(cand)) {
+        if (name.endsWith(".md") && isFile2(path15.join(cand, name))) {
           count += 1;
         }
       }
@@ -4207,14 +5667,14 @@ function _check_rule_scope_drift(project_root) {
   };
 }
 function _check_duplicate_scope_rules(project_root, userRulesDirOverride) {
-  const user_rules_dir = userRulesDirOverride ?? path7.join(os3.homedir(), ".claude", "rules");
+  const user_rules_dir = userRulesDirOverride ?? path15.join(os3.homedir(), ".claude", "rules");
   let project_rules_dir = null;
   if (_is_source_repo(project_root)) {
-    const cand = path7.join(project_root, "dist", "agent-src", "rules");
+    const cand = path15.join(project_root, "dist", "agent-src", "rules");
     if (isDir(cand)) project_rules_dir = cand;
   } else {
     for (const rel of _RULE_PROJECTION_DIRS) {
-      const cand = path7.join(project_root, rel);
+      const cand = path15.join(project_root, rel);
       if (isDir(cand)) {
         project_rules_dir = cand;
         break;
@@ -4283,7 +5743,7 @@ function _check_mcp_beta_readiness(project_root) {
   }
   const pending = [];
   for (const [gate_id, rel] of MCP_BETA_GATES) {
-    if (!pathExists(path7.join(project_root, rel))) {
+    if (!pathExists(path15.join(project_root, rel))) {
       pending.push(`${gate_id} (${rel})`);
     }
   }
@@ -4304,7 +5764,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 = path7.join(project_root, ".agent-tier-usage.jsonl");
+  let log_path = path15.join(project_root, ".agent-tier-usage.jsonl");
   let enabled = false;
   if (isFile2(settings_file)) {
     let raw;
@@ -4323,7 +5783,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 = path7.join(project_root, output["path"].trim());
+          log_path = path15.join(project_root, output["path"].trim());
         }
         const val = tu["enabled"];
         if (typeof val === "boolean") {
@@ -4348,7 +5808,7 @@ function _check_tier_usage_readiness(project_root) {
     return {
       id: "tier-usage-readiness",
       status: "warn",
-      message: `tier-usage telemetry on but ${path7.basename(log_path)} not yet written \u2014 no signal accumulated`,
+      message: `tier-usage telemetry on but ${path15.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"
     };
   }
@@ -4363,7 +5823,7 @@ function _check_tier_usage_readiness(project_root) {
     return {
       id: "tier-usage-readiness",
       status: "fail",
-      message: `cannot read ${path7.basename(log_path)}: ${osErrorStr(exc)}`,
+      message: `cannot read ${path15.basename(log_path)}: ${osErrorStr(exc)}`,
       remedy: "fix permissions on the tier-usage log"
     };
   }
@@ -4394,7 +5854,7 @@ function _check_tier_usage_readiness(project_root) {
     return {
       id: "tier-usage-readiness",
       status: "fail",
-      message: `${total} record(s) in ${path7.basename(log_path)} but 0 passed the privacy floor \u2014 report would refuse to render`,
+      message: `${total} record(s) in ${path15.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)"
     };
   }
@@ -4402,19 +5862,19 @@ function _check_tier_usage_readiness(project_root) {
     return {
       id: "tier-usage-readiness",
       status: "warn",
-      message: `${path7.basename(log_path)} present but empty \u2014 no signal yet`,
+      message: `${path15.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 ${path7.basename(log_path)} \u2014 retiering signal available`,
+    message: `${valid} record(s) past the privacy floor in ${path15.basename(log_path)} \u2014 retiering signal available`,
     remedy: ""
   };
 }
 function readText0(p) {
-  return fs6.readFileSync(p, "utf-8");
+  return fs11.readFileSync(p, "utf-8");
 }
 function osErrorStr(exc) {
   if (exc && typeof exc === "object" && "message" in exc) {
@@ -4587,7 +6047,7 @@ function _epoch_seconds(value) {
 function _codex_auth_expiry(auth_path) {
   let data;
   try {
-    data = JSON.parse(fs6.readFileSync(auth_path, "utf-8"));
+    data = JSON.parse(fs11.readFileSync(auth_path, "utf-8"));
   } catch {
     return null;
   }
@@ -4733,7 +6193,7 @@ function _check_team(project_root) {
   if (binary_missing) {
     remedies.push("install the codex CLI: `npm install -g @openai/codex`");
   }
-  const auth_path = path7.join(_codex_home(), "auth.json");
+  const auth_path = path15.join(_codex_home(), "auth.json");
   const authed = pathExists(auth_path);
   let auth_str;
   if (!authed) {
@@ -4821,7 +6281,7 @@ function _check_unsupported_combos(manifest) {
   };
 }
 function _wizard_state_path() {
-  return path7.join(event4u_root(), "state", "wizard-state.json");
+  return path15.join(event4u_root(), "state", "wizard-state.json");
 }
 function _check_wizard_state() {
   const state_pth = _wizard_state_path();
@@ -4901,7 +6361,7 @@ function _check_wizard_state() {
   };
 }
 function _check_settings_review_pending() {
-  const delta_pth = path7.join(event4u_root(), "state", "settings-delta.json");
+  const delta_pth = path15.join(event4u_root(), "state", "settings-delta.json");
   if (!pathExists(delta_pth)) {
     return {
       id: "settings-review-pending",
@@ -4927,7 +6387,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 = path7.join(project_root, DEFAULT_GITATTRIBUTES);
+  const target = path15.join(project_root, DEFAULT_GITATTRIBUTES);
   if (!pathExists(target)) {
     return {
       id: "memory-merge-union",
@@ -5254,13 +6714,15 @@ function _emit_text(project_root, missing, modified, foreign, tag_drift) {
 }
 var PROG = "agent-config doctor";
 var USAGE = `usage: ${PROG} [-h] [--project PROJECT] [--json] [--ci] [--check ID]
-                           [--trace-root] [--context] [--repair ID]
+                           [--trace-root] [--context] [--anatomy]
+                           [--repair ID]
 `;
 var _STORE_TRUE_FLAGS = {
   "--json": "json",
   "--ci": "ci",
   "--trace-root": "trace_root",
-  "--context": "context"
+  "--context": "context",
+  "--anatomy": "anatomy"
 };
 var _VALUE_FLAGS = {
   "--project": "project",
@@ -5273,7 +6735,7 @@ function _argError(msg) {
 `);
   throw new ArgparseExit(2);
 }
-function _parse(argv) {
+function _parse2(argv) {
   const opts = {
     project: null,
     json: false,
@@ -5281,6 +6743,7 @@ function _parse(argv) {
     check: null,
     trace_root: false,
     context: false,
+    anatomy: false,
     repair: null
   };
   const positionals = [];
@@ -5397,6 +6860,42 @@ function _run_context(opts) {
   }
   return 0;
 }
+function _run_anatomy(opts) {
+  const census = preamble_byte_census_exports;
+  const economy = dispatch_economy_report_exports;
+  const byteCensus = census.buildReport(census.parseArgs([]));
+  let economyReport = null;
+  let economyError = null;
+  try {
+    economyReport = economy.buildReport({
+      root: economy.DEFAULT_PROJECTS_ROOT,
+      auditDir: path15.join(process2.cwd(), economy.DEFAULT_AUDIT_DIR),
+      maxAgeDays: 14
+    });
+  } catch (err) {
+    economyError = err instanceof Error ? err.message : String(err);
+  }
+  if (opts.json) {
+    print(
+      _jsonDumpsIndentAscii(
+        {
+          preamble_byte_census: byteCensus,
+          dispatch_economy: economyReport,
+          dispatch_economy_unavailable: economyError
+        },
+        2
+      )
+    );
+    return 0;
+  }
+  print("\u2500\u2500 injection anatomy \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500");
+  print(census.renderText(byteCensus));
+  print("");
+  print(
+    economyReport !== null ? economy.renderText(economyReport) : `dispatch-economy report unavailable: ${economyError}`
+  );
+  return 0;
+}
 function _run_repair(opts) {
   const target = opts.repair;
   if (target === "wizard-state") {
@@ -5409,7 +6908,7 @@ function _run_repair(opts) {
     };
     if (exists2) {
       try {
-        fs6.unlinkSync(state_pth);
+        fs11.unlinkSync(state_pth);
       } catch (exc) {
         payload["action"] = "error";
         payload["error"] = osErrorStr(exc);
@@ -5435,8 +6934,8 @@ function _run_repair(opts) {
   eprint(`\u274C  doctor: unknown repair target ${pyRepr(target)}`);
   return 2;
 }
-function main(argv = null) {
-  const opts = _parse(argv !== null ? Array.from(argv) : process2.argv.slice(2));
+function main4(argv = null) {
+  const opts = _parse2(argv !== null ? Array.from(argv) : process2.argv.slice(2));
   if (opts.ci) {
     opts.json = true;
   }
@@ -5449,6 +6948,9 @@ function main(argv = null) {
   if (opts.context) {
     return _run_context(opts);
   }
+  if (opts.anatomy) {
+    return _run_anatomy(opts);
+  }
   let project_root;
   let origin;
   try {
@@ -5500,25 +7002,25 @@ function main(argv = null) {
   }
   return drift_present ? 1 : 0;
 }
-function _isCliEntry() {
+function _isCliEntry2() {
   if (process2.argv[1] === void 0) {
     return false;
   }
-  const argvUrl = pathToFileURL(path7.resolve(process2.argv[1])).href;
+  const argvUrl = pathToFileURL4(path15.resolve(process2.argv[1])).href;
   if (import.meta.url === argvUrl) {
     return true;
   }
   try {
-    const here = fs6.realpathSync(fileURLToPath2(import.meta.url));
-    const argv = fs6.realpathSync(path7.resolve(process2.argv[1]));
+    const here = fs11.realpathSync(fileURLToPath6(import.meta.url));
+    const argv = fs11.realpathSync(path15.resolve(process2.argv[1]));
     return here === argv;
   } catch {
     return false;
   }
 }
-if (_isCliEntry() || process2.argv[1] === _HERE2) {
+if (_isCliEntry2() || process2.argv[1] === _HERE6) {
   try {
-    process2.exitCode = main(process2.argv.slice(2));
+    process2.exitCode = main4(process2.argv.slice(2));
   } catch (e) {
     if (e instanceof ArgparseExit) {
       process2.exitCode = e.code;
@@ -5529,6 +7031,11 @@ if (_isCliEntry() || process2.argv[1] === _HERE2) {
 }
 
 export {
+  comparePair,
+  splitFrontmatter,
+  proseEqual,
+  frontmatterPaths,
+  censusRuleDir,
   ArgparseExit,
   _jsonDumpsIndentAscii,
   NO_FRONTMATTER,
@@ -5589,9 +7096,9 @@ export {
   _emit_json,
   _emit_checks_text,
   _emit_text,
-  _parse,
+  _parse2 as _parse,
   _run_trace_root,
   _run_context,
   _run_repair,
-  main
+  main4 as main
 };