@event4u/agent-config 14.10.0 → 14.12.0

package/src/scripts/sessions_cli.ts

@@ -45,12 +45,14 @@ import { fileURLToPath } from 'node:url';
 
 import { write_atomic } from './_lib/fs_atomic.js';
 import {
+    classify_collisions,
     iso_now,
     read_live_records,
     register_dir,
     safe_stem,
     ttl_is_measured,
     ttl_seconds_for,
+    type SessionRecord,
 } from './_lib/session_register.js';
 import { claim_file, claim_is_stale, claim_read_paths } from './session_register_hook.js';
 
@@ -62,7 +64,7 @@ function usage(): number {
             '                                           live sessions, plus unmerged branches',
             '                                           held by other worktrees (--branches adds',
             '                                           that axis to the JSON form)',
-            '  agent-config sessions:claim <slug>       claim a roadmap for this session',
+            '  agent-config sessions:claim <slug> [--paths <a,b,…>]       claim a roadmap for this session',
             '  agent-config sessions:claim <slug> --force   claim it even though a peer holds it',
             '  agent-config sessions:claim --release    drop this session\'s roadmap claim',
             '',
@@ -168,6 +170,30 @@ export function other_worktree_branches_detailed(
     return { rows, filtered: unmerged !== null };
 }
 
+/**
+ * `PATH OVERLAP` lines for this session against every live peer.
+ *
+ * Kept a separate, separately-labelled line rather than folded into the slug or
+ * branch report, because the three collisions call for three different moves: a
+ * slug collision means stop, a branch collision means coordinate, a path
+ * collision means reorder — take the disjoint steps first if ordering allows,
+ * otherwise name it and continue. The register is advisory and never a lock.
+ *
+ * Pure over the record arrays so the fixture test needs no register on disk.
+ */
+export function path_overlap_lines(
+    others: readonly SessionRecord[],
+    here: { branch: string | null; roadmap_slug: string | null; owned_paths?: readonly string[] },
+): string[] {
+    return classify_collisions(others, here)
+        .filter((c) => c.kind === 'path')
+        .map(
+            (c) =>
+                `  PATH OVERLAP  ${c.record.session_id}  ·  ${(c.paths ?? []).length} shared path(s): ` +
+                `${(c.paths ?? []).join(', ')}`,
+        );
+}
+
 function cmd_list(argv: string[], root: string): number {
     const as_json = argv.includes('--json');
     const dir = register_dir(root);
@@ -229,6 +255,21 @@ function cmd_list(argv: string[], root: string): number {
         );
     }
     write_held_branches(held, filtered);
+    // The path axis. Silent when this session has declared no owned paths, which
+    // is every session that has not run `sessions:claim --paths`.
+    const sid = env_session_id();
+    const mine = sid === null ? undefined : records.find((r) => r.session_id === sid);
+    const overlaps = path_overlap_lines(
+        records.filter((r) => r.session_id !== mine?.session_id),
+        {
+            branch: mine?.branch ?? null,
+            roadmap_slug: mine?.roadmap_slug ?? null,
+            ...(mine?.owned_paths !== undefined ? { owned_paths: mine.owned_paths } : {}),
+        },
+    );
+    if (overlaps.length > 0) {
+        process.stdout.write(`\n${overlaps.join('\n')}\n`);
+    }
     process.stdout.write(
         'Advisory only — this register is not a lock, and an idle session\n' +
             'disappears from it after its TTL although its user may return.\n',
@@ -432,7 +473,15 @@ function cmd_claim(argv: string[], root: string): number {
         );
         return 0;
     }
-    const slug = argv.find((a) => !a.startsWith('-'));
+    const paths_idx = argv.indexOf('--paths');
+    const paths_arg = paths_idx >= 0 ? (argv[paths_idx + 1] ?? '') : '';
+    const owned_paths = paths_arg
+        .split(',')
+        .map((x) => x.trim())
+        .filter((x) => x !== '');
+    // The slug is the first bare token that is not the VALUE of --paths; without
+    // this the comma list would be read as the slug on `claim --paths a,b road-to-x`.
+    const slug = argv.find((a, i) => !a.startsWith('-') && i !== paths_idx + 1);
     if (slug === undefined || slug.trim() === '') {
         return usage();
     }
@@ -476,7 +525,19 @@ function cmd_claim(argv: string[], root: string): number {
     try {
         write_atomic(
             target,
-            `${JSON.stringify({ slug: slug.trim(), written_at: iso_now(), session_id: sid }, null, 2)}\n`,
+            `${JSON.stringify(
+                {
+                    slug: slug.trim(),
+                    written_at: iso_now(),
+                    session_id: sid,
+                    // Absent, not empty, when nothing was declared: the whole
+                    // additive guarantee of `owned_paths` rests on the field not
+                    // being written at all in the ordinary case.
+                    ...(owned_paths.length > 0 ? { paths: owned_paths } : {}),
+                },
+                null,
+                2,
+            )}\n`,
         );
     } catch (exc) {
         process.stderr.write(`sessions:claim: could not write the claim — ${String(exc)}\n`);
@@ -484,6 +545,9 @@ function cmd_claim(argv: string[], root: string): number {
     }
     process.stdout.write(
         `Claimed "${slug.trim()}" for this session. It becomes visible to other\n` +
+            (owned_paths.length > 0
+                ? `Declared ${owned_paths.length} owned path(s); peers sharing one are labelled PATH OVERLAP.\n`
+                : '') +
             'sessions on the next turn, when the heartbeat lifts it into the register.\n' +
             (sid === null
                 ? 'NOTE: this host exports no session id, so the claim is scoped to this\n' +

package/src/scripts/skill_tools/score_skill_relevance.ts

@@ -34,7 +34,17 @@ import * as fs from 'node:fs';
 import * as path from 'node:path';
 import { fileURLToPath, pathToFileURL } from 'node:url';
 
-import { pyRound } from '../_lib/value_ladder.js';
+// The formula, the stopword list and the tokenizer live in one Node-free
+// module so the pure stdio-lite dispatcher can share them instead of growing
+// a second copy (road-to-skill-delivery-over-mcp risk 6). Everything below is
+// the disk half — globbing, frontmatter, the CLI — which stays here.
+import {
+    scoreSkill,
+    skillTerms as _sharedSkillTerms,
+    tokenize as _sharedTokenize,
+    triggerTextFromFlatLines,
+    type RankOptions,
+} from '../../shared/skillRanking.js';
 
 const _HERE = fileURLToPath(import.meta.url);
 // src/scripts/skill_tools/score_skill_relevance.ts → parents[3] of the .py
@@ -42,19 +52,6 @@ const _HERE = fileURLToPath(import.meta.url);
 export const ROOT = path.resolve(path.dirname(_HERE), '..', '..', '..');
 export const DEFAULT_SKILLS_DIR = path.join(ROOT, '.agent-src.uncondensed', 'skills');
 
-// re.compile(r"[a-z][a-z0-9]+") — applied to the lowercased text.
-const TOKEN_RE = /[a-z][a-z0-9]+/g;
-
-const STOPWORDS: ReadonlySet<string> = new Set([
-    'the', 'a', 'an', 'and', 'or', 'but', 'of', 'for', 'with', 'to', 'in',
-    'on', 'at', 'by', 'from', 'as', 'is', 'are', 'was', 'were', 'be', 'been',
-    'this', 'that', 'these', 'those', 'it', 'its', 'use', 'when', 'even',
-    'via', 'via:', 'into', 'onto', 'use:', 'skill', 'skills', 'task', 'tasks',
-    'code', 'file', 'files', 'doing', 'make', 'do', 'go', 'get', 'set',
-    'not', 'no', 'yes', 'any', 'some', 'all', 'one', 'two', 'new', 'old',
-    'user', 'users', 'our', 'your', 'their', 'they', 'we', 'you', 'i', 'me',
-]);
-
 /** Mirror Python len(str) — count Unicode code points, not UTF-16 units. */
 function pyLen(s: string): number {
     let n = 0;
@@ -65,16 +62,9 @@ function pyLen(s: string): number {
 }
 
 export function _tokenize(text: string): Set<string> {
-    const out = new Set<string>();
-    // The TOKEN_RE stopwords never contain digits, so the `len(t) > 2`
-    // filter is on code-point length (matches Python `len`).
-    const matches = text.toLowerCase().match(TOKEN_RE) ?? [];
-    for (const t of matches) {
-        if (!STOPWORDS.has(t) && pyLen(t) > 2) {
-            out.add(t);
-        }
-    }
-    return out;
+    // Single-sourced in `src/shared/skillRanking.ts`. Kept as an export because
+    // the CLI-parity suite and the hook path both import this name.
+    return _sharedTokenize(text);
 }
 
 export interface Frontmatter {
@@ -152,6 +142,8 @@ export interface Skill {
     description: string;
     personas: string[];
     terms: Set<string>;
+    /** `triggers[].keyword` / `.phrase` prose. Indexed only under keyword-v2. */
+    triggerText: string[];
 }
 
 function _load_skills(skillsDir: string): Skill[] {
@@ -167,11 +159,16 @@ function _load_skills(skillsDir: string): Skill[] {
             personas = [personas];
         }
         const personaList = [...personas];
+        const rawTriggers = fm['triggers'];
+        const triggerText = Array.isArray(rawTriggers)
+            ? triggerTextFromFlatLines(rawTriggers as string[])
+            : [];
         skills.push({
             name,
             description: desc,
             personas: personaList,
             terms: _tokenize(name + ' ' + desc),
+            triggerText,
         });
     }
     return skills;
@@ -214,43 +211,29 @@ function _globSkillMd(root: string): string[] {
     return dirs.map((name) => path.join(root, name, 'SKILL.md'));
 }
 
-function _score(taskTerms: Set<string>, skill: Skill): number {
-    if (taskTerms.size === 0) {
-        return 0;
-    }
-    const skillTerms = skill.terms;
-    let inter = 0;
-    for (const t of taskTerms) {
-        if (skillTerms.has(t)) {
-            inter++;
-        }
-    }
-    // overlap = |task ∩ skill| / max(|task|, 1)
-    const overlap = inter / Math.max(taskTerms.size, 1);
-    let personaHit = 0.0;
-    // task_lower = " ".join(task_terms) — Set iteration order = insertion order
-    // (matches Python set-iteration only incidentally; the membership tests
-    // below are order-independent so the result is deterministic).
-    const taskLower = [...taskTerms].join(' ');
-    for (const persona of skill.personas) {
-        const slug = String(persona).toLowerCase();
-        const parts = slug.split('-');
-        if (taskLower.includes(slug) || parts.some((part) => taskTerms.has(part))) {
-            personaHit = 1.0;
-            break;
-        }
-    }
-    return pyRound(overlap * 70 + personaHit * 30, 0);
+function _score(taskTerms: Set<string>, skill: Skill, opts: RankOptions = {}): number {
+    // Single-sourced in `src/shared/skillRanking.ts`. Under keyword-v1 (the
+    // default) `skill.terms` is already `tokenize(name + ' ' + description)`, so
+    // the precomputed set is reused unchanged; keyword-v2 re-derives the term
+    // set with the skill's trigger prose folded in.
+    const rankable = {
+        name: skill.name,
+        description: skill.description,
+        personas: skill.personas,
+        triggerText: skill.triggerText,
+    };
+    const terms = opts.includeTriggers ? _sharedSkillTerms(rankable, opts) : skill.terms;
+    return scoreSkill(taskTerms, rankable, terms);
 }
 
 export type RankRow = [string, number, string[]];
 
-export function rank(task: string, skillsDir: string): RankRow[] {
+export function rank(task: string, skillsDir: string, opts: RankOptions = {}): RankRow[] {
     const taskTerms = _tokenize(task);
     const skills = _load_skills(skillsDir);
     const rows: RankRow[] = [];
     for (const s of skills) {
-        const score = _score(taskTerms, s);
+        const score = _score(taskTerms, s, opts);
         if (score > 0) {
             rows.push([s.name, score, [...s.personas]]);
         }

package/src/scripts/sync_pr_branch.ts

@@ -83,6 +83,44 @@ const GENERATED = [
     // measured for road-to-merge-hotspot-drawdown. Regenerate; never merge.
     'agents/roadmaps/archive/INDEX.md',
     'agents/roadmaps/archive/index.json',
+    // ── Added 2026-08-25 (road-to-merge-surface-zero 1.1). Each carries its
+    // write site, because this list tells a human to DISCARD one side, and an
+    // entry added on a conflict count alone would tell them to discard hand
+    // work. Counts are from `pr_conflict_census --limit 2000` over 60 days.
+    //
+    // Written by `build_proof.ts:500` from `docs/CLAIMS.md`. 26 resolutions, and
+    // it fails in pairs: a CLAIMS.md edit leaves it stale, which reds both the
+    // drift-guard test and `demo-commands-still-pass`.
+    'docs/proof.md',
+    // Both written by `generate_catalog.ts` (`:166` for llms.txt) from SKILL.md
+    // frontmatter. Neither has ever been hand-authored.
+    'docs/skills-catalog.md',
+    'llms.txt',
+    // Written by `lint_originality.ts:340`. Named by step 1.1 and included
+    // although the census found ZERO conflicts on it in either window — it is
+    // genuinely generated and classifying it costs nothing. Recorded rather than
+    // quietly dropped: the step named it on conflict frequency, and that premise
+    // does not hold.
+    'agents/reports/originality.json',
+    'agents/reports/originality.md',
+];
+
+/**
+ * Generated paths a literal cannot express.
+ *
+ * `isGenerated` matches on equality or a trailing-slash prefix, so a per-pack
+ * manifest needs a pattern. Kept as a separate named list rather than by
+ * loosening the literal matcher: a glob inside the array above would make every
+ * future entry ambiguous about which kind of match it asks for.
+ */
+const GENERATED_PATTERNS: readonly { readonly re: RegExp; readonly why: string }[] = [
+    {
+        // `generate_pack_manifests.ts:427`, and the file's own first line reads
+        // "Generated by scripts/generate_pack_manifests.ts — DO NOT EDIT BY
+        // HAND". 12 resolutions over 60 days across two packs.
+        re: /^src\/domains\/[^/]+\/pack\.yaml$/,
+        why: 'per-pack manifest written by generate_pack_manifests.ts',
+    },
 ];
 
 /**
@@ -159,7 +197,8 @@ export function isUntrackedByDesign(rel: string): boolean {
 
 export function isGenerated(rel: string): boolean {
     const norm = rel.replace(/\\/g, '/');
-    return GENERATED.some((g) => (g.endsWith('/') ? norm.startsWith(g) : norm === g));
+    if (GENERATED.some((g) => (g.endsWith('/') ? norm.startsWith(g) : norm === g))) return true;
+    return GENERATED_PATTERNS.some((p) => p.re.test(norm));
 }
 
 /**

package/src/scripts/token_sink_report.ts

@@ -0,0 +1,239 @@
+#!/usr/bin/env node
+/**
+ * Token-sink ranking + re-read measurement over the local transcript store.
+ *
+ * `road-to-role-scoped-spawn-profiles` Phase 3 Steps 1-3. Phase 3 is declared
+ * independent of that roadmap's Phases 0-2 in both directions: it needs no
+ * payload capture and it arms nothing.
+ *
+ * **The denominator is published, deliberately.** Step 2's whole content is
+ * that *"a sink's share is only meaningful against the total it was measured
+ * from, and the store is one machine's history — the report says so rather
+ * than reading as a property of the package."* Every rendered figure is
+ * therefore accompanied by the record count, the date range, and the
+ * single-store caveat, and {@link Report.provenance} carries that sentence as
+ * data so a JSON consumer cannot strip it by taking the numbers only.
+ *
+ * **Two things this report is NOT.** It is not a cost figure — the weighting
+ * is the cost-SHAPED `weightedInputUnits` from `_lib/cc_transcript.ts`, not a
+ * price. And the wasted-token column is a `chars / 4` proxy over duplicate
+ * `tool_result` bodies (see `_lib/transcript_reads.ts`), because the
+ * transcript records no per-tool-result token count; it is named
+ * `wasted_tokens_proxy` everywhere so the label travels with the number.
+ *
+ * Class A: in-process, per-invocation, read-only, no network, no daemon, no
+ * writes outside stdout.
+ *
+ * Usage:
+ *   ./scripts-run src/scripts/token_sink_report [--format text|json]
+ *     [--root <path>] [--max-age-days <n>] [--top <n>]
+ */
+import * as path from 'node:path';
+import { fileURLToPath, pathToFileURL } from 'node:url';
+
+import {
+    DEFAULT_PROJECTS_ROOT,
+    billableInputTokens,
+    listTranscriptFiles,
+    scanTranscripts,
+    weightedInputUnits,
+    type TranscriptRecord,
+} from './_lib/cc_transcript.js';
+import { computeRereads, type RereadResult } from './_lib/transcript_reads.js';
+
+/**
+ * One token sink: a `bucket/model` pair. The bucket half is what makes the
+ * ranking answer the question the roadmap asks — `main` versus `subagent` is
+ * the axis a scoping decision acts on — and the model half keeps a cheap
+ * worker's traffic from being summed with an expensive orchestrator's.
+ */
+export interface Sink {
+    sink: string;
+    bucket: string;
+    model: string;
+    calls: number;
+    billable_input: number;
+    weighted_input_units: number;
+    /** This sink's share of total weighted input units, 0..1. */
+    weighted_share: number;
+}
+
+export function rankSinks(records: readonly TranscriptRecord[]): Sink[] {
+    const acc = new Map<string, Sink>();
+    for (const r of records) {
+        const key = `${r.bucket}/${r.model}`;
+        const row = acc.get(key) ?? {
+            sink: key,
+            bucket: r.bucket,
+            model: r.model,
+            calls: 0,
+            billable_input: 0,
+            weighted_input_units: 0,
+            weighted_share: 0,
+        };
+        row.calls += 1;
+        row.billable_input += billableInputTokens(r.usage);
+        row.weighted_input_units += weightedInputUnits(r.usage);
+        acc.set(key, row);
+    }
+    const rows = [...acc.values()];
+    const total = rows.reduce((s, r) => s + r.weighted_input_units, 0);
+    for (const r of rows) {
+        r.weighted_share = total > 0 ? r.weighted_input_units / total : 0;
+    }
+    rows.sort((a, b) => b.weighted_input_units - a.weighted_input_units || a.sink.localeCompare(b.sink));
+    return rows;
+}
+
+export interface Options {
+    format: 'text' | 'json';
+    root: string;
+    maxAgeDays: number;
+    top: number;
+}
+
+const DEFAULT_TOP = 15;
+
+export function parseArgs(argv: string[]): Options {
+    const opts: Options = {
+        format: 'text',
+        root: DEFAULT_PROJECTS_ROOT,
+        maxAgeDays: 90,
+        top: DEFAULT_TOP,
+    };
+    for (let i = 0; i < argv.length; i++) {
+        const a = argv[i];
+        if (a === undefined) continue;
+        if (a === '--format') opts.format = (argv[++i] as Options['format']) ?? opts.format;
+        else if (a.startsWith('--format=')) opts.format = a.slice('--format='.length) as Options['format'];
+        else if (a === '--root') opts.root = argv[++i] ?? opts.root;
+        else if (a.startsWith('--root=')) opts.root = a.slice('--root='.length);
+        else if (a === '--max-age-days') opts.maxAgeDays = Number(argv[++i]) || opts.maxAgeDays;
+        else if (a.startsWith('--max-age-days=')) opts.maxAgeDays = Number(a.slice('--max-age-days='.length)) || opts.maxAgeDays;
+        else if (a === '--top') opts.top = Number(argv[++i]) || opts.top;
+        else if (a.startsWith('--top=')) opts.top = Number(a.slice('--top='.length)) || opts.top;
+    }
+    if (opts.format !== 'text' && opts.format !== 'json') opts.format = 'text';
+    return opts;
+}
+
+/**
+ * The single-store caveat, carried as DATA rather than as rendering. A JSON
+ * consumer that keeps `sinks` and drops the prose still keeps this field.
+ */
+export const PROVENANCE =
+    'Local-store-derived: computed from one machine\'s ~/.claude/projects transcripts. ' +
+    'Every share below is a fact about this store, not a property of the package.';
+
+export interface Report {
+    schema: 'token-sink-report/v1';
+    root: string;
+    window_days: number;
+    provenance: string;
+    total_seen: number;
+    deduped_count: number;
+    dedup_ratio: number;
+    legs_scanned: number;
+    date_range: { first: string | null; last: string | null };
+    sinks: Sink[];
+    rereads: RereadResult;
+    wasted_tokens_proxy_note: string;
+}
+
+const PROXY_NOTE =
+    'wasted_tokens_proxy is a chars / 4 estimate over duplicate tool_result bodies. ' +
+    'The transcript records no per-tool-result token count, so this is a proxy, never a measurement.';
+
+export function buildReport(opts: Options): Report {
+    const scan = scanTranscripts({ root: opts.root, maxAgeDays: opts.maxAgeDays });
+    const files = listTranscriptFiles({ root: opts.root, maxAgeDays: opts.maxAgeDays });
+    const rereads = computeRereads(files);
+
+    const stamps = scan.records
+        .map((r) => r.timestamp)
+        .filter((t): t is string => typeof t === 'string' && t.length > 0)
+        .sort();
+
+    return {
+        schema: 'token-sink-report/v1',
+        root: opts.root,
+        window_days: opts.maxAgeDays,
+        provenance: PROVENANCE,
+        total_seen: scan.totalSeen,
+        deduped_count: scan.dedupedCount,
+        dedup_ratio: scan.dedup_ratio,
+        legs_scanned: rereads.legs_scanned,
+        date_range: { first: stamps[0] ?? null, last: stamps[stamps.length - 1] ?? null },
+        sinks: rankSinks(scan.records),
+        rereads,
+        wasted_tokens_proxy_note: PROXY_NOTE,
+    };
+}
+
+function pct(v: number): string {
+    return `${(v * 100).toFixed(1)}%`;
+}
+
+export function renderText(r: Report, top: number = DEFAULT_TOP): string {
+    const out: string[] = [];
+    out.push('token-sink report · schema token-sink-report/v1');
+    out.push('');
+    out.push('Denominator (read this before any share below):');
+    out.push(`  records (deduped) : ${r.deduped_count} of ${r.total_seen} seen (dedup ${pct(r.dedup_ratio)})`);
+    out.push(`  transcript legs   : ${r.legs_scanned}`);
+    out.push(`  date range        : ${r.date_range.first ?? 'n/a'} .. ${r.date_range.last ?? 'n/a'}`);
+    out.push(`  window            : ${r.window_days} days · root ${r.root}`);
+    out.push(`  provenance        : ${r.provenance}`);
+    out.push('');
+
+    if (r.deduped_count === 0) {
+        out.push('No records in this store for the given window — nothing to rank.');
+        out.push('');
+    } else {
+        out.push(`Token sinks, ranked by weighted input units (top ${top}):`);
+        for (const s of r.sinks.slice(0, top)) {
+            out.push(
+                `  ${s.sink.padEnd(38)} calls=${String(s.calls).padStart(6)} ` +
+                    `weighted=${s.weighted_input_units.toFixed(0).padStart(12)} share=${pct(s.weighted_share)}`,
+            );
+        }
+        out.push('');
+    }
+
+    out.push('Re-reads within a single transcript leg:');
+    out.push(`  reads observed    : ${r.rereads.total_reads}`);
+    out.push(`  duplicate reads   : ${r.rereads.duplicate_reads}`);
+    out.push(`  wasted (proxy)    : ${r.rereads.wasted_tokens_proxy} tokens`);
+    out.push(`  note              : ${r.wasted_tokens_proxy_note}`);
+    if (r.rereads.files.length === 0) {
+        out.push('  no file was read twice inside one leg in this window.');
+    } else {
+        out.push(`  top ${top} by wasted (proxy):`);
+        for (const f of r.rereads.files.slice(0, top)) {
+            out.push(
+                `    ${f.file_path}\n      reads=${f.total_reads} dup=${f.duplicate_reads} ` +
+                    `legs_with_reread=${f.legs_with_reread} wasted_proxy=${f.wasted_tokens_proxy}`,
+            );
+        }
+    }
+    return out.join('\n');
+}
+
+export function main(argv: string[] = process.argv.slice(2)): number {
+    const opts = parseArgs(argv);
+    const report = buildReport(opts);
+    if (opts.format === 'json') {
+        process.stdout.write(JSON.stringify(report, null, 2) + '\n');
+    } else {
+        process.stdout.write(renderText(report, opts.top) + '\n');
+    }
+    return 0;
+}
+
+const _HERE = fileURLToPath(import.meta.url);
+declare const __AGENT_CONFIG_BUNDLE__: boolean | undefined;
+const _bundled = typeof __AGENT_CONFIG_BUNDLE__ !== 'undefined' && __AGENT_CONFIG_BUNDLE__;
+if (!_bundled && process.argv[1] !== undefined) {
+    const invokedUrl = pathToFileURL(path.resolve(process.argv[1])).href;
+    if (pathToFileURL(_HERE).href === invokedUrl) process.exit(main());
+}