@event4u/agent-config 14.17.0 → 14.19.0

package/src/scripts/lint_readme_size.ts

@@ -1,28 +1,62 @@
 #!/usr/bin/env tsx
 /**
- * CI guard for README.md line budget.
+ * CI guard for README.md size and time-to-first-command.
  *
  * Ported from the retired Python `src/scripts/lint_readme_size.py` (ADR-200, Phase 4 /
  * Wave 4b). The CLI contract is pinned — `--quiet` flag, exit
- * codes (0 within budget, 1 over budget / missing), stdout/stderr split,
- * byte-identical finding messages.
+ * codes (0 within budget, 1 over budget / missing), stdout/stderr split.
  *
  * The role-first-onboarding roadmap (Phase 2 Step 6) freezes README at
  * its current length: replace, do not grow. Every line added above the
- * fold must displace an existing line. Budget: 750 lines max.
+ * fold must displace an existing line.
+ *
+ * Three budgets, because a line budget alone missed a full regression of this
+ * file once already — see WORD_LIMIT below for the measurement and the reason
+ * the two newer numbers are not derived from the current file.
  */
 
 import * as fs from 'node:fs';
+import * as os from 'node:os';
 import * as path from 'node:path';
 import { fileURLToPath, pathToFileURL } from 'node:url';
 
-import { assertWatchlistResolves, DeadScopeError } from './_lib/scan_scope.js';
+import { runGateCli, runSelfTest } from './_lib/gate_self_test.js';
+import { assertWatchlistResolves, DeadScopeError, reportScanned } from './_lib/scan_scope.js';
 
 const _HERE = fileURLToPath(import.meta.url);
 
 const README = 'README.md';
 const LIMIT = 750;
 
+/**
+ * Word and first-command budgets, derived from the README as it stood when
+ * `readme-and-docs-improvement.md` archived — NOT from the current file.
+ *
+ * That roadmap reached this same goal and archived complete on 2026-05-18. The
+ * file then drifted back, and the line budget above could not see it: lines
+ * went 747 -> 638, which is *better*, while words went 4849 -> 5550 and the
+ * first executable command moved from line 75 to line 160. A guard measuring
+ * only lines stayed green through every step of that, with 112 lines to spare.
+ *
+ * **This is the third recorded arrival of the same complaint, and nothing in
+ * the repository caught any of them.** Two independent external readers raised
+ * it again on 2026-09-06, three months after the fix archived as complete. A
+ * budget nobody watches is how a fix stops holding, which is why these two
+ * numbers are registered in `src/config/gate-coverage.yml` rather than living
+ * only here: removing them is then a gate failure rather than a quiet edit.
+ *
+ * Deriving these two numbers from the current file would make the gate green
+ * on day one and ratchet the regression in as the new floor. They come from
+ * the archive commit instead, and this command re-derives both:
+ *
+ *   git show 032a244a3:README.md > /tmp/r.md && \
+ *     echo "words=$(wc -w < /tmp/r.md)" \
+ *          "first_fence=$(grep -n '^```' /tmp/r.md | head -1 | cut -d: -f1)"
+ *   # words=4849 first_fence=75
+ */
+const WORD_LIMIT = 4849;
+const FIRST_COMMAND_LIMIT = 75;
+
 /**
  * Count splitlines() entries the way Python does — terminal `\n` does NOT
  * yield a trailing empty entry. Universal-newline aware (\r\n / \r / \n).
@@ -46,7 +80,10 @@ function _splitlinesCount(text: string): number {
 }
 
 function main(): number {
+    if (process.argv.slice(2).includes('--self-test')) return selfTest();
     const quiet = process.argv.slice(2).includes('--quiet');
+    const rootArgIdx = process.argv.indexOf('--root');
+    const root = rootArgIdx === -1 ? process.cwd() : (process.argv[rootArgIdx + 1] ?? process.cwd());
     // README is this gate's whole scope and resolves against cwd, so a wrong
     // cwd is indistinguishable from a deleted file. Replaces the bare
     // existsSync check: same exit code, but the failure now names the root it
@@ -56,7 +93,7 @@ function main(): number {
         assertWatchlistResolves({
             gate: 'lint_readme_size',
             candidates: [README],
-            repoRoot: process.cwd(),
+            repoRoot: root,
         });
     } catch (exc) {
         if (exc instanceof DeadScopeError) {
@@ -67,20 +104,129 @@ function main(): number {
         }
         throw exc;
     }
-    const text = fs.readFileSync(README, 'utf-8');
+    reportScanned({
+        gate: 'lint_readme_size',
+        scanned: 1,
+        units: 'file',
+        roots: [README],
+    });
+    const text = fs.readFileSync(path.join(root, README), 'utf-8');
     const n = _splitlinesCount(text);
-    if (n > LIMIT) {
-        process.stdout.write(
-            `FAIL  ${README}: ${n} lines (limit ${LIMIT}). Trim before merge.\n`,
+    const words = countWords(text);
+    const firstCommand = firstCommandLine(text);
+
+    // All three figures print on both paths. The regression this gate missed
+    // was visible in two numbers nobody was shown, so reporting only the one
+    // that failed would rebuild the blind spot one measurement further along.
+    const report =
+        `${README}: ${String(n)} lines (limit ${String(LIMIT)}) · ` +
+        `${String(words)} words (limit ${String(WORD_LIMIT)}) · ` +
+        `first command at line ${firstCommand === null ? 'none' : String(firstCommand)} ` +
+        `(limit ${String(FIRST_COMMAND_LIMIT)})`;
+
+    const failures: string[] = [];
+    if (n > LIMIT) failures.push(`${String(n)} lines exceeds ${String(LIMIT)}`);
+    if (words > WORD_LIMIT) {
+        failures.push(`${String(words)} words exceeds ${String(WORD_LIMIT)}`);
+    }
+    if (firstCommand === null) {
+        failures.push('no fenced command block at all');
+    } else if (firstCommand > FIRST_COMMAND_LIMIT) {
+        failures.push(
+            `first command at line ${String(firstCommand)} exceeds ${String(FIRST_COMMAND_LIMIT)}`,
         );
+    }
+
+    if (failures.length > 0) {
+        process.stdout.write(`FAIL  ${report}\n`);
+        for (const f of failures) {
+            process.stdout.write(`      - ${f}\n`);
+        }
+        process.stdout.write('      Trim before merge.\n');
         return 1;
     }
     if (!quiet) {
-        process.stdout.write(`OK    ${README}: ${n} lines (limit ${LIMIT}).\n`);
+        process.stdout.write(`OK    ${report}\n`);
     }
     return 0;
 }
 
+/** Whitespace-separated tokens, matching `wc -w` (which the budget derives from). */
+function countWords(text: string): number {
+    const trimmed = text.trim();
+    return trimmed === '' ? 0 : trimmed.split(/\s+/).length;
+}
+
+/**
+ * 1-based line of the first fenced block, or `null` when there is none.
+ *
+ * The opening fence is what a reader's eye reaches, so the fence line itself
+ * is the measurement — not the first line of code inside it.
+ */
+function firstCommandLine(text: string): number | null {
+    const lines = text.replace(/\r\n/g, '\n').replace(/\r/g, '\n').split('\n');
+    for (let i = 0; i < lines.length; i += 1) {
+        if (lines[i]!.startsWith('```')) return i + 1;
+    }
+    return null;
+}
+
+/**
+ * The gate proving it still DISCRIMINATES, not merely that it ran.
+ *
+ * One rejecting case per budget, because the failure this gate exists to end
+ * was a guard that measured one of the three and stayed green while the other
+ * two regressed. A suite that only exercises the line budget would reproduce
+ * that blind spot exactly.
+ */
+function selfTest(): number {
+    const tmp = fs.mkdtempSync(path.join(os.tmpdir(), 'readme-selftest-'));
+    const write = (name: string, body: string): string => {
+        const dir = path.join(tmp, name);
+        fs.mkdirSync(dir, { recursive: true });
+        fs.writeFileSync(path.join(dir, README), body, 'utf-8');
+        return dir;
+    };
+    const run = (root: string): number =>
+        runGateCli(process.cwd(), 'src/scripts/lint_readme_size.ts', ['--root', root], root);
+
+    const fence = '```bash\nnpx thing\n```\n';
+    const filler = (n: number): string => `${'word '.repeat(n).trim()}\n`;
+
+    try {
+        return runSelfTest({
+            gate: 'lint_readme_size',
+            minCases: 4,
+            minRejectCases: 3,
+            cases: [
+                {
+                    name: 'a README whose first command sits below the budget is rejected',
+                    expect: 'reject',
+                    run: () =>
+                        run(write('late-command', `${'filler\n'.repeat(FIRST_COMMAND_LIMIT + 5)}${fence}`)),
+                },
+                {
+                    name: 'a README over the word budget is rejected',
+                    expect: 'reject',
+                    run: () => run(write('wordy', `${fence}${filler(WORD_LIMIT + 50)}`)),
+                },
+                {
+                    name: 'a README over the line budget is rejected',
+                    expect: 'reject',
+                    run: () => run(write('long', `${fence}${'x\n'.repeat(LIMIT + 5)}`)),
+                },
+                {
+                    name: 'a short README with an early command passes',
+                    expect: 'accept',
+                    run: () => run(write('good', `# Title\n\n${fence}`)),
+                },
+            ],
+        });
+    } finally {
+        fs.rmSync(tmp, { recursive: true, force: true });
+    }
+}
+
 function _isCliEntry(): boolean {
     if (process.argv[1] === undefined) {
         return false;
@@ -107,4 +253,4 @@ if (_isCliEntry() || process.argv[1] === _HERE) {
     process.exit(main());
 }
 
-export { README, LIMIT, main };
+export { README, LIMIT, WORD_LIMIT, FIRST_COMMAND_LIMIT, countWords, firstCommandLine, main };

package/src/scripts/lint_reasoning_fixtures.ts

@@ -0,0 +1,216 @@
+#!/usr/bin/env tsx
+/**
+ * Structural validator for the RDP trigger-fixture corpus.
+ *
+ * `tests/reasoning-layer-eval/` shipped 21 fixtures and, after the Python
+ * retirement, zero validators: `find … -name '*.ts' -o -name '*.py'` returned
+ * nothing while the corpus's own README and `trigger-fixtures.json`'s
+ * `description` still told a reader to run two deleted files. A corpus nothing
+ * can check is a corpus nothing does check.
+ *
+ * Scope is deliberately the SHAPE and nothing else. Live scoring against a model
+ * is `skill_trigger_eval.ts`, which is billable and already exists; nothing about
+ * validating the corpus needs a model call. What the deleted `validate_fixtures.py`
+ * ALSO did and this does not is check the cost-gating invariants — that half was
+ * not ported and is not claimed here.
+ *
+ * Exit codes: 0 corpus well-formed · 1 a row is malformed · 2 the corpus is
+ * missing or unparseable.
+ */
+import * as fs from 'node:fs';
+import * as os from 'node:os';
+import * as path from 'node:path';
+import { fileURLToPath, pathToFileURL } from 'node:url';
+
+import { runGateCli, runSelfTest } from './_lib/gate_self_test.js';
+import { reportScanned } from './_lib/scan_scope.js';
+
+const _HERE = fileURLToPath(import.meta.url);
+const ROOT = path.resolve(path.dirname(_HERE), '..', '..');
+const CORPUS_REL = 'tests/reasoning-layer-eval/trigger-fixtures.json';
+
+/**
+ * The five keys a row carries, and no others.
+ *
+ * Exact-set rather than a minimum: an unknown key is how a schema drifts in a
+ * corpus with no reader, and the two additive fields this suite already has
+ * over the per-skill `evals/triggers.json` convention (`discipline`, `host`)
+ * are exactly what a permissive check would have let multiply.
+ */
+const REQUIRED_KEYS = ['q', 'trigger', 'discipline', 'host', 'note'] as const;
+const HOSTS = ['standard', 'strong'] as const;
+
+export interface Finding {
+    where: string;
+    reason: string;
+}
+
+export function validateCorpus(text: string): { findings: Finding[]; rows: number } {
+    const findings: Finding[] = [];
+    let doc: unknown;
+    try {
+        doc = JSON.parse(text);
+    } catch (exc) {
+        return {
+            findings: [{ where: CORPUS_REL, reason: `not valid JSON: ${String(exc)}` }],
+            rows: 0,
+        };
+    }
+    const top = doc as Record<string, unknown>;
+    for (const k of ['suite', 'description', 'queries']) {
+        if (top[k] === undefined) {
+            findings.push({ where: CORPUS_REL, reason: `top level is missing '${k}'` });
+        }
+    }
+    const queries = Array.isArray(top['queries']) ? (top['queries'] as unknown[]) : [];
+    if (queries.length === 0) {
+        findings.push({ where: CORPUS_REL, reason: "'queries' is empty or not an array" });
+        return { findings, rows: 0 };
+    }
+
+    queries.forEach((raw, i) => {
+        const where = `${CORPUS_REL}[${String(i)}]`;
+        if (raw === null || typeof raw !== 'object' || Array.isArray(raw)) {
+            findings.push({ where, reason: 'row is not an object' });
+            return;
+        }
+        const row = raw as Record<string, unknown>;
+        const keys = Object.keys(row).sort();
+        const expected: string[] = [...REQUIRED_KEYS].sort();
+        for (const k of expected) {
+            if (!keys.includes(k)) findings.push({ where, reason: `missing key '${k}'` });
+        }
+        for (const k of keys) {
+            if (!expected.includes(k)) findings.push({ where, reason: `unknown key '${k}'` });
+        }
+        if (row['q'] !== undefined && (typeof row['q'] !== 'string' || row['q'].trim() === '')) {
+            findings.push({ where, reason: "'q' must be a non-empty string" });
+        }
+        if (row['note'] !== undefined && (typeof row['note'] !== 'string' || row['note'].trim() === '')) {
+            findings.push({ where, reason: "'note' must be a non-empty string" });
+        }
+        if (row['discipline'] !== undefined && (typeof row['discipline'] !== 'string' || row['discipline'].trim() === '')) {
+            findings.push({ where, reason: "'discipline' must be a non-empty string" });
+        }
+        if (row['trigger'] !== undefined && typeof row['trigger'] !== 'boolean') {
+            findings.push({ where, reason: "'trigger' must be a boolean, not a string" });
+        }
+        if (row['host'] !== undefined && !(HOSTS as readonly unknown[]).includes(row['host'])) {
+            findings.push({
+                where,
+                reason: `'host' must be one of ${HOSTS.join('|')}, got ${JSON.stringify(row['host'])}`,
+            });
+        }
+    });
+    return { findings, rows: queries.length };
+}
+
+function main(): number {
+    if (process.argv.slice(2).includes('--self-test')) return selfTest();
+    const rootIdx = process.argv.indexOf('--root');
+    const root = rootIdx === -1 ? ROOT : (process.argv[rootIdx + 1] ?? ROOT);
+    const file = path.join(root, CORPUS_REL);
+    if (!fs.existsSync(file)) {
+        process.stderr.write(`❌  corpus not found: ${CORPUS_REL} (under ${root})\n`);
+        return 2;
+    }
+    const { findings, rows } = validateCorpus(fs.readFileSync(file, 'utf-8'));
+    // Emitted on the red path too: a gate that reports what it inspected only
+    // when it passes leaves the coverage census blind exactly when it matters.
+    reportScanned({
+        gate: 'lint_reasoning_fixtures',
+        scanned: rows,
+        units: 'fixture row(s)',
+        roots: [CORPUS_REL],
+    });
+    if (findings.length > 0) {
+        for (const f of findings) {
+            process.stdout.write(`❌  ${f.where}: ${f.reason}\n`);
+        }
+        process.stdout.write(`\n${String(findings.length)} malformed fixture finding(s).\n`);
+        return 1;
+    }
+    process.stdout.write(
+        `✅  lint_reasoning_fixtures: ${String(rows)} fixture row(s) well-formed ` +
+            `(${REQUIRED_KEYS.join(', ')}; host ∈ ${HOSTS.join('|')}).\n`,
+    );
+    return 0;
+}
+
+/** The gate proving it still DISCRIMINATES — one rejecting case per rule the roadmap names. */
+function selfTest(): number {
+    const tmp = fs.mkdtempSync(path.join(os.tmpdir(), 'rdp-fixtures-selftest-'));
+    const good = {
+        q: 'a question',
+        trigger: true,
+        discipline: 'grounding',
+        host: 'standard',
+        note: 'why',
+    };
+    const write = (name: string, queries: unknown[]): string => {
+        const dir = path.join(tmp, name, 'tests', 'reasoning-layer-eval');
+        fs.mkdirSync(dir, { recursive: true });
+        fs.writeFileSync(
+            path.join(dir, 'trigger-fixtures.json'),
+            JSON.stringify({ suite: 's', description: 'd', queries }),
+            'utf-8',
+        );
+        return path.join(tmp, name);
+    };
+    const run = (root: string): number =>
+        runGateCli(ROOT, 'src/scripts/lint_reasoning_fixtures.ts', ['--root', root], root);
+
+    try {
+        return runSelfTest({
+            gate: 'lint_reasoning_fixtures',
+            minCases: 4,
+            minRejectCases: 3,
+            cases: [
+                {
+                    name: 'a row with a sixth key is rejected',
+                    expect: 'reject',
+                    run: () => run(write('sixth-key', [{ ...good, extra: 1 }])),
+                },
+                {
+                    name: 'a row missing discipline is rejected',
+                    expect: 'reject',
+                    run: () => {
+                        const { discipline: _drop, ...rest } = good;
+                        return run(write('no-discipline', [rest]));
+                    },
+                },
+                {
+                    name: 'host: "medium" is rejected',
+                    expect: 'reject',
+                    run: () => run(write('bad-host', [{ ...good, host: 'medium' }])),
+                },
+                {
+                    name: 'a well-formed row passes',
+                    expect: 'accept',
+                    run: () => run(write('good', [good])),
+                },
+            ],
+        });
+    } finally {
+        fs.rmSync(tmp, { recursive: true, force: true });
+    }
+}
+
+function _isCliEntry(): boolean {
+    if (process.argv[1] === undefined) return false;
+    if (import.meta.url === pathToFileURL(path.resolve(process.argv[1])).href) return true;
+    try {
+        return (
+            fs.realpathSync(fileURLToPath(import.meta.url)) ===
+            fs.realpathSync(path.resolve(process.argv[1]))
+        );
+    } catch {
+        return false;
+    }
+}
+
+if (_isCliEntry() || process.argv[1] === _HERE) {
+    process.exit(main());
+}
+
+export { CORPUS_REL, REQUIRED_KEYS, HOSTS, main };

package/src/scripts/lint_skill_trigger_contradiction.ts

@@ -0,0 +1,161 @@
+#!/usr/bin/env tsx
+/**
+ * A skill may not say "explicit request only" and publish auto-trigger keywords.
+ *
+ * The description is consumed — it is the frontmatter a catalogue and a host
+ * surface read. The keyword section is not: measured across the tree, nothing
+ * in `src/` parses `## Auto-trigger keywords`, so a skill carrying both halves
+ * is not mis-ROUTED, it is mis-DESCRIBED. A reader deciding whether they may
+ * invoke the skill meets two opposite answers in one file, and the half that
+ * looks operational is the half nothing reads.
+ *
+ * Three skills shipped in that state and a human had to notice it. The pair is
+ * mechanically decidable from the file, so noticing it again should not be
+ * anybody's job.
+ *
+ * Deliberately not a judgement about WHICH half is right. Both are legitimate
+ * designs; only the contradiction is a defect, and which way to resolve it is
+ * the author's call.
+ *
+ * Exit codes: 0 no contradiction · 1 at least one file carries both.
+ */
+import * as fs from 'node:fs';
+import * as os from 'node:os';
+import * as path from 'node:path';
+import { fileURLToPath, pathToFileURL } from 'node:url';
+
+import { runGateCli, runSelfTest } from './_lib/gate_self_test.js';
+import { reportScanned } from './_lib/scan_scope.js';
+
+const _HERE = fileURLToPath(import.meta.url);
+const ROOT = path.resolve(path.dirname(_HERE), '..', '..');
+const SKILLS_REL = 'src/skills';
+
+const FRONTMATTER_RE = /^---\s*\n([\s\S]*?)\n---\s*\n/;
+/** Matched in the description only — the phrase is meaningful there, prose elsewhere. */
+const EXPLICIT_ONLY_RE = /explicit[- ]request[- ]only|explicit request only/i;
+const AUTO_TRIGGER_RE = /^##\s+Auto-trigger keywords\s*$/m;
+
+export function contradicts(text: string): boolean {
+    const fm = FRONTMATTER_RE.exec(text);
+    if (fm === null) return false;
+    // `description:` may be a folded or quoted scalar spanning lines, so the
+    // slice runs to the next top-level key rather than to the next newline.
+    const desc = /^description:([\s\S]*?)(?=\n[a-z_]+:|$)/im.exec(fm[1] as string);
+    if (desc === null) return false;
+    if (!EXPLICIT_ONLY_RE.test(desc[1] as string)) return false;
+    return AUTO_TRIGGER_RE.test(text);
+}
+
+function main(): number {
+    if (process.argv.slice(2).includes('--self-test')) return selfTest();
+    const rootIdx = process.argv.indexOf('--root');
+    const root = rootIdx === -1 ? ROOT : (process.argv[rootIdx + 1] ?? ROOT);
+    const dir = path.join(root, SKILLS_REL);
+    let names: string[] = [];
+    try {
+        names = fs.readdirSync(dir).sort();
+    } catch {
+        process.stderr.write(`❌  no skills directory under ${root}/${SKILLS_REL}\n`);
+        return 1;
+    }
+    const offenders: string[] = [];
+    let scanned = 0;
+    for (const n of names) {
+        const f = path.join(dir, n, 'SKILL.md');
+        if (!fs.existsSync(f)) continue;
+        scanned += 1;
+        if (contradicts(fs.readFileSync(f, 'utf-8'))) {
+            offenders.push(`${SKILLS_REL}/${n}/SKILL.md`);
+        }
+    }
+    reportScanned({
+        gate: 'lint_skill_trigger_contradiction',
+        scanned,
+        units: 'SKILL.md file(s)',
+        roots: [SKILLS_REL],
+    });
+    if (offenders.length > 0) {
+        for (const o of offenders) {
+            process.stdout.write(
+                `❌  ${o}: description says explicit-request-only AND the body publishes ` +
+                    '`## Auto-trigger keywords` — the two halves say opposite things ' +
+                    'and nothing in src/ parses the keyword half, so the operational-looking ' +
+                    'one is the inert one.\n',
+            );
+        }
+        process.stdout.write(
+            `\n${String(offenders.length)} contradicting skill(s). Resolve by removing whichever ` +
+                'half is not true; the check does not decide which.\n',
+        );
+        return 1;
+    }
+    process.stdout.write(
+        `✅  lint_skill_trigger_contradiction: ${String(scanned)} skill(s) inspected, ` +
+            'none claims explicit-request-only while publishing auto-trigger keywords.\n',
+    );
+    return 0;
+}
+
+function selfTest(): number {
+    const tmp = fs.mkdtempSync(path.join(os.tmpdir(), 'trigger-contradiction-selftest-'));
+    const write = (name: string, body: string): string => {
+        const dir = path.join(tmp, name, SKILLS_REL, 'sample');
+        fs.mkdirSync(dir, { recursive: true });
+        fs.writeFileSync(path.join(dir, 'SKILL.md'), body, 'utf-8');
+        return path.join(tmp, name);
+    };
+    const run = (root: string): number =>
+        runGateCli(ROOT, 'src/scripts/lint_skill_trigger_contradiction.ts', ['--root', root], root);
+
+    const both =
+        '---\nname: sample\ndescription: Does a thing; explicit request only.\n---\n\n## Auto-trigger keywords\n\nfoo\n';
+    const descOnly = '---\nname: sample\ndescription: Does a thing; explicit request only.\n---\n\nbody\n';
+    const autoOnly = '---\nname: sample\ndescription: Does a thing.\n---\n\n## Auto-trigger keywords\n\nfoo\n';
+
+    try {
+        return runSelfTest({
+            gate: 'lint_skill_trigger_contradiction',
+            minCases: 3,
+            minRejectCases: 1,
+            cases: [
+                {
+                    name: 'a skill carrying BOTH halves is rejected',
+                    expect: 'reject',
+                    run: () => run(write('both', both)),
+                },
+                {
+                    name: 'explicit-request-only with no keyword section passes',
+                    expect: 'accept',
+                    run: () => run(write('desc-only', descOnly)),
+                },
+                {
+                    name: 'auto-trigger keywords with no explicit-only claim passes',
+                    expect: 'accept',
+                    run: () => run(write('auto-only', autoOnly)),
+                },
+            ],
+        });
+    } finally {
+        fs.rmSync(tmp, { recursive: true, force: true });
+    }
+}
+
+function _isCliEntry(): boolean {
+    if (process.argv[1] === undefined) return false;
+    if (import.meta.url === pathToFileURL(path.resolve(process.argv[1])).href) return true;
+    try {
+        return (
+            fs.realpathSync(fileURLToPath(import.meta.url)) ===
+            fs.realpathSync(path.resolve(process.argv[1]))
+        );
+    } catch {
+        return false;
+    }
+}
+
+if (_isCliEntry() || process.argv[1] === _HERE) {
+    process.exit(main());
+}
+
+export { SKILLS_REL, main };