@event4u/agent-config 9.13.0 → 9.15.0

package/src/scripts/condense.ts

@@ -35,15 +35,23 @@ import { fileURLToPath, pathToFileURL } from 'node:url';
 import * as YAML from 'yaml';
 
 import {
+    _domains_command_logical,
     artefact_roots as _agent_src_artefact_roots,
     iter_all_sources as _agent_src_iter_all_sources,
     resolve_logical as _agent_src_resolve_logical,
     strip_source_prefix,
 } from './_lib/agent_src.js';
+// Import-safety note: `project_thin_rules` guards its CLI entry
+// (`_isCliEntry()` before `process.exit(main())`), so importing it here is
+// side-effect-free. condense.ts is bundled into the installer, where a bare
+// top-level `process.exit` would fire at consumer runtime — the documented
+// bundled-CLI-entry-guard landmine. Verified before wiring, not assumed.
+import { build_thin } from './project_thin_rules.js';
 import { build_claude_hook_matrix } from './_lib/claude_settings_hooks.js';
 import { is_claude_builtin_name } from './_lib/claude_builtin_names.js';
 import { project_settings_path, load_agent_settings } from './_lib/agent_settings.js';
 import { rule_is_compile_enabled } from './_lib/compile_time_toggles.js';
+import { resolve_rule_pack_scope } from './_lib/scoped_projection.js';
 import { info, success, flush_summary, resolve_level } from './_lib/script_output.js';
 import {
     TIER_TO_CLAUDE_MODEL as _TIER_TO_CLAUDE_MODEL,
@@ -987,13 +995,16 @@ export { _HRR_BANNER_MARKER };
 // (rule-router contract § Schema v2). Untagged rules fail safe: they ship.
 // ADR-040: projection-time filtering only, no runtime resolver.
 
-function _read_projection_list(key: string): string[] | null {
+function _read_projection_raw(key: string): unknown {
     const data = load_agent_settings({ project_path: MODULE_STATE.SETTINGS_FILE });
     const proj = data['projection'];
-    const value =
-        typeof proj === 'object' && proj !== null && !Array.isArray(proj)
-            ? (proj as Record<string, unknown>)[key]
-            : null;
+    return typeof proj === 'object' && proj !== null && !Array.isArray(proj)
+        ? (proj as Record<string, unknown>)[key]
+        : null;
+}
+
+function _read_projection_list(key: string): string[] | null {
+    const value = _read_projection_raw(key);
     if (Array.isArray(value) && value.length > 0) {
         return value.map((v) => String(v));
     }
@@ -1004,8 +1015,28 @@ function _read_rule_workspaces(): string[] | null {
     return _read_projection_list('rule_workspaces');
 }
 
+/** `runtime.active_packs` overlay, empty when unset (fresh-install default). */
+function _read_runtime_active_packs(): string[] {
+    const data = load_agent_settings({ project_path: MODULE_STATE.SETTINGS_FILE });
+    const rt = data['runtime'];
+    const value =
+        typeof rt === 'object' && rt !== null && !Array.isArray(rt)
+            ? (rt as Record<string, unknown>)['active_packs']
+            : null;
+    return Array.isArray(value) ? value.map((v) => String(v)) : [];
+}
+
+/**
+ * Pack scope for the rule layer. `rule_packs: auto` derives the active-pack
+ * set (the same one the skill/command prune uses) instead of a hand-typed id
+ * list; anything else keeps the historical list-or-inactive semantics.
+ */
 function _read_rule_packs(): string[] | null {
-    return _read_projection_list('rule_packs');
+    return resolve_rule_pack_scope(
+        _read_projection_raw('rule_packs'),
+        MODULE_STATE.PROJECT_ROOT,
+        _read_runtime_active_packs(),
+    );
 }
 
 /**
@@ -1044,11 +1075,19 @@ export function generate_rule_symlinks(): number {
 
     let thin_files: Record<string, string> | null = null;
     if (_lean_projection_mode() === 'thin') {
-        // The `project_thin_rules` twin is not ported (out of scope — thin mode
-        // is opt-in and not exercised by golden parity). Throw a clear error if
-        // a consumer actually enables it, mirroring an unmet import.
-        throw new Error(
-            'lean_projection.mode=thin requires project_thin_rules (not ported in condense.ts)',
+        // DEAD-SWITCH REPAIR (road-to-renewal-foundation Phase 2). This branch
+        // used to THROW: the port was skipped as "out of scope, not exercised by
+        // golden parity", which left a documented, settings-selectable mode that
+        // could only ever crash. `build_thin` was ported and has been present the
+        // whole time — the wiring was the only thing missing.
+        //
+        // Scope note: this repairs the SWITCH only. The default stays
+        // `eager-all`. Flipping it is parked behind the thin-projection honest
+        // null (thin win-rate 36.2% < the 48% pre-registered threshold), and
+        // nothing here disturbs that verdict — but a mode that throws cannot
+        // even be re-measured, which is why the repair earns its place alone.
+        thin_files = Object.fromEntries(
+            build_thin(MODULE_STATE.RULES_SOURCE, _read_rule_workspaces()),
         );
     }
 
@@ -1146,6 +1185,9 @@ function _WINDSURF_WORKFLOWS_DIR(): string {
 function _CURSOR_COMMANDS_DIR(): string {
     return path.join(MODULE_STATE.PROJECT_ROOT, '.cursor', 'commands');
 }
+function _CLAUDE_COMMANDS_DIR(): string {
+    return path.join(MODULE_STATE.PROJECT_ROOT, '.claude', 'commands');
+}
 
 function _parse_frontmatter(content: string): [Record<string, unknown>, string] {
     if (!content.startsWith('---')) {
@@ -1566,6 +1608,92 @@ export function extract_description_from_md(content: string): string {
     return '';
 }
 
+/**
+ * The `commands/<sub>` path of a command source file, or `null` when it is a
+ * FLAT command (`commands/<name>.md`).
+ *
+ * A nested path is what Claude Code renders as `/cluster:sub`. Flat command
+ * FILES are not registered by Claude Code (probed ≤ 2.1.204 — see the
+ * flat-command mitigation in `install.ts`), which is why flat commands keep a
+ * skill wrapper and nested ones do not need one.
+ */
+function _nested_command_subpath(source_file: string): string | null {
+    const rel = _relativeToPosix(source_file, MODULE_STATE.PROJECT_ROOT);
+    const logical = _domains_command_logical(rel);
+    if (logical === null || !logical.startsWith('commands/')) {
+        return null;
+    }
+    const sub = logical.slice('commands/'.length).replace(/\.md$/, '');
+    return sub.includes('/') ? sub : null;
+}
+
+/**
+ * Project-scope `.claude/commands/<cluster>/<sub>.md` — the colon form.
+ *
+ * Before this, the package repo's own `.claude/` carried NO commands
+ * directory: every command reached Claude Code as a hyphen-named skill
+ * wrapper in `.claude/skills/`, while the colon form existed only in the
+ * user-global tree written by `install.ts`. Every clustered command was
+ * therefore listed TWICE for anyone with a global install
+ * (`roadmap-process-full` AND `roadmap:process-full`), costing 4,214 GPT tok
+ * of always-loaded catalog for zero added reach — measured 2026-08-02.
+ *
+ * Emitting the nested form here lets `generate_claude_commands` stop wrapping
+ * the clustered commands: one listing, same reachability, and reachability no
+ * longer depends on a global deploy having run. Claude Code dedupes project
+ * and user scope by name, so the two copies of `/cluster:sub` collapse.
+ *
+ * ADR-003 (colon canonical for clusters) and ADR-044 (flat commands stay
+ * hyphenated) both hold: flat commands are untouched and keep their wrapper.
+ */
+export function generate_claude_project_commands(
+    active_command_slugs: ReadonlySet<string> | null = null,
+): number {
+    if (!_isDir(path.join(MODULE_STATE.PROJECT_ROOT, 'src', 'domains'))) {
+        return 0;
+    }
+    const nested: Array<[string, string]> = [];
+    for (const [source_file, slug] of iterCommands()) {
+        if (active_command_slugs !== null && !active_command_slugs.has(slug)) {
+            continue;
+        }
+        const sub = _nested_command_subpath(source_file);
+        if (sub !== null) {
+            nested.push([source_file, sub]);
+        }
+    }
+
+    const target_root = _CLAUDE_COMMANDS_DIR();
+    const valid = new Set(nested.map(([, sub]) => `${sub}.md`));
+    // Sweep stale links first: a renamed or deleted command must not linger as
+    // a dangling `/cluster:sub`.
+    if (_exists(target_root)) {
+        for (const item of _rglobSorted(target_root, '*.md')) {
+            const rel = _relativeToPosix(item, target_root);
+            if (!valid.has(rel)) {
+                fs.unlinkSync(item);
+            }
+        }
+    }
+
+    let count = 0;
+    for (const [source_file, sub] of nested) {
+        const link = path.join(target_root, `${sub}.md`);
+        _mkdirp(path.dirname(link));
+        if (_existsOrSymlink(link)) {
+            fs.unlinkSync(link);
+        }
+        // path.relative, not a hand-counted `../` run: the nesting depth
+        // varies (2 and 3 segments both occur) and an off-by-one here writes
+        // a dangling link that still LOOKS right in `ls -l`.
+        const rel_target = path.relative(path.dirname(link), source_file);
+        fs.symlinkSync(rel_target, link);
+        count += 1;
+    }
+    info(`  ✅  Linked ${count} \`.claude/commands/**/*.md\` files (colon form)`);
+    return count;
+}
+
 export function generate_claude_commands(active_command_slugs: ReadonlySet<string> | null = null): number {
     if (!_isDir(path.join(MODULE_STATE.PROJECT_ROOT, 'src', 'domains'))) {
         process.stderr.write('  ⚠️  src/domains/ not found — skipping commands\n');
@@ -1597,6 +1725,15 @@ export function generate_claude_commands(active_command_slugs: ReadonlySet<strin
             skipped += 1;
             continue;
         }
+        // A clustered command already reaches Claude Code as `/cluster:sub`
+        // from `.claude/commands/` (generate_claude_project_commands). A
+        // hyphen wrapper on top would be a second listing of the same command
+        // — the double-listing this de-duplicates. Flat commands still need
+        // the wrapper: Claude Code does not register flat command FILES.
+        if (_nested_command_subpath(source_file) !== null) {
+            skipped += 1;
+            continue;
+        }
         // Never claim a `/name` that is a Claude Code built-in command or
         // bundled skill — a same-name entry shadows the built-in (e.g. a
         // `review` entry hides Claude Code's own /review). Nested
@@ -2144,6 +2281,11 @@ function _generate_tools_inner(
         generate_gemini_md();
     }
     const skills = _tool_active('claude-code') ? generate_claude_skills(skill_names) : 0;
+    // Colon form first: `generate_claude_commands` skips every command this
+    // one emitted, so the ordering is what keeps the two from double-listing.
+    const claude_cmds = _tool_active('claude-code')
+        ? generate_claude_project_commands(cmd_slugs)
+        : 0;
     const commands = _tool_active('claude-code') ? generate_claude_commands(cmd_slugs) : 0;
     const subagents = _tool_active('claude-code') ? generate_claude_subagents() : 0;
     const subagent_contexts = generate_subagent_host_contexts();
@@ -2157,7 +2299,8 @@ function _generate_tools_inner(
     const windsurf_wf = _tool_active('windsurf') ? generate_windsurf_workflows(cmd_slugs) : 0;
     const summary =
         `✅  generate-tools — rules=${rules} skills=${skills} ` +
-        `commands=${commands} subagents=${subagents} subagent_contexts=${subagent_contexts} plugin_cmd_skills=${plugin_cmd_skills} ` +
+        `claude_commands=${claude_cmds} command_skills=${commands} ` +
+        `subagents=${subagents} subagent_contexts=${subagent_contexts} plugin_cmd_skills=${plugin_cmd_skills} ` +
         `plugin_hooks=${plugin_hooks} ` +
         `personas=${personas} user_types=${user_types} ` +
         `cursor_mdc=${cursor_mdc} windsurf_rules=${windsurf_modern} ` +

package/src/scripts/cost/budget.mjs

@@ -10,7 +10,7 @@
 // Env: BUDGET_STORE, BUDGET_CONFIG, BUDGET_PERIOD={today|week|month|all}, BUDGET_QUIET=1
 
 import { readFileSync, writeFileSync, existsSync, mkdirSync } from 'node:fs';
-import { dirname } from 'node:path';
+import { dirname, join } from 'node:path';
 
 const STORE = process.env.BUDGET_STORE || 'agents/cost-tracking/sessions.jsonl';
 const CONFIG = process.env.BUDGET_CONFIG || 'agents/cost-tracking/budget.json';
@@ -198,14 +198,75 @@ function cmdCheck() {
   if (hardStop) process.exit(1);
 }
 
+// --- Per-tier budget state (docs/contracts/budget-routing.md) -------------
+// v1 window for per-tier ceilings: rolling 24h. Sums ledger entries tagged
+// `tier:` plus pending reserves from tier-reserves.jsonl (the atomic-permit
+// file) so a concurrent dispatch cannot read a stale "available".
+
+function loadPerTierCeilings() {
+  const out = { cheap: null, medium: null, strong: null };
+  if (!existsSync(SETTINGS)) return out;
+  let inPerTier = false;
+  for (const line of readFileSync(SETTINGS, 'utf-8').split('\n')) {
+    if (/^ {4}per_tier:/.test(line)) { inPerTier = true; continue; }
+    if (inPerTier) {
+      const m = line.match(/^ {6}(cheap|medium|strong):\s*([0-9.]+|null)\s*(#.*)?$/);
+      if (m) {
+        out[m[1]] = m[2] === 'null' ? null : Number(m[2]);
+        continue;
+      }
+      if (/^ {0,5}\S/.test(line)) inPerTier = false;
+    }
+  }
+  return out;
+}
+
+function cmdTier(rest) {
+  const tier = rest[0];
+  if (!['cheap', 'medium', 'strong'].includes(tier)) {
+    console.error('usage: budget.mjs tier {cheap|medium|strong}');
+    process.exit(2);
+  }
+  const dayMs = 24 * 3600 * 1000;
+  const now = Date.now();
+  const inWindow = (ts) => ts && (now - new Date(ts).getTime()) < dayMs;
+  const spent = loadSessions()
+    .filter((s) => s.tier === tier && inWindow(s.capturedAt || s.endedAt || s.ts))
+    .reduce((acc, s) => acc + (Number(s.total_cost_usd ?? s.cost_usd ?? 0) || 0), 0);
+  let reserved = 0;
+  const reservePath = join(dirname(STORE), 'tier-reserves.jsonl');
+  if (existsSync(reservePath)) {
+    for (const line of readFileSync(reservePath, 'utf-8').split('\n')) {
+      if (!line.trim()) continue;
+      try {
+        const e = JSON.parse(line);
+        if (e.tier === tier && e.status === 'pending' && (now - e.ts_ms) < dayMs) {
+          reserved += Number(e.est_usd || 0) || 0;
+        }
+      } catch { /* skip malformed line */ }
+    }
+  }
+  const ceiling = loadPerTierCeilings()[tier];
+  const available = ceiling === null ? true : spent + reserved < ceiling;
+  console.log(JSON.stringify({
+    tier,
+    window: 'rolling-24h',
+    ceiling_usd: ceiling,
+    spent_usd: spent,
+    reserved_usd: reserved,
+    available,
+  }));
+}
+
 function main() {
   const [cmd, ...rest] = process.argv.slice(2);
   switch (cmd) {
     case 'set':   return cmdSet(rest);
     case 'get':   return cmdGet();
     case 'check': return cmdCheck();
+    case 'tier':  return cmdTier(rest);
     default:
-      console.error('usage: budget.mjs {set <usd>|get|check}');
+      console.error('usage: budget.mjs {set <usd>|get|check|tier <cheap|medium|strong>}');
       process.exit(2);
   }
 }

package/src/scripts/count_scoped_projection.ts

@@ -0,0 +1,104 @@
+#!/usr/bin/env tsx
+/**
+ * Emit the scoped-projection skill count — the number `docs/CLAIMS.md`
+ * publishes for the default install
+ * (road-to-reproducible-artefact-counts).
+ *
+ * The claim used to read "217 of 288 skills … with the counting method
+ * pinned in the benchmark doc", while that benchmark doc said 215 of 286.
+ * Both numbers were hand-typed, only one of them tracked the catalog, and
+ * the gap grew by one on every skill added because no gate could compare
+ * them. This script is the single derivation both now come from.
+ *
+ * It adds no counting mechanism of its own — that would be a second path
+ * free to disagree with the first, which is the defect, not the fix:
+ *
+ *   - the file set is `update_counts.iter_skills()`, the exact walk behind
+ *     the canonical `count('skills')`, so `projected + pruned === total`
+ *     holds by construction;
+ *   - the in/out predicate is `_lib/scoped_projection.is_pruned_under_scoped`,
+ *     the exact function `install.ts` applies when it prunes a real user's
+ *     tree, so the published number cannot describe a projection the
+ *     installer does not perform.
+ *
+ * `runtime.active_packs` is deliberately empty here: the claim is about the
+ * DEFAULT for a new install, and a fresh machine has no overlay. An operator
+ * who activates extra packs gets more skills than the claim states — the
+ * claim is a floor, and `--json` exposes `active_packs` so a reader can see
+ * the assumption rather than infer it.
+ *
+ * Usage:
+ *   ./scripts-run src/scripts/count_scoped_projection            # "217 of 288"
+ *   ./scripts-run src/scripts/count_scoped_projection --json
+ *   ./scripts-run src/scripts/count_scoped_projection --projected
+ *
+ * Exit codes: 0 ok · 1 the pack registry could not be read.
+ */
+
+import * as fs from 'node:fs';
+import * as path from 'node:path';
+import { fileURLToPath, pathToFileURL } from 'node:url';
+
+import {
+    scoped_projection_stats,
+    type ScopedProjectionStats,
+} from './_lib/scoped_projection.js';
+import { iter_skills, REPO_ROOT } from './update_counts.js';
+
+const _HERE = fileURLToPath(import.meta.url);
+
+export type { ScopedProjectionStats };
+
+/** Partition the canonical skill catalog with the installer's own predicate. */
+export function stats(package_root: string = REPO_ROOT): ScopedProjectionStats {
+    return scoped_projection_stats(package_root, iter_skills());
+}
+
+export function main(argv: readonly string[] = process.argv.slice(2)): number {
+    let s: ScopedProjectionStats;
+    try {
+        s = stats();
+    } catch (err) {
+        process.stderr.write(
+            `❌  scoped-projection count unavailable: ${(err as Error).message}\n` +
+                '    (src/config/discovery/packs.yml must exist and parse to a list)\n',
+        );
+        return 1;
+    }
+
+    if (argv.includes('--json')) {
+        process.stdout.write(`${JSON.stringify(s, null, 2)}\n`);
+        return 0;
+    }
+    if (argv.includes('--projected')) {
+        process.stdout.write(`${s.projected}\n`);
+        return 0;
+    }
+    if (argv.includes('--total')) {
+        process.stdout.write(`${s.total}\n`);
+        return 0;
+    }
+    process.stdout.write(`${s.projected} of ${s.total}\n`);
+    return 0;
+}
+
+function _isCliEntry(): boolean {
+    if (process.argv[1] === undefined) {
+        return false;
+    }
+    const argvUrl = pathToFileURL(path.resolve(process.argv[1])).href;
+    if (import.meta.url === argvUrl) {
+        return true;
+    }
+    try {
+        const here = fs.realpathSync(fileURLToPath(import.meta.url));
+        const argv = fs.realpathSync(path.resolve(process.argv[1]));
+        return here === argv;
+    } catch {
+        return false;
+    }
+}
+
+if (_isCliEntry() || process.argv[1] === _HERE) {
+    process.exit(main(process.argv.slice(2)));
+}

package/src/scripts/evaluator_umbrella.sh

@@ -23,8 +23,12 @@
 #   9. npx smoke            first-touch paths (--version, --help, mcp initialize)
 #   6-8 feed src/scripts/check_evaluator_budgets.ts against
 #   src/config/evaluator-budgets.json (owner + review date lint-enforced).
+#  8b. record publish     with UMBRELLA_RECORD=1, writes the measurement set to
+#                         agents/evidence/metrics/evaluator-measurements.json so
+#                         drift is visible in a diff the day it lands
 #
 # Usage: bash src/scripts/evaluator_umbrella.sh [--skip-pack <tarball>]
+#        UMBRELLA_RECORD=1 bash src/scripts/evaluator_umbrella.sh   # nightly
 set -euo pipefail
 
 ROOT="$(cd "$(dirname "${BASH_SOURCE[0]}")/../.." && pwd)"
@@ -166,9 +170,38 @@ console.log(JSON.stringify(m, null, 1));' \
   "$MEASURE_TMP" "$UNPACKED_BYTES" "$NM_MB" "$DEP_COUNT" "$CLI_MS" "$MCP_MS" "$CLI_COUNT" "$MCP_TOOLS" \
   "$COLD_START_MS" "$COLD_START_CONDITIONS"
 
-step "budget gate (absolute + >regression_pct creep)"
+# The budget gate runs BEFORE the record is refreshed, so the comparison is
+# fresh-vs-committed. Refreshing first would make every drift check trivially
+# green (road-to-gates-that-can-fail Phase 5).
+step "budget gate (absolute + >regression_pct creep + drift vs the committed record)"
 ./scripts-run src/scripts/check_evaluator_budgets --measurements "$MEASURE_TMP"
 
+# ------------------------------------------------- 8b. publish the record
+# With UMBRELLA_RECORD=1 (the nightly sets it) the measurement set is written
+# to a COMMITTED artifact, so budget drift is visible the day it lands instead
+# of at the next release — `cli_help_command_count` drifted 74 → 80 against a
+# value frozen at 79 with nobody seeing it. It lives under agents/evidence/,
+# the repo's committed-evidence tree, and NOT under src/config/, which ships:
+# this is maintainer evidence with nightly churn, not consumer runtime config,
+# and keeping it out of the tarball also keeps evaluator-budgets.json (the
+# policy) reviewable on its own. Sorted keys + fixed indent so a moved number
+# is a one-line diff.
+if [[ "${UMBRELLA_RECORD:-0}" == "1" ]]; then
+  step "publish the measurement record (agents/evidence/metrics/)"
+  RECORD_PATH="$ROOT/agents/evidence/metrics/evaluator-measurements.json"
+  mkdir -p "$(dirname "$RECORD_PATH")"
+  RUN_URL=""
+  if [[ -n "${GITHUB_REPOSITORY:-}" && -n "${GITHUB_RUN_ID:-}" ]]; then
+    RUN_URL="${GITHUB_SERVER_URL:-https://github.com}/$GITHUB_REPOSITORY/actions/runs/$GITHUB_RUN_ID"
+  fi
+  node src/scripts/record_evaluator_measurements.mjs \
+    --measurements "$MEASURE_TMP" \
+    --out "$RECORD_PATH" \
+    --sha "$(git rev-parse HEAD 2>/dev/null || echo '')" \
+    --run-url "$RUN_URL" \
+    --conditions "$COLD_START_CONDITIONS"
+fi
+
 # ------------------------------------------------------------- 9. npx smoke
 step "first-touch smoke (installed bin)"
 "$CLI_BIN" --version >/dev/null

package/src/scripts/generate_capability_matrix.ts

@@ -109,6 +109,14 @@ const _FN_SPEC: Record<string, FnSpec> = {
         artifact: 'commands',
         cells: { 'claude-code': 'native', augment: 'native' },
     },
+    // The colon form (`/cluster:sub`) in the project tree. Same artifact and
+    // the same native cell as the hyphen wrapper above — the two split the
+    // command population between them (nested here, flat there); this is not
+    // an added surface.
+    generate_claude_project_commands: {
+        artifact: 'commands',
+        cells: { 'claude-code': 'native' },
+    },
     generate_claude_subagents: {
         artifact: 'subagents',
         cells: { 'claude-code': 'native' },

package/src/scripts/generate_router_coverage_from_matrix.ts

@@ -0,0 +1,155 @@
+#!/usr/bin/env tsx
+/**
+ * Derive the routing-matrix router-coverage corpus (road-to-tested-routing
+ * Phase 2, PREREG P2 corpus expansion).
+ *
+ * Reads every per-rule routing matrix under `tests/eval/routing-matrix/`
+ * and emits ONE generated corpus file,
+ * `internal/bench/corpora/router-coverage/routing-matrix-derived.yaml`,
+ * with one `router-coverage` prompt per matrix POSITIVE, labelled
+ * `intended_triggers: [<rule>]`. Near-misses are deliberately NOT emitted —
+ * the corpus measures intended activation; the matrices' negative half is
+ * enforced by `tests/scripts/routing_matrix.test.ts`.
+ *
+ * Ownership (two-gate pattern): this generator is the only writer;
+ * `--check` re-derives in memory and exits 1 on drift, so the derived file
+ * can never be hand-edited into disagreement with its source matrices.
+ */
+import * as fs from "node:fs";
+import * as path from "node:path";
+import { fileURLToPath, pathToFileURL } from "node:url";
+import { parse as parseYaml } from "yaml";
+
+const REPO_ROOT = path.resolve(
+  path.dirname(fileURLToPath(import.meta.url)),
+  "..",
+  "..",
+);
+const MATRIX_DIR = path.join(REPO_ROOT, "tests", "eval", "routing-matrix");
+export const OUT_FILE = path.join(
+  REPO_ROOT,
+  "internal",
+  "bench",
+  "corpora",
+  "router-coverage",
+  "routing-matrix-derived.yaml",
+);
+
+interface MatrixCase {
+  prompt: string;
+  open_files?: string[];
+  command?: string;
+}
+interface MatrixFile {
+  rule: string;
+  positives: MatrixCase[];
+  near_misses: MatrixCase[];
+}
+
+/** Cheap language tag for the corpus `language:` field. */
+export function detect_language(prompt: string): "de" | "en" {
+  if (/[äöüßÄÖÜ]/.test(prompt)) {
+    return "de";
+  }
+  return /(^|\s)(der|die|das|und|nicht|bitte|keine?|mach|prüfe|erstelle|für)(\s|$)/i.test(prompt)
+    ? "de"
+    : "en";
+}
+
+function yamlQuote(s: string): string {
+  return JSON.stringify(s);
+}
+
+export function derive(): string {
+  const files = fs
+    .readdirSync(MATRIX_DIR)
+    .filter((f) => f.endsWith(".yaml"))
+    .sort();
+  const lines: string[] = [];
+  lines.push("# Router-coverage corpus — DERIVED FROM the per-rule routing matrices.");
+  lines.push("#");
+  lines.push("# GENERATED FILE — do not hand-edit. Source of truth:");
+  lines.push("#   tests/eval/routing-matrix/*.yaml");
+  lines.push("# Regenerate: npx tsx src/scripts/generate_router_coverage_from_matrix.ts");
+  lines.push("# Drift gate:  npx tsx src/scripts/generate_router_coverage_from_matrix.ts --check");
+  lines.push("");
+  lines.push("version: 1");
+  lines.push("corpus_id: router-coverage-routing-matrix-derived");
+  lines.push("selection_accuracy_target: 0.0");
+  lines.push("");
+  lines.push("prompts:");
+  for (const f of files) {
+    const parsed = parseYaml(fs.readFileSync(path.join(MATRIX_DIR, f), "utf-8")) as MatrixFile;
+    parsed.positives.forEach((c, i) => {
+      const id = `rm-${parsed.rule}-${String(i + 1).padStart(2, "0")}`;
+      lines.push(`  - id: ${id}`);
+      lines.push("    category: router-coverage");
+      lines.push(`    language: ${detect_language(c.prompt)}`);
+      lines.push(`    prompt: ${yamlQuote(c.prompt)}`);
+      lines.push("    expected_skills: []");
+      lines.push(`    intended_triggers: [${parsed.rule}]`);
+      if (c.open_files && c.open_files.length > 0) {
+        lines.push(`    open_files: [${c.open_files.map(yamlQuote).join(", ")}]`);
+      }
+      lines.push("");
+    });
+  }
+  return `${lines.join("\n").trimEnd()}\n`;
+}
+
+export function main(argv?: string[]): number {
+  const args = argv ?? process.argv.slice(2);
+  const check = args.includes("--check");
+  const derived = derive();
+  if (check) {
+    let current = "";
+    try {
+      current = fs.readFileSync(OUT_FILE, "utf-8");
+    } catch {
+      process.stderr.write(`missing derived corpus: ${OUT_FILE} — run the generator\n`);
+      return 1;
+    }
+    if (current !== derived) {
+      process.stderr.write(
+        "routing-matrix-derived.yaml is stale — regenerate via generate_router_coverage_from_matrix\n",
+      );
+      return 1;
+    }
+    process.stdout.write("routing-matrix-derived corpus: fresh\n");
+    return 0;
+  }
+  fs.writeFileSync(OUT_FILE, derived, "utf-8");
+  const promptCount = (derived.match(/^ {2}- id: /gm) ?? []).length;
+  const ruleCount = new Set(
+    [...derived.matchAll(/intended_triggers: \[([^\]]+)\]/g)].map((m) => m[1]),
+  ).size;
+  process.stdout.write(
+    `wrote ${path.relative(REPO_ROOT, OUT_FILE)} — ${promptCount} prompts, ${ruleCount} distinct rule ids\n`,
+  );
+  return 0;
+}
+
+declare const __AGENT_CONFIG_BUNDLE__: boolean | undefined;
+function _isCliEntry(): boolean {
+  if (typeof __AGENT_CONFIG_BUNDLE__ !== "undefined" && __AGENT_CONFIG_BUNDLE__) {
+    return false;
+  }
+  if (process.argv[1] === undefined) {
+    return false;
+  }
+  const argvUrl = pathToFileURL(path.resolve(process.argv[1])).href;
+  if (import.meta.url === argvUrl) {
+    return true;
+  }
+  try {
+    const here = fs.realpathSync(fileURLToPath(import.meta.url));
+    const argv1 = fs.realpathSync(path.resolve(process.argv[1]));
+    return here === argv1;
+  } catch {
+    return false;
+  }
+}
+
+if (_isCliEntry()) {
+  process.exit(main());
+}