@event4u/agent-config 8.8.0 → 8.9.0

package/src/scripts/lint_roadmap_complexity.ts

@@ -190,6 +190,9 @@ function lint_roadmap(
     _check_execution_mode(fm, problems);
     if (warnings) {
         _check_autonomous_authoring(text, fm, warnings);
+        _check_human_gate_steps(text, warnings);
+        _check_human_gate_phase_headings(text, warnings);
+        _check_human_gate_exit_criteria(text, warnings);
     }
     return problems;
 }
@@ -236,6 +239,127 @@ function _check_autonomous_authoring(text: string, fm: string, warnings: string[
     }
 }
 
+// Human-gate step patterns (templates/roadmaps.md rule 22) — checkbox
+// steps that park work on a human instead of the agent. Steps are
+// agent-executable by default; genuinely user-clearable gates belong in
+// a structured `## Blockers` entry, agent-checkable verifications become
+// commands / targeted tests. Warnings never fail the lint; they fire for
+// every execution mode (an interactive roadmap with sprinkled human-check
+// steps is the same authoring bug, just slower to hurt).
+const HUMAN_GATE_STEP_PATS: Array<[RegExp, string]> = [
+    [
+        /\b(user|maintainer|human|operator|stakeholder|product owner) (verifies|reviews|approves|confirms|signs?[- ]off(?: on)?|inspects|validates)\b/i,
+        "'<human> verifies / reviews / approves …' step",
+    ],
+    [
+        /\bmanually (verify|review|check|test|confirm|inspect|validate)\b/i,
+        "'manually verify / check …' step",
+    ],
+    [
+        /\bwait for (the )?(user|maintainer|stakeholders?|approval|confirmation|review|feedback)\b/i,
+        "'wait for approval / user' step",
+    ],
+    [/\bask the (user|maintainer)\b/i, "'ask the user' step"],
+    [
+        /\b(get|obtain|request|await|collect) ((the|an?|final) )?((user|maintainer|stakeholder|product owner|team) )?(approval|confirmation|sign[- ]?off)\b/i,
+        "'obtain approval / sign-off' step",
+    ],
+    [/\bsign[- ]?off (from|by)\b/i, "'sign-off from <human>' step"],
+    [/\bhuman review (required|needed|gate)\b/i, "'human review required' step"],
+    [
+        /\b(confirm|check|verify|review|clarify) with the (user|maintainer)\b/i,
+        "'confirm with the user' step",
+    ],
+];
+
+// Human-gate phase headings (template rule 22) — a phase whose TITLE is
+// the human checkpoint ("## Phase 5 — Review / Sign-off", "## User
+// Acceptance"). Whole-heading match after an optional "Phase N" prefix,
+// so working headings ("## Review existing skills") never fire.
+const HUMAN_GATE_HEADING_PAT =
+    /^#{2,3}\s+(?:phase\s+\d+\s*(?:[—–:.-])?\s*)?(?:review(?:\s*(?:[/&+]|and)\s*sign[- ]?off)?|sign[- ]?off|approval|user\s+acceptance(?:\s+testing)?|manual\s+(?:verification|review|testing|qa)|human\s+(?:validation|review))\s*$/i;
+
+// Human-approval exit / acceptance criteria (template rule 22) — criteria
+// must be agent-decidable (exit code, file exists, test passes), never
+// "user approves" / "looks good". Applied inside Exit-criteria /
+// Acceptance blocks only.
+const HUMAN_GATE_CRITERIA_PAT =
+    /\b(user|maintainer|human|operator|stakeholder|product owner)\b[^\n]{0,60}\b(approv\w*|confirm\w*|sign[- ]?off|reviews)\b|\b(approval|confirmation|sign[- ]?off)\s+(from|by|received)\b|\blooks good\b/i;
+
+const EXIT_CRITERIA_OPENER_PAT = /^\s*(?:[-*]\s+)?\*{0,2}(exit criteria|acceptance(?: criteria)?)\*{0,2}\s*:?/i;
+
+const RULE22_HINT =
+    'templates/roadmaps.md rule 22: steps and criteria are agent-decidable; ' +
+    'replace with an agent-verifiable check (command / targeted test) or, ' +
+    'if only a human can decide/authorize, a structured ## Blockers entry';
+
+function _check_human_gate_steps(text: string, warnings: string[]): void {
+    for (const rawLine of text.split('\n')) {
+        if (!/^\s*-\s*\[ \]/.test(rawLine)) {
+            continue;
+        }
+        for (const [re, label] of HUMAN_GATE_STEP_PATS) {
+            if (re.test(rawLine)) {
+                warnings.push(
+                    `human-gate step (${label}): ` +
+                        `"${rawLine.trim().slice(0, 80)}" — ${RULE22_HINT}`,
+                );
+                break;
+            }
+        }
+    }
+}
+
+function _check_human_gate_phase_headings(text: string, warnings: string[]): void {
+    for (const rawLine of text.split('\n')) {
+        if (!rawLine.startsWith('#')) {
+            continue;
+        }
+        if (HUMAN_GATE_HEADING_PAT.test(rawLine)) {
+            warnings.push(
+                `human-gate phase heading: "${rawLine.trim().slice(0, 80)}" — ` +
+                    'a phase whose work only a human can finish blocks autonomous ' +
+                    `execution; ${RULE22_HINT}`,
+            );
+        }
+    }
+}
+
+function _check_human_gate_exit_criteria(text: string, warnings: string[]): void {
+    let inHeadingBlock = false;
+    let inInlineBlock = false;
+    for (const rawLine of text.split('\n')) {
+        const heading = /^#{1,6}\s+(.*)$/.exec(rawLine);
+        if (heading) {
+            inHeadingBlock = /\b(acceptance|exit criteria)\b/i.test(heading[1]!);
+            inInlineBlock = false;
+            continue;
+        }
+        if (rawLine.trim() === '') {
+            inInlineBlock = false;
+            continue;
+        }
+        const opener = EXIT_CRITERIA_OPENER_PAT.test(rawLine);
+        if (opener) {
+            inInlineBlock = true;
+        }
+        if (!inHeadingBlock && !inInlineBlock) {
+            continue;
+        }
+        // Open-checkbox lines are covered by _check_human_gate_steps;
+        // done/deferred/cancelled lines record history, not future gates.
+        if (/^\s*-\s*\[[ xX~-]\]/.test(rawLine)) {
+            continue;
+        }
+        if (HUMAN_GATE_CRITERIA_PAT.test(rawLine)) {
+            warnings.push(
+                `human-approval exit criterion: "${rawLine.trim().slice(0, 80)}" — ` +
+                    `criteria must be agent-decidable; ${RULE22_HINT}`,
+            );
+        }
+    }
+}
+
 function _check_execution_mode(fm: string, problems: string[]): void {
     if (!fm || !/^execution:/m.test(fm)) {
         return; // absent field = interactive default — valid

package/src/scripts/lint_versioned_cache.ts

@@ -0,0 +1,195 @@
+#!/usr/bin/env tsx
+/**
+ * Versioned-cache lint (road-to-retrieval-substrate-hardening B5b).
+ *
+ * Every derived cache the suite writes MUST be safe to invalidate when its
+ * producer changes — otherwise a tool-version bump silently reads a
+ * stale-format cache and corrupts the read path. This lint makes that
+ * discipline structural: any cache-file path literal in `src/scripts/**`
+ * must EITHER carry a version namespace in the path (`v<N>`, a `${…version…}`
+ * interpolation, or a `_VERSION`/`schema_version` reference), OR carry an
+ * explicit invalidation justification comment (`cache-version:` /
+ * `cache-invalidation:`) within a few lines — an author's ack that the cache
+ * is invalidated by another mechanism (full overwrite, content hash, …).
+ *
+ * It is a FAILING gate (this roadmap introduces it), scoped tightly to
+ * cache-file SUFFIXES so it has near-zero false-positive surface: it fires on
+ * the derived caches later phases create (B2 index, B3 learning sidecar, B5a
+ * stat-index), not on directories or ordinary data files.
+ *
+ * Usage: lint_versioned_cache.ts [--dir <root>] [--format text|json] [--quiet]
+ * Exit codes: 0 = clean, 1 = usage error, 2 = violations found, 3 = internal.
+ */
+import * as fs from 'node:fs';
+import * as path from 'node:path';
+import process from 'node:process';
+import { fileURLToPath } from 'node:url';
+
+const PROG = 'lint_versioned_cache.ts';
+
+/** Window (lines) around a cache-path literal scanned for a justification. */
+export const JUSTIFY_WINDOW = 6;
+
+/**
+ * A path literal is a "derived cache file" when its basename matches one of
+ * these suffixes. Suffix-based (not dir-based) to keep the trigger precise —
+ * ordinary data/config JSON does not match.
+ */
+export const CACHE_SUFFIX_RE =
+    /(?:^|[\/'"`\-.])(?:[a-z0-9_\-.]*)(?:-index|\.index|-cache|\.cache|\.stat-index|-stat-index|\.agent-learning)\.json(?:['"`]|$)/i;
+
+/** A version namespace present in the path literal itself. */
+const VERSION_IN_PATH_RE = /(?:[\/_\-.]v\d+|\$\{[^}]*[Vv]ersion[^}]*\}|\$\{[^}]*VERSION[^}]*\})/;
+
+/** An explicit author justification comment near the literal. */
+const JUSTIFY_RE = /(?:cache-version:|cache-invalidation:)/i;
+
+/** A string / template literal containing a cache-file path. */
+const LITERAL_RE = /(['"`])((?:\\.|(?!\1).)*?)\1/g;
+
+export interface Violation {
+    file: string;
+    line: number; // 1-indexed
+    literal: string;
+    message: string;
+}
+
+function listTsFiles(root: string): string[] {
+    const out: string[] = [];
+    const skip = new Set([
+        'node_modules',
+        '.git',
+        'dist',
+        'coverage',
+        '.turbo',
+        '.cache',
+        '__pycache__',
+    ]);
+    const walk = (dir: string): void => {
+        let entries: fs.Dirent[];
+        try {
+            entries = fs.readdirSync(dir, { withFileTypes: true });
+        } catch {
+            return;
+        }
+        for (const e of entries) {
+            if (e.isDirectory()) {
+                if (!skip.has(e.name)) walk(path.join(dir, e.name));
+            } else if (e.isFile() && e.name.endsWith('.ts') && !e.name.endsWith('.d.ts')) {
+                out.push(path.join(dir, e.name));
+            }
+        }
+    };
+    walk(root);
+    return out.sort();
+}
+
+function _isCachePathLiteral(value: string): boolean {
+    // Reset lastIndex — CACHE_SUFFIX_RE has no /g flag, so test() is safe.
+    return CACHE_SUFFIX_RE.test(value);
+}
+
+export function scanFile(file: string, source: string): Violation[] {
+    const lines = source.split('\n');
+    const violations: Violation[] = [];
+    for (let i = 0; i < lines.length; i++) {
+        const text = lines[i] as string;
+        LITERAL_RE.lastIndex = 0;
+        let m: RegExpExecArray | null;
+        while ((m = LITERAL_RE.exec(text)) !== null) {
+            const value = m[2] as string;
+            if (!_isCachePathLiteral(value)) continue;
+            if (VERSION_IN_PATH_RE.test(value)) continue; // versioned in the path itself
+
+            // Look for a justification comment in the window around the literal.
+            const from = Math.max(0, i - JUSTIFY_WINDOW);
+            const to = Math.min(lines.length - 1, i + JUSTIFY_WINDOW);
+            let justified = false;
+            for (let j = from; j <= to; j++) {
+                if (JUSTIFY_RE.test(lines[j] as string)) {
+                    justified = true;
+                    break;
+                }
+            }
+            if (justified) continue;
+
+            violations.push({
+                file,
+                line: i + 1,
+                literal: value,
+                message:
+                    'derived cache without a version namespace — add a `v<N>` (or ' +
+                    '`${…version…}`) segment to the path, or an inline ' +
+                    '`// cache-invalidation: <why no version is needed>` comment',
+            });
+        }
+    }
+    return violations;
+}
+
+export function runChecks(root: string): Violation[] {
+    const violations: Violation[] = [];
+    for (const file of listTsFiles(root)) {
+        // Never lint this file itself — its regexes contain the very suffixes
+        // it hunts for.
+        if (path.basename(file) === 'lint_versioned_cache.ts') continue;
+        let source: string;
+        try {
+            source = fs.readFileSync(file, 'utf-8');
+        } catch {
+            continue;
+        }
+        violations.push(...scanFile(file, source));
+    }
+    return violations;
+}
+
+export function main(argv: string[]): number {
+    let dir = 'src/scripts';
+    let format: 'text' | 'json' = 'text';
+    let quiet = false;
+    for (let i = 0; i < argv.length; i++) {
+        const a = argv[i] as string;
+        if (a === '--dir') {
+            dir = argv[++i] ?? dir;
+        } else if (a.startsWith('--dir=')) {
+            dir = a.slice('--dir='.length);
+        } else if (a === '--format') {
+            format = (argv[++i] as 'text' | 'json') ?? 'text';
+        } else if (a === '--quiet') {
+            quiet = true;
+        } else if (a === '-h' || a === '--help') {
+            process.stdout.write(`usage: ${PROG} [--dir <root>] [--format text|json] [--quiet]\n`);
+            return 0;
+        } else {
+            process.stderr.write(`${PROG}: error: unknown argument ${a}\n`);
+            return 1;
+        }
+    }
+
+    let violations: Violation[];
+    try {
+        violations = runChecks(path.resolve(dir));
+    } catch (exc) {
+        process.stderr.write(`${PROG}: internal error: ${String(exc)}\n`);
+        return 3;
+    }
+
+    if (format === 'json') {
+        process.stdout.write(JSON.stringify({ violations }, null, 2) + '\n');
+        return violations.length > 0 ? 2 : 0;
+    }
+    if (violations.length === 0) {
+        if (!quiet) process.stdout.write(`${PROG}: no unversioned derived caches\n`);
+        return 0;
+    }
+    for (const v of violations) {
+        process.stdout.write(`❌ ${v.file}:${v.line} — cache '${v.literal}': ${v.message}\n`);
+    }
+    process.stdout.write(`${PROG}: ${violations.length} unversioned derived cache(s)\n`);
+    return 2;
+}
+
+if (fileURLToPath(import.meta.url) === path.resolve(process.argv[1] ?? '')) {
+    process.exit(main(process.argv.slice(2)));
+}

package/src/scripts/mcp_server/consumer_tool_catalog.json

@@ -70,7 +70,8 @@
           "types": {"type": "array", "items": {"type": "string"}, "minItems": 1, "description": "Memory types to scan, e.g. `historical-patterns`, `incident-learnings`, `ownership`. At least one required."},
           "keys": {"type": "array", "items": {"type": "string"}, "description": "Optional anchor paths or globs to match entries against (e.g. a file you are about to edit)."},
           "limit": {"type": "integer", "minimum": 1, "default": 5, "description": "Maximum entries to return per type. Defaults to 5."},
-          "detail": {"type": "string", "enum": ["index", "full"], "default": "full", "description": "'index' returns compact priced rows (id, title, tokens_estimate) instead of full bodies — call this first, then memory_get the ids you need. 'full' (default) returns complete entries."}
+          "detail": {"type": "string", "enum": ["index", "full"], "default": "full", "description": "'index' returns compact priced rows (id, title, tokens_estimate) instead of full bodies — call this first, then memory_get the ids you need. 'full' (default) returns complete entries."},
+          "token_budget": {"type": "integer", "minimum": 1, "description": "Optional token budget. When set, entries are rendered as one-line compact rows (id, type, confidence, `line`) and the row set is hard-cut at token_budget × 4 chars; omitted hits appear as a top-level `truncation` hint naming a concrete next step. Absent → the envelope is unchanged."}
         },
         "required": ["types"],
         "additionalProperties": false

package/src/scripts/mcp_server/tools.ts

@@ -477,6 +477,18 @@ async function _memoryLookupHandler(
         throw new Error("'detail' must be 'index' or 'full'");
     }
 
+    // B1 (road-to-retrieval-substrate-hardening): optional token budget →
+    // compact one-line rows, hard-cut with a truncation hint. Absent → the
+    // envelope is unchanged (v1 default-full contract holds).
+    const opts: { detail: 'full' | 'index'; token_budget?: number } = { detail: detailRaw };
+    if (args.token_budget !== undefined) {
+        const tb = args.token_budget;
+        if (typeof tb !== 'number' || !Number.isInteger(tb) || typeof tb === 'boolean' || tb < 1) {
+            throw new Error("'token_budget' must be a positive integer");
+        }
+        opts.token_budget = tb;
+    }
+
     const prevCwd = process.cwd();
     let envelope: Record<string, unknown>;
     try {
@@ -485,7 +497,7 @@ async function _memoryLookupHandler(
             [...(types as string[])],
             [...(keys as string[])],
             limitRaw,
-            { detail: detailRaw },
+            opts,
         );
     } finally {
         process.chdir(prevCwd);
@@ -1400,6 +1412,17 @@ export const ALLOWLIST: Record<string, BuiltinTool> = {
                         "this first, then memory_get the ids you need. " +
                         "'full' (default) returns complete entries.",
                 },
+                token_budget: {
+                    type: 'integer',
+                    minimum: 1,
+                    description:
+                        'Optional token budget. When set, entries are ' +
+                        'rendered as one-line compact rows (id, type, ' +
+                        'confidence, `line`) and the row set is hard-cut at ' +
+                        'token_budget × 4 chars; omitted hits appear as a ' +
+                        'top-level `truncation` hint naming a concrete next ' +
+                        'step. Absent → the envelope is unchanged.',
+                },
             },
             required: ['types'],
             additionalProperties: false,

package/src/scripts/measure_lexical_ranking.ts

@@ -0,0 +1,173 @@
+#!/usr/bin/env tsx
+/**
+ * Ranking-lift measurement for the hand-rolled lexical index
+ * (road-to-retrieval-substrate-hardening B2, deterministic + free).
+ *
+ * The gate on shipping the index (roadmap Phase 2): it must measurably rank
+ * BETTER than the current `_score` bucket scorer, else honest-null. This
+ * script runs both scorers over the SAME retrieval-precision corpus + store
+ * (internal/bench/second-brain/retrieval-store/) and reports, per task and in
+ * aggregate:
+ *
+ *   - mean top tie-set size — how many entries share the TOP score. `_score`
+ *     gives 0.8 to any keyword match, so the needed entry ties with its
+ *     confusers (the "recalls but does not rank" finding, mean 3.3). A good
+ *     ranker drives this toward 1.
+ *   - precision@1 / @k — was the NEEDED entry actually first / in the top-k.
+ *
+ * No model, no spend: pure retrieval scoring. Exit 0 ok / 1 error / 2 usage.
+ *
+ * Usage: measure_lexical_ranking.ts [--write] [--format text|json]
+ *   --write  persist the report to internal/bench/reports/lexical-ranking.json
+ */
+import * as fs from 'node:fs';
+import * as path from 'node:path';
+import { fileURLToPath } from 'node:url';
+
+import * as YAML from 'yaml';
+
+import { LexicalIndex } from './_lib/lexical_index.js';
+import { _score, _setIntakeRoot, _setKnowledgeRoot, _setMemoryRoot, retrieve } from './memory_lookup.js';
+
+const _HERE = fileURLToPath(import.meta.url);
+export const REPO_ROOT = path.resolve(path.dirname(_HERE), '..', '..');
+export const STORE_DIR = path.join(REPO_ROOT, 'internal', 'bench', 'second-brain', 'retrieval-store');
+export const CORPUS = path.join(STORE_DIR, 'retrieval-corpus.yml');
+export const REPORT = path.join(REPO_ROOT, 'internal', 'bench', 'reports', 'lexical-ranking.json');
+
+interface Task {
+    id: string;
+    query: string[];
+    needed: string;
+}
+
+interface TaskResult {
+    id: string;
+    needed: string;
+    baseline: { rank: number; tieSet: number };
+    index: { rank: number; tieSet: number };
+}
+
+interface RankingSummary {
+    tasks: number;
+    k: number;
+    baseline_mean_tie_set: number;
+    index_mean_tie_set: number;
+    baseline_precision_at_1: number;
+    index_precision_at_1: number;
+    baseline_precision_at_k: number;
+    index_precision_at_k: number;
+}
+
+/** Text an entry contributes to the index — the fields `_score` also reads. */
+function entryText(entry: Record<string, unknown>): string {
+    const parts: string[] = [];
+    for (const f of ['path', 'key', 'symptom', 'feature', 'rule', 'body']) {
+        const v = entry[f];
+        if (typeof v === 'string') parts.push(v);
+        else if (Array.isArray(v)) for (const x of v) parts.push(String(x));
+    }
+    return parts.join(' | ');
+}
+
+/** Top tie-set size + rank of the needed id in a sorted (id, score) list. */
+function diagnose(ranked: Array<{ id: string; score: number }>, needed: string): { rank: number; tieSet: number } {
+    if (ranked.length === 0) return { rank: -1, tieSet: 0 };
+    const top = ranked[0]?.score ?? 0;
+    const tieSet = ranked.filter((r) => r.score === top).length;
+    const rank = ranked.findIndex((r) => r.id === needed);
+    return { rank, tieSet };
+}
+
+export function measure(): { tasks: TaskResult[]; summary: RankingSummary } {
+    _setMemoryRoot(STORE_DIR);
+    _setKnowledgeRoot(path.join(STORE_DIR, 'knowledge-none'));
+    _setIntakeRoot(path.join(STORE_DIR, 'intake-none'));
+
+    const doc = YAML.parse(fs.readFileSync(CORPUS, 'utf-8')) as { type: string; k: number; tasks: Task[] };
+    const type = doc.type;
+    const k = doc.k;
+    const results: TaskResult[] = [];
+
+    for (const task of doc.tasks) {
+        // Shared universe: every store entry `_score` considers relevant.
+        const hits = retrieve([type], task.query, 100);
+
+        // Baseline — rank by the current bucket scorer, ties broken by the
+        // order `retrieve` already returns (store order), exactly as today.
+        const baselineRanked = hits.map((h) => ({ id: h.id, score: h.score }));
+        const baseline = diagnose(baselineRanked, task.needed);
+
+        // Index — BM25 over the same entries' text.
+        const index = new LexicalIndex(hits.map((h) => ({ id: h.id, text: entryText(h.entry) })));
+        const indexRanked = index.rank(task.query);
+        const idx = diagnose(indexRanked, task.needed);
+
+        results.push({ id: task.id, needed: task.needed, baseline, index: idx });
+        void _score; // referenced for provenance — retrieve() applies it internally
+    }
+
+    const n = results.length;
+    const mean = (sel: (r: TaskResult) => number): number =>
+        n === 0 ? 0 : Math.round((results.reduce((a, r) => a + sel(r), 0) / n) * 1000) / 1000;
+    const precAt = (sel: (r: TaskResult) => number, kk: number): number =>
+        n === 0 ? 0 : Math.round((results.filter((r) => sel(r) >= 0 && sel(r) < kk).length / n) * 1000) / 1000;
+
+    const summary = {
+        tasks: n,
+        k,
+        baseline_mean_tie_set: mean((r) => r.baseline.tieSet),
+        index_mean_tie_set: mean((r) => r.index.tieSet),
+        baseline_precision_at_1: precAt((r) => r.baseline.rank, 1),
+        index_precision_at_1: precAt((r) => r.index.rank, 1),
+        baseline_precision_at_k: precAt((r) => r.baseline.rank, k),
+        index_precision_at_k: precAt((r) => r.index.rank, k),
+    };
+    return { tasks: results, summary };
+}
+
+export function main(argv: string[]): number {
+    let write = false;
+    let format: 'text' | 'json' = 'text';
+    for (let i = 0; i < argv.length; i++) {
+        const a = argv[i] as string;
+        if (a === '--write') write = true;
+        else if (a === '--format') format = (argv[++i] as 'text' | 'json') ?? 'text';
+        else if (a === '-h' || a === '--help') {
+            process.stdout.write('usage: measure_lexical_ranking.ts [--write] [--format text|json]\n');
+            return 0;
+        } else {
+            process.stderr.write(`measure_lexical_ranking: unknown argument ${a}\n`);
+            return 2;
+        }
+    }
+
+    let out: { tasks: TaskResult[]; summary: RankingSummary };
+    try {
+        out = measure();
+    } catch (exc) {
+        process.stderr.write(`measure_lexical_ranking: error: ${String(exc)}\n`);
+        return 1;
+    }
+
+    if (write) {
+        fs.mkdirSync(path.dirname(REPORT), { recursive: true });
+        fs.writeFileSync(REPORT, JSON.stringify({ schema_version: 1, ...out }, null, 2) + '\n');
+    }
+    if (format === 'json') {
+        process.stdout.write(JSON.stringify(out, null, 2) + '\n');
+        return 0;
+    }
+    const s = out.summary;
+    process.stdout.write(
+        `lexical-ranking (${s.tasks} tasks, k=${s.k}):\n` +
+            `  mean top tie-set   baseline=${s.baseline_mean_tie_set}  index=${s.index_mean_tie_set}\n` +
+            `  precision@1        baseline=${s.baseline_precision_at_1}  index=${s.index_precision_at_1}\n` +
+            `  precision@${s.k}        baseline=${s.baseline_precision_at_k}  index=${s.index_precision_at_k}\n`,
+    );
+    return 0;
+}
+
+if (fileURLToPath(import.meta.url) === path.resolve(process.argv[1] ?? '')) {
+    process.exit(main(process.argv.slice(2)));
+}