@event4u/agent-config 9.16.0 → 9.18.0

package/src/scripts/check_condensation.ts

@@ -14,7 +14,8 @@
  * - All headings from source present in condensed
  * - All code blocks preserved exactly
  * - YAML frontmatter identical
- * - Word count reduction within healthy range (10-60%)
+ * - Word count: excessive-reduction alarm only (> 60% lost warns; expected
+ *   reduction is 0% post-ADR-201 verbatim copy — see the note near the check)
  * - Iron Law sections (## Iron Law / ### Iron Law / ## The Iron Law /
  *   Iron Laws / numbered) preserved per `preservation-guard`: heading
  *   verbatim at original level, structural-unit survival.

package/src/scripts/check_finding_dispositions.ts

@@ -0,0 +1,278 @@
+/**
+ * Finding-disposition gate (release-truth Phase 3).
+ *
+ * The recorded failure: the 9.14.0 release-PR self-review reported a critical
+ * symlink-traversal finding; the PR merged, the release head said "Security
+ * and correctness: none", and whether the finding was fixed or adjudicated
+ * false-positive was not reconstructable from the record.
+ *
+ * The record is a COMMITTED ledger — `agents/evidence/release-findings/
+ * <version>.json` — never the PR comment (council 2026-08-03: a comment is
+ * mutable and unaudited; it is transport, not a record). Every blocking/high
+ * finding in the ledger must carry a complete disposition
+ * `{status: fixed|false_positive|accepted_risk, commit (when fixed),
+ * rationale, verified_by}`; the release workflow is red while one does not.
+ *
+ * Modes:
+ *   --release X.Y.Z [--dir <ledger dir>]      validate the committed ledger
+ *   --pr <n>                                  additionally treat the gate's PR
+ *       comment (machine block) as a TRIGGER: every blocking finding the
+ *       comment reports must exist in the ledger — an un-ingested blocking
+ *       finding is red. Deleting the comment can evade the trigger, but the
+ *       committed ledger stays the durable record either way.
+ *   --ingest <findings.json> --release X.Y.Z  merge findings (from
+ *       self_review_gate --findings-out) into the ledger with an empty
+ *       disposition, so validation is red until a human fills it.
+ *
+ * Exit codes: 0 complete · 1 missing/incomplete dispositions · 2 usage or
+ * schema error. Deliberately NOT fail-open: this script never calls a model;
+ * a broken ledger file is a hard error, not a neutral skip.
+ */
+import { spawnSync } from 'node:child_process';
+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 REPO_ROOT = path.resolve(path.dirname(_HERE), '..', '..');
+
+export const LEDGER_DIR = 'agents/evidence/release-findings';
+export const DISPOSITION_STATUSES = ['fixed', 'false_positive', 'accepted_risk'] as const;
+export type DispositionStatus = (typeof DISPOSITION_STATUSES)[number];
+
+export interface LedgerFinding {
+    finding_id: string;
+    severity: 'critical' | 'high' | 'medium' | 'low';
+    kind: 'security' | 'claim' | 'correctness' | 'style';
+    title: string;
+    file?: string | null;
+    status?: string;
+    commit?: string;
+    rationale?: string;
+    verified_by?: string;
+    date?: string;
+}
+
+export interface Ledger {
+    schema_version: number;
+    release: string;
+    findings: LedgerFinding[];
+}
+
+/** Mirrors self_review_gate.classifyBlocking — security/claim × critical/high. */
+export function isBlocking(f: Pick<LedgerFinding, 'kind' | 'severity'>): boolean {
+    return (
+        (f.kind === 'security' || f.kind === 'claim') &&
+        (f.severity === 'critical' || f.severity === 'high')
+    );
+}
+
+/**
+ * Pure core: every blocking finding must carry a complete disposition.
+ * Returns one problem string per violation; empty array = gate green.
+ * Empty rationale / verified_by is a hygiene violation (waiver precedent:
+ * "empty string = hygiene violation"); status `fixed` requires a commit.
+ */
+export function missing_dispositions(findings: readonly LedgerFinding[]): string[] {
+    const problems: string[] = [];
+    for (const f of findings) {
+        if (!isBlocking(f)) {
+            continue;
+        }
+        const label = `${f.finding_id} (${f.severity} ${f.kind}: ${f.title})`;
+        const status = (f.status ?? '').trim();
+        if (!status) {
+            problems.push(`${label}: no disposition status`);
+            continue;
+        }
+        if (!(DISPOSITION_STATUSES as readonly string[]).includes(status)) {
+            problems.push(`${label}: unknown status ${JSON.stringify(status)}`);
+            continue;
+        }
+        if (!(f.rationale ?? '').trim()) {
+            problems.push(`${label}: empty rationale`);
+        }
+        if (!(f.verified_by ?? '').trim()) {
+            problems.push(`${label}: empty verified_by`);
+        }
+        if (status === 'fixed' && !(f.commit ?? '').trim()) {
+            problems.push(`${label}: status "fixed" without a commit`);
+        }
+    }
+    return problems;
+}
+
+/** Findings the gate comment reported but the ledger never ingested. */
+export function unrecorded_findings(
+    reported: ReadonlyArray<Pick<LedgerFinding, 'finding_id' | 'severity' | 'kind' | 'title'>>,
+    ledger: readonly LedgerFinding[],
+): string[] {
+    const known = new Set(ledger.map((f) => f.finding_id));
+    return reported
+        .filter((f) => isBlocking(f) && !known.has(f.finding_id))
+        .map((f) => `${f.finding_id} (${f.severity} ${f.kind}: ${f.title}) reported by the self-review but not in the ledger`);
+}
+
+export function parse_ledger(raw: string, source: string): Ledger {
+    let data: unknown;
+    try {
+        data = JSON.parse(raw);
+    } catch (e) {
+        throw new Error(`${source}: invalid JSON (${e instanceof Error ? e.message : String(e)})`);
+    }
+    const obj = data as Partial<Ledger>;
+    if (obj.schema_version !== 1 || typeof obj.release !== 'string' || !Array.isArray(obj.findings)) {
+        throw new Error(`${source}: expected {schema_version: 1, release, findings[]}`);
+    }
+    for (const f of obj.findings) {
+        if (!f || typeof f.finding_id !== 'string' || !f.finding_id.trim()) {
+            throw new Error(`${source}: finding without a finding_id`);
+        }
+    }
+    return obj as Ledger;
+}
+
+const _MACHINE_BLOCK_RE = /<!-- release-findings-json: (\[.*?\]) -->/su;
+
+/** Extract reported findings from the gate's PR comments (latest block wins). */
+export function parse_comment_findings(commentBodies: readonly string[]): LedgerFinding[] {
+    for (let i = commentBodies.length - 1; i >= 0; i--) {
+        const m = _MACHINE_BLOCK_RE.exec(commentBodies[i]!);
+        if (m) {
+            try {
+                return JSON.parse(m[1]!) as LedgerFinding[];
+            } catch {
+                return [];
+            }
+        }
+    }
+    return [];
+}
+
+function _ledger_path(dir: string, release: string): string {
+    return path.join(dir, `${release}.json`);
+}
+
+function _gh_comment_bodies(pr: string): string[] {
+    const r = spawnSync(
+        'gh',
+        ['pr', 'view', pr, '--json', 'comments', '-q', '[.comments[].body] | @json'],
+        { encoding: 'utf-8', cwd: REPO_ROOT, maxBuffer: 64 * 1024 * 1024 },
+    );
+    if (r.status !== 0) {
+        process.stderr.write(`gh pr view ${pr} failed: ${r.stderr}\n`);
+        process.exit(2);
+    }
+    try {
+        return JSON.parse(JSON.parse(r.stdout.trim())) as string[];
+    } catch {
+        return [];
+    }
+}
+
+function main(argv: readonly string[]): number {
+    let release: string | null = null;
+    let dir = path.join(REPO_ROOT, LEDGER_DIR);
+    let pr: string | null = null;
+    let ingest: string | null = null;
+    for (let i = 0; i < argv.length; i++) {
+        const a = argv[i];
+        if (a === '--release') release = argv[++i] ?? null;
+        else if (a === '--dir') dir = argv[++i] ?? dir;
+        else if (a === '--pr') pr = argv[++i] ?? null;
+        else if (a === '--ingest') ingest = argv[++i] ?? null;
+        else {
+            process.stderr.write(`unknown argument: ${a}\n`);
+            return 2;
+        }
+    }
+    if (!release) {
+        const pkg = JSON.parse(
+            fs.readFileSync(path.join(REPO_ROOT, 'package.json'), 'utf-8'),
+        ) as Record<string, unknown>;
+        release = String(pkg['version']);
+    }
+    const ledgerPath = _ledger_path(dir, release);
+
+    if (ingest) {
+        const incoming = parse_ledger(
+            JSON.stringify({
+                schema_version: 1,
+                release,
+                findings: (JSON.parse(fs.readFileSync(ingest, 'utf-8')) as { findings: LedgerFinding[] }).findings,
+            }),
+            ingest,
+        );
+        let ledger: Ledger = { schema_version: 1, release, findings: [] };
+        if (fs.existsSync(ledgerPath)) {
+            ledger = parse_ledger(fs.readFileSync(ledgerPath, 'utf-8'), ledgerPath);
+        }
+        const known = new Set(ledger.findings.map((f) => f.finding_id));
+        let added = 0;
+        for (const f of incoming.findings) {
+            if (!known.has(f.finding_id)) {
+                ledger.findings.push(f);
+                added++;
+            }
+        }
+        fs.mkdirSync(path.dirname(ledgerPath), { recursive: true });
+        fs.writeFileSync(ledgerPath, JSON.stringify(ledger, null, 2) + '\n');
+        process.stdout.write(
+            `📥  ingested ${added} new finding(s) into ${path.relative(REPO_ROOT, ledgerPath)} — ` +
+                'fill dispositions before the release validation goes green\n',
+        );
+        return 0;
+    }
+
+    let ledger: Ledger = { schema_version: 1, release, findings: [] };
+    if (fs.existsSync(ledgerPath)) {
+        try {
+            ledger = parse_ledger(fs.readFileSync(ledgerPath, 'utf-8'), ledgerPath);
+        } catch (e) {
+            process.stderr.write(`❌  ${e instanceof Error ? e.message : String(e)}\n`);
+            return 2;
+        }
+    }
+
+    const problems = missing_dispositions(ledger.findings);
+    if (pr) {
+        const reported = parse_comment_findings(_gh_comment_bodies(pr));
+        problems.push(...unrecorded_findings(reported, ledger.findings));
+    }
+
+    if (problems.length === 0) {
+        const n = ledger.findings.length;
+        process.stdout.write(
+            n === 0
+                ? `✅  no recorded findings for ${release} (ledger ${fs.existsSync(ledgerPath) ? 'empty' : 'absent'})\n`
+                : `✅  all ${n} recorded finding(s) for ${release} dispositioned (blocking ones completely)\n`,
+        );
+        return 0;
+    }
+    process.stderr.write(`❌  undispositioned blocking finding(s) for ${release}:\n`);
+    for (const p of problems) {
+        process.stderr.write(`    - ${p}\n`);
+    }
+    process.stderr.write(
+        `    Record dispositions in ${path.relative(REPO_ROOT, ledgerPath)} ` +
+            '({finding_id, status: fixed|false_positive|accepted_risk, commit, rationale, verified_by}).\n' +
+            '    Ingest reported findings: ./scripts-run src/scripts/check_finding_dispositions ' +
+            `--ingest <findings.json> --release ${release}\n`,
+    );
+    return 1;
+}
+
+const _isMain = (() => {
+    const entry = process.argv[1];
+    if (!entry) return false;
+    try {
+        return fs.realpathSync(entry) === fs.realpathSync(_HERE);
+    } catch {
+        return false;
+    }
+})();
+
+if (_isMain) {
+    process.exit(main(process.argv.slice(2)));
+}

package/src/scripts/check_pack_size.ts

@@ -10,9 +10,10 @@
  *   2. PER-SKILL share of the skills subtree — no single skill may silently
  *      reclaim space freed elsewhere. Named exceptions carry a reason.
  *
- * The UNPACKED size is deliberately NOT re-gated here: it is already owned by
- * `evaluator-budgets.unpacked_size_mb`, measured at release time on the BUILT
- * artifact. Two gates for one lever is how conflicting numbers start.
+ * The UNPACKED size is deliberately NOT gated here — and since 2026-08-04 not
+ * anywhere: the former `evaluator-budgets.unpacked_size_mb` key was removed by
+ * maintainer decision (see `removed_2026_08_04` in evaluator-budgets.json);
+ * the evaluator umbrella still measures it as evidence.
  *
  * Usage:
  *   ./scripts-run src/scripts/check_pack_size [--json]

package/src/scripts/check_references.ts

@@ -58,6 +58,7 @@ const SKIP_DIRS = [
     'agents/reports', // transient run reports — historical/scratch refs, not stable artefacts
     'agents/roadmaps/skipped', // skipped roadmaps — abandoned plans w/ forward-refs that never shipped
     'agents/runtime', // volatile / machine-generated artefacts (gitignored)
+    'agents/state', // Tier-1 hook runtime state (gitignored, agents-layout § state/) — targets are runtime-created, never in the tree
     'agents/tmp', // user inbox (gitignored) — user-dropped notes/todos; agents only read + move to tmp.old/
     'agents/tmp.old', // processed inbox archive (gitignored) — consumed tmp/ files; janitor TTL 30 days
     'agents/.harvest-local', // deliberate gitignored evidence store (source-confidentiality) — refs to it can never resolve in CI

package/src/scripts/check_release_highlights.ts

@@ -0,0 +1,300 @@
+/**
+ * Highlight plausibility gate (release-truth Phase 2).
+ *
+ * The recorded failure: the curated release head said `_none_` twice while
+ * false — 9.13.0 shipped behaviour changes, a removed public trigger type, a
+ * security fix, and honest nulls; the head claimed none of it. Same at
+ * 9.14.0.
+ *
+ * This gate derives GENERATED evidence categories from the release span
+ * (security-tagged commits, behaviour/default changes from conventional
+ * commit types + rule/schema diffs, honest-null markers, removed public
+ * surface) and FAILS when a populated generated category meets a `_none_`
+ * curated field. It blocks the contradiction only — a human still writes the
+ * prose; nothing here auto-formulates highlights, and a filled field is
+ * never judged for quality.
+ *
+ * Derivation is deliberately conservative (documented per-label below):
+ * a false red makes every release annoying; a miss only returns the head to
+ * the pre-gate state. Adjudication of derived evidence stays human.
+ *
+ * Usage:
+ *   check_release_highlights --version X.Y.Z [--from <ref>] [--to <ref>]
+ *       [--changelog <path>]
+ *
+ * `--from` defaults to the latest reachable release tag before `--to`
+ * (default HEAD). Exit codes: 0 plausible · 1 contradiction · 2 usage error.
+ */
+import { spawnSync } from 'node:child_process';
+import * as fs from 'node:fs';
+import * as path from 'node:path';
+import process from 'node:process';
+import { fileURLToPath } from 'node:url';
+
+import { extract_changelog_section } from './_lib/release_material.js';
+
+const _HERE = fileURLToPath(import.meta.url);
+const REPO_ROOT = path.resolve(path.dirname(_HERE), '..', '..');
+
+// The five curated labels, mirrored from release.ts RELEASE_HEAD_SECTIONS
+// (kept literal here so this checker has no import edge into the release
+// pipeline it audits; the unit tests pin the two lists against each other).
+export const HEAD_LABELS: readonly string[] = [
+    'Behaviour changes',
+    'Default changes + migration',
+    'Security and correctness',
+    'Honest nulls',
+    'Known limitations',
+];
+
+export const HEAD_NONE = '_none_';
+
+export interface SpanCommit {
+    sha: string;
+    subject: string;
+    body: string;
+    /** `A` / `M` / `D` / `R…` status per touched path. */
+    files: ReadonlyArray<{ status: string; path: string }>;
+    breaking: boolean;
+}
+
+/** Public artefact trees whose deletions count as removed public surface. */
+const _PUBLIC_SURFACE_PREFIXES = [
+    'src/skills/',
+    'src/rules/',
+    'src/agent-src/commands/',
+    'src/domains/',
+];
+
+const _RULE_OR_SCHEMA_PREFIXES = ['src/rules/', 'src/scripts/schemas/'];
+
+/**
+ * Derive evidence per curated label from the span. Rules per label:
+ *
+ * - Security and correctness: conventional scope matching /secur/i, or the
+ *   whole word "security" in the subject.
+ * - Behaviour changes: breaking (`!` / BREAKING CHANGE) commits, diffs
+ *   touching `src/rules/` or `src/scripts/schemas/`, and deletions under the
+ *   public artefact trees (removed public surface).
+ * - Default changes + migration: subject carrying the whole word "default",
+ *   "migration", or "migrate".
+ * - Honest nulls: subject or body carrying an "honest null" marker.
+ * - Known limitations: never derived — pure prose, not gate-checkable.
+ */
+export function derive_categories(commits: readonly SpanCommit[]): Record<string, string[]> {
+    const out: Record<string, string[]> = {};
+    for (const label of HEAD_LABELS) {
+        out[label] = [];
+    }
+    const evidence = (c: SpanCommit): string => `${c.sha.slice(0, 7)} ${c.subject}`;
+    for (const c of commits) {
+        const scopeMatch = /^\w+\(([^)]*)\)!?:/u.exec(c.subject);
+        const scope = scopeMatch ? scopeMatch[1]! : '';
+        if (/secur/iu.test(scope) || /\bsecurity\b/iu.test(c.subject)) {
+            out['Security and correctness']!.push(evidence(c));
+        }
+        const removedPublic = c.files.filter(
+            (f) => f.status.startsWith('D') && _PUBLIC_SURFACE_PREFIXES.some((p) => f.path.startsWith(p)),
+        );
+        const ruleOrSchema = c.files.some((f) =>
+            _RULE_OR_SCHEMA_PREFIXES.some((p) => f.path.startsWith(p)),
+        );
+        if (c.breaking || ruleOrSchema || removedPublic.length > 0) {
+            const detail =
+                removedPublic.length > 0
+                    ? `${evidence(c)} (removes ${removedPublic.map((f) => f.path).join(', ')})`
+                    : evidence(c);
+            out['Behaviour changes']!.push(detail);
+        }
+        if (/\b(default|migration|migrate)\b/iu.test(c.subject)) {
+            out['Default changes + migration']!.push(evidence(c));
+        }
+        if (/honest[ -]null/iu.test(`${c.subject}\n${c.body}`)) {
+            out['Honest nulls']!.push(evidence(c));
+        }
+    }
+    return out;
+}
+
+/**
+ * Parse the curated head from a changelog section body. Returns null when
+ * the section carries no `### Release highlights` head (pre-9.9.0 entries).
+ */
+export function parse_curated_head(sectionBody: string): Record<string, string> | null {
+    if (!sectionBody.includes('### Release highlights')) {
+        return null;
+    }
+    const out: Record<string, string> = {};
+    for (const label of HEAD_LABELS) {
+        const re = new RegExp(
+            `^-\\s+\\*\\*${label.replace(/[.*+?^${}()|[\]\\]/gu, '\\$&')}:\\*\\*\\s*(.*)$`,
+            'm',
+        );
+        const m = re.exec(sectionBody);
+        if (m) {
+            out[label] = m[1]!.trim();
+        }
+    }
+    return Object.keys(out).length > 0 ? out : null;
+}
+
+export interface Contradiction {
+    label: string;
+    evidence: string[];
+}
+
+/**
+ * A populated generated category meeting a `_none_` curated field is a
+ * contradiction. Filled fields and underived labels never fail.
+ */
+export function highlight_contradictions(
+    curated: Readonly<Record<string, string>>,
+    derived: Readonly<Record<string, readonly string[]>>,
+): Contradiction[] {
+    const out: Contradiction[] = [];
+    for (const label of HEAD_LABELS) {
+        const curatedValue = (curated[label] ?? '').trim();
+        const ev = derived[label] ?? [];
+        if (curatedValue === HEAD_NONE && ev.length > 0) {
+            out.push({ label, evidence: [...ev] });
+        }
+    }
+    return out;
+}
+
+// ─── git span collection (CLI only — the core above is pure) ────────────────
+
+const _RECORD = '\u001e';
+const _FIELD = '\u001f';
+
+export function _parse_git_log(raw: string): SpanCommit[] {
+    const commits: SpanCommit[] = [];
+    for (const record of raw.split(_RECORD)) {
+        if (!record.trim()) {
+            continue;
+        }
+        const [head, ...restLines] = record.split('\n');
+        const parts = (head ?? '').split(_FIELD);
+        if (parts.length < 3) {
+            continue;
+        }
+        const sha = parts[0]!.trim();
+        const subject = parts[1]!;
+        const bodyParts: string[] = [parts.slice(2).join(_FIELD)];
+        const files: Array<{ status: string; path: string }> = [];
+        for (const line of restLines) {
+            const m = /^([A-Z]\d*)\t(.+)$/u.exec(line);
+            if (m) {
+                // Renames carry two paths; the last tab field is the new path,
+                // the first the old — record both so a rename out of a public
+                // tree still counts its origin path.
+                const segs = m[2]!.split('\t');
+                for (const p of segs) {
+                    files.push({ status: m[1]!, path: p });
+                }
+            } else {
+                // %b is multi-line — everything that is not a name-status
+                // line is body continuation (honest-null markers live there).
+                bodyParts.push(line);
+            }
+        }
+        const body = bodyParts.join('\n');
+        commits.push({
+            sha,
+            subject,
+            body,
+            files,
+            breaking: /^\w+(\([^)]*\))?!:/u.test(subject) || /BREAKING CHANGE/u.test(body),
+        });
+    }
+    return commits;
+}
+
+function _git(args: string[]): string {
+    const r = spawnSync('git', args, { encoding: 'utf-8', cwd: REPO_ROOT, maxBuffer: 64 * 1024 * 1024 });
+    if (r.status !== 0) {
+        process.stderr.write(`git ${args.join(' ')} failed: ${r.stderr}\n`);
+        process.exit(2);
+    }
+    return r.stdout;
+}
+
+function _collect_span(from: string, to: string): SpanCommit[] {
+    const raw = _git([
+        'log',
+        `${from}..${to}`,
+        '--no-merges',
+        '--name-status',
+        '--format=%x1e%H%x1f%s%x1f%b',
+    ]);
+    return _parse_git_log(raw);
+}
+
+function main(argv: readonly string[]): number {
+    let version: string | null = null;
+    let from: string | null = null;
+    let to = 'HEAD';
+    let changelogPath = path.join(REPO_ROOT, 'CHANGELOG.md');
+    for (let i = 0; i < argv.length; i++) {
+        const a = argv[i];
+        if (a === '--version') version = argv[++i] ?? null;
+        else if (a === '--from') from = argv[++i] ?? null;
+        else if (a === '--to') to = argv[++i] ?? to;
+        else if (a === '--changelog') changelogPath = argv[++i] ?? changelogPath;
+        else {
+            process.stderr.write(`unknown argument: ${a}\n`);
+            return 2;
+        }
+    }
+    if (!version) {
+        process.stderr.write('--version X.Y.Z is required\n');
+        return 2;
+    }
+    if (!from) {
+        from = _git(['describe', '--tags', '--abbrev=0', '--match', '[0-9]*.[0-9]*.[0-9]*', `${to}^`]).trim();
+    }
+    const section = extract_changelog_section(fs.readFileSync(changelogPath, 'utf-8'), version);
+    if (!section) {
+        process.stderr.write(`CHANGELOG carries no section for ${version}\n`);
+        return 2;
+    }
+    const curated = parse_curated_head(section.body);
+    if (!curated) {
+        process.stdout.write(`ℹ️  no curated head in the ${version} section — nothing to check\n`);
+        return 0;
+    }
+    const derived = derive_categories(_collect_span(from, to));
+    const contradictions = highlight_contradictions(curated, derived);
+    if (contradictions.length === 0) {
+        process.stdout.write(`✅  curated head plausible for ${version} (span ${from}..${to})\n`);
+        return 0;
+    }
+    process.stderr.write(
+        `❌  curated head contradicts the release span for ${version} (${from}..${to}):\n`,
+    );
+    for (const c of contradictions) {
+        process.stderr.write(`    - **${c.label}:** is \`_none_\` but the span carries:\n`);
+        for (const e of c.evidence) {
+            process.stderr.write(`        ${e}\n`);
+        }
+    }
+    process.stderr.write(
+        '    Fill the curated head in CHANGELOG.md (a human writes the prose) or adjudicate ' +
+            'the evidence in the PR — the gate only blocks the `_none_` contradiction.\n',
+    );
+    return 1;
+}
+
+const _isMain = (() => {
+    const entry = process.argv[1];
+    if (!entry) return false;
+    try {
+        return fs.realpathSync(entry) === fs.realpathSync(_HERE);
+    } catch {
+        return false;
+    }
+})();
+
+if (_isMain) {
+    process.exit(main(process.argv.slice(2)));
+}

package/src/scripts/check_release_pr_shape.ts

@@ -34,6 +34,10 @@ const ALLOWLIST_GLOBS = [
     'src/domains/*/pack.yaml',
     'src/domains/*/README.md',
     'docs/archive/CHANGELOG-pre-*.md',
+    // Finding-disposition ledger (release-truth Phase 3) — a release PR must
+    // be able to carry the dispositions of its own self-review findings; the
+    // finding-dispositions gate is red until blocking ones are recorded here.
+    'agents/evidence/release-findings/*.json',
     // Project-settings template pin — bumped by release.ts set_template_pin and
     // its regenerated dist twin (kept in lockstep with package.json.version).
     'src/agent-src/templates/agents/agent-project-settings.example.yml',