@event4u/agent-config 9.23.0 → 9.25.0

package/src/scripts/check_depth_budget.ts

@@ -0,0 +1,295 @@
+#!/usr/bin/env tsx
+/**
+ * check_depth_budget — a per-file ceiling on the on-demand depth layer.
+ *
+ * ## The gap
+ *
+ * Rules carry a char cap (`lint_load_context.cap_for`). Skills carry a token
+ * budget class (`lint_token_budget_discipline`). The always-loaded set carries
+ * two budgets (`check_always_budget`). The 161 context and guideline files those
+ * rules and skills *route to* carry none — which is where the budget the other
+ * three gates defend leaks back in as on-demand bloat.
+ *
+ * The existence proof is in the corpus and is self-documenting:
+ * `contexts/execution/roadmap-process-loop.md` states **"Size budget: ≤ 4,000
+ * chars"** in its own header and is over 20,000. It declared a budget, nothing
+ * measured it, and it went 5× over.
+ *
+ * ## What this number is — and what it is NOT
+ *
+ * 16,000 chars is a **growth ratchet, not a quality threshold.** Say it plainly
+ * because the temptation to dress it up is exactly the failure this suite
+ * records elsewhere: a published measurement over 7,308 trajectories was used
+ * two days ago to set a *skill* ceiling at 3,500 tokens, and that measurement
+ * does not transfer here. Skills are procedural and load together; depth files
+ * are declarative and load one or two at a time. Applying the skill number to
+ * this layer would be a percentile wearing a study's clothes.
+ *
+ * So the honest claim is narrow: 16,000 sits just above the current p99, it
+ * makes the four existing outliers visible, and it stops a fifth from arriving
+ * unnoticed. Nothing here claims a reader comprehends 15,999 chars and fails at
+ * 16,001. If someone later measures comprehension degradation on *this* layer,
+ * that measurement replaces this number and this paragraph.
+ *
+ * ## Why a ratchet rather than advisory
+ *
+ * The plan said advisory-until-classified. Advisory is right when a new gate
+ * would land as an unfixable blocker — but it has a second-order cost this
+ * repository has already paid: an advisory line in a gate that exits 0 is a
+ * number nobody is obliged to move, and the four outliers would still be four
+ * outliers a year from now.
+ *
+ * The ratchet gives both halves. The four current over-ceiling files are
+ * recorded as a baseline and do not block; a fifth does. Shrink-only, so the
+ * count may fall and never rise. That is enforcement without a flag day, and it
+ * is the mechanism this suite already uses for exactly this shape.
+ *
+ * Exit codes: 0 = at or under baseline, 1 = a new over-ceiling file, 2 = usage.
+ */
+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 { checkRatchet } from './_lib/gate_baseline.js';
+import { GateLedger } from './_lib/gate_ledger.js';
+import { runGateCli, runSelfTest } from './_lib/gate_self_test.js';
+import { reportScanned } from './_lib/scan_scope.js';
+
+const SCRIPTS_DIR = path.dirname(fileURLToPath(import.meta.url));
+const REAL_REPO_ROOT = path.dirname(path.dirname(SCRIPTS_DIR));
+
+/**
+ * The ceiling, in characters.
+ *
+ * Deliberately expressed in chars, not tokens: every sibling budget in this
+ * suite that must be cheap to check uses chars, and a char count is the one
+ * measure that cannot drift with a tokenizer version.
+ */
+export const DEPTH_CEILING_CHARS = 16_000;
+
+/** The two roots that make up the on-demand depth layer. */
+export const DEPTH_ROOTS = ['src/agent-src/contexts', 'docs/guidelines'] as const;
+
+export interface DepthFile {
+    readonly file: string;
+    readonly chars: number;
+}
+
+function* walk(dir: string): Generator<string> {
+    let entries: fs.Dirent[];
+    try {
+        entries = fs.readdirSync(dir, { withFileTypes: true });
+    } catch {
+        return;
+    }
+    for (const e of entries.sort((a, b) => (a.name < b.name ? -1 : 1))) {
+        const full = path.join(dir, e.name);
+        if (e.isDirectory()) {
+            yield* walk(full);
+        } else if (e.isFile() && e.name.endsWith('.md')) {
+            yield full;
+        }
+    }
+}
+
+export function collectDepthFiles(repoRoot: string): string[] {
+    const out: string[] = [];
+    for (const root of DEPTH_ROOTS) {
+        for (const f of walk(path.join(repoRoot, root))) {
+            out.push(f);
+        }
+    }
+    // A file reachable from both roots would be counted twice; dedupe on the
+    // resolved path so the published `scanned:` count is the number of distinct
+    // artefacts judged.
+    return [...new Set(out)].sort();
+}
+
+export function measure(repoRoot: string, files: readonly string[]): DepthFile[] {
+    const out: DepthFile[] = [];
+    for (const f of files) {
+        let chars: number;
+        try {
+            chars = fs.readFileSync(f, 'utf-8').length;
+        } catch {
+            continue;
+        }
+        out.push({ file: path.relative(repoRoot, f).split(path.sep).join('/'), chars });
+    }
+    return out;
+}
+
+interface Args {
+    readonly json: boolean;
+    readonly quiet: boolean;
+}
+
+function parseArgs(argv: readonly string[]): Args {
+    let json = false;
+    let quiet = false;
+    for (const arg of argv) {
+        if (arg === '--json') { json = true; }
+        else if (arg === '--quiet') { quiet = true; }
+        else if (arg === '-h' || arg === '--help') {
+            process.stdout.write('usage: check_depth_budget [--json] [--quiet]\n');
+            process.exit(0);
+        } else {
+            process.stderr.write(`check_depth_budget: unrecognized argument: ${arg}\n`);
+            process.exit(2);
+        }
+    }
+    return { json, quiet };
+}
+
+export function selfTest(): number {
+    const tmp = fs.mkdtempSync(path.join(os.tmpdir(), 'cdb-selftest-'));
+    const mkRepo = (bodies: Record<string, number>): string => {
+        const root = fs.mkdtempSync(path.join(tmp, 'repo-'));
+        for (const [rel, size] of Object.entries(bodies)) {
+            const p = path.join(root, rel);
+            fs.mkdirSync(path.dirname(p), { recursive: true });
+            fs.writeFileSync(p, 'x'.repeat(size), 'utf-8');
+        }
+        // A baseline of 0 makes any over-ceiling file a violation, which is the
+        // discrimination the self-test needs to prove.
+        const cfg = path.join(root, 'src', 'config');
+        fs.mkdirSync(cfg, { recursive: true });
+        fs.writeFileSync(
+            path.join(cfg, 'gate-violation-baselines.json'),
+            JSON.stringify({ gates: {} }),
+            'utf-8',
+        );
+        return root;
+    };
+    const run = (root: string): number => {
+        // `runGateCli` forwards the parent env, so this is how the child is
+        // pointed at the synthetic tree.
+        process.env['CHECK_DEPTH_BUDGET_ROOT'] = root;
+        try {
+            return runGateCli(REAL_REPO_ROOT, 'src/scripts/check_depth_budget.ts', ['--quiet'], root);
+        } finally {
+            delete process.env['CHECK_DEPTH_BUDGET_ROOT'];
+        }
+    };
+
+    try {
+        const over = mkRepo({ 'docs/guidelines/big.md': DEPTH_CEILING_CHARS + 1 });
+        const under = mkRepo({ 'docs/guidelines/ok.md': DEPTH_CEILING_CHARS - 1 });
+        const exact = mkRepo({ 'docs/guidelines/edge.md': DEPTH_CEILING_CHARS });
+        const empty = mkRepo({ 'README.md': 10 });
+        return runSelfTest({
+            gate: 'check_depth_budget',
+            minCases: 3,
+            minRejectCases: 2,
+            cases: [
+                { name: 'a file one char over the ceiling is rejected', expect: 'reject', run: () => run(over) },
+                { name: 'a file one char under the ceiling passes', expect: 'accept', run: () => run(under) },
+                {
+                    name: 'the ceiling itself is inclusive — exactly at the limit passes',
+                    expect: 'accept',
+                    run: () => run(exact),
+                },
+                {
+                    name: 'a dead scan root is rejected, not reported as clean',
+                    expect: 'reject',
+                    run: () => run(empty),
+                },
+            ],
+        });
+    } finally {
+        fs.rmSync(tmp, { recursive: true, force: true });
+    }
+}
+
+export function main(argv?: readonly string[]): number {
+    const raw = argv ?? process.argv.slice(2);
+    if (raw.includes('--self-test')) {
+        return selfTest();
+    }
+    const args = parseArgs(raw);
+    // Default to the root derived from this file's own location — robust to
+    // whatever cwd a wrapper or hook invokes the gate from. The env override
+    // exists so the self-test can drive the REAL binary against a synthetic
+    // tree; deliberately NOT a cwd fallback, because a "use the real repo when
+    // the given root looks empty" rule would make the dead-scan-root case
+    // silently pass by scanning the wrong corpus — the exact failure the
+    // `assertScanned` contract exists to catch.
+    const root = process.env['CHECK_DEPTH_BUDGET_ROOT'] ?? REAL_REPO_ROOT;
+
+    const files = collectDepthFiles(root);
+    const ledger = new GateLedger('check_depth_budget');
+    ledger.plan(files.map((f) => path.relative(root, f).split(path.sep).join('/')));
+
+    const measured = measure(root, files);
+    const over = measured.filter((m) => m.chars > DEPTH_CEILING_CHARS)
+        .sort((a, b) => b.chars - a.chars);
+    const overSet = new Set(over.map((o) => o.file));
+    for (const m of measured) {
+        if (overSet.has(m.file)) {
+            ledger.fail(m.file, `${String(m.chars)} chars > ceiling ${String(DEPTH_CEILING_CHARS)}`);
+        } else {
+            ledger.complete(m.file);
+        }
+    }
+    const tally = ledger.finalize();
+
+    if (args.json) {
+        process.stdout.write(
+            `${JSON.stringify(
+                { version: 1, ceiling: DEPTH_CEILING_CHARS, over, scanned: measured.length, ledger: tally },
+                null,
+                2,
+            )}\n`,
+        );
+    } else if (!args.quiet && over.length > 0) {
+        process.stdout.write(
+            `\nOver the ${String(DEPTH_CEILING_CHARS)}-char depth ceiling ` +
+                '(a growth ratchet, NOT a measured quality threshold):\n',
+        );
+        for (const o of over) {
+            process.stdout.write(`  ${String(o.chars).padStart(7, ' ')}  ${o.file}\n`);
+        }
+    }
+
+    reportScanned({
+        gate: 'check_depth_budget',
+        scanned: measured.length,
+        units: 'depth file(s)',
+        roots: [...DEPTH_ROOTS],
+    });
+
+    const verdict = checkRatchet({
+        gate: 'check_depth_budget',
+        actual: over.length,
+        repoRoot: root,
+    });
+    if (verdict.ok) {
+        process.stdout.write(`\n⚠️   ${verdict.message}\n`);
+        return 0;
+    }
+    process.stderr.write(`\n❌  ${verdict.message}\n`);
+    return 1;
+}
+
+const _HERE = fileURLToPath(import.meta.url);
+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());
+}

package/src/scripts/conformance_scan.ts

@@ -0,0 +1,392 @@
+#!/usr/bin/env node
+/**
+ * Behavioural conformance scan — replays the local transcript store through the
+ * checks this suite MECHANISES, and nothing else.
+ *
+ * The scope constraint is the point, and it is a council ruling
+ * (2026-08-06): *"a conformance scan that checks un-mechanised rules is
+ * theatre — if you can't gate it, don't pretend measuring it post-hoc is
+ * enforcement."* So this scan carries exactly four checks, one per shipped
+ * gate, and every classifier is IMPORTED from the gate it measures rather than
+ * re-implemented here. A second copy of a classifier is the "second artefact to
+ * keep in sync" the repo's own principle forbids, and it would let the scan and
+ * the gate disagree silently.
+ *
+ *   language-pin      ← language_mirror_hook.classify
+ *   git-authorization ← git_authorization_hook.classifyAuthorization
+ *                       + block_unauthorized_git.commandOp / BLOCK_OPS
+ *   vacuous-evidence  ← before_complete_hook.isVacuousOutput / isCiPoll / pendingCount
+ *   evidence-steering ← evidence_independence.isEvaluationPrompt / preloadedVerdict
+ *
+ * Deliberately NOT scanned: ask-shape, session-canary, promissory closings,
+ * checkbox batching, symptom-vs-root-cause. Those are left as prose by
+ * `road-to-agent-behavior-conformance`, and measuring them here would claim a
+ * rigour the tree does not have.
+ *
+ * This is a REPORT, not a gate: exit 0 on every path except an unreadable
+ * store. It answers "did the shipped gates have anything to bite on?" —
+ * which is also the only honest way to find out whether they help.
+ */
+import fs from "node:fs";
+import path from "node:path";
+import { fileURLToPath, pathToFileURL } from "node:url";
+
+import { classify } from "./language_mirror_hook.js";
+import { classifyAuthorization, type GitOp } from "./git_authorization_hook.js";
+import { BLOCK_OPS, commandOp } from "./hooks/block_unauthorized_git.js";
+import { isVacuousOutput, isCiPoll, pendingCount } from "./before_complete_hook.js";
+import { isEvaluationPrompt, isSelfScoped, preloadedVerdict } from "./hooks/evidence_independence.js";
+
+export interface Violation {
+  check: "language-pin" | "git-authorization" | "vacuous-evidence" | "evidence-steering";
+  session: string;
+  at: string;
+  detail: string;
+}
+
+export interface SessionReport {
+  session: string;
+  user_turns: number;
+  assistant_turns: number;
+  violations: Violation[];
+}
+
+export interface ScanReport {
+  scanned_at: string;
+  store: string;
+  sessions: number;
+  totals: Record<string, number>;
+  per_session: SessionReport[];
+}
+
+type Entry = Record<string, unknown>;
+
+function _isObject(v: unknown): v is Record<string, unknown> {
+  return typeof v === "object" && v !== null && !Array.isArray(v);
+}
+
+/** Text of a user-role entry, or null when it is not a real chat message. */
+export function userText(entry: Entry): string | null {
+  if (entry["type"] !== "user" || entry["isSidechain"] === true) {
+    return null;
+  }
+  const msg = entry["message"];
+  const content = _isObject(msg) ? msg["content"] : undefined;
+  let text = "";
+  if (typeof content === "string") {
+    text = content;
+  } else if (Array.isArray(content)) {
+    text = content
+      .filter((b) => _isObject(b) && b["type"] === "text")
+      .map((b) => String((b as Record<string, unknown>)["text"] ?? ""))
+      .join("\n");
+  }
+  if (!text.trim()) {
+    return null;
+  }
+  if (text.includes("<system-reminder>") || text.startsWith("<local-command-stdout>")) {
+    return null;
+  }
+  return text;
+}
+
+/** Assistant prose, or null. */
+export function assistantText(entry: Entry): string | null {
+  if (entry["type"] !== "assistant" || entry["isSidechain"] === true) {
+    return null;
+  }
+  const msg = entry["message"];
+  const content = _isObject(msg) ? msg["content"] : undefined;
+  if (!Array.isArray(content)) {
+    return null;
+  }
+  const text = content
+    .filter((b) => _isObject(b) && b["type"] === "text")
+    .map((b) => String((b as Record<string, unknown>)["text"] ?? ""))
+    .join("\n")
+    .trim();
+  return text || null;
+}
+
+/** Tool-use blocks from an assistant entry. */
+function toolUses(entry: Entry): Array<{ name: string; input: Record<string, unknown> }> {
+  const msg = entry["message"];
+  const content = _isObject(msg) ? msg["content"] : undefined;
+  if (!Array.isArray(content)) {
+    return [];
+  }
+  return content
+    .filter((b) => _isObject(b) && b["type"] === "tool_use")
+    .map((b) => {
+      const o = b as Record<string, unknown>;
+      return {
+        name: String(o["name"] ?? ""),
+        input: _isObject(o["input"]) ? (o["input"] as Record<string, unknown>) : {},
+      };
+    });
+}
+
+/**
+ * A skill / slash-command body arriving in the user role. This is the
+ * transcript shape that made the language defect invisible: it occupies the
+ * user role but is not a chat message, so it must never become the language
+ * trigger — the same reason `language_mirror_hook` pins at prompt-submit time.
+ */
+export function isInjectedBody(text: string): boolean {
+  if (/^(Base directory for this skill|<command-message>|<command-name>|<local-command)/.test(text)) {
+    return true;
+  }
+  return text.length > 2500 && classify(text).language === "en";
+}
+
+/** Rough English-opener test for the language check (first prose line only). */
+const EN_OPENER =
+  /^(let me|i'?ll |i'?m |found it|ok[,. ]|okay|alright|here'?s|now[,. ]|looking|checking|reading|running|the |this |that |there |we |you |good |right[,. ]|perfect|done[.,]|all |confirmed|correct)/i;
+
+export function scanSession(sessionId: string, lines: string[]): SessionReport {
+  const report: SessionReport = {
+    session: sessionId,
+    user_turns: 0,
+    assistant_turns: 0,
+    violations: [],
+  };
+
+  let pinned: "de" | "en" | null = null;
+  let authorized = new Set<GitOp>();
+  let sawPending = false;
+  let evaluationsThisTurn = 0;
+
+  for (const line of lines) {
+    if (!line.trim()) {
+      continue;
+    }
+    let entry: Entry;
+    try {
+      entry = JSON.parse(line) as Entry;
+    } catch {
+      continue;
+    }
+
+    const ut = userText(entry);
+    if (ut !== null) {
+      if (isInjectedBody(ut)) {
+        // Not a chat message — it changes neither the pin nor the ledger.
+        continue;
+      }
+      report.user_turns += 1;
+      const c = classify(ut);
+      if (c.language !== "und") {
+        pinned = c.language;
+      }
+      authorized = new Set(classifyAuthorization(ut).authorized);
+      sawPending = false;
+      evaluationsThisTurn = 0;
+      continue;
+    }
+
+    if (entry["type"] !== "assistant" || entry["isSidechain"] === true) {
+      continue;
+    }
+    const at = String(entry["timestamp"] ?? "");
+
+    const prose = assistantText(entry);
+    if (prose !== null) {
+      report.assistant_turns += 1;
+      if (pinned === "de") {
+        const first = prose.split("\n").find((l) => l.trim()) ?? "";
+        const c = classify(first);
+        if (first.length > 12 && (c.language === "en" || EN_OPENER.test(first.trim()))) {
+          report.violations.push({
+            check: "language-pin",
+            session: sessionId,
+            at,
+            detail: `German pin, English reply opener: "${first.slice(0, 110)}"`,
+          });
+        }
+      }
+    }
+
+    for (const tu of toolUses(entry)) {
+      const cmd =
+        typeof tu.input["command"] === "string" ? (tu.input["command"] as string) : null;
+      if (cmd !== null) {
+        const op = commandOp(cmd);
+        if (op !== null && !authorized.has(op) && BLOCK_OPS.has(op)) {
+          report.violations.push({
+            check: "git-authorization",
+            session: sessionId,
+            at,
+            detail: `irreversible \`${op}\` with no authorization in the turn's prompt: ${cmd.slice(0, 110)}`,
+          });
+        }
+        if (isCiPoll(cmd)) {
+          // A settle claim needs a prior in-flight observation in the same turn.
+          // The transcript carries the poll but not always its output, so this
+          // check only fires on the shape it can actually read.
+          const out = typeof entry["toolUseResult"] === "string" ? entry["toolUseResult"] : "";
+          const pending = out ? pendingCount(out) : null;
+          if (pending !== null && pending > 0) {
+            sawPending = true;
+          } else if (out && (isVacuousOutput(out) || (pending === 0 && !sawPending))) {
+            report.violations.push({
+              check: "vacuous-evidence",
+              session: sessionId,
+              at,
+              detail: `CI poll read as settled without an in-flight observation: ${out.slice(0, 90)}`,
+            });
+          }
+        }
+      }
+
+      const prompt =
+        typeof tu.input["prompt"] === "string" ? (tu.input["prompt"] as string) : null;
+      if (prompt !== null && isEvaluationPrompt(prompt)) {
+        const preloaded = preloadedVerdict(prompt);
+        if (preloaded !== null) {
+          report.violations.push({
+            check: "evidence-steering",
+            session: sessionId,
+            at,
+            detail: `evaluation prompt pre-loads its verdict: "${preloaded}"`,
+          });
+        } else if (isSelfScoped(prompt)) {
+          if (evaluationsThisTurn >= 1) {
+            report.violations.push({
+              check: "evidence-steering",
+              session: sessionId,
+              at,
+              detail: "second self-review dispatch in one turn (verdict shopping)",
+            });
+          }
+          evaluationsThisTurn += 1;
+        }
+      }
+    }
+  }
+
+  return report;
+}
+
+/** Default Claude Code transcript store for a project directory. */
+export function defaultStore(projectDir: string): string {
+  const slug = projectDir.replace(/\//g, "-");
+  return path.join(process.env["HOME"] ?? "", ".claude", "projects", slug);
+}
+
+export function scanStore(store: string, limit: number): ScanReport {
+  const files = fs
+    .readdirSync(store)
+    .filter((f) => f.endsWith(".jsonl"))
+    .map((f) => ({ f, m: fs.statSync(path.join(store, f)).mtimeMs }))
+    .sort((a, b) => b.m - a.m)
+    .slice(0, limit)
+    .map((x) => x.f);
+
+  const per_session: SessionReport[] = [];
+  for (const f of files) {
+    const lines = fs.readFileSync(path.join(store, f), "utf8").split("\n");
+    const r = scanSession(f.replace(/\.jsonl$/, "").slice(0, 8), lines);
+    if (r.assistant_turns > 0) {
+      per_session.push(r);
+    }
+  }
+
+  const totals: Record<string, number> = {
+    "language-pin": 0,
+    "git-authorization": 0,
+    "vacuous-evidence": 0,
+    "evidence-steering": 0,
+  };
+  for (const s of per_session) {
+    for (const v of s.violations) {
+      totals[v.check] = (totals[v.check] ?? 0) + 1;
+    }
+  }
+
+  return {
+    scanned_at: new Date().toISOString(),
+    store,
+    sessions: per_session.length,
+    totals,
+    per_session,
+  };
+}
+
+export function render(report: ScanReport): string {
+  const lines: string[] = [];
+  lines.push(`conformance:behavior · ${report.sessions} session(s) · ${report.store}`);
+  for (const [k, v] of Object.entries(report.totals)) {
+    lines.push(`  ${v === 0 ? "✅" : "⚠️ "} ${k.padEnd(18)} ${v}`);
+  }
+  const worst = [...report.per_session]
+    .filter((s) => s.violations.length > 0)
+    .sort((a, b) => b.violations.length - a.violations.length)
+    .slice(0, 5);
+  if (worst.length > 0) {
+    lines.push("");
+    lines.push("  Highest-violation sessions:");
+    for (const s of worst) {
+      lines.push(`    ${s.session}  ${s.violations.length} across ${s.assistant_turns} turns`);
+    }
+  }
+  lines.push("");
+  lines.push("  Scanned checks are exactly the mechanised ones. Ask-shape, session-canary,");
+  lines.push("  promissory closings and checkbox batching are left as prose and NOT measured.");
+  return lines.join("\n");
+}
+
+export function main(argv?: string[]): number {
+  const args = argv ?? process.argv.slice(2);
+  let store: string | null = null;
+  let limit = 30;
+  let json = false;
+  let out: string | null = null;
+  for (let i = 0; i < args.length; i += 1) {
+    const a = args[i];
+    if (a === "--store" && args[i + 1] !== undefined) {
+      store = args[++i] as string;
+    } else if (a === "--limit" && args[i + 1] !== undefined) {
+      limit = Number(args[++i]);
+    } else if (a === "--json") {
+      json = true;
+    } else if (a === "--output" && args[i + 1] !== undefined) {
+      out = args[++i] as string;
+    }
+  }
+  const resolved = store ?? defaultStore(process.cwd());
+  if (!fs.existsSync(resolved)) {
+    process.stderr.write(`conformance:behavior: no transcript store at ${resolved}\n`);
+    return 1;
+  }
+  const report = scanStore(resolved, Number.isFinite(limit) && limit > 0 ? limit : 30);
+  if (out) {
+    fs.writeFileSync(out, `${JSON.stringify(report, null, 2)}\n`, "utf8");
+  }
+  process.stdout.write(json ? `${JSON.stringify(report, null, 2)}\n` : `${render(report)}\n`);
+  return 0;
+}
+
+declare const __AGENT_CONFIG_BUNDLE__: boolean | undefined;
+function _isCliEntry(): boolean {
+  if (typeof __AGENT_CONFIG_BUNDLE__ !== "undefined" && __AGENT_CONFIG_BUNDLE__) {
+    return false;
+  }
+  if (process.argv[1] === undefined) {
+    return false;
+  }
+  const argvUrl = pathToFileURL(path.resolve(process.argv[1])).href;
+  if (import.meta.url === argvUrl) {
+    return true;
+  }
+  try {
+    const here = fs.realpathSync(fileURLToPath(import.meta.url));
+    const argv = fs.realpathSync(path.resolve(process.argv[1]));
+    return here === argv;
+  } catch {
+    return false;
+  }
+}
+
+if (_isCliEntry()) {
+  process.exit(main());
+}