@event4u/agent-config 14.19.0 → 14.21.0

package/src/scripts/check_pack_size.ts

@@ -23,6 +23,7 @@
  */
 
 import { execFileSync } from 'node:child_process';
+import { createHash } from 'node:crypto';
 import * as fs from 'node:fs';
 import * as path from 'node:path';
 import { fileURLToPath } from 'node:url';
@@ -206,6 +207,220 @@ export function classifyPayload(files: readonly PackFile[]): string[] {
     return out;
 }
 
+/**
+ * Payload TYPE classification — what an entry IS, not where it sits.
+ *
+ * `CONTENT_CLASSES` above matches PATHS. That catches the shapes with a naming
+ * convention (a `.pem`, a `.test.js`, a `.vscode/` directory) and is blind to
+ * everything else: a compiled binary named `helper`, an archive named
+ * `data.md`, an extensionless script nobody looked at. Extension is the
+ * attacker's choice; the first bytes are not.
+ *
+ * Priority is archive > binary > dotfile > no-extension > text, so each entry
+ * lands in exactly one class and a count is a partition of the payload.
+ */
+export type PayloadType = 'text' | 'dotfile' | 'no-extension' | 'binary' | 'archive';
+
+export const PAYLOAD_TYPES: readonly PayloadType[] = [
+    'archive',
+    'binary',
+    'dotfile',
+    'no-extension',
+    'text',
+];
+
+/** Leading magic bytes for the archive container formats worth naming. */
+const ARCHIVE_MAGIC: ReadonlyArray<readonly number[]> = [
+    [0x50, 0x4b, 0x03, 0x04], // zip / jar / docx / xlsx
+    [0x1f, 0x8b], // gzip
+    [0x42, 0x5a, 0x68], // bzip2
+    [0xfd, 0x37, 0x7a, 0x58, 0x5a, 0x00], // xz
+    [0x04, 0x22, 0x4d, 0x18], // lz4
+    [0x28, 0xb5, 0x2f, 0xfd], // zstd
+    [0x37, 0x7a, 0xbc, 0xaf, 0x27, 0x1c], // 7z
+    [0x52, 0x61, 0x72, 0x21], // rar
+];
+
+/** How many leading bytes are read to decide. */
+export const MAGIC_BYTES_READ = 512;
+
+function startsWith(buf: Uint8Array, sig: readonly number[]): boolean {
+    if (buf.length < sig.length) return false;
+    return sig.every((b, i) => buf[i] === b);
+}
+
+/**
+ * Classify one entry from its name and its first bytes.
+ *
+ * `head` is null when the file could not be read. That is NOT text: an entry
+ * the check could not open is an entry it did not classify, and the caller
+ * treats it as a failure rather than letting it fall through to the class that
+ * needs no exception.
+ */
+export function classifyEntry(entryPath: string, head: Uint8Array | null): PayloadType | 'unreadable' {
+    if (head === null) return 'unreadable';
+    if (ARCHIVE_MAGIC.some((sig) => startsWith(head, sig))) return 'archive';
+    if (head.length > 0) {
+        // A NUL byte is decisive. Short of that, a high proportion of C0
+        // control bytes outside tab/newline/CR is what separates a compiled
+        // object from prose that happens to contain an unusual character.
+        if (head.includes(0)) return 'binary';
+        let control = 0;
+        for (const b of head) {
+            if (b < 0x09 || (b > 0x0d && b < 0x20)) control += 1;
+        }
+        if (control / head.length > 0.1) return 'binary';
+    }
+    const base = entryPath.split('/').pop() ?? entryPath;
+    if (base.startsWith('.')) return 'dotfile';
+    if (!base.includes('.')) return 'no-extension';
+    return 'text';
+}
+
+/**
+ * An entry admitted into a class that would otherwise be empty.
+ *
+ * BOUND, not allow-listed, and the distinction is the whole point. A count
+ * ratchet ("8 extensionless entries are fine") is satisfied by ANY eight
+ * extensionless entries, so swapping one for something else passes silently —
+ * the same key-lookup weakness the Phase 5 pragma work removed one layer up.
+ * Here the binding is `sha256(path + "\n" + size)`: change the file and the
+ * exception stops applying, which re-fires the check on the entry that changed.
+ *
+ * NOT a `*_allowlist.json`. There is no file to grow, each entry states its own
+ * reason next to the class it excepts, and adding one is a reviewed code change
+ * in the gate — the same shape `CONTENT_CLASSES` already uses for its ratchets.
+ *
+ * Recompute a fingerprint with:
+ *   ./scripts-run src/scripts/check_pack_size   (the failure names path and size)
+ */
+export interface BoundPayloadException {
+    readonly fingerprint: string;
+    readonly path: string;
+    readonly size: number;
+    readonly why: string;
+}
+
+export function payloadFingerprint(entryPath: string, size: number): string {
+    return createHash('sha256').update(`${entryPath}\n${String(size)}`).digest('hex');
+}
+
+/**
+ * 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.
+ *
+ * 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.
+ */
+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' },
+    { fingerprint: 'a4f51dba3a66c0f2c3548e77961271ed4d7b5ec8a6661ea359ff044758f0d921', path: 'src/templates/minimal/.agent-settings.yml', size: 1042, why: 'the minimal-install settings template; the dot is the consumer-side filename' },
+    { fingerprint: 'a9cb828c7f3e6ac62d3c55c2fd215779307bf695a065498b1d1e1188210ebea8', path: 'LICENSE', size: 1064, why: 'the licence npm requires in the tarball; extensionless by convention' },
+    { fingerprint: 'e89a3d025a838e295838db68d0d832c701eeca01bb7e6c3983d3a48950f80017', path: 'NOTICE', size: 472, why: 'attribution notice shipped with the licence; extensionless by convention' },
+    { fingerprint: 'c9da3c6e2476a6d2b9610a1fbf638ba9bb78ddd76fc0f799631d601774c32cab', path: 'dist/agent-src/templates/hooks/pre-commit-frontmatter', size: 2537, why: 'git hook template — git requires a hook file to carry no extension' },
+    { fingerprint: 'aeffa474df3f805de07cdc9c6960c4918aa8e51e317fa1c30906d2f0267b7a16', path: 'dist/agent-src/templates/hooks/pre-commit-roadmap-progress', size: 3988, why: 'git hook template — same reason' },
+    { fingerprint: '914f9c34551c5f4c42a70cd8bb0cd7b73078b0c4e7815b551833a3c64c8476d3', path: 'src/scripts/agent-config', size: 2391, why: 'the CLI entry script; an executable entry point carries no extension by convention' },
+    { fingerprint: '0bb1cdd48ac2e9b6a2a56cde25de9fc221d75d42683680284c43118cff796e92', path: 'src/scripts/hooks/shims/php', size: 4439, why: 'shim invoked as the command name `php`; an extension would break the lookup' },
+    { fingerprint: 'b14bdd3cd589848ad8e6d7e5f4ee633dc9005a2a97abba327a9426ce556714da', path: 'src/scripts/install', size: 22049, why: 'the installer entry script; same reason as the CLI entry' },
+    { fingerprint: '1fb564019de468368e34941dffd5eb8bc994364313e02f476ff354ac0da464d7', path: 'src/templates/minimal/overrides-gitkeep', size: 164, why: 'placeholder that becomes .gitkeep on install; extensionless on purpose' },
+];
+
+/** Read the first bytes of a payload entry from the tree it was packed from. */
+function readHead(entryPath: string, root: string): Uint8Array | null {
+    try {
+        const fd = fs.openSync(path.join(root, entryPath), 'r');
+        try {
+            const buf = Buffer.alloc(MAGIC_BYTES_READ);
+            const read = fs.readSync(fd, buf, 0, MAGIC_BYTES_READ, 0);
+            return buf.subarray(0, read);
+        } finally {
+            fs.closeSync(fd);
+        }
+    } catch {
+        return null;
+    }
+}
+
+export interface TypeClassification {
+    readonly counts: Record<PayloadType | 'unreadable', number>;
+    /** Entries in a non-`text` class with no bound exception. */
+    readonly unbound: Array<{ path: string; size: number; type: PayloadType | 'unreadable'; fingerprint: string }>;
+    /** Bound exceptions matching no entry in this payload. */
+    readonly unusedExceptions: string[];
+}
+
+/**
+ * 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.
+ */
+export function classifyPayloadTypes(
+    files: readonly PackFile[],
+    root = REPO_ROOT,
+    head: (p: string) => Uint8Array | null = (p) => readHead(p, root),
+): TypeClassification {
+    const counts: Record<PayloadType | 'unreadable', number> = {
+        archive: 0,
+        binary: 0,
+        dotfile: 0,
+        'no-extension': 0,
+        text: 0,
+        unreadable: 0,
+    };
+    const byFingerprint = new Map(BOUND_PAYLOAD_EXCEPTIONS.map((e) => [e.fingerprint, e]));
+    const used = new Set<string>();
+    const unbound: TypeClassification['unbound'] = [];
+    for (const f of files) {
+        const type = classifyEntry(f.path, head(f.path));
+        counts[type] += 1;
+        if (type === 'text') continue;
+        const fingerprint = payloadFingerprint(f.path, f.size);
+        if (byFingerprint.has(fingerprint)) {
+            used.add(fingerprint);
+            continue;
+        }
+        unbound.push({ path: f.path, size: f.size, type, fingerprint });
+    }
+    return {
+        counts,
+        unbound,
+        unusedExceptions: BOUND_PAYLOAD_EXCEPTIONS.filter((e) => !used.has(e.fingerprint)).map((e) => e.path),
+    };
+}
+
+/** One line naming every type class and its count. */
+export function payloadTypeLine(c: TypeClassification): string {
+    const parts = [...PAYLOAD_TYPES, 'unreadable' as const]
+        .filter((t) => t !== 'unreadable' || c.counts.unreadable > 0)
+        .map((t) => `${t} ${String(c.counts[t])}`);
+    return `${parts.join(' · ')} — ${String(c.unbound.length)} unaccounted`;
+}
+
+/** Violations from the type classification, as human-readable lines. */
+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[].`,
+    );
+}
+
 /** Per-class counts, for the green-path report. */
 export function payloadClassCounts(
     files: readonly PackFile[],
@@ -377,8 +592,8 @@ function selfTest(): number {
         Array.from({ length: n }, (_, i) => `dist/hooks/chunk-${String(i)}.js.map`);
     return runSelfTest({
         gate: 'check_pack_size',
-        minCases: 9,
-        minRejectCases: 5,
+        minCases: 14,
+        minRejectCases: 9,
         cases: [
             {
                 name: 'credential-shaped: a .pem in the payload is refused',
@@ -410,6 +625,95 @@ function selfTest(): number {
                 expect: 'accept',
                 run: () => (classifyPayload(builtPayload(...maps(120))).length > 0 ? 1 : 0),
             },
+            {
+                // MAGIC BYTES, NOT THE EXTENSION. This is the whole reason the
+                // type pass exists beside the path pass above: an archive named
+                // `.md` is invisible to every path pattern in CONTENT_CLASSES.
+                name: 'type/archive: a zip planted under a .md name is classified archive, not text',
+                expect: 'reject',
+                run: () =>
+                    typeClassViolations(
+                        classifyPayloadTypes(packFiles('src/skills/x/SKILL.md'), REPO_ROOT, () =>
+                            Uint8Array.from([0x50, 0x4b, 0x03, 0x04, 0x14, 0x00]),
+                        ),
+                    ).length > 0
+                        ? 1
+                        : 0,
+            },
+            {
+                name: 'type/archive: the SAME path with ordinary text is classified text and passes',
+                expect: 'accept',
+                run: () =>
+                    typeClassViolations(
+                        classifyPayloadTypes(packFiles('src/skills/x/SKILL.md'), REPO_ROOT, () =>
+                            new TextEncoder().encode('# An ordinary skill\n'),
+                        ),
+                    ).length > 0
+                        ? 1
+                        : 0,
+            },
+            {
+                name: 'type/binary: a NUL-bearing entry is refused however it is named',
+                expect: 'reject',
+                run: () =>
+                    typeClassViolations(
+                        classifyPayloadTypes(packFiles('src/scripts/helper.ts'), REPO_ROOT, () =>
+                            Uint8Array.from([0x7f, 0x45, 0x4c, 0x46, 0x02, 0x00, 0x00]),
+                        ),
+                    ).length > 0
+                        ? 1
+                        : 0,
+            },
+            {
+                name: 'type/extensionless: an unbound extensionless entry is refused',
+                expect: 'reject',
+                run: () =>
+                    typeClassViolations(
+                        classifyPayloadTypes(packFiles('src/scripts/newtool'), REPO_ROOT, () =>
+                            new TextEncoder().encode('#!/bin/sh\n'),
+                        ),
+                    ).length > 0
+                        ? 1
+                        : 0,
+            },
+            {
+                // The property a COUNT ratchet cannot have. LICENSE is bound at
+                // its measured size; the same path at a different size is a
+                // different artifact and the exception stops applying.
+                name: 'type/binding: a bound entry whose SIZE changed is refused again',
+                expect: 'reject',
+                run: () =>
+                    typeClassViolations(
+                        classifyPayloadTypes([{ path: 'LICENSE', size: 999999 }], REPO_ROOT, () =>
+                            new TextEncoder().encode('MIT\n'),
+                        ),
+                    ).length > 0
+                        ? 1
+                        : 0,
+            },
+            {
+                name: 'type/binding: that same entry at its recorded size passes',
+                expect: 'accept',
+                run: () =>
+                    typeClassViolations(
+                        classifyPayloadTypes([{ path: 'LICENSE', size: 1064 }], REPO_ROOT, () =>
+                            new TextEncoder().encode('MIT\n'),
+                        ),
+                    ).length > 0
+                        ? 1
+                        : 0,
+            },
+            {
+                // An entry the check could not open is one it did not classify.
+                name: 'type/unreadable: an entry that cannot be read is refused, never assumed text',
+                expect: 'reject',
+                run: () =>
+                    typeClassViolations(
+                        classifyPayloadTypes(packFiles('src/scripts/gone.ts'), REPO_ROOT, () => null),
+                    ).length > 0
+                        ? 1
+                        : 0,
+            },
             {
                 name: 'a plain payload passes — the classes are not firing on everything',
                 expect: 'accept',
@@ -477,7 +781,12 @@ 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 errors = [...evaluate(budget, pack), ...classifyPayload(pack.files)];
+    const types = classifyPayloadTypes(pack.files);
+    const errors = [
+        ...evaluate(budget, pack),
+        ...classifyPayload(pack.files),
+        ...typeClassViolations(types),
+    ];
     const { perSkill, total } = skillBytes(pack.files);
     if (argv.includes('--json')) {
         process.stdout.write(
@@ -485,6 +794,15 @@ export function main(argv: readonly string[] = process.argv.slice(2)): number {
         );
         return errors.length > 0 ? 1 : 0;
     }
+    // Printed BEFORE the verdict and on EVERY path, red included. The counts are
+    // 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`);
+    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.
+        process.stdout.write(`    bound exception matched no entry: ${unused}\n`);
+    }
     if (errors.length > 0) {
         for (const e of errors) process.stderr.write(`❌  pack size: ${e}\n`);
         return 1;

package/src/scripts/check_release_highlights.ts

@@ -71,18 +71,12 @@ import {
     collect_span_commits,
     derive_categories,
     parse_git_log,
-    mix_response_blockers,
-    previous_promise,
     previous_release_tag,
-    promise_readback_blockers,
     stale_draft_labels,
 } from './_lib/release_highlights.js';
-import { loadTaxonomy, measureRange } from './measure_release_mix.js';
 import {
     CURATED_HEAD_INSTRUCTION,
-    PROMISE_READBACK_MARKER,
     extract_changelog_section,
-    previous_changelog_version,
 } from './_lib/release_material.js';
 import { assertScanned, assertWatchlistResolves, DeadScopeError } from './_lib/scan_scope.js';
 
@@ -244,23 +238,6 @@ export function main(argv: readonly string[]): number {
         );
         return 1;
     }
-    // Hoisted above the curated-head branches on purpose. It used to sit inside
-    // `contradictions.length === 0`, so CI reached it only for a section that
-    // HAS a head, carries no unrewritten draft and contradicts nothing — while
-    // the local guards call the same predicate unconditionally. A section
-    // without a curated head was therefore refused locally and waved through by
-    // CI: one predicate, two different gatekeepers, which is the drift this
-    // change exists to remove.
-    const mix = check_governance_mix_response(section.body, from, to, version);
-    if (mix !== 0) {
-        return mix;
-    }
-
-    const readback = check_previous_promise_readback(changelogText, section.body, version);
-    if (readback !== 0) {
-        return readback;
-    }
-
     const curated = parse_curated_head(section.body);
     if (!curated) {
         process.stdout.write(`ℹ️  no curated head in the ${version} section — nothing to check\n`);
@@ -356,140 +333,6 @@ export function main(argv: readonly string[]): number {
     return 1;
 }
 
-/**
- * The governance-versus-product response, checked for PRESENCE, never for the
- * ratio (ADR-253).
- *
- * `measure_release_mix` publishes a level. This is the one place that level has
- * a consequence, and the consequence is deliberately about completeness of the
- * written answer: when governance-only commits strictly outnumber consumer-only
- * commits over the release span, the section under release must carry a written
- * response naming either the next cycle's consumer work or a maintainer
- * justification. No number is enforced, and no number can be — both council
- * seats refused a threshold on fewer than two readings, and a gate with no
- * threshold that blocks on the ratio is a smuggled threshold.
- *
- * The response lives OUTSIDE the curated head, as its own `> **Governance
- * mix:**` line, so it does not consume the head's ten-line cap and does not
- * become a sixth label every historical section would suddenly lack.
- *
- * Scope matches every other check here: only the section under release is read.
- *
- * A measurement failure DEGRADES to a printed warning rather than to a refusal.
- * This is a governance signal, not a correctness or security control, and a
- * shallow clone or a missing tag on the release path would otherwise turn an
- * unrelated environment fact into a blocked release.
- */
-export function check_governance_mix_response(
-    body: string,
-    from: string,
-    to: string,
-    version: string,
-): number {
-    let reading;
-    try {
-        reading = measureRange(from, to, loadTaxonomy(), version, REPO_ROOT);
-    } catch (err) {
-        process.stdout.write(
-            `⚠️   governance mix not measured for ${version}: ${(err as Error).message}\n`,
-        );
-        return 0;
-    }
-    const o = reading.response_obligation;
-    const level = `governance-only ${o.governance_only} vs consumer-only ${o.consumer_only} (taxonomy ${reading.taxonomy_version})`;
-    if (!o.triggered) {
-        process.stdout.write(`✅  governance mix for ${version}: ${level} — no response owed\n`);
-        return 0;
-    }
-    // ONE predicate, shared with `guard_release_branch_push` — see
-    // `mix_response_blockers`. This side prints and exits; the local side dies
-    // before anything leaves the machine. Neither owns the rule.
-    const blockers = mix_response_blockers(body, version, `\`release/${version}\``, {
-        triggered: true,
-        level,
-    });
-    if (blockers.length === 0) {
-        process.stdout.write(`✅  governance mix for ${version}: ${level} — response present\n`);
-        return 0;
-    }
-    process.stderr.write(
-        `❌  the ${version} section owes a governance-versus-product response: ${level}.\n` +
-            blockers.map((b) => `    - ${b}\n`).join('') +
-            '    Governance-only commits outnumber consumer-only commits over the release span, so\n' +
-            '    the section carries a written response naming either the next cycle\'s consumer work\n' +
-            '    or a maintainer justification (docs/contracts/CHANGELOG-conventions.md § Governance-\n' +
-            '    versus-product response; the decline this replaces is ADR-253).\n' +
-            '    Only that section is read; historical sections are out of scope. No ratio is\n' +
-            '    enforced — this blocks a MISSING answer, never a particular number.\n' +
-            '    Reproduce locally, before any push:\n' +
-            `        ./scripts-run src/scripts/check_release_highlights --version ${version}\n`,
-    );
-    return 1;
-}
-
-/**
- * The previous release's promise, read back at the next release.
- *
- * `_lib/release_material.ts` generates `Next cycle ships …` and, until this
- * check existed, nothing ever asked what became of it: 14.18.0 promised the MCP
- * bridge repair, and no gate in the tree would have noticed the same promise
- * being reprinted in 14.19.0 and 14.20.0. A commitment nothing reads back is
- * free to restate, and one that is free to restate is not a commitment.
- *
- * Only the section under release is read, and only the previous section's
- * governance-response block — the same scope every other check here uses, so a
- * historical section cannot red a future release.
- *
- * The check is about ANSWERING, never about having kept the promise. A gate
- * that refused an unkept promise would price honesty above silence and teach
- * the next author to promise nothing.
- */
-export function check_previous_promise_readback(
-    changelogText: string,
-    body: string,
-    version: string,
-): number {
-    const previousVersion = previous_changelog_version(changelogText, version);
-    if (previousVersion === null) {
-        process.stdout.write(`✅  no previous CHANGELOG section before ${version} — no promise to read back\n`);
-        return 0;
-    }
-    const promise = previous_promise(changelogText, previousVersion);
-    if (promise === null) {
-        process.stdout.write(
-            `✅  the ${previousVersion} section made no next-cycle promise — nothing owed by ${version}\n`,
-        );
-        return 0;
-    }
-    const blockers = promise_readback_blockers(
-        body,
-        version,
-        previousVersion,
-        promise,
-        `\`release/${version}\``,
-    );
-    if (blockers.length === 0) {
-        process.stdout.write(`✅  ${version} answers the ${previousVersion} next-cycle promise\n`);
-        return 0;
-    }
-    process.stderr.write(
-        `❌  the ${version} section owes an answer to the ${previousVersion} next-cycle promise.\n` +
-            blockers.map((b) => `    - ${b}\n`).join('') +
-            `    The ${previousVersion} promise reads:\n` +
-            promise
-                .split('\n')
-                .map((l) => `        ${l}\n`)
-                .join('') +
-            `    Answering it is one blockquote line under the curated head, e.g.\n` +
-            `        > ${PROMISE_READBACK_MARKER} the <promise> did not ship; <what happened>.\n` +
-            '    Shipped, did not ship, or withdrawn with a reason — the check refuses a MISSING\n' +
-            '    answer, never a particular outcome. An unkept promise answered honestly passes.\n' +
-            '    Reproduce locally, before any push:\n' +
-            `        ./scripts-run src/scripts/check_release_highlights --version ${version}\n`,
-    );
-    return 1;
-}
-
 const _isMain = (() => {
     const entry = process.argv[1];
     if (!entry) return false;

package/src/scripts/council_cli.ts

@@ -78,8 +78,11 @@ import {
 } from './ai_council/config.js';
 import { AuthCache, select_solo_member } from './ai_council/solo_dispatch.js';
 import { InvalidModeError, resolve_global_mode } from './ai_council/modes.js';
-import { resolveMemberTransport } from './ai_council/transport_resolver.js';
-import { classifyCliFailure, type AbsentReason } from './ai_council/transport_resolver.js';
+import { classifyCliFailure, resolveMemberTransport, type AbsentReason } from './ai_council/transport_resolver.js';
+import {
+    disabledSeats as _disabledSeats,
+    resolvedTransportFor as _resolvedTransportFor,
+} from './ai_council/status_surface.js';
 import { evaluateQuorum, type QuorumResult } from './ai_council/quorum.js';
 import {
     _emitQuorumEvent,
@@ -2163,31 +2166,6 @@ function _emit_shadow_slo_banner(): void {
  * leaves nothing to infer. Exit is always 0 — this reports a state, it does not
  * gate — and the verdict line is machine-greppable in both directions.
  */
-/**
- * Resolve the concrete transport a member would use on THIS machine right now.
- *
- * `cmd_status` exists to answer "is the council reachable, and will it bill me".
- * Since the transport-mode setting was removed, the second half is not a value
- * anyone can look up in the config — it is a per-machine resolution. Printing a
- * configured mode would be the same class of stale answer the removed setting
- * produced. `mode` is pinned to `auto` because the loader no longer emits
- * anything else.
- */
-function _resolvedTransportFor(
-    name: string,
-    member: { readonly binary: string | null; readonly api_key_ref: string | null },
-    report?: EnvironmentReport,
-): ReturnType<typeof resolveMemberTransport> {
-    return resolveMemberTransport({
-        provider: name,
-        report: report ?? detectEnvironment(),
-        invocationMode: null,
-        memberSettings: null,
-        globalMode: 'auto',
-        binaryOverride: member.binary,
-    });
-}
-
 /** Gather what `fallbackPostureFor` needs; the decision itself is pure. */
 function _posture(
     name: string,
@@ -2263,6 +2241,9 @@ export function cmd_status(args: Args, opts: { env?: Record<string, string | und
                                 transport: t.available ? t.transport : null,
                                 billing: t.available ? t.billing : null,
                                 reason: t.reason,
+                                absent_reason: t.absentReason,
+                                policy_exclusion: m.policy_exclusion,
+                                content_ceiling: m.content_ceiling,
                             },
                         ];
                     }),
@@ -2273,6 +2254,7 @@ export function cmd_status(args: Args, opts: { env?: Record<string, string | und
                         enabledMembers.map(([n, m]) => [n, _posture(n, m)]),
                     ),
                 },
+                disabled_seats: _disabledSeats(cfg),
                 ignored_transport_keys: cfg?.ignored_transport_keys ?? [],
                 qualification: qualificationJson(qualifications),
                 qualified_members: countableSeats(qualifications),
@@ -2310,6 +2292,15 @@ export function cmd_status(args: Args, opts: { env?: Record<string, string | und
             const billing = t.available ? ` · ${t.billing}` : '';
             const detail = t.available ? t.transport : `unavailable — ${t.reason ?? 'no usable transport'}`;
             _stdout(`  transport        ${name}: ${detail}${billing}\n`);
+            // 2.1: the machine-readable half of the refusal.
+            if (!t.available && t.absentReason !== null && t.absentReason.startsWith('policy_')) {
+                _stdout(`  policy           ${name}: ${t.absentReason}\n`);
+            }
+            _stdout(`  content ceiling  ${name}: ${member.content_ceiling}\n`);
+        }
+        // 1.2: a disabled seat was invisible here — `enabled` members only.
+        for (const [name, reason] of Object.entries(_disabledSeats(cfg))) {
+            _stdout(`  disabled seat    ${name}: ${reason}\n`);
         }
         for (const line of renderPostureLines(
             enabledMembers.map(([n, m]) => [n, _posture(n, m)] as const),