@event4u/agent-config 9.14.0 → 9.15.0

package/src/scripts/_lib/tier_budget_routing.ts

@@ -0,0 +1,234 @@
+/**
+ * Budget-aware tier routing (road-to-tested-routing Phase 7).
+ *
+ * Deterministic decision layer for `docs/contracts/budget-routing.md`:
+ * pick the cheapest CLASSIFIER-ADEQUATE tier that has available budget;
+ * cheap exhausted but a stronger tier funded → route up, never block;
+ * everything exhausted or unreadable → session model + notice (fail-open).
+ *
+ * Two hard mechanism requirements from the contract:
+ * - `acquireBudgetPermit` is an ATOMIC reserve — O_EXCL lock file, then
+ *   sum + append-pending in one critical section. Check-then-spend races
+ *   two concurrent dispatches past the ceiling (council finding
+ *   2026-08-03).
+ * - `tripCooldown` / cool-down state — a 429/quota error pauses a tier
+ *   (default 60 min) instead of retry-looping; `pickTier` skips cooling
+ *   tiers via the same relation.
+ *
+ * Pure decision logic is I/O-free; only the permit/cool-down helpers
+ * touch the filesystem (ledger + state under agents/cost-tracking/).
+ */
+import * as fs from 'node:fs';
+import * as path from 'node:path';
+
+export type BudgetTier = 'cheap' | 'medium' | 'strong';
+
+/** Ordered cheapest-first — the relation walks this order upward. */
+export const TIER_ORDER: readonly BudgetTier[] = ['cheap', 'medium', 'strong'];
+
+export interface TierBudgetState {
+    /** USD ceiling from cost.budgets.per_tier.<tier>; null = no tier cap. */
+    ceiling_usd: number | null;
+    /** Ledger-summed spend for this tier in the ceiling's window (USD). */
+    spent_usd: number;
+    /** Epoch ms until which this tier is cooling after a quota error; 0 = live. */
+    cooldown_until_ms: number;
+}
+
+export type BudgetRoutingSwitch = 'ask' | 'auto' | 'off';
+
+export interface PickTierInputs {
+    /** Cheapest tier the classifier marked adequate (quality floor). */
+    adequate_tier: BudgetTier;
+    /** Per-tier budget state, complete over TIER_ORDER. */
+    budgets: Record<BudgetTier, TierBudgetState>;
+    /** subagents.budget_routing setting. */
+    routing_switch: BudgetRoutingSwitch;
+    /** Estimated cost of the dispatch (USD) for the availability check. */
+    estimated_cost_usd: number;
+    /** Clock injection — never Date.now() in the decision path. */
+    now_ms: number;
+}
+
+export interface PickTierDecision {
+    /** 'tier' → dispatch on `tier`; 'session' → run on the session model. */
+    route: 'tier' | 'session';
+    tier: BudgetTier | null;
+    /** 'proceed' | 'ask' (switch=ask and a budget-motivated downshift) */
+    action: 'proceed' | 'ask';
+    /** Non-empty when the relation degraded (exhausted / cooling / off). */
+    notice: string;
+    reason: string;
+}
+
+function tierAvailable(
+    s: TierBudgetState,
+    est: number,
+    now: number,
+): { ok: boolean; why: string } {
+    if (s.cooldown_until_ms > now) {
+        return { ok: false, why: 'cooling after quota error' };
+    }
+    if (s.ceiling_usd === null) {
+        return { ok: true, why: 'no tier cap' };
+    }
+    if (s.spent_usd + est > s.ceiling_usd) {
+        return { ok: false, why: `ceiling ${s.ceiling_usd} reached (spent ${s.spent_usd})` };
+    }
+    return { ok: true, why: 'within ceiling' };
+}
+
+/** The binding relation from docs/contracts/budget-routing.md. */
+export function pickTier(inp: PickTierInputs): PickTierDecision {
+    if (inp.routing_switch === 'off') {
+        return {
+            route: 'session',
+            tier: null,
+            action: 'proceed',
+            notice: '',
+            reason: 'budget_routing off — session model, today\'s behavior',
+        };
+    }
+    const startIdx = TIER_ORDER.indexOf(inp.adequate_tier);
+    const skipped: string[] = [];
+    for (let i = startIdx; i < TIER_ORDER.length; i += 1) {
+        const tier = TIER_ORDER[i] as BudgetTier;
+        const avail = tierAvailable(inp.budgets[tier], inp.estimated_cost_usd, inp.now_ms);
+        if (avail.ok) {
+            const degraded = i > startIdx;
+            return {
+                route: 'tier',
+                tier,
+                action: inp.routing_switch === 'ask' ? 'ask' : 'proceed',
+                notice: degraded
+                    ? `cheapest adequate tier unavailable (${skipped.join('; ')}) — routed up to ${tier}`
+                    : '',
+                reason: `${tier}: ${avail.why}${degraded ? '' : ' — cheapest adequate tier'}`,
+            };
+        }
+        skipped.push(`${tier}: ${avail.why}`);
+    }
+    return {
+        route: 'session',
+        tier: null,
+        action: 'proceed',
+        notice: `all tier budgets unavailable (${skipped.join('; ')}) — session model, work not blocked`,
+        reason: 'fail-open: budget machinery degrades savings, never work',
+    };
+}
+
+// ── Atomic permit + cool-down (filesystem side) ────────────────────────────
+
+export const RESERVE_FILE = 'tier-reserves.jsonl';
+export const COOLDOWN_FILE = 'tier-cooldowns.json';
+export const DEFAULT_COOLDOWN_MS = 60 * 60 * 1000;
+
+interface ReserveEntry {
+    ts_ms: number;
+    tier: BudgetTier;
+    est_usd: number;
+    status: 'pending';
+}
+
+/**
+ * Atomic budget reserve: O_EXCL lock → sum ledger+reserves → append a
+ * pending entry → release. Returns granted=false (never throws) when the
+ * ceiling would be crossed or the lock cannot be taken quickly — the
+ * caller falls back per the relation (fail-open at the DECISION layer,
+ * conservative at the SPEND layer).
+ */
+export function acquireBudgetPermit(options: {
+    tracking_dir: string;
+    tier: BudgetTier;
+    estimated_cost_usd: number;
+    ceiling_usd: number | null;
+    spent_usd: number;
+    now_ms: number;
+}): { granted: boolean; reason: string } {
+    const dir = options.tracking_dir;
+    fs.mkdirSync(dir, { recursive: true });
+    const lock = path.join(dir, `${RESERVE_FILE}.lock`);
+    let fd: number;
+    try {
+        fd = fs.openSync(lock, 'wx');
+    } catch {
+        return { granted: false, reason: 'reserve lock busy — treat tier as unavailable this instant' };
+    }
+    try {
+        const reservePath = path.join(dir, RESERVE_FILE);
+        let reserved = 0;
+        if (fs.existsSync(reservePath)) {
+            for (const line of fs.readFileSync(reservePath, 'utf-8').split('\n')) {
+                if (!line.trim()) continue;
+                try {
+                    const e = JSON.parse(line) as ReserveEntry;
+                    if (e.tier === options.tier && e.status === 'pending') {
+                        reserved += e.est_usd;
+                    }
+                } catch {
+                    // tolerate a torn line — reserve file is advisory spend state
+                }
+            }
+        }
+        if (
+            options.ceiling_usd !== null &&
+            options.spent_usd + reserved + options.estimated_cost_usd > options.ceiling_usd
+        ) {
+            return {
+                granted: false,
+                reason: `ceiling ${options.ceiling_usd} would be crossed (spent ${options.spent_usd} + reserved ${reserved})`,
+            };
+        }
+        const entry: ReserveEntry = {
+            ts_ms: options.now_ms,
+            tier: options.tier,
+            est_usd: options.estimated_cost_usd,
+            status: 'pending',
+        };
+        fs.appendFileSync(reservePath, `${JSON.stringify(entry)}\n`, 'utf-8');
+        return { granted: true, reason: 'reserved' };
+    } finally {
+        fs.closeSync(fd);
+        fs.rmSync(lock, { force: true });
+    }
+}
+
+/** Record a quota/429 error: the tier cools down; pickTier skips it. */
+export function tripCooldown(options: {
+    tracking_dir: string;
+    tier: BudgetTier;
+    now_ms: number;
+    cooldown_ms?: number;
+}): number {
+    const until = options.now_ms + (options.cooldown_ms ?? DEFAULT_COOLDOWN_MS);
+    const p = path.join(options.tracking_dir, COOLDOWN_FILE);
+    let state: Record<string, number> = {};
+    try {
+        state = JSON.parse(fs.readFileSync(p, 'utf-8')) as Record<string, number>;
+    } catch {
+        state = {};
+    }
+    state[options.tier] = until;
+    fs.mkdirSync(options.tracking_dir, { recursive: true });
+    fs.writeFileSync(p, `${JSON.stringify(state, null, 2)}\n`, 'utf-8');
+    return until;
+}
+
+/** Read the cool-down map (missing/torn file → all tiers live). */
+export function readCooldowns(tracking_dir: string): Record<BudgetTier, number> {
+    const empty: Record<BudgetTier, number> = { cheap: 0, medium: 0, strong: 0 };
+    try {
+        const raw = JSON.parse(
+            fs.readFileSync(path.join(tracking_dir, COOLDOWN_FILE), 'utf-8'),
+        ) as Record<string, unknown>;
+        for (const t of TIER_ORDER) {
+            const v = raw[t];
+            if (typeof v === 'number' && Number.isFinite(v)) {
+                empty[t] = v;
+            }
+        }
+        return empty;
+    } catch {
+        return empty;
+    }
+}

package/src/scripts/_lib/tool_adapter_registry.ts

@@ -31,7 +31,14 @@ export const ADAPTER_REGISTRY: readonly AdapterEntry[] = [
     {
         tool: 'Claude Code',
         kind: 'native',
-        roots: ['.claude/rules', '.claude/skills', '.claude/agents', '.claude/personas', '.claude/user-types'],
+        roots: [
+            '.claude/rules',
+            '.claude/skills',
+            '.claude/commands',
+            '.claude/agents',
+            '.claude/personas',
+            '.claude/user-types',
+        ],
         generator_tag: 'claude-code',
     },
     { tool: 'Cursor', kind: 'native', roots: ['.cursor/rules', '.cursor/commands'], generator_tag: 'cursor' },

package/src/scripts/_lib/trigger_eval_floors.ts

@@ -29,3 +29,12 @@ export const DOMAIN_FLOORS: Readonly<Record<string, TriggerEvalFloor>> = {
 export function floor_for(skill: string | null | undefined): TriggerEvalFloor {
     return (skill !== null && skill !== undefined && DOMAIN_FLOORS[skill]) || DEFAULT_FLOOR;
 }
+
+/**
+ * Advisory floor for the rules-mode canary leg (`rule_trigger_eval.ts`,
+ * road-to-tested-routing Phase 4). Deliberately loose: it is a drift canary
+ * over a ~40-case derived suite spanning ~97 rules, not a per-rule quality
+ * gate — ratchet only after live baseline data exists. A breach fails the
+ * scheduled canary job only, never a PR.
+ */
+export const RULES_MODE_FLOOR: TriggerEvalFloor = { minRecall: 0.5, minPrecision: 0.5 };

package/src/scripts/_lib/trigger_routers.ts

@@ -42,14 +42,20 @@ export interface FetchRouterOpts {
     model?: string;
     apiKey?: string;
     fetchImpl?: FetchImpl;
+    /**
+     * Prompt header prepended to the catalogue (default: the skill-routing
+     * header). The rules-mode eval (`rule_trigger_eval.ts`) injects its own
+     * header here so it reuses this transport code unchanged.
+     */
+    promptHeader?: string;
 }
 
 const MAX_TOKENS = 256;
 
 /** Build the system prompt the same way AnthropicRouter does. */
-function buildSystemPrompt(skills: SkillMeta[]): string {
+function buildSystemPrompt(skills: SkillMeta[], header: string = ROUTING_PROMPT_HEADER): string {
     const catalogue = skills.map((s) => `- ${s.name} :: ${s.description}`).join('\n');
-    return ROUTING_PROMPT_HEADER + catalogue + '\n';
+    return header + catalogue + '\n';
 }
 
 function requireKey(name: string, apiKey: string | undefined): string {
@@ -97,11 +103,13 @@ export class OpenAiRouter implements TriggerRouter {
     private _model: string;
     private _apiKey: string;
     private _fetch: FetchImpl;
+    private _promptHeader: string | undefined;
 
     constructor(opts: FetchRouterOpts = {}) {
         this._model = opts.model ?? 'gpt-4o-mini';
         this._apiKey = requireKey('OpenAiRouter', opts.apiKey);
         this._fetch = opts.fetchImpl ?? (globalThis.fetch as unknown as FetchImpl);
+        this._promptHeader = opts.promptHeader;
     }
 
     route(_query: string, _skills: SkillMeta[]): [string[], number, number] {
@@ -109,7 +117,7 @@ export class OpenAiRouter implements TriggerRouter {
     }
 
     async routeAsync(query: string, skills: SkillMeta[]): Promise<[string[], number, number]> {
-        const systemPrompt = buildSystemPrompt(skills);
+        const systemPrompt = buildSystemPrompt(skills, this._promptHeader);
         const body = JSON.stringify({
             model: this._model,
             max_tokens: MAX_TOKENS,
@@ -156,12 +164,14 @@ export class GeminiRouter implements TriggerRouter {
     private _model: string;
     private _apiKey: string;
     private _fetch: FetchImpl;
+    private _promptHeader: string | undefined;
 
     constructor(opts: FetchRouterOpts = {}) {
         // flash, NOT pro: pro burns ~150 "thinking" tokens on trivial prompts.
         this._model = opts.model ?? 'gemini-2.5-flash';
         this._apiKey = requireKey('GeminiRouter', opts.apiKey);
         this._fetch = opts.fetchImpl ?? (globalThis.fetch as unknown as FetchImpl);
+        this._promptHeader = opts.promptHeader;
     }
 
     route(_query: string, _skills: SkillMeta[]): [string[], number, number] {
@@ -169,7 +179,7 @@ export class GeminiRouter implements TriggerRouter {
     }
 
     async routeAsync(query: string, skills: SkillMeta[]): Promise<[string[], number, number]> {
-        const systemPrompt = buildSystemPrompt(skills);
+        const systemPrompt = buildSystemPrompt(skills, this._promptHeader);
         const url =
             `https://generativelanguage.googleapis.com/v1beta/models/` +
             `${this._model}:generateContent?key=${this._apiKey}`;
@@ -221,11 +231,13 @@ export class AnthropicFetchRouter implements TriggerRouter {
     private _model: string;
     private _apiKey: string;
     private _fetch: FetchImpl;
+    private _promptHeader: string | undefined;
 
     constructor(opts: FetchRouterOpts = {}) {
         this._model = opts.model ?? 'claude-haiku-4-5-20251001';
         this._apiKey = requireKey('AnthropicFetchRouter', opts.apiKey);
         this._fetch = opts.fetchImpl ?? (globalThis.fetch as unknown as FetchImpl);
+        this._promptHeader = opts.promptHeader;
     }
 
     route(_query: string, _skills: SkillMeta[]): [string[], number, number] {
@@ -233,7 +245,7 @@ export class AnthropicFetchRouter implements TriggerRouter {
     }
 
     async routeAsync(query: string, skills: SkillMeta[]): Promise<[string[], number, number]> {
-        const systemPrompt = buildSystemPrompt(skills);
+        const systemPrompt = buildSystemPrompt(skills, this._promptHeader);
         const body = JSON.stringify({
             model: this._model,
             max_tokens: MAX_TOKENS,

package/src/scripts/adr/regenerate_index.ts

@@ -8,8 +8,9 @@
  * Ported from the retired Python `src/scripts/adr/regenerate_index.py` (ADR-200).
  * The CLI contract is pinned — `--dir` (default `docs/adr/`),
  * `--check`, exit codes (0 / 1 / 2), the stdout/stderr split, byte-identical
- * messages, AND byte-identical generated `INDEX.md`. No behaviour changes —
- * historical quirks preserved (consumers pin the exact behaviour).
+ * messages. One deliberate deviation from the Python output: the INDEX.md
+ * header names this TypeScript generator, not the retired `.py` (the ported
+ * self-misdescription was itself a defect — ADR-hygiene roadmap, Phase 1).
  */
 import * as fs from 'node:fs';
 import * as path from 'node:path';
@@ -244,7 +245,7 @@ export function render(num: Row[], leg: Row[], outside: OutsideRow[] = []): stri
     const out = [
         '# ADR Index',
         '',
-        '_Auto-generated by `scripts/adr/regenerate_index.py`. Do not edit._',
+        '_Auto-generated by `src/scripts/adr/regenerate_index.ts`. Do not edit._',
         '',
     ];
     if (num.length === 0 && leg.length === 0 && outside.length === 0) {

package/src/scripts/ai-video/lib/parse-blueprint.sh

@@ -4,7 +4,7 @@
 # stdout. Pure POSIX-compatible bash (no associative arrays, runs
 # on macOS bash 3.2); jq required for JSON safety.
 #
-# Schema: .agent-src.uncondensed/skills/scene-expander/scene-blueprint.schema.yaml
+# Schema: src/skills/scene-expander/scene-blueprint.schema.yaml
 # Contract: scripts/media/lib/adapter-contract.md
 #
 # Usage:

package/src/scripts/ai_council/compile_corpus.ts

@@ -10,7 +10,7 @@
  * human-authored source-of-truth for PR review. This script reads it
  * through the hardened {@link parse_corpus_strict} parser and writes a YAML
  * lockfile that becomes the **runtime** source-of-truth. The pattern mirrors
- * `dist/agent-src/` vs `.agent-src.uncondensed/`: human edits Markdown,
+ * `dist/agent-src/` vs `src/`: human edits Markdown,
  * `task consistency` enforces lockfile parity via the same
  * `git diff --quiet` gate.
  *

package/src/scripts/audit_cloud_compatibility.ts

@@ -22,6 +22,8 @@ import * as path from 'node:path';
 import process from 'node:process';
 import { fileURLToPath, pathToFileURL } from 'node:url';
 
+import { DeadScopeError, assertScanned } from './_lib/scan_scope.js';
+
 type Json = unknown;
 type JsonObject = Record<string, Json>;
 
@@ -29,9 +31,25 @@ const _HERE = fileURLToPath(import.meta.url);
 
 // src/scripts/audit_cloud_compatibility.ts → parents[2] of the .py file = repo root.
 export const ROOT = path.resolve(path.dirname(_HERE), '..', '..');
-export const SOURCE = path.join(ROOT, '.agent-src.uncondensed');
 export const SCAN_DIRS = ['skills', 'rules', 'commands', 'guidelines'];
 
+/**
+ * Where each artefact kind actually lives.
+ *
+ * Every kind used to be `SOURCE/<kind>` under one pre-ADR-051 container. All
+ * four resolved to a missing directory after the move, so `scan()` returned []
+ * and the audit emitted `"total": 0` with every histogram empty — a cloud-
+ * compatibility report over zero artefacts. The four kinds now have four
+ * unrelated homes (commands are not a directory at all but one `command.md`
+ * leaf per verb), so the mapping is explicit rather than a join.
+ */
+export const KIND_ROOTS: Readonly<Record<string, string>> = {
+    skills: path.join(ROOT, 'src', 'skills'),
+    rules: path.join(ROOT, 'src', 'rules'),
+    commands: path.join(ROOT, 'src', 'domains'),
+    guidelines: path.join(ROOT, 'docs', 'guidelines'),
+};
+
 // --- patterns (global so findall returns every non-overlapping match) ---------
 const SCRIPT_RE = /scripts\/[a-z_]+\.(?:py|sh)|python3\s+scripts\/|bash\s+scripts\/|\.\/scripts\//g;
 const TASK_RE = /`task\s+[a-z][a-z0-9-]+`/g;
@@ -357,7 +375,7 @@ interface Row extends ClassifyEvidence {
 export function scan(): Row[] {
     const rows: Row[] = [];
     for (const sub of SCAN_DIRS) {
-        const base = path.join(SOURCE, sub);
+        const base = KIND_ROOTS[sub] as string;
         if (!_isDir(base)) {
             continue;
         }
@@ -565,6 +583,23 @@ export function main(argv: string[] | null = null): number {
     }
 
     const rows = scan();
+    // Scope assertion: a cloud-compat report over an empty corpus is not "no
+    // cloud-incompatible artefacts", it is a report about nothing — the exact
+    // `"total": 0` output this audit produced while its roots were dead.
+    try {
+        assertScanned({
+            gate: 'audit_cloud_compatibility',
+            scanned: rows.length,
+            units: 'artefact(s)',
+            roots: SCAN_DIRS.map((k) => _relativeToPosix(KIND_ROOTS[k] as string, ROOT)),
+        });
+    } catch (exc) {
+        if (!(exc instanceof DeadScopeError)) {
+            throw exc;
+        }
+        process.stderr.write(`❌  ${exc.message}\n`);
+        return 2;
+    }
     const summary = summarize(rows);
 
     if (args.details) {

package/src/scripts/audit_initial_context.ts

@@ -59,9 +59,22 @@ const MONOLITH_TOOLS = ['.windsurfrules'];
 // costing?" question as the rule/description surfaces, for the MCP slice. The
 // source-of-truth catalog is the one shipped by this package's MCP server.
 const MCP_CATALOG = path.join(REPO_ROOT, 'src', 'scripts', 'mcp_server', 'consumer_tool_catalog.json');
-// This package ships a single MCP server; the accounting is keyed by server so
-// a multi-server consumer surface generalises without a shape change.
+// The catalog is served by TWO transports with two different tool lists, so
+// pricing it once produced a number no client ever loads:
+//
+//   - stdio  (`src/scripts/mcp_server/`) registers only the implemented tools
+//     (`REGISTRY` in mcp_server/tools.ts) — the 12 discovery stubs are
+//     deliberately unregistered (ADR-132), so a local client sees 19.
+//   - worker (`internal/workers/mcp/`) maps EVERY catalog entry into
+//     `tools/list` (`stubs.ts::listTools`), tagging stubs `_meta.stub` and
+//     answering calls with the not_implemented envelope — so it sees 31.
+//
+// Pricing all 31 under one label reported a hybrid client that cannot exist,
+// and made the over-subscription flag fire on a count no local install pays.
+// Keying by transport keeps the per-server shape and makes each number belong
+// to a real client. `implemented_on` in the catalog is what distinguishes them.
 const MCP_SERVER_NAME = 'agent-config';
+const MCP_TRANSPORTS = ['stdio', 'worker'] as const;
 // Soft advisory ceiling on tool count per server. "Few used" cannot be known at
 // audit time (no runtime call data), so over-subscription is a count-based
 // heuristic: many tools => maintainer should review which earn their cost.
@@ -396,24 +409,40 @@ export function mcp_tool_schemas(): Record<string, McpServer> {
         return {};
     }
     const tools = (catalog.tools as unknown[]) ?? [];
-    const priced: McpPriced[] = tools
-        .filter((t): t is Record<string, unknown> => typeof t === 'object' && t !== null && !Array.isArray(t))
-        .map((t) => _measure_tool_schema(t));
-    // priced.sort(key=lambda r: (-int(r["tokens_gpt"]), str(r["name"])))
-    priced.sort(
-        (a, b) => b.tokens_gpt - a.tokens_gpt || (a.name < b.name ? -1 : a.name > b.name ? 1 : 0),
+    const records = tools.filter(
+        (t): t is Record<string, unknown> => typeof t === 'object' && t !== null && !Array.isArray(t),
     );
-    const server: McpServer = {
-        tool_count: priced.length,
-        chars: priced.reduce((acc, r) => acc + r.chars, 0),
-        tokens_gpt: priced.reduce((acc, r) => acc + r.tokens_gpt, 0),
-        tokens_claude: priced.reduce((acc, r) => acc + r.tokens_claude, 0),
-        tokens_gpt_exact: priced.length > 0 ? priced.every((r) => Boolean(r.tokens_gpt_exact)) : true,
-        over_subscription: priced.length > MCP_OVERSUBSCRIPTION_TOOL_CAP,
-        oversubscription_cap: MCP_OVERSUBSCRIPTION_TOOL_CAP,
-        tools: priced.map((r) => ({ name: r.name, tokens_gpt: r.tokens_gpt, chars: r.chars })),
+
+    /** Tools a given transport actually returns from `tools/list`. */
+    const served = (transport: string): Record<string, unknown>[] => {
+        // The Worker serves the whole catalog (stubs included, flagged
+        // `_meta.stub`); stdio serves only what `implemented_on` names.
+        if (transport === 'worker') return records;
+        return records.filter(
+            (t) => Array.isArray(t.implemented_on) && (t.implemented_on as unknown[]).includes(transport),
+        );
     };
-    return { [MCP_SERVER_NAME]: server };
+
+    const out: Record<string, McpServer> = {};
+    for (const transport of MCP_TRANSPORTS) {
+        const priced: McpPriced[] = served(transport).map((t) => _measure_tool_schema(t));
+        // priced.sort(key=lambda r: (-int(r["tokens_gpt"]), str(r["name"])))
+        priced.sort(
+            (a, b) => b.tokens_gpt - a.tokens_gpt || (a.name < b.name ? -1 : a.name > b.name ? 1 : 0),
+        );
+        out[`${MCP_SERVER_NAME} (${transport})`] = {
+            tool_count: priced.length,
+            chars: priced.reduce((acc, r) => acc + r.chars, 0),
+            tokens_gpt: priced.reduce((acc, r) => acc + r.tokens_gpt, 0),
+            tokens_claude: priced.reduce((acc, r) => acc + r.tokens_claude, 0),
+            tokens_gpt_exact:
+                priced.length > 0 ? priced.every((r) => Boolean(r.tokens_gpt_exact)) : true,
+            over_subscription: priced.length > MCP_OVERSUBSCRIPTION_TOOL_CAP,
+            oversubscription_cap: MCP_OVERSUBSCRIPTION_TOOL_CAP,
+            tools: priced.map((r) => ({ name: r.name, tokens_gpt: r.tokens_gpt, chars: r.chars })),
+        };
+    }
+    return out;
 }
 
 export function build(): Record<string, unknown> {
@@ -678,7 +707,12 @@ export function main(argv: string[] | null = null): number {
         const rf = rfVals.length > 0 ? (rfVals[0] as Measure) : ({} as Measure);
         const dc = data.description_catalog as Record<string, Measure>;
         const mcp = (data.mcp_tool_schemas as Record<string, McpServer>) ?? {};
-        const mcp_gpt = Object.values(mcp).reduce((acc, s) => acc + s.tokens_gpt, 0);
+        // MAX, not sum: the entries are two TRANSPORTS of the same server, and
+        // a client connects over exactly one of them. Summing would bill the
+        // 19 implemented tools twice and gate on a client that cannot exist —
+        // the same conflation the per-transport split exists to remove. The
+        // budget is what the worst-case single client actually loads.
+        const mcp_gpt = Object.values(mcp).reduce((acc, s) => Math.max(acc, s.tokens_gpt), 0);
         const checks: Record<string, number> = {
             'rules.gpt': rf.tokens_gpt ?? 0,
             // The always-SCANNED skill descriptions (258 source skills) — the

package/src/scripts/audit_likelihood.ts

@@ -30,6 +30,8 @@ import * as fs from 'node:fs';
 import * as path from 'node:path';
 import { fileURLToPath, pathToFileURL } from 'node:url';
 
+import { DeadScopeError, assertScanned } from './_lib/scan_scope.js';
+
 const _HERE = fileURLToPath(import.meta.url);
 // src/scripts/audit_likelihood.py → parent.parent.parent == repo root.
 export const REPO_ROOT = path.resolve(path.dirname(_HERE), '..', '..');
@@ -38,9 +40,20 @@ export const AUDIT_JSON = path.join(REPORT_DIR, 'auto-rules-audit.json');
 export const AUDIT_MD = path.join(REPORT_DIR, 'auto-rules-audit.md');
 export const LIKELIHOOD_JSON = path.join(REPORT_DIR, 'auto-rules-likelihood.json');
 
+/**
+ * The corpus a rule's trigger terms are scored against.
+ *
+ * The first two globs named the pre-ADR-051 source container, so skills and
+ * commands — by far the largest and most trigger-dense part of the corpus —
+ * contributed nothing. The audit still printed a score for every rule, derived
+ * from contexts + guidelines alone; that biases every score downward and makes
+ * the low-likelihood flag unreliable in the direction that matters (false
+ * "nothing triggers this"). Commands are now one `command.md` leaf per verb
+ * under `src/domains`.
+ */
 const CORPUS_GLOBS: readonly string[] = [
-    '.agent-src.uncondensed/skills/**/SKILL.md',
-    '.agent-src.uncondensed/commands/**/*.md',
+    'src/skills/**/SKILL.md',
+    'src/domains/**/command.md',
     'agents/settings/contexts/**/*.md',
     'docs/guidelines/**/*.md',
 ];
@@ -403,6 +416,22 @@ export function main(): number {
     }
     const rules: Json[] = JSON.parse(fs.readFileSync(AUDIT_JSON, 'utf-8'))['rules'];
     const corpus = build_corpus();
+    // Scope assertion: an empty corpus scores every rule as low-likelihood
+    // while looking exactly like a completed audit.
+    try {
+        assertScanned({
+            gate: 'audit_likelihood',
+            scanned: corpus.size,
+            units: 'distinct corpus token(s)',
+            roots: CORPUS_GLOBS,
+        });
+    } catch (exc) {
+        if (!(exc instanceof DeadScopeError)) {
+            throw exc;
+        }
+        process.stderr.write(`❌  ${exc.message}\n`);
+        return 2;
+    }
     const scores = rules.map((r) => score(r, corpus));
     fs.writeFileSync(
         LIKELIHOOD_JSON,