@event4u/agent-config 14.23.0 → 15.0.0

package/src/scripts/_lib/tolerance_shadow.ts

@@ -0,0 +1,177 @@
+/**
+ * Shadow records for the value-reconciliation tolerance — the window whose
+ * distribution a threshold may later be read off.
+ *
+ * NO NEW CONCERN. `check_estate_count` reports zero growth allowance on hook
+ * concerns, and the roadmap step says so in as many words: extend the existing
+ * shadow gate. These records therefore ride `source_first_gate_hook.ts`'s
+ * `SHADOW_LOG` — the same JSONL file, the same gitignored local-only path — and
+ * are told apart by their own `record` discriminator. Nothing new is registered,
+ * nothing new fires, and the concern count is unmoved.
+ *
+ * NO SELF-REPORTED VERDICT, which is the property the step's verify clause
+ * names and the one most easily lost. A record says what the distance WAS and
+ * what each candidate threshold WOULD have done with it. It never says whether
+ * that was right. A field like `was_correct` would be the mechanism grading its
+ * own homework, and a distribution of self-assessments measures the assessor —
+ * the same reason `source_first_gate_hook` records `would_warn` per candidate
+ * instead of one `warn`.
+ *
+ * COUNTERFACTUAL, NOT CHOSEN. `CANDIDATE_COLOR_THRESHOLDS` and
+ * `CANDIDATE_LENGTH_THRESHOLDS` are evaluation points, not defaults: every
+ * record carries the outcome at each, so the window yields a curve rather than
+ * a yes/no. That is the council's own instruction — evaluate several candidate
+ * thresholds counterfactually, never select one as behaviour — and it is why a
+ * spread exists at all. `SHIPPED_TOLERANCE` stays `null` on both axes
+ * throughout the window.
+ *
+ * PRIVACY BY CONSTRUCTION. The record type carries a kind, a metric, numbers,
+ * a token NAME, and booleans. It has no field able to hold a file path, a
+ * prompt, a selector, or any document content — the same stance
+ * `source_first_gate_hook.ts` states for its own record. A token name is a
+ * project's own vocabulary and is the one string here; it is what makes a
+ * distribution readable per token rather than only in aggregate.
+ */
+import { appendShadowLine } from '../hooks/source_first_gate_hook.js';
+
+import type {
+    COLOR_DISTANCE_METRIC,
+    LENGTH_DISTANCE_METRIC,
+    ValueKind,
+    ValueRow,
+} from './design_tolerance.js';
+
+/**
+ * Colour ΔEOK evaluation points. Spread deliberately across two orders of
+ * magnitude: the window has to show where the curve bends, and a spread
+ * clustered around a guess would only confirm the guess.
+ */
+export const CANDIDATE_COLOR_THRESHOLDS: readonly number[] = [0.001, 0.005, 0.01, 0.02, 0.05];
+
+/**
+ * Length evaluation points, in CSS pixels. `1` is here because it is the one
+ * externally observed candidate in the evidence set (Primer's spacing plugin),
+ * and it is one point on a curve rather than a preferred value.
+ */
+export const CANDIDATE_LENGTH_THRESHOLDS: readonly number[] = [0.5, 1, 2, 4];
+
+/** Discriminator on the shared shadow log. */
+export const TOLERANCE_SHADOW_RECORD = 'tolerance_shadow' as const;
+
+export interface CounterfactualOutcome {
+    threshold: number;
+    /** Would this value have been reconciled onto the token at that threshold? */
+    would_reconcile: boolean;
+}
+
+export interface ToleranceShadowRecord {
+    record: typeof TOLERANCE_SHADOW_RECORD;
+    kind: ValueKind;
+    metric: typeof COLOR_DISTANCE_METRIC | typeof LENGTH_DISTANCE_METRIC;
+    /** Distance to the nearest project token, in `metric`. */
+    distance: number;
+    /** The token's own name. No value, no path, no content. */
+    nearest_token: string;
+    /** What the mechanism actually did — `false` throughout the shadow window. */
+    acted: boolean;
+    counterfactual: CounterfactualOutcome[];
+}
+
+export function candidatesFor(kind: ValueKind): readonly number[] {
+    return kind === 'color' ? CANDIDATE_COLOR_THRESHOLDS : CANDIDATE_LENGTH_THRESHOLDS;
+}
+
+/**
+ * Build a record from a reconciled value row, or `null` when the row carries
+ * nothing to measure.
+ *
+ * A row with no candidate token is deliberately NOT recorded as a distance of
+ * zero or of infinity: it is the absence of a measurement, and a window that
+ * silently folded those in would report a distribution over a population that
+ * includes non-observations.
+ */
+export function toleranceShadowRecord(
+    kind: ValueKind,
+    row: ValueRow,
+): ToleranceShadowRecord | null {
+    if (row.nearest === null || row.distance === null || row.metric === null) return null;
+    const distance = row.distance;
+    return {
+        record: TOLERANCE_SHADOW_RECORD,
+        kind,
+        metric: row.metric,
+        distance,
+        nearest_token: row.nearest.name,
+        acted: row.outcome === 'reconciled',
+        counterfactual: candidatesFor(kind).map((threshold) => ({
+            threshold,
+            would_reconcile: distance <= threshold,
+        })),
+    };
+}
+
+/**
+ * Append the records for one reconciliation pass to the shared shadow log.
+ *
+ * THE WINDOW IS ONLY OPEN IF SOMETHING WRITES TO IT. A blind review of the
+ * branch that shipped this module found the header above claiming records ride
+ * `SHADOW_LOG` while the module had no writer and no caller — so
+ * `FLIP_CRITERION`'s reverse trigger ("fewer than 20 records in 8 weeks")
+ * was satisfied by construction, which is a criterion that measures nothing.
+ * The writer is `appendShadowLine`, reused rather than reimplemented: it is
+ * already replay-aware and already fail-open, and a second writer to one log is
+ * two chances to disagree about the format.
+ *
+ * Returns the number of records written — rows with nothing to measure are
+ * skipped, so this is not `rows.length`.
+ */
+export function recordToleranceShadow(
+    root: string,
+    rows: ReadonlyArray<{ kind: ValueKind; row: ValueRow }>,
+): number {
+    let written = 0;
+    for (const { kind, row } of rows) {
+        const record = toleranceShadowRecord(kind, row);
+        if (record === null) continue;
+        appendShadowLine(root, record as unknown as Record<string, unknown>);
+        written += 1;
+    }
+    return written;
+}
+
+/**
+ * Pre-registered flip criterion, written BEFORE the window opens — which is the
+ * third clause of the step's verify and the one a later reader cannot
+ * reconstruct. Prose rather than code on purpose: nothing evaluates it
+ * automatically, and a function that returned `true` here would be the
+ * mechanism authorising its own promotion.
+ */
+export const FLIP_CRITERION = `
+Shadow -> a shipped tolerance, when ALL of:
+
+  a. >= 200 tolerance_shadow records, or >= 4 weeks of window, whichever comes
+     first, with at least 50 records on EACH axis. Colour and length are
+     separate distributions and a threshold read off a pooled one is read off
+     the wrong population.
+  b. The chosen candidate's counterfactual FALSE-RECONCILIATION share -- rows a
+     human reviewer marks as "should have been preserved" that the candidate
+     would have reconciled -- is at or below 1 %, estimated per axis. The
+     reviewer labels are collected OUTSIDE this record type on purpose: a
+     record that carried its own correctness label would be the self-report
+     this module refuses.
+  c. The MISSED-reconciliation share is reported alongside it and is not
+     optimised away. A threshold of zero trivially satisfies (b) and is useless;
+     both error directions are stated or the criterion is not met.
+  d. The distribution is not obviously bimodal. A bimodal curve means the
+     tolerance model itself is wrong -- two populations are being measured as
+     one -- and the response is to re-cut the model, never to pick a threshold
+     between the modes.
+
+Reverse trigger: fewer than 20 records in 8 weeks -> evaluate removing the
+mechanism. A reconciliation nobody exercises is prose with a config key.
+
+Never lifted by this criterion: enabling the mechanism BY DEFAULT is a
+consumer-facing default flip and stays owner-reserved, recorded in
+agents/roadmaps/stubs/road-to-frontend-power-default-flip.md. Meeting a to d
+authorises a shipped tolerance VALUE, not a shipped default.
+`.trim();

package/src/scripts/ai_council/redact_low_impact_entry.ts

@@ -33,6 +33,14 @@
  * 7. Business-context SQL identifiers — caller-supplied table / column
  *    allow-list. Default empty.
  * 8. Inline code excerpts > 40 chars — any backtick-fenced run > 40.
+ *
+ * loss_class: exact
+ *
+ * Named despite the module's name: the redactor never rewrites. It returns a
+ * {@link RedactionResult} verdict and the caller refuses, so no byte of the
+ * input is dropped or replaced here — "a rewritten secret is still a leaked
+ * secret". `exact` is the class that says nothing is lost, and it is what this
+ * module guarantees its callers.
  */
 
 import { _RAW_KEY_PREFIXES } from './config.js';

package/src/scripts/autonomy_friction_traffic.ts

@@ -0,0 +1,379 @@
+/**
+ * autonomy_friction_traffic — what share of REAL Bash traffic this package
+ * can spare a host confirmation, and what the rest is shaped like.
+ *
+ * WHY A SECOND FRICTION INSTRUMENT. `autonomy_friction_corpus` measures seven
+ * declared payload classes through the real dispatcher: it answers "does the
+ * classifier behave as designed" and it answers it exactly. What it cannot
+ * answer is "how much of what the agent actually types does the design
+ * cover", because a hand-written corpus contains the shapes its author
+ * thought of. That number turned out to be the one that mattered: measured
+ * over 7,569 distinct real Bash calls in 39 transcripts on 2026-09-10,
+ * category A covered 126 of them — 1.7 %.
+ *
+ * WHAT IT MEASURES, STATED NARROWLY. Three things, over a transcript store:
+ * the share of Bash calls that are category A (the calls this package hands
+ * the host an explicit `permissionDecision: allow` for); which disqualifier
+ * each remaining call hits FIRST; and how many carry one of the two shapes
+ * the chain-nudge concern flags. It is NOT a measurement of confirmations the
+ * operator saw. The host's own permission documentation records that
+ * `permissions.allow` does not bypass the auto-mode classifier, so a consumer
+ * whose settings already allow a call may see no prompt for a call counted
+ * here as uncovered, and a call inside category A may still be classified by
+ * the host. Reading this as host behaviour is the
+ * fact-about-our-plumbing-written-as-a-fact-about-the-host collapse the hook
+ * contract warns about three times.
+ *
+ * NOT A GATE. It has no baseline and fails nothing. A gate over this number
+ * would ratchet a figure that moves with how the operator happened to work
+ * that week, which is a measurement of the week and not of the tree. Exit 1
+ * means the store was unreadable or empty — a probe that reports zeros from
+ * an absent store is worse than one that refuses.
+ *
+ * SHARED DETECTORS, NOT A SECOND COPY. The avoidable-shape counts come from
+ * the concern's own exported `detectEditByShell` / `detectChaining`, and the
+ * metacharacter class is `category_a`'s own exported constant, so a change to
+ * either moves this report and the live carrier together. A private copy here
+ * would let the two drift and the report would then describe a carrier that
+ * does not exist — the first draft held exactly such a copy, and it computed
+ * the split the whole report turns on.
+ *
+ * WHAT MAKES A FIGURE FROM THIS PROBE COMPARABLE. Two properties, both of
+ * which the first draft lacked. Calls are deduplicated by tool-use id, because
+ * a resumed session rewrites its earlier turns into a new transcript and a
+ * window of files therefore counts them twice. And the running session's own
+ * transcript is excluded by default, because every call the probe itself makes
+ * lands in a file it is about to read — two runs minutes apart reported 7,518
+ * and 7,653 for the same tree before that. What remains uncontrolled is the
+ * window: `--limit 40` names the 40 most recent transcripts, and which files
+ * those are moves as new sessions appear. So pin the DATE with the figure and
+ * read a later run as measuring the window as well as the tree.
+ *
+ * Usage:
+ *   ./scripts-run src/scripts/autonomy_friction_traffic [--store DIR] [--limit N] [--json]
+ *   … [--include-current]   include the running session's own transcript
+ */
+import * as fs from "node:fs";
+import * as os from "node:os";
+import * as path from "node:path";
+import process from "node:process";
+import { fileURLToPath } from "node:url";
+
+import { detectChaining, detectEditByShell } from "./hooks/chain_nudge_hook.js";
+import {
+    isCategoryABashCommand,
+    namesConsequenceOperation,
+    SHELL_METACHARACTERS,
+} from "./hooks/category_a.js";
+
+// Re-exported so a test can assert this module refuses on the CLASSIFIER's
+// metacharacter set rather than on a copy of it. The first draft held a private
+// regex literal here while the header claimed shared detectors, and that copy
+// computed the split the whole report turns on.
+export { SHELL_METACHARACTERS };
+
+/** How many transcripts to read when `--limit` is absent. */
+const DEFAULT_LIMIT = 40;
+
+/** One measured report. */
+export interface TrafficReport {
+    store: string;
+    transcripts: number;
+    calls: number;
+    categoryA: number;
+    /** First disqualifier for each non-category-A call. */
+    disqualifiers: Record<string, number>;
+    /** Head token → count, for non-category-A calls only. */
+    heads: Record<string, number>;
+    /** The chain-nudge shape classes, counted over every call. */
+    shapes: { editByShell: number; chain: number };
+    /** Which write shapes, in the concern's own words. */
+    editShapes: Record<string, number>;
+}
+
+/** One Bash call, with the tool-use id that identifies it across files. */
+export interface BashCall {
+    /** The host's `tool_use` id, or `""` when the record carries none. */
+    id: string;
+    command: string;
+}
+
+/**
+ * Every Bash call in one transcript's text.
+ *
+ * Line-delimited JSON, one record per line, so a malformed line is skipped
+ * rather than costing the file. The `"Bash"` pre-filter is a cheap reject: a
+ * transcript is megabytes and most lines carry no tool call at all.
+ *
+ * The id comes out with the command because a resumed session writes a new
+ * transcript carrying the earlier turns again — counting a window of files
+ * therefore counts some calls twice, and the id is what tells the copies apart
+ * from two genuinely identical commands.
+ */
+export function extractCommands(text: string): BashCall[] {
+    const out: BashCall[] = [];
+    for (const line of text.split("\n")) {
+        if (!line.includes('"Bash"')) continue;
+        let rec: unknown;
+        try {
+            rec = JSON.parse(line) as unknown;
+        } catch {
+            continue;
+        }
+        const content = (rec as { message?: { content?: unknown } })?.message?.content;
+        if (!Array.isArray(content)) continue;
+        for (const block of content) {
+            const b = block as { type?: unknown; name?: unknown; id?: unknown; input?: { command?: unknown } };
+            if (b?.type !== "tool_use" || b?.name !== "Bash") continue;
+            if (typeof b.input?.command !== "string") continue;
+            out.push({ id: typeof b.id === "string" ? b.id : "", command: b.input.command });
+        }
+    }
+    return out;
+}
+
+/**
+ * The distinct calls in `calls`, keyed by tool-use id.
+ *
+ * A call with no id cannot be deduplicated and is kept — dropping it would
+ * silently shrink the denominator, and an over-count biases the report toward
+ * looking worse than it is, which is the safe direction for a friction figure.
+ */
+export function dedupeCalls(calls: readonly BashCall[]): string[] {
+    const seen = new Set<string>();
+    const out: string[] = [];
+    for (const call of calls) {
+        if (call.id) {
+            if (seen.has(call.id)) continue;
+            seen.add(call.id);
+        }
+        out.push(call.command);
+    }
+    return out;
+}
+
+/**
+ * The transcript of the session running this probe, if the host names one.
+ *
+ * Excluded by default. A probe whose window includes its own session measures
+ * the measurement: every call this run makes lands in the file it is reading,
+ * so two runs minutes apart report different totals for the same tree and the
+ * figure cannot be pinned. `--include-current` opts back in.
+ */
+export function currentSessionTranscript(store: string): string | null {
+    const id = process.env["CLAUDE_CODE_SESSION_ID"];
+    return id ? path.join(store, `${id}.jsonl`) : null;
+}
+
+/** The head token of a command, lower-cased, or `""`. */
+export function headToken(command: string): string {
+    return (command.trim().split(/\s+/)[0] ?? "").toLowerCase();
+}
+
+/**
+ * Why this call is not category A, in one word.
+ *
+ * Only the FIRST disqualifier is reported, because that is the one a change
+ * would have to remove: a chained command whose head is also unlisted stays
+ * uncovered if only the head is added.
+ *
+ * The buckets mirror `category_a`'s own order of refusal, including the
+ * consequence-word check — without it `git push origin main` and `gh pr merge`
+ * landed in the head bucket, and a report saying "N fail on the head token"
+ * then counted operations that would be refused whatever the head list said.
+ *
+ * The last bucket is still an UPPER BOUND rather than an exact head count: a
+ * simple command can also be refused for a directory flag whose value escapes
+ * the working tree, and that case is not separable from here without
+ * reimplementing the argv walk. Read it as "refused after the shape and the
+ * operation were cleared", and never as "adding this head would cover it".
+ */
+export function firstDisqualifier(command: string): string {
+    if (!command.trim()) return "empty-command";
+    if (SHELL_METACHARACTERS.test(command)) return "shell-metacharacter";
+    if (namesConsequenceOperation(command)) return "names-a-consequence-operation";
+    return "not-an-allowlisted-operation";
+}
+
+/** Classify a command set. Pure — the caller supplies the strings. */
+export function classify(store: string, transcripts: number, commands: readonly string[]): TrafficReport {
+    const report: TrafficReport = {
+        store,
+        transcripts,
+        calls: commands.length,
+        categoryA: 0,
+        disqualifiers: {},
+        heads: {},
+        shapes: { editByShell: 0, chain: 0 },
+        editShapes: {},
+    };
+    for (const command of commands) {
+        const write = detectEditByShell(command);
+        if (write) {
+            report.shapes.editByShell += 1;
+            report.editShapes[write] = (report.editShapes[write] ?? 0) + 1;
+        } else if (detectChaining(command)) {
+            report.shapes.chain += 1;
+        }
+        if (isCategoryABashCommand(command)) {
+            report.categoryA += 1;
+            continue;
+        }
+        const why = firstDisqualifier(command);
+        report.disqualifiers[why] = (report.disqualifiers[why] ?? 0) + 1;
+        const head = headToken(command);
+        report.heads[head] = (report.heads[head] ?? 0) + 1;
+    }
+    return report;
+}
+
+/** The default transcript store for the checkout this file lives in. */
+export function defaultStore(repoRoot: string): string {
+    const slug = repoRoot.replace(/\//g, "-");
+    return path.join(os.homedir(), ".claude", "projects", slug);
+}
+
+/** The `--limit` most recently modified transcripts in `store`. */
+export function transcriptPaths(store: string, limit: number): string[] {
+    let names: string[];
+    try {
+        names = fs.readdirSync(store);
+    } catch {
+        return [];
+    }
+    return names
+        .filter((n) => n.endsWith(".jsonl"))
+        .map((n) => path.join(store, n))
+        .map((p) => {
+            try {
+                return { p, m: fs.statSync(p).mtimeMs };
+            } catch {
+                return { p, m: 0 };
+            }
+        })
+        .sort((a, b) => b.m - a.m)
+        .slice(0, limit)
+        .map((x) => x.p);
+}
+
+/** Top `n` entries of a histogram, descending. */
+function top(hist: Record<string, number>, n: number): Array<[string, number]> {
+    return Object.entries(hist)
+        .sort((a, b) => b[1] - a[1])
+        .slice(0, n);
+}
+
+function pct(part: number, whole: number): string {
+    return whole === 0 ? "n/a" : `${((part / whole) * 100).toFixed(1)} %`;
+}
+
+export function render(r: TrafficReport): string {
+    const lines: string[] = [];
+    lines.push("autonomy_friction_traffic — category-A coverage over real Bash traffic\n");
+    lines.push(`  store        ${r.store}`);
+    lines.push(`  transcripts  ${r.transcripts}`);
+    lines.push(`  Bash calls   ${r.calls}\n`);
+    lines.push(`  category A (this package hands the host an allow)  ${r.categoryA}  (${pct(r.categoryA, r.calls)})`);
+    lines.push(`  no allow emitted                                   ${r.calls - r.categoryA}  (${pct(r.calls - r.categoryA, r.calls)})\n`);
+    lines.push("  first disqualifier:");
+    for (const [k, v] of top(r.disqualifiers, 10)) lines.push(`    ${String(v).padStart(6)}  ${k}`);
+    lines.push("\n  top head tokens among the uncovered:");
+    for (const [k, v] of top(r.heads, 15)) lines.push(`    ${String(v).padStart(6)}  ${k}`);
+    lines.push("\n  chain-nudge shape classes (counted over every call):");
+    lines.push(`    ${String(r.shapes.editByShell).padStart(6)}  edit-by-shell  (${pct(r.shapes.editByShell, r.calls)})`);
+    lines.push(`    ${String(r.shapes.chain).padStart(6)}  chain          (${pct(r.shapes.chain, r.calls)})`);
+    for (const [k, v] of top(r.editShapes, 6)) lines.push(`      ${String(v).padStart(4)}  ${k}`);
+    lines.push("\n  Not a gate: no baseline, fails nothing. See this file's header for what");
+    lines.push("  the number does and does not say about what the operator was prompted for.\n");
+    return `${lines.join("\n")}\n`;
+}
+
+/**
+ * The value of `flag`, `undefined` when the flag is absent, `null` when it is
+ * present with no value.
+ *
+ * The three states are distinct because the caller must refuse the third. A
+ * valueless `--store` used to collapse into "absent" and fall back to the
+ * default store silently, which is the same class of defect as the `--limit`
+ * coercion beside it: an argument that silently changes the window.
+ */
+function argValue(argv: readonly string[], flag: string): string | null | undefined {
+    const i = argv.indexOf(flag);
+    if (i === -1) return undefined;
+    const value = argv[i + 1];
+    return value === undefined || value.startsWith("--") ? null : value;
+}
+
+export function main(argv: string[] = process.argv.slice(2)): number {
+    if (argv.includes("--help") || argv.includes("-h")) {
+        process.stdout.write(
+            "usage: autonomy_friction_traffic [--store DIR] [--limit N] [--json] [--include-current]\n" +
+                "  Category-A coverage over the Bash calls in a transcript store,\n" +
+                "  plus the shape classes the chain-nudge concern flags. Calls are\n" +
+                "  deduplicated by tool-use id and the running session's own\n" +
+                "  transcript is excluded unless --include-current is passed.\n" +
+                "  Exit 1 when the store is unreadable or holds no Bash call.\n",
+        );
+        return 0;
+    }
+    const repoRoot = path.resolve(path.dirname(fileURLToPath(import.meta.url)), "..", "..");
+    const storeArg = argValue(argv, "--store");
+    if (storeArg === null) {
+        process.stderr.write("autonomy_friction_traffic: --store needs a directory\n");
+        return 1;
+    }
+    const store = storeArg ?? defaultStore(repoRoot);
+    const limitRaw = argValue(argv, "--limit");
+    let limit = DEFAULT_LIMIT;
+    if (limitRaw !== undefined) {
+        const parsed = limitRaw === null ? NaN : Number(limitRaw);
+        // Validated rather than coerced: `--limit -5` silently dropped the
+        // five OLDEST transcripts through `Array.slice`, `--limit 0` reported
+        // an empty store as the reason, and a typo fell back to 40 without
+        // saying so. A window is the report's denominator; a wrong one is a
+        // wrong measurement wearing the right shape.
+        if (!Number.isInteger(parsed) || parsed < 1) {
+            process.stderr.write(`autonomy_friction_traffic: --limit must be a positive integer, got ${limitRaw ?? "no value"}\n`);
+            return 1;
+        }
+        limit = parsed;
+    }
+
+    const current = argv.includes("--include-current") ? null : currentSessionTranscript(store);
+    const paths = transcriptPaths(store, limit).filter((p) => p !== current);
+    const calls: BashCall[] = [];
+    for (const p of paths) {
+        let text: string;
+        try {
+            text = fs.readFileSync(p, "utf8");
+        } catch {
+            continue;
+        }
+        calls.push(...extractCommands(text));
+    }
+    const commands = dedupeCalls(calls);
+    if (commands.length === 0) {
+        process.stderr.write(
+            `autonomy_friction_traffic: no Bash call found under ${store} ` +
+                `(${paths.length} transcript(s) read) — nothing measured\n`,
+        );
+        return 1;
+    }
+    const report = classify(store, paths.length, commands);
+    process.stdout.write(argv.includes("--json") ? `${JSON.stringify(report, null, 2)}\n` : render(report));
+    return 0;
+}
+
+function _isCliEntry(): boolean {
+    const argv1 = process.argv[1];
+    if (argv1 === undefined) return false;
+    try {
+        return fs.realpathSync(argv1) === fs.realpathSync(fileURLToPath(import.meta.url));
+    } catch {
+        return false;
+    }
+}
+
+if (_isCliEntry()) {
+    process.exit(main());
+}