@event4u/agent-config 7.3.0 → 7.5.0

package/src/scripts/_lib/token_count.ts

@@ -1,41 +1,80 @@
 /**
- * Real-tokenizer counting for the budget tooling (roadmap 0B.1).
+ * Real-tokenizer counting for the budget tooling
+ * (roadmap 0B.1 → token-saving Phase 0, "real tokenizer into the bench path").
  *
- * TypeScript twin of `src/scripts/_lib/token_count.py` (ADR-200 —
- * Python→TS migration, Phase 2 / Wave 1). Public API mirrors the
- * Python module exactly (snake_case kept deliberately).
+ * `char != token`. Every budget in this suite is historically in characters;
+ * this helper reports a token count *alongside* chars so chars stay the cheap
+ * proxy and tokens become the truth where a real tokenizer is available.
  *
- * `char != token`. Every budget in this suite is historically in
- * characters; this helper adds a token count *alongside* chars so chars
- * stay the cheap proxy and tokens become the truth where a real
- * tokenizer is available.
+ * Design — optional dependency, graceful proxy fallback, **synchronous** API:
  *
- * Design — no silent installs, no mandatory network:
+ * - **GPT** — uses `js-tiktoken` (encoding `cl100k_base`) when the dependency
+ *   is present, producing EXACT BPE counts flagged `exact: true`. `js-tiktoken`
+ *   is a build/measurement-time **devDependency** (consumed by the bench /
+ *   audit tooling, never shipped to a consumer runtime). When it is absent —
+ *   e.g. a consumer that installed without devDependencies — the module falls
+ *   back to the documented `chars / 4` proxy flagged `exact: false`. The
+ *   optional load is a synchronous `createRequire(...)` inside a try/catch so
+ *   the public `measure()` / `gpt_tokens()` API stays synchronous and never
+ *   hard-fails on a missing dependency (no mandatory install, no network).
+ * - **Claude** — no offline Claude tokenizer exists; documented `chars / 3.6`
+ *   proxy, always `exact: false`. (Anthropic's exact count is API-only.)
  *
- * - **GPT** — the Python original uses `tiktoken` when installed; no
- *   tokenizer dependency ships with the TS twin, so the documented
- *   `chars / 4` proxy applies, flagged `exact: false`
- *   (`TIKTOKEN_AVAILABLE` is always `false` here — matching the
- *   Python module's behaviour when tiktoken is absent).
- * - **Claude** — no offline tokenizer; documented `chars / 3.6` proxy
- *   flagged `exact: false`.
+ * Both proxies are intentionally conservative ratios drawn from English-prose +
+ * markdown samples; they are estimates, never gates.
  *
- * Both proxies are intentionally conservative ratios drawn from
- * English-prose + markdown samples; they are estimates, never gates.
+ * The `*_proxy` helpers (`gpt_tokens_proxy`, `measure_proxy`,
+ * `method_note_proxy`) expose the fallback math directly — they are used by the
+ * fallback regression guard in the test suite and by any report that wants to
+ * record both the exact and the proxy count to flag the delta.
  *
- * Parity notes: "chars" counts Unicode code points (Python `len(str)`),
- * not UTF-16 units; rounding is banker's rounding (Python `round()`).
+ * Parity notes: "chars" counts Unicode code points (`len(str)` parity), not
+ * UTF-16 units; proxy rounding is banker's rounding.
  */
 
+import { createRequire } from "node:module";
+
 // Proxy ratios (chars per token) for the no-tokenizer fallback. Tuned for
 // English markdown rule/skill prose; deliberately conservative.
 const _GPT_CHARS_PER_TOKEN = 4.0;
 const _CLAUDE_CHARS_PER_TOKEN = 3.6;
 
-const _TIKTOKEN_ENCODING = "o200k_base"; // GPT-4o / GPT-4.1 family.
+// Roadmap (token-saving Phase 0) mandates the `cl100k_base` encoding. The
+// dependency also bundles `o200k_base` (GPT-4o / GPT-4.1 family); switching the
+// GPT count basis is a one-line change to this constant. The exact-vs-proxy
+// delta is recorded in every report via `method_note()`.
+const _TIKTOKEN_ENCODING = "cl100k_base";
+
+/** Minimal structural type for the js-tiktoken encoder we rely on. */
+interface _Encoder {
+  encode(text: string): number[];
+}
+
+/**
+ * Load the optional `js-tiktoken` encoder synchronously, returning `null` when
+ * the dependency is absent or fails to initialise (graceful proxy fallback).
+ * `createRequire` resolves the CJS build so the call stays synchronous even
+ * though this module is ESM.
+ */
+function _loadEncoder(): _Encoder | null {
+  try {
+    const require = createRequire(import.meta.url);
+    const mod = require("js-tiktoken") as {
+      getEncoding(name: string): _Encoder;
+    };
+    return mod.getEncoding(_TIKTOKEN_ENCODING);
+  } catch {
+    return null;
+  }
+}
+
+// Resolved once at module load. js-tiktoken's `getEncoding` is synchronous with
+// bundled rank tables, so eager init is cheap and keeps `TIKTOKEN_AVAILABLE` a
+// plain const (the historical API shape).
+const _ENCODER: _Encoder | null = _loadEncoder();
 
-// No tiktoken port ships with the TS twin — always the proxy path.
-export const TIKTOKEN_AVAILABLE = false;
+/** True when the real tokenizer is available (exact GPT counts), else proxy. */
+export const TIKTOKEN_AVAILABLE = _ENCODER !== null;
 
 /** A single token measurement and whether it is exact or a proxy. */
 export class TokenCount {
@@ -49,7 +88,7 @@ export class TokenCount {
   }
 }
 
-/** Count Unicode code points — Python `len(str)` parity. */
+/** Count Unicode code points — `len(str)` parity. */
 function _len(text: string): number {
   let count = 0;
   // for..of iterates code points, so astral chars count once.
@@ -57,7 +96,7 @@ function _len(text: string): number {
   return count;
 }
 
-/** Python `round()` — round half to even (banker's rounding). */
+/** Banker's rounding (round half to even) — proxy-path parity. */
 function _python_round(x: number): number {
   const floor = Math.floor(x);
   const diff = x - floor;
@@ -66,17 +105,31 @@ function _python_round(x: number): number {
   return floor % 2 === 0 ? floor : floor + 1;
 }
 
-/** Render a float like Python's f-string (4.0 → "4.0", 3.6 → "3.6"). */
+/** Render a float like a Python f-string (4.0 → "4.0", 3.6 → "3.6"). */
 function _py_float_repr(x: number): string {
   return Number.isInteger(x) ? `${x}.0` : `${x}`;
 }
 
-/** GPT token count — char proxy (tiktoken unavailable in the TS twin). */
+/**
+ * GPT token count — EXACT via js-tiktoken (`cl100k_base`) when available,
+ * otherwise the documented `chars / 4` proxy.
+ */
 export function gpt_tokens(text: string): TokenCount {
+  if (_ENCODER !== null) {
+    return new TokenCount(_ENCODER.encode(text).length, true);
+  }
+  return gpt_tokens_proxy(text);
+}
+
+/**
+ * GPT proxy count (`chars / 4`, banker's rounding) — the fallback path,
+ * exposed directly for the fallback regression guard and delta reporting.
+ */
+export function gpt_tokens_proxy(text: string): TokenCount {
   return new TokenCount(_python_round(_len(text) / _GPT_CHARS_PER_TOKEN), false);
 }
 
-/** Claude token count — documented offline proxy (no local tokenizer). */
+/** Claude token count — documented offline proxy (no local Claude tokenizer). */
 export function claude_tokens(text: string): TokenCount {
   return new TokenCount(
     _python_round(_len(text) / _CLAUDE_CHARS_PER_TOKEN),
@@ -95,9 +148,9 @@ export interface Measure {
 /**
  * Return chars + per-model token counts for one text blob.
  *
- * Keys: chars, tokens_gpt, tokens_gpt_exact, tokens_claude,
- * tokens_claude_exact. The `*_exact` booleans tell a report consumer
- * whether the number is a real tokenizer count or a proxy estimate.
+ * `tokens_gpt` is exact (js-tiktoken) when available; `tokens_gpt_exact` tells
+ * the report consumer which path produced it. `tokens_claude` is always the
+ * proxy (no offline Claude tokenizer).
  */
 export function measure(text: string): Measure {
   const g = gpt_tokens(text);
@@ -111,6 +164,31 @@ export function measure(text: string): Measure {
   };
 }
 
+/**
+ * Proxy-only measure (forces the chars-based estimate for GPT regardless of
+ * tokenizer availability). Use to record both the exact and the proxy count
+ * and flag the delta, and as the fallback regression guard.
+ */
+export function measure_proxy(text: string): Measure {
+  const g = gpt_tokens_proxy(text);
+  const c = claude_tokens(text);
+  return {
+    chars: _len(text),
+    tokens_gpt: g.tokens,
+    tokens_gpt_exact: g.exact,
+    tokens_claude: c.tokens,
+    tokens_claude_exact: c.exact,
+  };
+}
+
+/** Proxy-path provenance string (the fallback note). */
+export function method_note_proxy(): string {
+  return (
+    `tokens_gpt: proxy (chars/${_py_float_repr(_GPT_CHARS_PER_TOKEN)}, tiktoken not installed); ` +
+    `tokens_claude: proxy (chars/${_py_float_repr(_CLAUDE_CHARS_PER_TOKEN)})`
+  );
+}
+
 /** One-line provenance of how token counts were produced (for reports). */
 export function method_note(): string {
   if (TIKTOKEN_AVAILABLE) {
@@ -119,8 +197,5 @@ export function method_note(): string {
       `tokens_claude: proxy (chars/${_py_float_repr(_CLAUDE_CHARS_PER_TOKEN)})`
     );
   }
-  return (
-    `tokens_gpt: proxy (chars/${_py_float_repr(_GPT_CHARS_PER_TOKEN)}, tiktoken not installed); ` +
-    `tokens_claude: proxy (chars/${_py_float_repr(_CLAUDE_CHARS_PER_TOKEN)})`
-  );
+  return method_note_proxy();
 }

package/src/scripts/audit_initial_context.ts

@@ -67,13 +67,41 @@ const MCP_SERVER_NAME = 'agent-config';
 const MCP_OVERSUBSCRIPTION_TOOL_CAP = 25;
 
 // Initial-token budget per surface (null = advisory only, no gate).
-const BUDGETS: Record<string, number | null> = {
+//
+// PROVISIONAL caps (token-saving Phase 8): regression caps at the current
+// surface + ~15% headroom — NOT the quality elbow. The context-rot quality
+// elbow (the roadmap's intended threshold) needs the Phase 0 live validation
+// run, which is operator/cost-gated; until then these caps stop SILENT growth
+// of the always-loaded token surface. Re-anchor with evidence once the elbow is
+// measured. `rules.gpt` stays advisory here — the always-RULES surface is gated
+// (char-based, extended size) by `check_always_budget`; a token cap would be
+// redundant.
+export const BUDGETS: Record<string, number | null> = {
     'rules.gpt': null,
-    'skill_catalog.gpt': null,
-    'command_catalog.gpt': null,
-    'mcp_schemas.gpt': null,
+    'skill_catalog.gpt': 12_500, // always-scanned skill descriptions (skills_core_source, 258); current ~10,999
+    'command_catalog.gpt': 5_800, // always-scanned command catalog; current ~5,005
+    'mcp_schemas.gpt': 3_500, // per-connected-client MCP tool schemas; current ~2,942
 };
 
+/**
+ * Pure budget check: return one breach line per surface whose measured token
+ * count exceeds its cap. A `null`/absent cap is advisory (never a breach).
+ * Exported so the gate's pass/fail logic is unit-testable (token-saving Phase 8).
+ */
+export function evaluate_budgets(
+    checks: Record<string, number>,
+    budgets: Record<string, number | null>,
+): string[] {
+    const breaches: string[] = [];
+    for (const [key, val] of Object.entries(checks)) {
+        const cap = budgets[key];
+        if (cap !== null && cap !== undefined && val > cap) {
+            breaches.push(`${key} ${val} > budget ${cap}`);
+        }
+    }
+    return breaches;
+}
+
 type Measure = token_count.Measure & { files?: number; entries?: number };
 
 function _isDir(p: string): boolean {
@@ -645,7 +673,6 @@ export function main(argv: string[] | null = null): number {
     const data = build();
 
     if (args.fail_if_over_budget) {
-        const breaches: string[] = [];
         const rfVals = Object.values(data.rule_footprint as Record<string, Measure>);
         const rf = rfVals.length > 0 ? (rfVals[0] as Measure) : ({} as Measure);
         const dc = data.description_catalog as Record<string, Measure>;
@@ -653,16 +680,14 @@ export function main(argv: string[] | null = null): number {
         const mcp_gpt = Object.values(mcp).reduce((acc, s) => acc + s.tokens_gpt, 0);
         const checks: Record<string, number> = {
             'rules.gpt': rf.tokens_gpt ?? 0,
-            'skill_catalog.gpt': (dc.skills_projected as Measure).tokens_gpt,
+            // The always-SCANNED skill descriptions (258 source skills) — the
+            // surface the host reads for selection — not the larger per-tool
+            // projected catalog (skills_projected, 412 entries). Phase 8.
+            'skill_catalog.gpt': (dc.skills_core_source as Measure).tokens_gpt,
             'command_catalog.gpt': (dc.commands_core_source as Measure).tokens_gpt,
             'mcp_schemas.gpt': mcp_gpt,
         };
-        for (const [key, val] of Object.entries(checks)) {
-            const cap = BUDGETS[key];
-            if (cap !== null && cap !== undefined && val > cap) {
-                breaches.push(`${key} ${val} > budget ${cap}`);
-            }
-        }
+        const breaches = evaluate_budgets(checks, BUDGETS);
         if (breaches.length > 0) {
             process.stdout.write('❌  initial-context budget: ' + breaches.join('; ') + '\n');
             return 1;

package/src/scripts/bench_quality_run.ts

@@ -0,0 +1,253 @@
+#!/usr/bin/env tsx
+/**
+ * Thin-vs-eager quality-run producer (token-saving Phase 0 EXIT).
+ *
+ * The missing RUNNER that produces `internal/bench/reports/quality-run.json` —
+ * the report the `check_quality_regression` gate consumes. For each labelled
+ * golden task it generates the agent's answer under the THIN rule context
+ * (kernel bodies + non-kernel pointers) and the EAGER context (all rule bodies),
+ * then judges the pair with the length-controlled paired judge
+ * (`evaluatePair`: both orders → reject-on-flip).
+ *
+ * Model calls (answer generation + judging) go through the proven council
+ * `AnthropicClient` (synchronous curl → Anthropic Messages API) — so this is
+ * **API-gated**: a real run needs an Anthropic key and costs money proportional
+ * to (golden tasks × 2 arms + 2 judge calls) × the rule-context size. Use
+ * `--dry-run` (deterministic mock, no API) to prove the pipeline + see the
+ * output shape first, and `--limit N` to bound a live run.
+ *
+ * CLI:
+ *   ./scripts-run src/scripts/bench_quality_run --dry-run            # mock, no API
+ *   ./scripts-run src/scripts/bench_quality_run --limit 5            # live, first 5 tasks
+ *   ./scripts-run src/scripts/bench_quality_run --model claude-sonnet-4-5
+ * Then gate on it: ./scripts-run src/scripts/check_quality_regression
+ *
+ * Exit codes: 0 wrote report · 1 error.
+ */
+import { createRequire } from 'node:module';
+import * as fs from 'node:fs';
+import * as path from 'node:path';
+import process from 'node:process';
+import { fileURLToPath, pathToFileURL } from 'node:url';
+
+import yaml from 'js-yaml';
+
+import { build_thin, RULES_SOURCE } from './project_thin_rules.js';
+import { evaluatePair, type JudgeFn, type JudgeVerdict, type PairResult } from './check_quality_regression.js';
+
+const _HERE = fileURLToPath(import.meta.url);
+const REPO_ROOT = path.resolve(path.dirname(_HERE), '..', '..');
+const GOLDEN = path.join(REPO_ROOT, 'internal/bench/corpora/token-quality-golden.yaml');
+const OUT = path.join(REPO_ROOT, 'internal/bench/reports/quality-run.json');
+const DEFAULT_THRESHOLD = 0.48;
+
+export interface GoldenTask {
+  id: string;
+  rubric: string;
+  prompt: string;
+  must_include: string[];
+  must_not: string[];
+}
+
+/** Load the labelled golden tasks (stubs are skipped — they have no real rubric). */
+export function load_golden(file = GOLDEN): GoldenTask[] {
+  const doc = yaml.load(fs.readFileSync(file, 'utf-8')) as { tasks?: unknown[] };
+  const tasks = Array.isArray(doc?.tasks) ? doc.tasks : [];
+  const out: GoldenTask[] = [];
+  for (const t of tasks as Array<Record<string, unknown>>) {
+    if (t.label_status !== 'labelled') continue;
+    const exp = (t.expected ?? {}) as Record<string, unknown>;
+    out.push({
+      id: String(t.id),
+      rubric: String(exp.rubric ?? ''),
+      prompt: String(t.prompt ?? ''),
+      must_include: Array.isArray(exp.must_include) ? exp.must_include.map(String) : [],
+      must_not: Array.isArray(exp.must_not) ? exp.must_not.map(String) : [],
+    });
+  }
+  return out;
+}
+
+/** Assemble the always-loaded rule context for each arm (eager bodies vs thin pointers). */
+export function assemble_contexts(rulesDir = RULES_SOURCE): { eager: string; thin: string } {
+  const thinMap = build_thin(rulesDir);
+  const thin = [...thinMap.values()].join('\n\n');
+  const eager = fs
+    .readdirSync(rulesDir)
+    .filter((n) => n.endsWith('.md'))
+    .sort()
+    .map((n) => fs.readFileSync(path.join(rulesDir, n), 'utf-8'))
+    .join('\n\n');
+  return { eager, thin };
+}
+
+/** A model that answers a task under a given rule context. */
+export type AnswerFn = (armContext: string, task: GoldenTask) => string;
+
+/** A judge that, given the FULL task (rubric + anchors) + two presented answers,
+ * returns the order-relative verdict. Wrapped into evaluatePair's narrow JudgeFn. */
+export type ModelJudgeFn = (task: GoldenTask, first: string, second: string) => JudgeVerdict;
+
+/** Build the judge user-prompt — length-controlled (ignore verbosity). */
+export function judge_prompt(task: GoldenTask, first: string, second: string): string {
+  return (
+    `Rubric: ${task.rubric}\n` +
+    (task.must_include.length ? `Must satisfy: ${task.must_include.join('; ')}\n` : '') +
+    (task.must_not.length ? `Must avoid: ${task.must_not.join('; ')}\n` : '') +
+    `\nTwo answers to the same request. Judge ONLY which better satisfies the rubric —\n` +
+    `IGNORE length and verbosity (a longer answer is not better).\n\n` +
+    `--- ANSWER A ---\n${first}\n\n--- ANSWER B ---\n${second}\n\n` +
+    `Reply with exactly one line: "VERDICT: A", "VERDICT: B", or "VERDICT: TIE".`
+  );
+}
+
+/** Parse a judge reply into the order-relative verdict (default tie = inconclusive). */
+export function parse_verdict(reply: string): JudgeVerdict {
+  const m = /VERDICT:\s*(A|B|TIE)/i.exec(reply);
+  if (!m) return 'tie';
+  const v = (m[1] as string).toUpperCase();
+  return v === 'A' ? 'first' : v === 'B' ? 'second' : 'tie';
+}
+
+/** Run every task through both arms + the paired judge. Pure given the injected fns. */
+export function run_golden_judge(
+  tasks: GoldenTask[],
+  contexts: { eager: string; thin: string },
+  answer: AnswerFn,
+  judge: ModelJudgeFn,
+): PairResult[] {
+  return tasks.map((task) => {
+    const thinAnswer = answer(contexts.thin, task);
+    const eagerAnswer = answer(contexts.eager, task);
+    // evaluatePair calls its JudgeFn with the narrow {id,rubric} ctx; capture
+    // the full task here so the model judge gets the rubric + anchors.
+    const judgeFn: JudgeFn = (_ctx, first, second) => judge(task, first, second);
+    return evaluatePair(task, thinAnswer, eagerAnswer, judgeFn);
+  });
+}
+
+// ── Mock model (--dry-run): deterministic, no API ───────────────────────────
+function mock_answer(_ctx: string, task: GoldenTask): string {
+  return `Answer to ${task.id}: ${(task.must_include[0] ?? 'addresses the request')}.`;
+}
+const mock_judge: ModelJudgeFn = () => 'tie'; // dry-run can't truly compare → all ties
+
+interface Args {
+  dryRun: boolean;
+  model: string;
+  limit: number | null;
+  output: string;
+}
+
+function parse_args(argv: string[]): Args | number {
+  const a: Args = { dryRun: false, model: 'claude-sonnet-4-5', limit: null, output: OUT };
+  for (let i = 0; i < argv.length; i += 1) {
+    const arg = argv[i];
+    if (arg === '--dry-run') a.dryRun = true;
+    else if (arg === '--model') a.model = String(argv[(i += 1)] ?? a.model);
+    else if (arg === '--output') a.output = String(argv[(i += 1)] ?? a.output);
+    else if (arg === '--limit') {
+      const v = Number(argv[(i += 1)]);
+      if (!Number.isInteger(v) || v < 1) {
+        process.stderr.write('error: --limit must be a positive integer\n');
+        return 1;
+      }
+      a.limit = v;
+    } else if (arg === '-h' || arg === '--help') {
+      process.stdout.write('usage: bench_quality_run [--dry-run] [--model M] [--limit N] [--output PATH]\n');
+      return 0;
+    } else {
+      process.stderr.write(`error: unknown argument: ${arg}\n`);
+      return 1;
+    }
+  }
+  return a;
+}
+
+function main(argv: string[]): number {
+  const parsed = parse_args(argv);
+  if (typeof parsed === 'number') return parsed;
+  const args = parsed;
+
+  let tasks = load_golden();
+  if (tasks.length === 0) {
+    process.stderr.write('error: no labelled golden tasks — fill internal/bench/corpora/token-quality-golden.yaml\n');
+    return 1;
+  }
+  if (args.limit !== null) tasks = tasks.slice(0, args.limit);
+  const contexts = assemble_contexts();
+
+  let answer: AnswerFn;
+  let judge: ModelJudgeFn;
+  let modelLabel: string;
+
+  if (args.dryRun) {
+    answer = mock_answer;
+    judge = mock_judge;
+    modelLabel = 'dry-run-mock';
+    process.stdout.write(`⚠️  --dry-run: deterministic mock, no API. Output shape only.\n`);
+  } else {
+    // Live path — reuse the proven council AnthropicClient (sync curl). API-gated.
+    let client: { ask(system: string, user: string): { text: string } };
+    try {
+      // Lazy import so --dry-run + tests never touch the council key path.
+      const require = createRequire(import.meta.url);
+      const clients = require('./ai_council/clients.js') as {
+        AnthropicClient: new (o: { model: string; api_key: string }) => { ask(s: string, u: string): { text: string } };
+        load_anthropic_key: () => string;
+      };
+      client = new clients.AnthropicClient({ model: args.model, api_key: clients.load_anthropic_key() });
+    } catch (e) {
+      process.stderr.write(
+        `error: live model unavailable (${(e as Error).message}). ` +
+          `Set an Anthropic key (see install-anthropic-key) or use --dry-run.\n`,
+      );
+      return 1;
+    }
+    const SYS =
+      'You are an AI coding agent governed by the following always-loaded package rules. ' +
+      'Answer the user request as that agent would, honouring these rules:\n\n';
+    answer = (ctx, task) => client.ask(SYS + ctx, task.prompt).text;
+    judge = (task, first, second) =>
+      parse_verdict(
+        client.ask('You are a strict, length-neutral answer judge.', judge_prompt(task, first, second)).text,
+      );
+    modelLabel = args.model;
+    process.stdout.write(
+      `Live run: ${tasks.length} tasks × 2 arms + 2 judge calls each via ${args.model}. This costs API $.\n`,
+    );
+  }
+
+  let results: PairResult[];
+  try {
+    results = run_golden_judge(tasks, contexts, answer, judge);
+  } catch (e) {
+    process.stderr.write(`error: run failed: ${(e as Error).message}\n`);
+    return 1;
+  }
+
+  const payload = {
+    generated_by: 'bench_quality_run',
+    judge_model: modelLabel,
+    dry_run: args.dryRun,
+    threshold: DEFAULT_THRESHOLD,
+    results,
+  };
+  fs.writeFileSync(args.output, JSON.stringify(payload, null, 2) + '\n');
+  const thinWins = results.filter((r) => r.winner === 'thin').length;
+  const eagerWins = results.filter((r) => r.winner === 'eager').length;
+  process.stdout.write(
+    `→ wrote ${path.relative(REPO_ROOT, args.output)} (${results.length} pairs; ` +
+      `thin ${thinWins} / eager ${eagerWins}). Gate: \`check_quality_regression\`.\n`,
+  );
+  return 0;
+}
+
+const _IS_MAIN =
+  process.argv[1] !== undefined &&
+  import.meta.url === pathToFileURL(path.resolve(process.argv[1])).href;
+if (_IS_MAIN) {
+  process.exit(main(process.argv.slice(2)));
+}
+
+export { main, mock_answer };