@event4u/agent-config 14.20.0 → 14.21.0

package/src/scripts/check_branch_work_committed.ts

@@ -0,0 +1,234 @@
+/**
+ * Refuse a push that leaves this branch's OWN work uncommitted.
+ *
+ * The defect, measured on 2026-09-07 in `fix/release-obligation-answerable`:
+ * a merge-reconciliation baseline was computed, written into
+ * `gate-violation-baselines.json` AFTER `git add`, and then committed with
+ * `git commit --no-edit` — which captured the STAGED side. The reconciled
+ * number stayed in the working tree, the push went out without it, and the
+ * pushed branch asserted a baseline the tree contradicted. The operator found
+ * it, not the pipeline.
+ *
+ * Nothing in CI can catch this class: CI checks out the pushed commit, where
+ * the working tree that holds the lost edit does not exist. The only place the
+ * evidence is available is the machine doing the push, which is why this gate
+ * is pre-push and local-only — the same reach `check_branch_freshness` has.
+ *
+ * The discriminator, whose work is it:
+ *
+ * A dirty tree at push time is not automatically a defect. Gate scripts write
+ * reports, a parallel session may touch a shared file, a test run leaves
+ * artifacts. Blocking on all of it would train the operator to set the skip
+ * variable, which is worse than no gate.
+ *
+ * So the split is by AUTHORSHIP, and it is decidable from git alone:
+ *
+ *   1. INDEX/WORKTREE DIVERGENCE (`MM`, `AM`, `RM`, …) — the file is staged
+ *      AND changed again since. That is "edited after `git add`" as a fact, not
+ *      an inference, and it is exactly the shape that produced the defect.
+ *   2. STAGED AT ALL — `git add` is a recorded intent to ship the file, and a
+ *      push carries commits rather than the index, so a staged-but-uncommitted
+ *      path is this branch's work being left behind by definition. No
+ *      authorship inference is needed for this class.
+ *   3. A DIRTY FILE THIS BRANCH'S OWN COMMITS TOUCHED — the branch has been
+ *      editing it deliberately, so an open change to it is this branch's
+ *      unfinished work rather than someone else's noise.
+ *   4. EVERYTHING ELSE — a dirty file the branch never committed, or an
+ *      untracked file. Reported by name, never blocking: this is where a
+ *      parallel session's edit and a gate script's own report output land, and
+ *      the branch has no claim on either.
+ *
+ * Class 4 is advisory, and the residual limit is stated rather than hidden: a
+ * file this branch created and has neither staged nor committed is
+ * indistinguishable from a foreign untracked file. Class 2 closes it at the
+ * first `git add` — which was itself a finding of testing this gate against the
+ * live tree, where its own source file sat in class 4 until the rule was
+ * widened.
+ */
+import * as path from 'node:path';
+import process from 'node:process';
+import { spawnSync } from 'node:child_process';
+import { fileURLToPath } from 'node:url';
+
+import { reportScanned } from './_lib/scan_scope.js';
+
+const _HERE = fileURLToPath(import.meta.url);
+const REPO_ROOT = path.resolve(path.dirname(_HERE), '..', '..');
+
+export interface WorkVerdict {
+    /** False when the push must be refused. */
+    ok: boolean;
+    /** Files that are this branch's own unfinished work, with the reason. */
+    blocking: { path: string; why: string }[];
+    /** Files that are dirty but not this branch's to answer for. */
+    advisory: string[];
+}
+
+/** One `git status --porcelain` row. */
+interface StatusRow {
+    index: string;
+    worktree: string;
+    path: string;
+}
+
+export function parsePorcelain(porcelain: string): StatusRow[] {
+    const out: StatusRow[] = [];
+    for (const line of porcelain.split('\n')) {
+        if (line.length < 4) continue;
+        const index = line[0] as string;
+        const worktree = line[1] as string;
+        let p = line.slice(3);
+        // Renames read `R  old -> new`; the new path is the one that matters.
+        const arrow = p.indexOf(' -> ');
+        if (arrow !== -1) p = p.slice(arrow + 4);
+        out.push({ index, worktree, path: p.replace(/^"|"$/gu, '') });
+    }
+    return out;
+}
+
+/**
+ * The verdict, as a pure function of the two git readings — so the rules are
+ * unit-testable without a repository, the shape `confirmGate` and
+ * `preflightPosition` already use in this pipeline.
+ */
+export function classifyBranchWork(opts: {
+    porcelain: string;
+    /** Files this branch's own commits touched (`git diff --name-only base..HEAD`). */
+    branchFiles: readonly string[];
+}): WorkVerdict {
+    const touched = new Set(opts.branchFiles);
+    const blocking: { path: string; why: string }[] = [];
+    const advisory: string[] = [];
+
+    for (const row of parsePorcelain(opts.porcelain)) {
+        const untracked = row.index === '?' && row.worktree === '?';
+        const staged = row.index !== ' ' && !untracked;
+        const dirty = row.worktree !== ' ' && !untracked;
+
+        if (staged && dirty) {
+            blocking.push({
+                path: row.path,
+                why: 'staged AND changed again since — edited after `git add`, so the commit would capture the stale side',
+            });
+            continue;
+        }
+        if (staged) {
+            blocking.push({
+                path: row.path,
+                why: 'staged but never committed — `git add` records the intent to ship it, and a push carries commits, not the index',
+            });
+            continue;
+        }
+        if (dirty && touched.has(row.path)) {
+            blocking.push({
+                path: row.path,
+                why: "this branch's own commits touch this file, so an open change to it is unfinished work from this branch",
+            });
+            continue;
+        }
+        advisory.push(row.path);
+    }
+    return { ok: blocking.length === 0, blocking, advisory };
+}
+
+function git(args: readonly string[]): string {
+    const r = spawnSync('git', args, { cwd: REPO_ROOT, encoding: 'utf-8' });
+    return r.status === 0 ? (r.stdout ?? '') : '';
+}
+
+/** Files this branch's commits touched, relative to where it left the base. */
+export function branchOwnFiles(baseRef: string): string[] {
+    const base = git(['merge-base', baseRef, 'HEAD']).trim();
+    if (base === '') return [];
+    return git(['diff', '--name-only', `${base}..HEAD`])
+        .split('\n')
+        .filter((l) => l.trim() !== '');
+}
+
+export function main(argv: readonly string[]): number {
+    const quiet = argv.includes('--quiet');
+    let baseRef = 'origin/main';
+    const bi = argv.indexOf('--base');
+    if (bi !== -1 && argv[bi + 1]) baseRef = argv[bi + 1] as string;
+
+    const porcelain = git(['status', '--porcelain']);
+    const verdict = classifyBranchWork({ porcelain, branchFiles: branchOwnFiles(baseRef) });
+
+    // Through the shared reporter, not a hand-written line: `check_gate_coverage`
+    // reads the CALL, and a printed `scanned:` string satisfies the eye while
+    // leaving the gate unhardened (measured — this gate reded that ratchet on
+    // its first CI run for exactly that reason).
+    //
+    // Zero rows is the GOOD state here, which inverts the usual dead-scope
+    // reasoning: for every other gate an empty corpus may mean the root moved,
+    // while for this one it means the operator has nothing outstanding. The
+    // scope cannot go dead either — `git status` is the corpus, and a reading it
+    // could not produce comes back as an empty string from a non-zero exit,
+    // which is indistinguishable from clean and is why the reason below is
+    // stated rather than left implicit.
+    reportScanned({
+        gate: 'check_branch_work_committed',
+        scanned: parsePorcelain(porcelain).length,
+        units: 'dirty path(s)',
+        roots: ['git status --porcelain'],
+        allowEmpty:
+            'EMPTY_VALID: a clean working tree is this gate\'s PASSING state, not a dead scope. ' +
+            'The corpus is git\'s own status output over the whole repository, so there is no ' +
+            'root to move; zero rows means the operator has committed everything, which is the ' +
+            'outcome the gate exists to produce.',
+    });
+
+    if (verdict.ok) {
+        if (!quiet) {
+            process.stdout.write(
+                `✅  check_branch_work_committed: nothing of this branch's own work is uncommitted` +
+                    (verdict.advisory.length > 0
+                        ? ` (${String(verdict.advisory.length)} unrelated dirty path(s) left alone)\n`
+                        : '\n'),
+            );
+        }
+        if (verdict.advisory.length > 0 && !quiet) {
+            for (const p of verdict.advisory) {
+                process.stdout.write(`    ·  ${p} — not touched by this branch's commits\n`);
+            }
+        }
+        return 0;
+    }
+
+    process.stderr.write(
+        `❌  check_branch_work_committed: ${String(verdict.blocking.length)} file(s) carry this ` +
+            "branch's own uncommitted work:\n",
+    );
+    for (const b of verdict.blocking) {
+        process.stderr.write(`    - ${b.path}\n        ${b.why}\n`);
+    }
+    process.stderr.write(
+        '    A push that leaves them behind ships a branch whose tree contradicts its own\n' +
+            '    commits, and NO CI gate can see it — CI checks out the commit, never the tree\n' +
+            '    the edit is sitting in.\n' +
+            '    Commit them (or `git restore` what was not meant to land), then push again.\n' +
+            '    Genuinely foreign changes are reported without blocking; if one of these is\n' +
+            "    truly a parallel session's, commit around it with an explicit pathspec.\n" +
+            '    WIP push: AGENT_CONFIG_SKIP_PREPUSH_WORKTREE=1.\n',
+    );
+    if (verdict.advisory.length > 0) {
+        process.stderr.write(
+            `    Left alone (${String(verdict.advisory.length)}): ${verdict.advisory.join(', ')}\n`,
+        );
+    }
+    return 1;
+}
+
+const _isMain = (() => {
+    const entry = process.argv[1];
+    if (!entry) return false;
+    try {
+        return path.resolve(entry) === path.resolve(_HERE);
+    } catch {
+        return false;
+    }
+})();
+
+if (_isMain) {
+    process.exit(main(process.argv.slice(2)));
+}

package/src/scripts/check_pack_size.ts

@@ -319,7 +319,7 @@ 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: 'fdf6334f2342a48faaea708fd43853066f7057e528dfd1dd6fb5dcf8c0f67845', path: 'agents/templates/.ai-council.yml.example', size: 29872, why: 'shipped council config TEMPLATE — a dotfile because the file it is copied to is one' },
+    { 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' },

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),