@event4u/agent-config 14.21.0 → 14.22.0

package/src/scripts/check_estate_count.ts

@@ -155,8 +155,6 @@ import { materialiseSubtree } from './_lib/base_tree.js';
 import { SKILLS_POSIX, measureSkillEstate } from './_lib/skill_estate.js';
 import { CONCERN_MANIFEST_POSIX, countConcerns } from './_lib/concern_estate.js';
 import { runGateCli, runSelfTest, type SelfTestCase } from './_lib/gate_self_test.js';
-import { countDeclaredCarriers, declaresCarrier } from './_lib/carrier_status.js';
-import { carrierEstateCases } from './_lib/estate_carrier_cases.js';
 
 const GATE = 'check_estate_count';
 const BUDGET_REL = path.join('src', 'config', 'estate-count-budget.json');
@@ -438,38 +436,12 @@ function countIn(roadmapRoot: string, sub: string): number {
     }
 }
 
-/**
- * Top-level roadmaps `collect()` drops for declaring `status: carrier`, added
- * back so that FLIPPING a status is count-neutral.
- *
- * Measured before this: flipping one file to `carrier` moved `active_roadmaps
- * 3 → 2` and the gate printed "estate within its ratchet", because a count
- * below the floor is a drawdown and free. The floor is measured at the base
- * ref, so once such a flip merges the lowered number becomes the next floor —
- * the file cannot be flipped back without paying, and any roadmap can be
- * laundered out of the count by adding one word.
- *
- * A reclassification is not a disposal, so the metric counts the file on both
- * sides. Same argument `open_blockers` makes below for spanning `later/`.
- * Deleting a carrier is still a shrink and still earns no offset
- * (`classifyDiff`); adding one is growth that takes the claim path.
- *
- * This is therefore the one roadmap metric that does NOT equal the dashboard
- * header, stated here rather than left to be tripped over.
- */
-function countActiveCarriers(roadmapRoot: string): number {
-    return countDeclaredCarriers(roadmapRoot, isRoadmapCandidate, fs, path.join);
-}
-
 /**
  * Roadmaps parked in `later/` whose blockers count, parsed for them.
  *
- * Skips a draft AND a carrier, which is the same pair `collect()` skips on the
- * active side. It used to skip only the draft, so parking a carrier moved its
- * blockers INTO the gated count while the identical file at the top level kept
- * them out — a ratchet verdict that moved on a relocation, for no stated
- * reason. Three of the four status readers learned `carrier` when the status
- * shipped; this is the fourth.
+ * Skips exactly what `collect()` skips on the active side, through the same
+ * `isUnscheduled` predicate. Skipping a different set here would make a ratchet
+ * verdict move on a relocation, for no stated reason.
  */
 function laterRoadmaps(roadmapRoot: string): Array<{ open_blockers: readonly unknown[] }> {
     const dir = path.join(roadmapRoot, 'later');
@@ -496,10 +468,13 @@ function laterRoadmaps(roadmapRoot: string): Array<{ open_blockers: readonly unk
 /**
  * Count the estate, three ways.
  *
- * `active_roadmaps` is `collect()` PLUS the top-level carriers `collect()`
- * drops, so the parser is shared with the dashboard while a status flip stays
- * count-neutral — see `countActiveCarriers` for why that beats parity here, and
- * for the one number on this gate that the dashboard header does not print.
+ * `active_roadmaps` is `collect()`, so the parser is shared with the dashboard
+ * and the number equals the dashboard header. It used to carry an add-back for
+ * the top-level roadmaps `collect()` dropped for declaring `status: carrier`,
+ * which existed only to keep FLIPPING to that status count-neutral — a flip
+ * lowered the count, a count below the floor is a free drawdown, and the
+ * lowered number then became the next floor. ADR-262 deleted the status, so
+ * there is no flip to neutralise and no divergence from the header left.
  * `later_roadmaps` is a directory listing because parked files are
  * outside that corpus by design — filtered through the same `is_roadmap_candidate`
  * predicate as the active side, so `later/README.md` is not a roadmap here either.
@@ -524,7 +499,7 @@ export function countEstate(repoRoot: string): EstateCounts {
         rows.reduce((n, r) => n + r.open_blockers.length, 0);
     const skills = measureSkillEstate(repoRoot);
     return {
-        active_roadmaps: stats.length + countActiveCarriers(roadmapRoot),
+        active_roadmaps: stats.length,
         later_roadmaps: countIn(roadmapRoot, 'later'),
         open_blockers: openOf(stats) + openOf(laterRoadmaps(roadmapRoot)),
         skill_count: skills.skill_count,
@@ -590,9 +565,6 @@ export function exemptionReason(text: string): string | null {
     return reason === '' ? null : reason;
 }
 
-/** Re-export; `_lib/carrier_status.ts` holds the one implementation. */
-export const isCarrierText = declaresCarrier;
-
 /**
  * Classify the change's effect on the active roadmap tree.
  *
@@ -604,13 +576,6 @@ export const isCarrierText = declaresCarrier;
 export function classifyDiff(
     nameStatus: string,
     readFile: (rel: string) => string | null,
-    /**
-     * The file's content at the BASE ref, for paths this change removed — a
-     * deleted carrier cannot be read from the working tree and its status
-     * decides whether the deletion earns an offset. Defaults to null, which
-     * reproduces the previous scoring for any caller without a pre-image.
-     */
-    readBase: (rel: string) => string | null = () => null,
 ): OffsetLedger {
     const added: string[] = [];
     const offsets: string[] = [];
@@ -624,10 +589,8 @@ export function classifyDiff(
             const from = cols[1] ?? '';
             const to = cols[2] ?? '';
             if (isActiveTopLevel(from) && isDisposed(to)) {
-                if (!isCarrierText(readBase(from))) {
-                    offsets.push(from);
-                    if (isParked(to)) parked.push(to);
-                }
+                offsets.push(from);
+                if (isParked(to)) parked.push(to);
             } else if (isDisposed(from) && isActiveTopLevel(to)) {
                 added.push(to);
             }
@@ -638,10 +601,7 @@ export function classifyDiff(
         if (status === 'A') {
             added.push(file);
         } else if (status === 'D') {
-            // A carrier's removal is never an offset. See `readBase`.
-            if (!isCarrierText(readBase(file))) {
-                offsets.push(file);
-            }
+            offsets.push(file);
         }
     }
     for (const file of added) {
@@ -832,20 +792,13 @@ export function evaluate(
         if (!diff.ok) {
             offsetSkipReason = `git diff against ${baseRef} failed — one-in-one-out not evaluated`;
         } else {
-            offsets = classifyDiff(
-                diff.stdout,
-                (rel) => {
-                    try {
-                        return fs.readFileSync(path.join(repoRoot, rel), 'utf-8');
-                    } catch {
-                        return null;
-                    }
-                },
-                (rel) => {
-                    const show = git(['show', `${baseRef}:${rel}`], repoRoot);
-                    return show.ok ? show.stdout : null;
-                },
-            );
+            offsets = classifyDiff(diff.stdout, (rel) => {
+                try {
+                    return fs.readFileSync(path.join(repoRoot, rel), 'utf-8');
+                } catch {
+                    return null;
+                }
+            });
         }
         const patch = git(
             ['diff', '--unified=0', '--find-renames', `${baseRef}...HEAD`, '--', ROADMAPS_REL],
@@ -982,9 +935,6 @@ function selfTest(): number {
     const roadmap = (name: string, extra = ''): string =>
         `# Roadmap: ${name}\n\n## Phase 1\n\n- [ ] **1.1** s\n${extra}`;
 
-    /** A `status: carrier` roadmap — counted as estate, and never an offset. */
-    const CARRIER = `---\nstatus: carrier\n---\n# Roadmap: carrier\n\n## Phase 1\n\n- [~] **1.1** s\n`;
-
     /**
      * A `status: draft` roadmap — invisible to `collect()`, so adding one cannot
      * move `active_roadmaps`. That is what makes it the fixture for a case that
@@ -1197,14 +1147,25 @@ function selfTest(): number {
                     after: (dir) => write(dir, 'agents/roadmaps/later/road-to-parked.md', roadmap('P')),
                 }),
         },
-        ...carrierEstateCases({
-            fixture,
-            write,
-            remove: (dir, rel) => fs.rmSync(path.join(dir, rel)),
-            roadmap,
-            CARRIER,
-            DRAFT,
-        }),
+        {
+            // Survives the deletion of the carrier cases this used to control
+            // for (ADR-262): it asserts the plain rule those cases were the
+            // exception to — a removal offsets an addition — over a DRAFT
+            // addition, which `collect()` cannot see, so only the offset
+            // scoring can decide it.
+            name: 'deleting an ordinary roadmap offsets a new draft → accept',
+            expect: 'accept',
+            run: () =>
+                fixture({
+                    roadmaps: 3,
+                    base: 'main',
+                    before: (dir) => write(dir, 'agents/roadmaps/road-to-spare.md', roadmap('S')),
+                    after: (dir) => {
+                        fs.rmSync(path.join(dir, 'agents/roadmaps/road-to-spare.md'));
+                        write(dir, 'agents/roadmaps/road-to-new.md', DRAFT);
+                    },
+                }),
+        },
         {
             name: 'a new open blocker with no claim → reject',
             expect: 'reject',

package/src/scripts/check_pack_size.ts

@@ -22,7 +22,7 @@
  * Exit codes: 0 green · 1 over budget · 2 misuse / unreadable input.
  */
 
-import { execFileSync } from 'node:child_process';
+import { execFileSync, spawnSync } from 'node:child_process';
 import { createHash } from 'node:crypto';
 import * as fs from 'node:fs';
 import * as path from 'node:path';
@@ -30,6 +30,12 @@ import { fileURLToPath } from 'node:url';
 
 import { assertScanned, DeadScopeError } from './_lib/scan_scope.js';
 import { runSelfTest } from './_lib/gate_self_test.js';
+import {
+    type EligibilityVerdict,
+    evaluateEntry,
+    type GrammarProbe,
+    loadManifest,
+} from './_lib/packed_binary_predicate.js';
 
 const REPO_ROOT = path.resolve(fileURLToPath(import.meta.url), '..', '..', '..');
 const BUDGET_PATH = path.join(REPO_ROOT, 'src', 'config', 'pack-size-budget.json');
@@ -306,19 +312,26 @@ export function payloadFingerprint(entryPath: string, size: number): string {
 }
 
 /**
- * Measured on the BUILT payload, 2026-09-07: 3041 entries, of which 3026 are
- * text and these 15 are not. `archive` is empty and stays a hard zero.
+ * Bound exceptions exist for `dotfile` and `no-extension` ONLY.
  *
- * The roadmap step that added this expected `binary` to be zero too. It is not:
- * three 69-byte PNG placeholders ship as media-adapter fixtures. Recorded as a
- * correction rather than resolved by redefining the class — they are genuinely
- * binary, they genuinely ship, and dropping them from the published surface is
- * a consumer-visible change that belongs to whoever owns those adapters.
+ * `binary` and `archive` are not exceptable HERE and never will be: this table
+ * is prose-bound, and prose is exactly what a binary must not be admitted on.
+ * `archive` remains a hard zero with no admission path of any kind. `binary`
+ * has one since 2026-09-08 — `src/config/packed-binary-manifest.json`, gated by
+ * the mechanically verified predicate in `_lib/packed_binary_predicate.ts`,
+ * which re-derives every claim from the packed bytes. Adding a `binary` row to
+ * the table below still does nothing. That is AC-6 of
+ * `road-to-scan-that-fails-closed` read literally, after an AI council
+ * (2026-09-07, 2 seats, unanimous over two rounds) resolved the split between
+ * reading "at zero" as the ratchet and as the observed count. It chose the
+ * observed count, and chose disposition 3 — ship a textual representation —
+ * over generating fixtures at dry-run time, on the measurement that 12 of the
+ * 15 asset-bearing media fixtures ALREADY ship an ASCII placeholder at their
+ * documented path (`FIXTURE-<adapter-id>-<ext>`). The three 69-byte PNGs that
+ * used to sit here were the outliers, not the norm; they now carry the sibling
+ * convention and the class is empty by observation.
  */
 const BOUND_PAYLOAD_EXCEPTIONS: readonly BoundPayloadException[] = [
-    { fingerprint: '955b5da399e14fb39cfe1f3279044061043e64e2bd1576871514db927e56d701', path: 'src/scripts/media/lib/fixtures/flux/asset-0001.png', size: 69, why: 'media-adapter response fixture — a 69-byte placeholder PNG the flux adapter test decodes; binary by construction' },
-    { fingerprint: 'c2dd9743367ece8ffe0deef5e798d39967c22245749fd7f798edd8aa78b70f59', path: 'src/scripts/media/lib/fixtures/gemini-image/asset-0001.png', size: 69, why: 'media-adapter response fixture — same class as the flux placeholder' },
-    { fingerprint: 'cbac44d021a1dc41b938e798eb9be4147fc9d35194c348dfe9acaa0596bc83a5', path: 'src/scripts/media/lib/fixtures/ideogram/asset-0001.png', size: 69, why: 'media-adapter response fixture — same class as the flux placeholder' },
     { fingerprint: '47e4328e71652a0375ade7eb4dac8a3e4b6df1c6e4e74caa75287266676cc9a6', path: 'agents/templates/.ai-council.yml.example', size: 30561, why: 'shipped council config TEMPLATE — a dotfile because the file it is copied to is one. RE-PINNED 2026-09-07, 29,872 -> 30,561 bytes: the exception is path-AND-size-bound by design, so this branch adding a `disabled_reason` honest-null block to the gemini seat in the template invalidated it and the gate refused the entry as unaccounted. The re-pin excepts the SAME path for the SAME reason at its measured new size — it does not widen the class, raise a cap, or except anything the gate was not already carrying.' },
     { fingerprint: 'd36a53951c184db7481139235056e90b53a853714b3a68b31ba1349ecb95ac1d', path: 'agents/templates/.ai-video.xml.example', size: 9209, why: 'shipped video-provider config template — same reason as the council template' },
     { fingerprint: 'f83229412cf8cceaadd0cb1934140a0c7c8277df43edc590f370572f6df6da98', path: 'dist/agent-src/templates/agents/.gitattributes.fragment', size: 2140, why: 'gitattributes fragment the installer appends to a consumer repo' },
@@ -360,16 +373,25 @@ export interface TypeClassification {
 /**
  * Classify the whole payload by type and report what is not accounted for.
  *
- * Every entry outside `text` needs a bound exception. `archive` has none and is
- * meant to stay that way; `binary` has three, named; the dotfile and
- * extensionless entries are each bound to a path AND a size, so replacing one
- * with different content re-fires the check on that entry rather than passing
- * inside a count.
+ * `archive` stays a closed class: no admission path, so an entry in it is
+ * always a violation. `binary` is admitted only through `eligible` — the
+ * caller supplies the verdicts, this function never decides eligibility itself
+ * — and an INELIGIBLE binary is unaccounted exactly as before.
+ *
+ * The counts are the OBSERVED payload and are never reduced by eligibility. A
+ * caller compares `observed` against `allowed` (the number of entries that
+ * passed the predicate); nothing here subtracts an excused file from a count,
+ * because a measurement an exception can move is not a measurement.
+ *
+ * Dotfile and extensionless entries are each bound to a path AND a size, so
+ * replacing one with different content re-fires the check on that entry rather
+ * than passing inside a count.
  */
 export function classifyPayloadTypes(
     files: readonly PackFile[],
     root = REPO_ROOT,
     head: (p: string) => Uint8Array | null = (p) => readHead(p, root),
+    eligible: ReadonlySet<string> = new Set<string>(),
 ): TypeClassification {
     const counts: Record<PayloadType | 'unreadable', number> = {
         archive: 0,
@@ -387,7 +409,11 @@ export function classifyPayloadTypes(
         counts[type] += 1;
         if (type === 'text') continue;
         const fingerprint = payloadFingerprint(f.path, f.size);
-        if (byFingerprint.has(fingerprint)) {
+        // A binary is accounted for ONLY by the mechanical predicate. It is
+        // never matched against the prose table, so a `binary` row added there
+        // would still do nothing.
+        if (type === 'binary' && eligible.has(f.path)) continue;
+        if (type !== 'binary' && type !== 'archive' && byFingerprint.has(fingerprint)) {
             used.add(fingerprint);
             continue;
         }
@@ -400,6 +426,127 @@ export function classifyPayloadTypes(
     };
 }
 
+/**
+ * Binary eligibility over the packed payload.
+ *
+ * The probe is a CHILD PROCESS running the engine's own loader
+ * (`code_graph/grammar_probe.ts`), not a reimplementation here: a second
+ * loader inside the gate could accept bytes the engine rejects, which is the
+ * one failure mode that would let a broken grammar ship while the gate called
+ * it valid.
+ *
+ * A probe that cannot run at all yields `null` for every file, which FAILS
+ * conditions 8 and 9 rather than passing them — an unverifiable binary is not
+ * an eligible one.
+ */
+export interface BinaryEligibilityReport {
+    /** Paths that passed every condition. */
+    readonly eligible: ReadonlySet<string>;
+    /** Every packed binary, eligible or not, with its failing conditions. */
+    readonly verdicts: readonly EligibilityVerdict[];
+    /** True count of binaries in the payload — never reduced by eligibility. */
+    readonly observedCount: number;
+    /** True byte total of those binaries. */
+    readonly observedBytes: number;
+    /** Entries that passed the predicate. Compliance is observed <= allowed. */
+    readonly allowedCount: number;
+    /** Byte total of the allowed entries. */
+    readonly allowedBytes: number;
+}
+
+export function evaluateBinaryEligibility(
+    files: readonly PackFile[],
+    root = REPO_ROOT,
+    probeAll: (paths: readonly string[]) => Map<string, GrammarProbe | null> = probeGrammars,
+): BinaryEligibilityReport {
+    const manifest = loadManifest(root);
+    const packedPaths = new Set(files.map((f) => f.path));
+    const binaries = files.filter((f) => classifyEntry(f.path, readHead(f.path, root)) === 'binary');
+    const probes = probeAll(binaries.map((b) => b.path));
+
+    const verdicts: EligibilityVerdict[] = [];
+    for (const b of binaries) {
+        let bytes: Uint8Array | null = null;
+        try {
+            bytes = fs.readFileSync(path.join(root, b.path));
+        } catch {
+            bytes = null;
+        }
+        verdicts.push(
+            evaluateEntry({
+                filePath: b.path,
+                packedPaths,
+                manifest,
+                bytes,
+                probe: probes.get(b.path) ?? null,
+            }),
+        );
+    }
+    const eligible = new Set(verdicts.filter((v) => v.eligible).map((v) => v.path));
+    const sizeOf = new Map(files.map((f) => [f.path, f.size]));
+    return {
+        eligible,
+        verdicts,
+        observedCount: binaries.length,
+        observedBytes: binaries.reduce((n, b) => n + b.size, 0),
+        allowedCount: eligible.size,
+        allowedBytes: [...eligible].reduce((n, p) => n + (sizeOf.get(p) ?? 0), 0),
+    };
+}
+
+/** Run the production loader over `paths` in one child process. */
+function probeGrammars(paths: readonly string[]): Map<string, GrammarProbe | null> {
+    const out = new Map<string, GrammarProbe | null>();
+    for (const p of paths) out.set(p, null);
+    if (paths.length === 0) return out;
+    const script = path.join(REPO_ROOT, 'src/scripts/code_graph/grammar_probe.ts');
+    const res = spawnSync('npx', ['tsx', script, ...paths.map((p) => path.join(REPO_ROOT, p))], {
+        cwd: REPO_ROOT,
+        encoding: 'utf-8',
+    });
+    if (res.status !== 0 || !res.stdout.trim()) return out;
+    try {
+        const rows = JSON.parse(res.stdout.trim()) as Array<{
+            path: string;
+            ok: boolean;
+            abi?: number;
+            grammar_id?: string;
+        }>;
+        for (const r of rows) {
+            const rel = path.relative(REPO_ROOT, r.path);
+            if (r.ok && typeof r.abi === 'number' && typeof r.grammar_id === 'string') {
+                out.set(rel, { abi: r.abi, grammar_id: r.grammar_id });
+            }
+        }
+    } catch {
+        /* an unparseable probe leaves every entry null, which fails 8 and 9 */
+    }
+    return out;
+}
+
+/** The always-printed binary line: the measurement, then the allowance. */
+export function binaryLine(r: BinaryEligibilityReport): string {
+    return (
+        `binary: observed ${String(r.observedCount)} (${r.observedBytes.toLocaleString('en-US')} B) · ` +
+        `allowed ${String(r.allowedCount)} (${r.allowedBytes.toLocaleString('en-US')} B)`
+    );
+}
+
+/**
+ * Compliance is `observed <= allowed`.
+ *
+ * Stated as its own check rather than inferred from the unaccounted list,
+ * because the two can only ever agree by construction and a gate that relies on
+ * that is one refactor away from silently accepting an excess.
+ */
+export function binaryComplianceViolations(r: BinaryEligibilityReport): string[] {
+    if (r.observedCount <= r.allowedCount) return [];
+    return [
+        `binary payload: observed ${String(r.observedCount)} entries but only ${String(r.allowedCount)} are ` +
+            'allowed by src/config/packed-binary-manifest.json under the eligibility predicate',
+    ];
+}
+
 /** One line naming every type class and its count. */
 export function payloadTypeLine(c: TypeClassification): string {
     const parts = [...PAYLOAD_TYPES, 'unreadable' as const]
@@ -413,11 +560,17 @@ export function typeClassViolations(c: TypeClassification): string[] {
     return c.unbound.map(
         (u) =>
             `payload type \`${u.type}\`: ${u.path} (${String(u.size)} bytes) is not accounted for. ` +
-            (u.type === 'archive' || u.type === 'binary'
-                ? 'This class is meant to be empty. '
-                : 'Every dotfile and extensionless entry is carried by a path-and-size-bound exception. ') +
-            `If it belongs in the published surface, add a BoundPayloadException with ` +
-            `fingerprint sha256:${u.fingerprint} and a reason; otherwise exclude it from package.json files[].`,
+            (u.type === 'archive'
+                ? 'Archive is a closed class with no admission path of any kind. ' +
+                  'Exclude it from package.json files[].'
+                : u.type === 'binary'
+                  ? 'A binary ships only via src/config/packed-binary-manifest.json, and only when every ' +
+                    'condition of the eligibility predicate holds on the packed bytes ' +
+                    '(_lib/packed_binary_predicate.ts). Add or correct its manifest entry, or exclude it ' +
+                    'from package.json files[]. The failing conditions are listed above.'
+                  : 'Every dotfile and extensionless entry is carried by a path-and-size-bound exception. ' +
+                    `If it belongs in the published surface, add a BoundPayloadException with ` +
+                    `fingerprint sha256:${u.fingerprint} and a reason; otherwise exclude it from package.json files[].`),
     );
 }
 
@@ -664,6 +817,81 @@ function selfTest(): number {
                         ? 1
                         : 0,
             },
+            {
+                // THE PROSE-PATH SENSITIVITY PROOF. `LICENSE` at 1064 bytes
+                // carries a real bound exception, so under the pre-2026-09-07
+                // code this entry passed. It is fed binary head bytes here, and
+                // binary outranks no-extension in `classifyEntry`, so a
+                // prose-exceptable `binary` class would accept it. It must not.
+                //
+                // STILL LOAD-BEARING after the 2026-09-08 reopening, and more
+                // so: `binary` is admissible again, but ONLY through the
+                // mechanically verified manifest. This row is what goes red if
+                // anyone ever wires the prose table back into the class.
+                name: 'type/binary: a manifest-eligible binary IS admitted',
+                expect: 'accept',
+                // THE OPEN-PATH ACCEPTING CONTROL. The council's own argument
+                // against the closed class was that a control nobody saw fire
+                // is a claim; the same holds in reverse for a path nobody saw
+                // accept. Without this row every binary assertion here is a
+                // rejection, and a predicate that only ever refuses is
+                // indistinguishable from the hard zero it replaced.
+                run: () =>
+                    typeClassViolations(
+                        classifyPayloadTypes(
+                            [{ path: 'src/vendor/grammars/tree-sitter-php.wasm', size: 812594 }],
+                            REPO_ROOT,
+                            () => Uint8Array.from([0x00, 0x61, 0x73, 0x6d, 0x01, 0x00, 0x00, 0x00]),
+                            new Set(['src/vendor/grammars/tree-sitter-php.wasm']),
+                        ),
+                    ).length > 0
+                        ? 1
+                        : 0,
+            },
+            {
+                name: 'type/binary: the SAME path is refused when eligibility did not pass',
+                expect: 'reject',
+                // The paired negative. Same path, same bytes, empty eligible
+                // set — so the admission demonstrably comes from the predicate
+                // and not from the path looking familiar.
+                run: () =>
+                    typeClassViolations(
+                        classifyPayloadTypes(
+                            [{ path: 'src/vendor/grammars/tree-sitter-php.wasm', size: 812594 }],
+                            REPO_ROOT,
+                            () => Uint8Array.from([0x00, 0x61, 0x73, 0x6d, 0x01, 0x00, 0x00, 0x00]),
+                            new Set<string>(),
+                        ),
+                    ).length > 0
+                        ? 1
+                        : 0,
+            },
+            {
+                name: 'type/binary: an entry with a VALID bound exception is still refused once it reads binary',
+                expect: 'reject',
+                run: () =>
+                    typeClassViolations(
+                        classifyPayloadTypes([{ path: 'LICENSE', size: 1064 }], REPO_ROOT, () =>
+                            Uint8Array.from([0x7f, 0x45, 0x4c, 0x46, 0x02, 0x00, 0x00]),
+                        ),
+                    ).length > 0
+                        ? 1
+                        : 0,
+            },
+            {
+                // The negative control for the row above: the SAME exceptable
+                // path with ordinary text still passes on its exception.
+                name: 'type/extensionless: the same bound entry with text content still passes',
+                expect: 'accept',
+                run: () =>
+                    typeClassViolations(
+                        classifyPayloadTypes([{ path: 'LICENSE', size: 1064 }], REPO_ROOT, () =>
+                            new TextEncoder().encode('Apache License\n'),
+                        ),
+                    ).length > 0
+                        ? 1
+                        : 0,
+            },
             {
                 name: 'type/extensionless: an unbound extensionless entry is refused',
                 expect: 'reject',
@@ -781,11 +1009,15 @@ export function main(argv: readonly string[] = process.argv.slice(2)): number {
     // still knows the population it was red over.
     process.stdout.write(`scanned: ${String(pack.files.length)}\n`);
 
-    const types = classifyPayloadTypes(pack.files);
+    // Binary eligibility, decided on the PACKED bytes before classification so
+    // the classifier is told which paths passed and never decides itself.
+    const binaryReport = evaluateBinaryEligibility(pack.files);
+    const types = classifyPayloadTypes(pack.files, REPO_ROOT, (p) => readHead(p, REPO_ROOT), binaryReport.eligible);
     const errors = [
         ...evaluate(budget, pack),
         ...classifyPayload(pack.files),
         ...typeClassViolations(types),
+        ...binaryComplianceViolations(binaryReport),
     ];
     const { perSkill, total } = skillBytes(pack.files);
     if (argv.includes('--json')) {
@@ -798,6 +1030,13 @@ export function main(argv: readonly string[] = process.argv.slice(2)): number {
     // what a reader needs to judge a violation: "one unaccounted binary" reads
     // very differently against a payload of 3 binaries than against one of 0.
     process.stdout.write(`    payload types: ${payloadTypeLine(types)}\n`);
+    // The observed binary count and byte total on EVERY run, green or red.
+    // Eligibility must never move a measurement, so both totals are printed
+    // beside the allowance rather than folded into it.
+    process.stdout.write(`    ${binaryLine(binaryReport)}\n`);
+    for (const v of binaryReport.verdicts.filter((x) => !x.eligible)) {
+        for (const f of v.failures) process.stdout.write(`      ${v.path}: ${f}\n`);
+    }
     for (const unused of types.unusedExceptions) {
         // Not an error: an unbuilt tree legitimately packs fewer files. Named
         // so a stale exception is visible rather than accumulating unread.

package/src/scripts/check_roadmap_trackable.ts

@@ -19,6 +19,16 @@
  * `skipped/`, template/README/open-questions) MUST:
  *   1. Be parseable by the dashboard's `PHASE_RE` (>= one `## Phase <id>`).
  *   2. Have at least one trackable checkbox under every parsed phase.
+ *   3. Not declare a RETIRED `status:` value.
+ *
+ * `status: draft` is the one exemption. It used to have a second, `carrier`,
+ * which ADR-262 deleted: a `status:` value never again decides whether an
+ * autonomous run may act on a roadmap, so a receiver of deferred work is now
+ * ordinary estate and passes normal trackability. A surviving `status: carrier`
+ * is REJECTED here with the migration diagnostic rather than silently ignored —
+ * deleting a vocabulary term quietly would leave old files wearing a value
+ * nothing reads, and the next author would infer a meaning from its presence.
+ * The retired set and its diagnostic live in `_lib/retired_status.ts`.
  *
  * Exit codes:
  *   0 — every active roadmap has parseable phases with >= 1 checkbox per phase.
@@ -31,6 +41,7 @@ import { fileURLToPath, pathToFileURL } from 'node:url';
 
 import { checkRatchet } from './_lib/gate_baseline.js';
 import { assertScanned, DeadScopeError } from './_lib/scan_scope.js';
+import { declaresRetiredStatus, retiredStatusDiagnostic } from './_lib/retired_status.js';
 
 const QUIET = process.argv.slice(2).includes('--quiet');
 
@@ -49,15 +60,6 @@ const PHASE_RE =
 // FRONTMATTER_RE = re.compile(r"\A---\n(.*?)\n---\s*\n", re.DOTALL)
 const FRONTMATTER_RE = /^---\n([\s\S]*?)\n---\s*\n/;
 const DRAFT_VALUES: ReadonlySet<string> = new Set(['draft']);
-/**
- * A carrier holds obligations deferred out of an archived parent. It is not
- * schedulable work — every item in it has an unmet resumption trigger — and it
- * has no `## Phase` headings by construction, so it is skipped exactly where a
- * draft is. It differs from a draft in what protects it: a draft may be deleted
- * freely, a carrier may not, and `lint_carrier_integrity` reds when one loses
- * its receiver.
- */
-const CARRIER_VALUES: ReadonlySet<string> = new Set(['carrier']);
 
 const EXCLUDE_NAMES: ReadonlySet<string> = new Set([
     'template.md',
@@ -101,11 +103,6 @@ function is_draft(fm: Map<string, string>): boolean {
     return DRAFT_VALUES.has((fm.get('status') ?? '').toLowerCase());
 }
 
-/** True for a `status: carrier` roadmap — see CARRIER_VALUES. */
-function is_carrier(fm: Map<string, string>): boolean {
-    return CARRIER_VALUES.has((fm.get('status') ?? '').toLowerCase());
-}
-
 /** Mirror update_roadmap_progress.is_roadmap_candidate (POSIX path parts). */
 function is_roadmap_candidate(p: string): boolean {
     const name = path.basename(p);
@@ -182,7 +179,7 @@ function find_active_roadmaps(root: string): string[] {
             continue;
         }
         const text = fs.readFileSync(p, 'utf-8');
-        if (is_draft(parse_frontmatter(text)) || is_carrier(parse_frontmatter(text))) {
+        if (is_draft(parse_frontmatter(text))) {
             continue;
         }
         out.push(p);
@@ -193,6 +190,13 @@ function find_active_roadmaps(root: string): string[] {
 /** Return human-readable violation strings for a single roadmap. */
 function violations_for(p: string): string[] {
     const text = fs.readFileSync(p, 'utf-8');
+    const retired = declaresRetiredStatus(text);
+    if (retired !== null) {
+        // Returned alone: a file wearing a deleted status has a migration to do
+        // before its phase structure is worth reporting on, and stacking phase
+        // findings on top would bury the one finding that has to be read first.
+        return [`${p}: ${retiredStatusDiagnostic(retired)}`];
+    }
     PHASE_RE.lastIndex = 0;
     const matches: Array<{ start: number; end: number; id: string; name: string | undefined }> =
         [];
@@ -359,7 +363,6 @@ export {
     CHECKBOX_RE,
     PHASE_RE,
     is_draft,
-    is_carrier,
     is_roadmap_candidate,
     parse_frontmatter,
     find_active_roadmaps,