@event4u/agent-config 16.3.0 → 16.5.0

package/src/scripts/ai_council/modification_review.ts

@@ -0,0 +1,100 @@
+/**
+ * modification_review — the review verb for a diff whose bundle contains a
+ * gated path: how a seat closes, and how the record's verdict follows.
+ *
+ * `road-to-self-modification-that-a-council-must-pass` steps 3.2 and 3.3.
+ *
+ * WHY THE EXISTING STANCE PARSER AND NOT A NEW ONE. Seats already close on a
+ * `STANCE: … | CONFIDENCE: … | DEALBREAKER: …` line, and `stance_tally` already
+ * parses it — including the two cosmetic defects it forgives. A second grammar
+ * for the same closing line would be a second thing to keep in step with the
+ * prompt, and the first time they diverged a seat's verdict would be read by
+ * one and dropped by the other.
+ *
+ * WHAT IS DELIBERATELY NOT USED. Not the option tally, and not the synthesis
+ * verdict line. Both answer which OPTION wins a deliberation; this review asks
+ * whether each SEAT passed a change, which is a different question over the
+ * same replies. Nor is the diff lens's own closing line asked for — a lens is
+ * not a seat.
+ *
+ * WHY A VERB OF ITS OWN HERE RATHER THAN AN `agent-config` COMMAND. The CLI
+ * help-count budget is at its maximum (`cli_help_command_count` in
+ * `src/config/evaluator-budgets.json`), so a new top-level verb would spend a
+ * ratchet this change has no claim on. It dispatches inside `council_cli`.
+ */
+
+import { parse_stance_line } from './stance_tally.js';
+
+/**
+ * The closed vocabulary a seat may close on. Open it and a grep for a passing
+ * verdict starts reading words nobody adjudicated — the failure
+ * `ratification-artifact.md` names for its own `verdict` field.
+ */
+export const MODIFICATION_VERDICT_LABELS = [
+    'ratified',
+    'confirmed-non-expanding',
+    'refused',
+] as const;
+
+export type ModificationVerdictLabel = (typeof MODIFICATION_VERDICT_LABELS)[number];
+
+/** The record's verdict: a seat label, or the one value no seat may utter. */
+export type ModificationVerdict = ModificationVerdictLabel | 'non-convergent';
+
+/**
+ * Read ONE seat's reply. Returns its label when the seat concluded, `null`
+ * otherwise — a missing line, an abstention, or any other label.
+ *
+ * `null` is never inferred from surrounding prose: a seat that writes
+ * "I would call this ratified" has not closed on a stance line, and reading it
+ * as a conclusion is how a review starts reporting verdicts nobody gave.
+ */
+export function seatConclusion(text: string): ModificationVerdictLabel | null {
+    const line = parse_stance_line(text);
+    if (line === null) return null;
+    const label = line.label.trim().toLowerCase();
+    return (MODIFICATION_VERDICT_LABELS as readonly string[]).includes(label)
+        ? (label as ModificationVerdictLabel)
+        : null;
+}
+
+/**
+ * Read every seat, keeping the non-concluding ones present and `null` rather
+ * than dropping them. A dropped seat is indistinguishable from a seat that was
+ * never asked, and the quorum rule below has to tell those apart.
+ */
+export function readSeatConclusions(
+    replies: Readonly<Record<string, string>>,
+): Record<string, ModificationVerdictLabel | null> {
+    const out: Record<string, ModificationVerdictLabel | null> = {};
+    for (const [seat, text] of Object.entries(replies)) {
+        out[seat] = seatConclusion(text);
+    }
+    return out;
+}
+
+/**
+ * Derive the record's verdict. ONE rule, and the ORDER is the rule:
+ *
+ *   1. any concluding seat on `refused`  → `refused`
+ *   2. concluding providers < required   → `non-convergent`
+ *   3. any concluding seat on `ratified` → `ratified`
+ *   4. otherwise (all concluded, all non-expanding) → `confirmed-non-expanding`
+ *
+ * Step 1 precedes step 2 on purpose. A single refusing seat is a refusal even
+ * when it is the only seat that concluded: letting the quorum rule fire first
+ * would turn "one reviewer said no" into "not enough reviewers answered", which
+ * reads as a retryable condition rather than as the objection it is.
+ */
+export function deriveModificationVerdict(
+    seats: Readonly<Record<string, ModificationVerdictLabel | null>>,
+    requiredProviders: number,
+): ModificationVerdict {
+    const concluded = Object.values(seats).filter(
+        (v): v is ModificationVerdictLabel => v !== null,
+    );
+    if (concluded.includes('refused')) return 'refused';
+    if (concluded.length < requiredProviders) return 'non-convergent';
+    if (concluded.includes('ratified')) return 'ratified';
+    return 'confirmed-non-expanding';
+}

package/src/scripts/ai_council/modification_review_questions.ts

@@ -0,0 +1,90 @@
+/**
+ * modification_review_questions — the fixed set a modification review asks
+ * every seat, one by one.
+ *
+ * `road-to-self-modification-that-a-council-must-pass` step 3.1. The owner's
+ * directive of 2026-10-05 is that self-modification is a goal, confirmed by a
+ * council that "always questions critically and checks what the modification
+ * does". A council that is merely ASKED for an opinion produces an opinion; a
+ * council handed a fixed list answers the same nine things about every change,
+ * and a reader can tell which one a seat skipped.
+ *
+ * WHY A CONSTANT RATHER THAN PROSE IN A PROMPT. The list is the review's
+ * contract, so it is quoted in `docs/contracts/ratification-artifact.md` and
+ * read from here by whatever renders the prompt. One definition, two readers —
+ * the alternative is a prompt and a contract that drift apart silently, which
+ * is the drift this package's own gates exist to catch.
+ *
+ * WHERE THE TREE ALREADY WORDS A QUESTION, THAT WORDING IS USED rather than
+ * paraphrased. Two do: `evaluator-independence`'s weakening clause and the
+ * synthesis prompt's kill-switch criteria. A paraphrase would be a second,
+ * slightly different standard for the same thing — and each carries a `source`
+ * so a reader can check the borrow rather than take it.
+ */
+
+/** One question, addressable on its own so a skipped answer is visible. */
+export interface ModificationReviewQuestion {
+    /** Stable id; the record's body keys each seat's answer by it. */
+    readonly id: string;
+    /** The question as asked, verbatim. */
+    readonly text: string;
+    /** Where the wording came from, when it was taken rather than written. */
+    readonly source?: string;
+}
+
+/**
+ * The nine, in the order step 3.1 enumerates them. Order is part of the
+ * contract: a seat answering one by one answers them in this sequence, so a
+ * record can be read against the list without matching prose to intent.
+ */
+export const MODIFICATION_REVIEW_QUESTIONS: readonly ModificationReviewQuestion[] = [
+    {
+        id: 'behaviour-change',
+        text: 'What behaviour changes, including what follows from it that the diff does not state?',
+    },
+    {
+        id: 'boundary-direction',
+        text: 'Which authority or safety boundary becomes wider or narrower, and in which direction?',
+    },
+    {
+        id: 'weakens-its-own-judge',
+        text:
+            'Does the change weaken anything that judges it — a test, a gate, a threshold, this review? ' +
+            'The standard is quoted rather than paraphrased: the implementer never silently ' +
+            'weakens an assertion, deletes, skips or xfails a failing test, lowers a threshold, ' +
+            'or changes fixture semantics to fit the code. Does this change do any of those?',
+        source: 'src/rules/evaluator-independence.md § Tests are evaluators',
+    },
+    {
+        id: 'route-around',
+        text: 'Is another host or projection left as a way around the control this change touches?',
+    },
+    {
+        id: 'undo',
+        text: 'Can it be undone, and how — by whom, with what authority, and against which revision?',
+    },
+    {
+        id: 'falsifier',
+        text:
+            'What observation would show the claimed benefit to be false, and what rollback / ' +
+            'kill-switch criteria does the change omit?',
+        source: 'src/scripts/ai_council/prompts.ts (DESIGN_MODE, ROADMAP_MODE)',
+    },
+    {
+        id: 'smaller-change',
+        text: 'Would a smaller change do, and what does the larger one buy that the smaller one does not?',
+    },
+    {
+        id: 'instruction-weight',
+        text: 'What does it add to standing instruction weight that every later session pays?',
+    },
+    {
+        id: 'untrusted-steering',
+        text: 'Could untrusted content steer the path this change opens, and what bounds it if so?',
+    },
+];
+
+/** The list as a seat sees it: numbered, in order, nothing dropped. */
+export function renderModificationReviewQuestions(): string {
+    return MODIFICATION_REVIEW_QUESTIONS.map((q, i) => `${i + 1}. ${q.text}`).join('\n');
+}

package/src/scripts/ai_council/orchestrator.ts

@@ -412,7 +412,7 @@ export function consult(
         return [];
     }
     const resolvedBudget = budget ?? new CostBudget();
-    if (members.length > resolvedBudget.max_calls) {
+    if (resolvedBudget.max_calls > 0 && members.length > resolvedBudget.max_calls) {
         throw new Error(
             `Council has ${members.length} members but budget caps at ` +
                 `${resolvedBudget.max_calls} calls.`,
@@ -802,9 +802,9 @@ function _run_round(
             );
             actual_usd = _total_usd(actual);
             spent.usd += _total_usd(actual);
-            // Persist to the rolling 24h ledger when the daily cap is
-            // active. Errors are swallowed inside record_spend.
-            if (budget.daily_limit_usd > 0 && !response.error) {
+            // Ledger every billable response, bounded or not (ADR-279): a cap
+            // decides whether the total is compared, never whether it is kept.
+            if (!response.error) {
                 _record_daily_spend(_total_usd(actual), effective.name, effective.model, {
                     cache_read_input_tokens: response.cache_read_input_tokens,
                     cache_creation_input_tokens: response.cache_creation_input_tokens,
@@ -1246,7 +1246,7 @@ export function run_debate(
         return [];
     }
     const budget = budget0 ?? new CostBudget();
-    if (members.length > budget.max_calls) {
+    if (budget.max_calls > 0 && members.length > budget.max_calls) {
         throw new Error(
             `Debate has ${members.length} members but budget caps at ` +
                 `${budget.max_calls} calls.`,

package/src/scripts/ai_council/spend_gate.ts

@@ -20,9 +20,9 @@ import type { ExternalAIClient } from './clients.js';
 import { would_exceed as _would_exceed_daily } from './budget_guard.js';
 
 export class CostBudget {
-    max_input_tokens: number;
-    max_output_tokens: number;
-    max_calls: number;
+    max_input_tokens: number; // 0 = input-token ceiling disabled
+    max_output_tokens: number; // 0 = output-token ceiling disabled
+    max_calls: number; // 0 = per-invocation call cap disabled (fan-out unbounded)
     max_total_usd: number; // 0 = USD ceiling disabled (token caps still apply)
     daily_limit_usd: number; // 0 = rolling 24h cap disabled (D3)
 
@@ -35,8 +35,11 @@ export class CostBudget {
             daily_limit_usd?: number;
         } = {},
     ) {
-        this.max_input_tokens = args.max_input_tokens ?? 50_000;
-        this.max_output_tokens = args.max_output_tokens ?? 20_000;
+        // ADR-279: the two token ceilings default to 0 = unbounded, as the two
+        // USD ceilings below already did. `max_calls` keeps its default — it
+        // bounds fan-out against a plan quota, not money.
+        this.max_input_tokens = args.max_input_tokens ?? 0;
+        this.max_output_tokens = args.max_output_tokens ?? 0;
         this.max_calls = args.max_calls ?? 10;
         this.max_total_usd = args.max_total_usd ?? 0.0;
         this.daily_limit_usd = args.daily_limit_usd ?? 0.0;
@@ -101,9 +104,17 @@ export function _breach(
     budget: CostBudget,
 ): BreachKind {
     const usd = est ? _total_usd(est) : 0.0;
+    // Zero disables a token cap, as `ai-council-config.md:84-86` has always
+    // said it does. Until 2026-10-06 these two comparisons carried no guard
+    // while the two USD comparisons below them did, so a budget with every
+    // cap at zero — the contract's "no bound at all" — breached on a
+    // ten-token estimate. The guard goes on each cap separately: a user who
+    // set one and left the other at zero is bounded by the one they set.
     if (
-        spent.input + (est ? est.input_tokens : 0) > budget.max_input_tokens ||
-        spent.output + (est ? est.output_tokens : 0) > budget.max_output_tokens
+        (budget.max_input_tokens > 0 &&
+            spent.input + (est ? est.input_tokens : 0) > budget.max_input_tokens) ||
+        (budget.max_output_tokens > 0 &&
+            spent.output + (est ? est.output_tokens : 0) > budget.max_output_tokens)
     ) {
         return 'tokens';
     }

package/src/scripts/ai_team/config.ts

@@ -31,9 +31,10 @@
  * 1. `ai_team` absent → defaults. Non-mapping → error.
  * 2. Unknown keys under `ai_team` are rejected — a typo must never
  *    silently disable a gate (`allow_delegate` misspelled = delegation
- *    stays off AND the load fails loudly). `enabled` is the one
- *    deliberate exception: accepted, untyped, ignored (see above).
- * 3. `allow_delegate`, `suppress_setup_hint` are booleans.
+ *    stays off AND the load fails loudly). `enabled` and
+ *    `suppress_setup_hint` are the deliberate exceptions: retired keys,
+ *    accepted, untyped, ignored, so a leftover line never fails `/team`.
+ * 3. `allow_delegate` is a boolean.
  * 4. `model` is a non-empty string. `'auto'` = pass no `--model` flag
  *    (the codex CLI default applies); any other value passes through
  *    verbatim.
@@ -63,7 +64,6 @@ export interface AiTeamConfig {
     readonly model: string;
     readonly allow_delegate: boolean;
     readonly max_calls_per_day: number;
-    readonly suppress_setup_hint: boolean;
     readonly review_gate: AiTeamReviewGateConfig;
 }
 
@@ -78,7 +78,6 @@ export const AI_TEAM_DEFAULTS: AiTeamConfig = Object.freeze({
     model: 'auto',
     allow_delegate: false,
     max_calls_per_day: 50,
-    suppress_setup_hint: false,
     review_gate: AI_TEAM_REVIEW_GATE_DEFAULTS,
 });
 
@@ -93,17 +92,18 @@ const _KNOWN_KEYS: ReadonlySet<string> = new Set([
     'model',
     'allow_delegate',
     'max_calls_per_day',
-    'suppress_setup_hint',
     'review_gate',
 ]);
 
 /**
- * Deleted key accepted-and-ignored for migration grace (see module docstring).
- * Never added to `_KNOWN_KEYS` — it carries no validated type and is never
- * read into `AiTeamConfig`; it exists in this set only so the unknown-key
+ * Deleted keys accepted-and-ignored for migration grace (see module docstring).
+ * Never added to `_KNOWN_KEYS` — they carry no validated type and are never
+ * read into `AiTeamConfig`; they exist in this set only so the unknown-key
  * loop below does not fail-closed an existing project's leftover value.
+ * `suppress_setup_hint` is the shipped template's own line, so every install
+ * that ran the wizard carries it.
  */
-const _DELETED_KEYS: ReadonlySet<string> = new Set(['enabled']);
+const _DELETED_KEYS: ReadonlySet<string> = new Set(['enabled', 'suppress_setup_hint']);
 
 const _KNOWN_REVIEW_GATE_KEYS: ReadonlySet<string> = new Set([
     'managed',
@@ -205,11 +205,6 @@ export function build_ai_team_config(raw: unknown): AiTeamConfig {
     }
 
     const allow_delegate = _requireBool(raw, 'allow_delegate', AI_TEAM_DEFAULTS.allow_delegate);
-    const suppress_setup_hint = _requireBool(
-        raw,
-        'suppress_setup_hint',
-        AI_TEAM_DEFAULTS.suppress_setup_hint,
-    );
 
     let model = AI_TEAM_DEFAULTS.model;
     if ('model' in raw) {
@@ -236,7 +231,7 @@ export function build_ai_team_config(raw: unknown): AiTeamConfig {
 
     const review_gate = _build_review_gate('review_gate' in raw ? raw['review_gate'] : undefined);
 
-    return { model, allow_delegate, max_calls_per_day, suppress_setup_hint, review_gate };
+    return { model, allow_delegate, max_calls_per_day, review_gate };
 }
 
 /**

package/src/scripts/audit_user_type_axis.ts

@@ -3,10 +3,15 @@
  * Audit the user-type axis frontmatter coverage (step-9 Phase 4).
  *
  * Ported from the retired Python `src/scripts/audit_user_type_axis.py` (ADR-200,
- * Phase 8 / Wave 8a). The CLI contract is pinned — the single
- * `--quiet` flag, exit code (1 when orphans exist, else 0), the stdout
- * split, byte-identical stdout summary, AND byte-identical generated
- * Markdown report. Stdlib-only — no YAML dependency.
+ * Phase 8 / Wave 8a). The CLI contract is pinned — `--quiet`, exit code (1
+ * when orphans exist, else 0), the stdout split, byte-identical stdout
+ * summary, AND byte-identical generated Markdown report. Stdlib-only — no YAML
+ * dependency.
+ *
+ * `--write` (2026-10-07) is the one deliberate addition: the report is written
+ * ONLY under it. Every run used to rewrite the tracked report, so the
+ * `lint-user-type-axis` task — a read — dirtied the working tree. The lint
+ * reads; `task regen-user-type-axis-report` writes.
  *
  * Two checks across `src/skills/`:
  *
@@ -242,6 +247,7 @@ export function _render_report(
 
 export function main(argv: string[]): number {
     const quiet = argv.includes('--quiet');
+    const write = argv.includes('--write');
     // Scope assertion: the orphan/unused verdict is a set difference against
     // the skills corpus, so an unreadable corpus does not yield "no orphans",
     // it yields a vacuous answer that looks identical to a clean one.
@@ -267,9 +273,11 @@ export function main(argv: string[]): number {
     const orphans = new Set<string>([...used].filter((v) => !declared.has(v)));
     const unused = new Set<string>([...declared].filter((v) => !used.has(v)));
 
-    const report = _render_report(declared, byValue, orphans, unused);
-    fs.mkdirSync(path.dirname(REPORT_PATH), { recursive: true });
-    fs.writeFileSync(REPORT_PATH, report, 'utf-8');
+    if (write) {
+        const report = _render_report(declared, byValue, orphans, unused);
+        fs.mkdirSync(path.dirname(REPORT_PATH), { recursive: true });
+        fs.writeFileSync(REPORT_PATH, report, 'utf-8');
+    }
 
     if (!quiet) {
         process.stdout.write(
@@ -283,7 +291,11 @@ export function main(argv: string[]): number {
         if (unused.size > 0) {
             process.stdout.write('  warn unused: ' + _sorted(unused).join(', ') + '\n');
         }
-        process.stdout.write(`  report: ${_relativeToPosix(REPORT_PATH, REPO_ROOT)}\n`);
+        process.stdout.write(
+            write
+                ? `  report: ${_relativeToPosix(REPORT_PATH, REPO_ROOT)}\n`
+                : '  report: not written (pass --write to regenerate it)\n',
+        );
     }
 
     if (orphans.size === 0) {

package/src/scripts/bench_ab_clone.ts

@@ -199,8 +199,7 @@ export function write_clone_settings(variant: string, target: string): void {
         '# Generated by bench_ab_clone.py for the A/B/C value benchmark.\n' +
         '# Only the RDP toggle is set here; everything else uses package defaults.\n' +
         'reasoning:\n' +
-        `  enabled: ${enabled}\n` +
-        '  auto_gate: true\n';
+        `  enabled: ${enabled}\n`;
     fs.writeFileSync(path.join(target, '.agent-settings.yml'), settings, 'utf-8');
 }
 

package/src/scripts/bench_concern_spawn_path.ts

@@ -0,0 +1,129 @@
+#!/usr/bin/env tsx
+/**
+ * Wall time of one blocking `pre_tool_use` concern through the SPAWN path —
+ * interpreter start included — as p50 and p95.
+ *
+ * `road-to-a-ratification-fence-that-follows-its-imports` 4.1, the receiver for
+ * the half of the archived plumbing roadmap's AC-3 that was carried "as the
+ * narrowing it is". `concern_sla_ms` measures in-process concern work only, so
+ * `sla_ms x 3` could not be judged as a spawn timeout: the tree had no
+ * spawn-path number. This produces one.
+ *
+ * It replicates `dispatch_hook._run_concern`'s isolated branch rather than
+ * calling it (that function is private plumbing and editing it to export a
+ * helper would be a gated change for a measurement): the same `tsx` binary the
+ * dispatcher resolves from `node_modules/.bin`, the same envelope builder
+ * (`_build_envelope`), the same hardened env, the envelope on stdin, and the
+ * concern's own `--platform` argument. What it does not include is the
+ * dispatcher's own start-up, which happens once per event, not once per
+ * concern.
+ *
+ * It gates nothing and wires nothing. Whether a timeout of `sla_ms x 3` is
+ * tenable is a READING of its output, made by whoever reads it, and one
+ * machine's p95 is that machine's.
+ *
+ * Usage:
+ *     npx tsx src/scripts/bench_concern_spawn_path.ts [--runs 20] [--concern block-no-verify]
+ *
+ * Exit 0 on a measurement, 2 when the concern or `tsx` cannot be found.
+ */
+
+import { spawnSync } from 'node:child_process';
+import * as fs from 'node:fs';
+import * as os from 'node:os';
+import * as path from 'node:path';
+import { performance } from 'node:perf_hooks';
+import { fileURLToPath, pathToFileURL } from 'node:url';
+
+import { parse as parseYaml } from 'yaml';
+
+import { hardenedSpawnEnv } from './_lib/spawn_env.js';
+import { _build_envelope } from './hooks/dispatch_hook.js';
+
+const _HERE = fileURLToPath(import.meta.url);
+const REPO = path.resolve(path.dirname(_HERE), '..', '..');
+
+/** Nearest-rank percentile over a sorted copy. */
+export function percentile(samples: readonly number[], p: number): number {
+    if (samples.length === 0) {
+        return Number.NaN;
+    }
+    const sorted = [...samples].sort((a, b) => a - b);
+    const rank = Math.max(1, Math.ceil((p / 100) * sorted.length));
+    return sorted[Math.min(rank, sorted.length) - 1] as number;
+}
+
+function concernScript(name: string): string | null {
+    const manifest = parseYaml(fs.readFileSync(path.join(REPO, 'src/scripts/hook_manifest.yaml'), 'utf8')) as {
+        concerns?: Record<string, { script?: string; severity?: string }>;
+    };
+    const def = manifest.concerns?.[name];
+    return def?.script === undefined ? null : path.join(REPO, def.script);
+}
+
+export function main(argv: readonly string[] = process.argv.slice(2)): number {
+    let runs = 20;
+    let concern = 'block-no-verify';
+    for (let i = 0; i < argv.length; i += 1) {
+        if (argv[i] === '--runs') {
+            runs = Number(argv[i + 1] ?? runs);
+            i += 1;
+        } else if (argv[i] === '--concern') {
+            concern = argv[i + 1] ?? concern;
+            i += 1;
+        }
+    }
+    const script = concernScript(concern);
+    const tsx = path.join(REPO, 'node_modules', '.bin', process.platform === 'win32' ? 'tsx.cmd' : 'tsx');
+    if (script === null || !fs.existsSync(script) || !fs.existsSync(tsx)) {
+        process.stderr.write(`bench_concern_spawn_path: concern ${concern} or ${tsx} not found\n`);
+        return 2;
+    }
+    const payload = JSON.stringify({
+        session_id: 'bench',
+        hook_event_name: 'PreToolUse',
+        tool_name: 'Bash',
+        tool_input: { command: 'ls' },
+    });
+    const envelope = _build_envelope(
+        {
+            platform: 'claude',
+            event: 'pre_tool_use',
+            native_event: 'PreToolUse',
+        } as Parameters<typeof _build_envelope>[0],
+        payload,
+    );
+    const input = JSON.stringify(envelope);
+    const env = hardenedSpawnEnv({ AGENT_CONFIG_PACKAGE_ROOT: REPO });
+
+    const samples: number[] = [];
+    const codes = new Set<number | null>();
+    for (let i = 0; i < runs; i += 1) {
+        const t0 = performance.now();
+        const proc = spawnSync(tsx, [script, '--platform', 'claude'], {
+            input,
+            encoding: 'utf-8',
+            cwd: REPO,
+            env,
+            timeout: 30_000,
+        });
+        samples.push(performance.now() - t0);
+        codes.add(proc.status);
+    }
+    const cpu = os.cpus()[0]?.model ?? 'unknown cpu';
+    process.stdout.write(
+        [
+            `concern: ${concern} (${path.relative(REPO, script)})`,
+            `runner: ${os.platform()} ${os.arch()} · ${cpu} · ${String(os.cpus().length)} cpus · node ${process.version}`,
+            `runs: ${String(runs)} · exit codes: ${[...codes].join(', ')}`,
+            `p50: ${percentile(samples, 50).toFixed(1)} ms`,
+            `p95: ${percentile(samples, 95).toFixed(1)} ms`,
+            `max: ${Math.max(...samples).toFixed(1)} ms`,
+        ].join('\n') + '\n',
+    );
+    return 0;
+}
+
+if (process.argv[1] !== undefined && import.meta.url === pathToFileURL(process.argv[1]).href) {
+    process.exit(main());
+}