@event4u/agent-config 16.0.0 → 16.1.0

package/src/scripts/closure_scan.ts

@@ -0,0 +1,333 @@
+#!/usr/bin/env tsx
+/**
+ * The closure detector — finds the open decisions in a plan, and classifies
+ * each one by OWNERSHIP. It never resolves one.
+ *
+ * That boundary is the whole design. A decision dispatcher was killed on
+ * purpose: no TypeScript path routes a decision, and this script adds none.
+ * What it adds is the half that can be mechanical — *which questions are open,
+ * and whose they are* — so the claim "this plan reached execution with twelve
+ * open technical decisions and asked the owner none of them" is falsifiable
+ * rather than a feeling.
+ *
+ * Detector families, each a phrase an author writes when they KNOW something
+ * is open. Deliberately narrow: a detector that fires on ordinary plan prose
+ * turns every producer red at once, and the cheapest repair is then to weaken
+ * it until it finds nothing.
+ *
+ *   `tbd`                      TBD / to be decided / decide later
+ *   `unpicked-alternative`     "either X or Y", "option A … option B"
+ *   `unchecked-assumption`     "assuming", "presumably", "probably fine"
+ *   `missing-verify`           an open step with no `verify:` line
+ *   `ambiguous-acceptance`     a vague acceptance criterion (improve / clean up
+ *                              / best practices / handle errors properly)
+ *   `contradictory`            "contradicts", "conflicts with", "but also"
+ *   `product-semantics`        two valid user-visible outcomes
+ *   `typed-op`                 an operation from the typed vocabulary
+ *   `spend`                    a ceiling or quota question
+ *
+ * Ownership classification is the output that matters. Six families classify
+ * to a technical class the agent, an independent session, a council or a team
+ * resolves; exactly two reach the owner (`product-semantics` → `product-owned`,
+ * `typed-op` → `destructive-owned`); `spend` reaches nobody — it pauses and
+ * reports (ADR-268 § 8).
+ *
+ * Exit codes: 0 no open decisions · 1 open decisions found · 2 bad argv.
+ * Finding open decisions is the POINT, so `--strict` is what makes exit 1 a
+ * failure for a caller that wants one; the default is a report.
+ */
+
+import * as fs from 'node:fs';
+import * as path from 'node:path';
+import process from 'node:process';
+import { fileURLToPath } from 'node:url';
+
+const _HERE = fileURLToPath(import.meta.url);
+const _PROG = 'closure_scan';
+
+export type Kind =
+    | 'tbd'
+    | 'unpicked-alternative'
+    | 'unchecked-assumption'
+    | 'missing-verify'
+    | 'ambiguous-acceptance'
+    | 'contradictory'
+    | 'product-semantics'
+    | 'typed-op'
+    | 'spend';
+
+export interface Finding {
+    readonly id: string;
+    readonly line: number;
+    readonly kind: Kind;
+    readonly ownership: string;
+    readonly excerpt: string;
+}
+
+/**
+ * Kind → ownership class. The two owner-routed rows are the whole cost of
+ * closure: everything else is resolved without reaching a person, which is
+ * what "zero owner questions for twelve technical ambiguities" means.
+ */
+export const OWNERSHIP_BY_KIND: Readonly<Record<Kind, string>> = {
+    tbd: 'contested-technical',
+    'unpicked-alternative': 'contested-technical',
+    'unchecked-assumption': 'reversible-technical',
+    'missing-verify': 'deterministic',
+    'ambiguous-acceptance': 'reversible-technical',
+    contradictory: 'contested-technical',
+    'product-semantics': 'product-owned',
+    'typed-op': 'destructive-owned',
+    spend: 'spend-exhaustion',
+};
+
+/** Classes that reach a person. Everything else closes without an ask. */
+export const OWNER_ROUTED: ReadonlySet<string> = new Set([
+    'product-owned',
+    'business-owned',
+    'destructive-owned',
+]);
+
+interface Pattern {
+    readonly kind: Kind;
+    readonly re: RegExp;
+}
+
+const LINE_PATTERNS: readonly Pattern[] = [
+    { kind: 'tbd', re: /\bTBD\b/ },
+    { kind: 'tbd', re: /\bto be decided\b/i },
+    { kind: 'tbd', re: /\bdecide later\b/i },
+    { kind: 'unpicked-alternative', re: /\beither\b[^.]{3,80}\bor\b/i },
+    { kind: 'unpicked-alternative', re: /\boption A\b[^.]{0,120}\boption B\b/i },
+    { kind: 'unpicked-alternative', re: /\bwe could (?:either )?\w+[^.]{0,80}\bor\b/i },
+    // "two equal technical strategies" is the canonical unpicked alternative,
+    // and the phrasing an author reaches for when the choice is genuinely open
+    // — it carries no `either`, no `or` and no `option A`.
+    { kind: 'unpicked-alternative', re: /\btwo (?:equal|competing)\b[^.]{0,60}\b(?:strateg|approach|design|option)/i },
+    { kind: 'unchecked-assumption', re: /\bassuming\b/i },
+    { kind: 'unchecked-assumption', re: /\bpresumably\b/i },
+    { kind: 'unchecked-assumption', re: /\bprobably (?:fine|works|ok)\b/i },
+    { kind: 'ambiguous-acceptance', re: /\b(?:improve|optimi[sz]e)\b(?![^.]*\bby\b)/i },
+    { kind: 'ambiguous-acceptance', re: /\bmake it (?:better|cleaner|nicer)\b/i },
+    { kind: 'ambiguous-acceptance', re: /\buse best practices\b/i },
+    { kind: 'ambiguous-acceptance', re: /\bhandle errors properly\b/i },
+    { kind: 'contradictory', re: /\bcontradicts\b/i },
+    { kind: 'contradictory', re: /\bconflicts with\b/i },
+    { kind: 'product-semantics', re: /\buser-visible\b[^.]{0,80}\b(?:or|versus|vs\.?)\b/i },
+    { kind: 'product-semantics', re: /\bwhat the user sees\b/i },
+    { kind: 'product-semantics', re: /\btwo valid (?:user|product) semantics\b/i },
+    { kind: 'typed-op', re: /\b(?:merge|force-push|deploy|publish|purchase|rotate the secret)\b/i },
+    { kind: 'spend', re: /\b(?:over|above|crosses?) the (?:configured )?(?:spend )?ceiling\b/i },
+    { kind: 'spend', re: /\bquota (?:is )?(?:exhausted|gone)\b/i },
+];
+
+const STEP_RE = /^\s*-\s\[[ x~-]\]\s/;
+const OPEN_STEP_RE = /^\s*-\s\[ \]\s/;
+const H2_RE = /^##\s+/;
+const DISCHARGE_H2_RE = /^##\s+(Decisions|Blockers|Kill register|Risk Register)\s*$/;
+const ACCEPTANCE_H2_RE = /^##\s+Acceptance Criteria\s*$/;
+
+function _isFence(line: string): boolean {
+    return /^\s*(```|~~~)/.test(line);
+}
+
+/**
+ * A scan unit: one logical statement, which is NOT one physical line.
+ *
+ * A roadmap step wraps over several lines, and the ambiguity it carries
+ * routinely straddles the wrap ("either newline-delimited JSON / or a single
+ * array"). Matching per line missed exactly those, which are the ones an
+ * author is least likely to notice. A step block is therefore ONE unit, joined
+ * and matched once — which also means one finding per step at most, so a step
+ * carrying two hedges is one open decision rather than two.
+ */
+export interface Unit {
+    /** 1-based line of the unit's first line. */
+    readonly line: number;
+    readonly text: string;
+    readonly inAcceptance: boolean;
+    readonly isOpenStep: boolean;
+    readonly hasVerify: boolean;
+}
+
+export function units(lines: readonly string[]): Unit[] {
+    const out: Unit[] = [];
+    let inFence = false;
+    let inDischarge = false;
+    let inAcceptance = false;
+    let i = 0;
+    while (i < lines.length) {
+        const line = lines[i] as string;
+        if (_isFence(line)) {
+            inFence = !inFence;
+            i += 1;
+            continue;
+        }
+        if (inFence) {
+            i += 1;
+            continue;
+        }
+        if (H2_RE.test(line)) {
+            inDischarge = DISCHARGE_H2_RE.test(line);
+            inAcceptance = ACCEPTANCE_H2_RE.test(line);
+        }
+        if (inDischarge) {
+            i += 1;
+            continue;
+        }
+        if (STEP_RE.test(line)) {
+            let j = i + 1;
+            while (j < lines.length && !STEP_RE.test(lines[j] as string) && !H2_RE.test(lines[j] as string)) {
+                j += 1;
+            }
+            const block = lines.slice(i, j);
+            out.push({
+                line: i + 1,
+                // Whitespace-normalised: a wrapped step joined with a single
+                // space still carries the next line's indent, so a pattern
+                // written with single spaces stops matching across the wrap —
+                // which is the case this unit exists to catch.
+                text: block.join(' ').replace(/\s+/g, ' '),
+                inAcceptance,
+                isOpenStep: OPEN_STEP_RE.test(line),
+                hasVerify: /(?:^|\s)verify:/m.test(block.join('\n')),
+            });
+            i = j;
+            continue;
+        }
+        out.push({
+            line: i + 1,
+            text: line,
+            inAcceptance,
+            isOpenStep: false,
+            hasVerify: false,
+        });
+        i += 1;
+    }
+    return out;
+}
+
+export function scan(text: string): Finding[] {
+    const lines = text.split('\n');
+    const findings: Finding[] = [];
+
+    for (const u of units(lines)) {
+        if (/<!--\s*closure:\s*ignore\s*-->/.test(u.text)) continue;
+        let matched: Kind | null = null;
+        for (const { kind, re } of LINE_PATTERNS) {
+            if (re.test(u.text)) {
+                matched = kind;
+                break;
+            }
+        }
+        // An open step carries a `verify:` line — a step whose success cannot
+        // be checked is a trigger for a question, not for work. Acceptance
+        // criteria are criteria, not steps: they have their own contract and
+        // carry no verify line by design.
+        if (matched === null && u.isOpenStep && !u.hasVerify && !u.inAcceptance) {
+            matched = 'missing-verify';
+        }
+        if (matched === null) continue;
+        findings.push({
+            id: '',
+            line: u.line,
+            kind: matched,
+            ownership: OWNERSHIP_BY_KIND[matched],
+            excerpt: u.text.trim().replace(/\s+/g, ' ').slice(0, 120),
+        });
+    }
+
+    findings.sort((a, b) => a.line - b.line);
+    return findings.map((f, idx) => ({ ...f, id: `C${String(idx + 1)}` }));
+}
+
+/** The `## Decisions` skeleton — one row per finding, resolution left open. */
+export function renderRows(findings: readonly Finding[]): string {
+    const header = '| ID | ownership | resolved by | decision | evidence | revisit if |';
+    const sep = '|---|---|---|---|---|---|';
+    const rows = findings.map(
+        (f) => `| ${f.id} | ${f.ownership} | <resolver> | <decision> | ${f.kind}:${String(f.line)} | <condition> |`,
+    );
+    return [header, sep, ...rows].join('\n');
+}
+
+export function ownerQuestionCount(findings: readonly Finding[]): number {
+    return findings.filter((f) => OWNER_ROUTED.has(f.ownership)).length;
+}
+
+// --------------------------------------------------------------------------
+// CLI.
+// --------------------------------------------------------------------------
+
+function _usage(): string {
+    return (
+        `usage: ${_PROG} [-h] [--json] [--rows] [--strict] <roadmap.md>\n\n` +
+        `Find and classify the open decisions in a plan. Resolves nothing.\n`
+    );
+}
+
+export function main(argv?: readonly string[]): number {
+    const args = argv ?? process.argv.slice(2);
+    let json = false;
+    let rows = false;
+    let strict = false;
+    const paths: string[] = [];
+    for (const a of args) {
+        if (a === '-h' || a === '--help') {
+            process.stdout.write(_usage());
+            return 0;
+        } else if (a === '--json') json = true;
+        else if (a === '--rows') rows = true;
+        else if (a === '--strict') strict = true;
+        else if (a.startsWith('-')) {
+            process.stderr.write(`${_usage()}${_PROG}: error: unrecognized arguments: ${a}\n`);
+            return 2;
+        } else paths.push(a);
+    }
+    if (paths.length !== 1) {
+        process.stderr.write(`${_usage()}${_PROG}: error: exactly one roadmap path is required\n`);
+        return 2;
+    }
+    const target = path.resolve(paths[0] as string);
+    let text: string;
+    try {
+        text = fs.readFileSync(target, 'utf-8');
+    } catch {
+        process.stderr.write(`${_PROG}: error: cannot read ${paths[0] as string}\n`);
+        return 2;
+    }
+
+    const findings = scan(text);
+    const owner = ownerQuestionCount(findings);
+
+    if (json) {
+        process.stdout.write(
+            JSON.stringify({ findings, open: findings.length, owner_questions: owner }, null, 2) + '\n',
+        );
+    } else if (rows) {
+        process.stdout.write(renderRows(findings) + '\n');
+    } else {
+        process.stdout.write(`open decisions: ${String(findings.length)}\n`);
+        process.stdout.write(`owner questions: ${String(owner)}\n`);
+        for (const f of findings) {
+            process.stdout.write(
+                `  ${f.id}  ${String(f.line).padStart(4)}  ${f.kind.padEnd(20)} ${f.ownership.padEnd(22)} ${f.excerpt}\n`,
+            );
+        }
+    }
+    if (!findings.length) return 0;
+    return strict ? 1 : 0;
+}
+
+function _isCliEntry(): boolean {
+    if (!process.argv[1]) return false;
+    try {
+        return fs.realpathSync(_HERE) === fs.realpathSync(path.resolve(process.argv[1]));
+    } catch {
+        return false;
+    }
+}
+
+if (_isCliEntry() || process.argv[1] === _HERE) {
+    process.exitCode = main();
+}

package/src/scripts/compile_hook_manifest.ts

@@ -23,10 +23,21 @@
  * Run after editing the manifest:
  *     ./scripts-run src/scripts/compile_hook_manifest
  *
+ * `--out <path>` writes the compiled bytes THERE and leaves the tree alone. It
+ * exists for `check_generator_sync`, whose contract is that a triple regenerates
+ * into a temp dir the gate owns and never into the working tree — a gate that
+ * repaired the artefact it is measuring would turn every staleness into a silent
+ * green plus an unexplained dirty file. Anything that wants to compare against
+ * the committed JSON uses this flag; anything that wants to FIX it omits it.
+ *
  * `tests/hooks/hook_manifest_compiled.test.ts` fails if the committed JSON
- * stops matching the YAML, so a forgotten run is caught rather than shipped.
+ * stops matching the YAML, so a forgotten run is caught rather than shipped —
+ * but only against the COMMITTED blob in CI. Locally that same test reads the
+ * working tree, so a recompile that was run and never committed makes it pass
+ * over a defect that is still on the branch. See the discriminator in
+ * `check_generator_sync`'s header.
  *
- * Exit codes: 0 written (or already current) · 2 internal error.
+ * Exit codes: 0 written (or already current) · 2 internal error or usage.
  */
 import * as fs from 'node:fs';
 import * as path from 'node:path';
@@ -46,9 +57,38 @@ export function compile(yamlText: string): string {
     });
 }
 
-export function main(): number {
+export function main(argv: readonly string[] = process.argv.slice(2)): number {
+    let outPath: string | null = null;
+    for (let i = 0; i < argv.length; i += 1) {
+        const a = argv[i] as string;
+        if (a === '--out') {
+            const next = argv[i + 1];
+            if (next === undefined || next.startsWith('--')) {
+                process.stderr.write('compile_hook_manifest: --out needs a path\n');
+                return 2;
+            }
+            outPath = next;
+            i += 1;
+            continue;
+        }
+        process.stderr.write(
+            `compile_hook_manifest: unknown argument ${JSON.stringify(a)}\n` +
+                'usage: compile_hook_manifest [--out <path>]\n',
+        );
+        return 2;
+    }
+
     const text = fs.readFileSync(YAML_PATH, 'utf-8');
     const next = compile(text);
+
+    if (outPath !== null) {
+        // Comparison copy. No `already current` short-circuit: the caller asked
+        // for the bytes, and an unwritten file would read as a generator that
+        // silently did nothing.
+        fs.writeFileSync(outPath, next);
+        return 0;
+    }
+
     const current = fs.existsSync(JSON_PATH) ? fs.readFileSync(JSON_PATH, 'utf-8') : null;
     if (current === next) {
         process.stdout.write('compile_hook_manifest: already current\n');

package/src/scripts/council_record_shape.ts

@@ -0,0 +1,209 @@
+#!/usr/bin/env tsx
+/**
+ * When a council record owes the owner an options block — and when it must not.
+ *
+ * The output contract used to end every council run with a numbered-options
+ * block carrying the host verdict, unconditionally. Under an ownership axis
+ * that is wrong in one specific case and right in every other: a **conclusive
+ * technical** verdict is a resolution, and handing it to the owner as options
+ * routes a technical decision to a person because it was hard — the move
+ * ADR-268 § 10 forbids by name.
+ *
+ * So the block becomes conditional, on exactly two readable fields:
+ *
+ *   owed          the verdict is owner-owned (`product-owned`, `business-owned`,
+ *                 `destructive-owned`), OR the council did not converge. Both
+ *                 are cases where nobody but the owner can close it, and the
+ *                 block carries the council's PROPOSAL for them to confirm.
+ *   forbidden     the verdict is technical AND conclusive. The record states
+ *                 the resolution; the run continues.
+ *
+ * Convergence is read, not inferred: a record that does not say whether its
+ * members converged is itself the finding, because "conclusive" would then be
+ * the author's word for it rather than a property of the run.
+ *
+ * This is an evaluator over a record, not a gate over the tree — the tree's
+ * council records are gitignored and pruned (they are dev-time scratch; the
+ * durable record is the convergence inlined into the artifact). It exists so
+ * the contract is checkable against a fixture rather than asserted in prose.
+ *
+ * Exit codes: 0 conforming · 1 findings · 2 bad argv.
+ */
+
+import * as fs from 'node:fs';
+import * as path from 'node:path';
+import process from 'node:process';
+import { fileURLToPath } from 'node:url';
+
+const _HERE = fileURLToPath(import.meta.url);
+const _PROG = 'council_record_shape';
+
+/** Owner-owned classes — the only ones a council may not close for the owner. */
+export const OWNER_OWNED: ReadonlySet<string> = new Set([
+    'product-owned',
+    'business-owned',
+    'destructive-owned',
+]);
+
+// Emphasis is stripped before these run (see `_plain`): the label is written
+// `Ownership:`, `**Ownership:**` and `- **Ownership**:` across the corpus, and
+// a pattern that tries to spell all three is how one spelling ends up silently
+// unreadable.
+const OWNERSHIP_RE = /^\s*[-*]?\s*Ownership\s*:\s*`?([a-z-]+)`?/im;
+const CONVERGENCE_RE = /^\s*[-*]?\s*Convergence\s*:\s*(.+)$/im;
+const OPTIONS_HEADING_RE = /^#{2,4}\s+(?:Options|Owner options|User options)\b/im;
+const NUMBERED_OPTION_RE = /^\s*1\.\s+\S/m;
+
+export interface RecordShape {
+    readonly ownership: string | null;
+    readonly convergence: string | null;
+    readonly convergent: boolean;
+    readonly hasOptionsBlock: boolean;
+}
+
+/**
+ * A convergence line is conclusive when it says so in the vocabulary the
+ * council already uses: `2/2`, `unanimous`, `convergent`. `split`, `1/2` and
+ * `no quorum` are the other side, and they win on conflict — a line reading
+ * "2/2 but split" is not a resolution.
+ */
+export function isConvergent(line: string): boolean {
+    if (/\b(?:split|divergent|no quorum|abstain|inconclusive)\b/i.test(line)) return false;
+    if (/\b(?:unanimous|convergent|conclusive)\b/i.test(line)) return true;
+    const m = /(\d+)\s*\/\s*(\d+)/.exec(line);
+    if (m) return m[1] === m[2];
+    return false;
+}
+
+/** Markdown emphasis removed, line structure kept. */
+export function _plain(text: string): string {
+    return text.replace(/\*+/g, '');
+}
+
+export function parseRecord(text: string): RecordShape {
+    const plain = _plain(text);
+    const o = OWNERSHIP_RE.exec(plain);
+    const c = CONVERGENCE_RE.exec(plain);
+    const convergence = c ? (c[1] as string).trim() : null;
+    const headingIdx = OPTIONS_HEADING_RE.exec(plain);
+    return {
+        ownership: o ? (o[1] as string) : null,
+        convergence,
+        convergent: convergence === null ? false : isConvergent(convergence),
+        hasOptionsBlock: headingIdx !== null && NUMBERED_OPTION_RE.test(plain.slice(headingIdx.index)),
+    };
+}
+
+/** True when the record must carry an owner-facing options block. */
+export function owesOwnerOptions(shape: RecordShape): boolean {
+    if (shape.ownership !== null && OWNER_OWNED.has(shape.ownership)) return true;
+    return !shape.convergent;
+}
+
+export function checkRecord(rel: string, text: string): string[] {
+    const out: string[] = [];
+    const shape = parseRecord(text);
+    if (shape.ownership === null) {
+        out.push(`${rel}: no \`Ownership:\` line — the routing cannot be read`);
+    }
+    if (shape.convergence === null) {
+        out.push(
+            `${rel}: no \`Convergence:\` line — "conclusive" would be the author's word for it ` +
+                `rather than a property of the run`,
+        );
+        return out;
+    }
+    const owed = owesOwnerOptions(shape);
+    if (owed && !shape.hasOptionsBlock) {
+        out.push(
+            `${rel}: owner-owned or non-convergent, and carries no owner-facing options block — ` +
+                `the owner still has to confirm the council's proposal`,
+        );
+    }
+    if (!owed && shape.hasOptionsBlock) {
+        out.push(
+            `${rel}: a conclusive technical verdict carries an owner-facing options block — ` +
+                `that routes a technical decision to the owner because it was hard (ADR-268 § 10)`,
+        );
+    }
+    return out;
+}
+
+function _usage(): string {
+    return `usage: ${_PROG} [-h] [--self-test] <record.md>...\n`;
+}
+
+export function main(argv?: readonly string[]): number {
+    const args = argv ?? process.argv.slice(2);
+    const paths: string[] = [];
+    for (const a of args) {
+        if (a === '-h' || a === '--help') {
+            process.stdout.write(_usage());
+            return 0;
+        }
+        if (a === '--self-test') return _selfTest();
+        if (a.startsWith('-')) {
+            process.stderr.write(`${_usage()}${_PROG}: error: unrecognized arguments: ${a}\n`);
+            return 2;
+        }
+        paths.push(a);
+    }
+    if (!paths.length) {
+        process.stderr.write(`${_usage()}${_PROG}: error: at least one record path is required\n`);
+        return 2;
+    }
+    const findings: string[] = [];
+    for (const p of paths) {
+        let text: string;
+        try {
+            text = fs.readFileSync(path.resolve(p), 'utf-8');
+        } catch {
+            process.stderr.write(`${_PROG}: error: cannot read ${p}\n`);
+            return 2;
+        }
+        findings.push(...checkRecord(p, text));
+    }
+    if (findings.length) {
+        for (const f of findings) process.stderr.write(`❌  ${f}\n`);
+        return 1;
+    }
+    process.stdout.write(`✅  ${_PROG}: ${String(paths.length)} record(s) conform\n`);
+    return 0;
+}
+
+function _selfTest(): number {
+    const technical = '- Ownership: contested-technical\n- Convergence: 2/2 convergent\n';
+    const product = '- Ownership: product-owned\n- Convergence: 2/2 convergent\n';
+    const options = '\n## Options\n\n1. Take the council proposal\n2. Something else\n';
+    const failures: string[] = [];
+    if (checkRecord('a', technical).length !== 0) failures.push('a conclusive technical verdict red');
+    if (checkRecord('b', technical + options).length === 0) {
+        failures.push('an options block on a conclusive technical verdict did not red');
+    }
+    if (checkRecord('c', product + options).length !== 0) failures.push('an owner-owned proposal red');
+    if (checkRecord('d', product).length === 0) {
+        failures.push('an owner-owned verdict with no proposal did not red');
+    }
+    if (checkRecord('e', '- Ownership: contested-technical\n- Convergence: 1/2 split\n').length === 0) {
+        failures.push('a non-convergent technical verdict with no proposal did not red');
+    }
+    if (failures.length) {
+        for (const f of failures) process.stderr.write(`❌  ${_PROG} --self-test: ${f}\n`);
+        return 1;
+    }
+    process.stdout.write(`✅  ${_PROG} --self-test: all five directions hold\n`);
+    return 0;
+}
+
+function _isCliEntry(): boolean {
+    if (!process.argv[1]) return false;
+    try {
+        return fs.realpathSync(_HERE) === fs.realpathSync(path.resolve(process.argv[1]));
+    } catch {
+        return false;
+    }
+}
+
+if (_isCliEntry() || process.argv[1] === _HERE) {
+    process.exitCode = main();
+}