@event4u/agent-config 14.9.0 → 14.10.0

package/dist/discovery/dormancy-report.md

@@ -1,6 +1,6 @@
 # Discovery — Dormancy Report
 
-- Generated: `2026-08-23T01:36:08Z`
+- Generated: `2026-08-23T02:30:18Z`
 - Window: **6 months** without a commit
 
 > Dormancy triggers **review, never auto-deprecation**

package/dist/discovery/orphan-report.md

@@ -1,6 +1,6 @@
 # Discovery — Orphan Report
 
-- Generated: `2026-08-23T01:36:08Z`
+- Generated: `2026-08-23T02:30:18Z`
 - Orphan artefacts: **0**
 
 > An orphan is an artefact whose declared pack has no other members.

package/dist/discovery/packs.json

@@ -1,6 +1,6 @@
 {
-  "checksum": "sha256:9317e131726d366f7508a28af162952845a4a5bbfdd0fee947504b3be5538ba4",
-  "generated_at": "2026-08-23T01:36:08Z",
+  "checksum": "sha256:b5481a95fd4f5f0901fb80d9993f809fa9f890c7ff18e6fc9b863356b5037a73",
+  "generated_at": "2026-08-23T02:30:18Z",
   "packs": [
     {
       "always_on": false,

package/dist/discovery/trust-report.md

@@ -1,6 +1,6 @@
 # Discovery — Trust Report
 
-- Generated: `2026-08-23T01:36:08Z`
+- Generated: `2026-08-23T02:30:18Z`
 - Workspaces tracked: **10**
 - Human-review-required artefacts: **3**
 

package/dist/discovery/workspaces.json

@@ -1,6 +1,6 @@
 {
-  "checksum": "sha256:9317e131726d366f7508a28af162952845a4a5bbfdd0fee947504b3be5538ba4",
-  "generated_at": "2026-08-23T01:36:08Z",
+  "checksum": "sha256:b5481a95fd4f5f0901fb80d9993f809fa9f890c7ff18e6fc9b863356b5037a73",
+  "generated_at": "2026-08-23T02:30:18Z",
   "scanner_version": "de0a22b4ac4c",
   "workspaces": [
     {

package/dist/mcp/registry-manifest.json

@@ -9,7 +9,7 @@
     "homepage": "https://event4u-app.github.io/agent-config",
     "name": "@event4u/agent-config",
     "repository": "https://github.com/event4u-app/agent-config",
-    "version": "14.9.0"
+    "version": "14.10.0"
   },
   "registries": [
     {

package/dist/mcp/server.json

@@ -9,12 +9,12 @@
       "transport": {
         "type": "stdio"
       },
-      "version": "14.9.0"
+      "version": "14.10.0"
     }
   ],
   "repository": {
     "source": "github",
     "url": "https://github.com/event4u-app/agent-config"
   },
-  "version": "14.9.0"
+  "version": "14.10.0"
 }

package/package.json

@@ -1,7 +1,7 @@
 {
     "name": "@event4u/agent-config",
     "mcpName": "io.github.event4u-app/agent-config",
-    "version": "14.9.0",
+    "version": "14.10.0",
     "description": "Governed skills, rules and commands for AI coding tools (Claude Code, Cursor, Windsurf, Copilot) — every claim machine-checked, including \"zero runtime daemon\".",
     "license": "MIT",
     "private": false,

package/src/config/gate-coverage.yml

@@ -297,6 +297,26 @@ gates:
     no_canary_reason: >-
       the violation is a MODIFICATION, not a creation: this gate reds when package.json `files[]` or `.npmignore` changes and the committed artefact does not, and the canary contract is create-only. A planted FILE cannot move either surface — the closest it gets is changing the payload-derived shadowed set, which is informational and deliberately excluded from the drift verdict, so a plant would leave the gate green and be reported as dead. Discrimination is proven by the gate's own `--self-test` (8 cases, 5 rejecting) over the pattern matcher, and end to end by hand: editing `files[]` alone exits 1, regenerating exits 0, editing `.npmignore` alone exits 1, restoring exits 0.
 
+  - id: check_pack_passport_reconciliation
+    argv: []
+    min_scanned: 15
+    corpus: "the generated token_passport block in every src/packs/*/pack.yaml (17 at registration)"
+    status: enforced
+    no_canary_reason: >-
+      this is a LISTING, not an enforcement: `main()` returns 0 on every path by design, so no planted file can make it red and the harness's "caught the planted defect" observation is unreachable by construction. It is registered for its `scanned:` floor, which is the one thing about it that CAN break — a passport block that stops being generated, or a packs root that moves. Discrimination is proven by the gate's own `--self-test` (6 cases, 3 rejecting) over the two pure units behind the number: the passport parser and the reconciliation ratio.
+    note: >
+      Registered because it emits the `scanned:` contract line, and a test in
+      this tree requires every emitter to be registered — it caught this entry
+      being absent, which is the coverage register working as intended.
+
+      It exits 0 on a large gap ON PURPOSE. The ±10 % band it was specified with
+      assumed packs roughly PARTITION the tree; measured, `dependencies` claims
+      4 skills and 0 rules against 291 and 118, so gaps of 84 % and above are a
+      property of the tree rather than a defect. A gate red by construction gets
+      disabled rather than fixed, so this reports coverage instead. The condition
+      that would make the exit code follow the band — pack coverage approaching
+      the tree — is recorded in docs/contracts/pack-token-passport.md.
+
   - id: check_gate_completeness
     argv: []
     min_scanned: 180

package/src/config/preamble-payload-budget.json

@@ -1,72 +1,76 @@
 {
-    "_comment": "Per-spawn preamble payload ceiling (road-to-cache-economy Phase 3), unblocked by C-3 measuring 38.0% against a 15% bar. This is a RATCHET, not the roadmap's literal candidate numbers: those (median 40k / p95 50k) were anchored to an upstream ~37k baseline, while this package's own deterministic in-repo payload is ~102.5k tokens — a hard 40k gate would be red on the day it lands and would teach the reader to ignore it. The ratchet fails on GROWTH instead, so the number can only walk down, and the 40k/50k target stays recorded as the destination. Only the deterministic, in-repo buckets are gated: user-scope rules depend on what the developer happens to have installed globally and are therefore not CI-checkable.",
-    "schema_version": 1,
-    "registered_at": "2026-07-30",
-    "owner": "maintainer",
-    "review_by": "2027-07-30",
-    "metric": {
-        "basis": "chars/4 token estimate over the projected tree, produced by src/scripts/preamble_byte_census.ts",
-        "gated_buckets": [
-            "project-scope rules (dist/agent-src/rules/*.md)",
-            "preloaded skills catalog (name + description, dist/agent-src/skills)",
-            "CLAUDE.md hierarchy (project + project-local)"
-        ],
-        "excluded_buckets": [
-            "user-scope rules (~/.claude/rules/*.md) — machine-dependent, not CI-checkable",
-            "tool definitions + dispatch prompt — no local source carries the request payload; the census reports it as an explicit residual"
-        ]
-    },
-    "baseline_tokens": 102520,
-    "baseline_history": [
-        {
-            "tokens": 102599,
-            "at": "2026-07-30",
-            "why": "registered with the gate"
-        },
-        {
-            "tokens": 102520,
-            "at": "2026-07-31",
-            "why": "free tightening: the measured tree came in 79 tok under the registered baseline, so the ratchet walks down to meet it. Not a claimed reduction — nothing was optimised; the point of a ratchet is that a lower measurement becomes the new ceiling instead of becoming unused headroom."
-        }
+  "_comment": "Per-spawn preamble payload ceiling (road-to-cache-economy Phase 3), unblocked by C-3 measuring 38.0% against a 15% bar. This is a RATCHET, not the roadmap's literal candidate numbers: those (median 40k / p95 50k) were anchored to an upstream ~37k baseline, while this package's own deterministic in-repo payload is ~102.5k tokens \u2014 a hard 40k gate would be red on the day it lands and would teach the reader to ignore it. The ratchet fails on GROWTH instead, so the number can only walk down, and the 40k/50k target stays recorded as the destination. Only the deterministic, in-repo buckets are gated: user-scope rules depend on what the developer happens to have installed globally and are therefore not CI-checkable.",
+  "schema_version": 1,
+  "registered_at": "2026-07-30",
+  "owner": "maintainer",
+  "review_by": "2027-07-30",
+  "metric": {
+    "basis": "chars/4 token estimate over the projected tree, produced by src/scripts/preamble_byte_census.ts",
+    "gated_buckets": [
+      "project-scope rules (dist/agent-src/rules/*.md)",
+      "preloaded skills catalog (name + description, dist/agent-src/skills)",
+      "CLAUDE.md hierarchy (project + project-local)"
     ],
-    "headroom_pct": 5,
-    "target_tokens": {
-        "median": 40000,
-        "p95": 50000,
-        "_comment": "The roadmap's candidate numbers, kept as the destination. Reaching them needs reductions this package has not built yet; scope-dedup (C-3) removes a redundant COPY at the consumer, it does not shrink the suite itself."
-    },
-    "target_schedule": {
-        "_comment": "road-to-inbox-harvest-2026-08-d-context-ledger Step 5.3. The target above was a destination with no route: the ratchet fails on GROWTH only, so the corpus can drift away from 40k indefinitely without any gate objecting. These milestones give the destination a schedule. They are DATES WITH NUMBERS, not a derivation - no measurement in this tree says the estate can reach 85k by a given day, and pretending otherwise would be the invented-threshold failure this file's own baseline_history is careful to avoid. What they buy is that a miss becomes a published fact with an owner instead of a silent drift.",
-        "owner": "maintainer",
-        "measured_at_registration": {
-            "tokens": 125593,
-            "at": "2026-08-15",
-            "note": "MEASURED total at registration time, from check_preamble_payload_budget. It is ~23k ABOVE both baseline_tokens (102520) and the derived ceiling, i.e. the gate is red on the tree as it stands. The baseline is deliberately NOT raised to meet it - raising a ratchet baseline to clear a failing check is the config-weakening move this repo blocks by construction. It is recorded here so the milestones below are planned against the real starting point rather than a stale one. Per-rule ranking: agents/evidence/analysis/rule-paths-coverage-census.md"
-        },
-        "milestones": [
-            {
-                "by": "2026-11-10",
-                "tokens": 102520,
-                "why": "Return to the registered baseline. This is a RECOVERY milestone, not progress toward 40k - it undoes drift rather than shrinking the estate. The date is the review_by both budget files already carry, so it needs no new calendar."
-            },
-            {
-                "by": "2027-02-10",
-                "tokens": 85000,
-                "why": "First real reduction. The rule-paths census shows 92.1% of rule weight sits in the auto tier and the top 20 files carry 35.5% of it, so a scoped tranche is the plausible mechanism - GATED on the paths-scoping consumer decision, which is a human call and may resolve against scoping entirely."
-            },
-            {
-                "by": "2027-05-10",
-                "tokens": 60000,
-                "why": "Second reduction. No mechanism is committed for this one; it exists so the destination keeps a date after the first tranche lands, and it is the milestone most likely to be revised on evidence."
-            }
-        ],
-        "on_miss": "A missed milestone is PUBLISHED - recorded here with the measured number and the reason - and never silently re-dated. Two consecutive misses mean the schedule was wrong or the destination is unreachable with the mechanisms available; either outcome is a decision to surface, not a date to move again.",
-        "revisit_if": "The paths-scoping decision resolves against scoping (removing the only named mechanism for the 85k milestone), or a measured reduction lands ahead of schedule and the remaining milestones are re-derived from it."
+    "excluded_buckets": [
+      "user-scope rules (~/.claude/rules/*.md) \u2014 machine-dependent, not CI-checkable",
+      "tool definitions + dispatch prompt \u2014 no local source carries the request payload; the census reports it as an explicit residual",
+      "personas (src/agent-src/personas, 36 files, ~37,181 tok) \u2014 measured ZERO standing cost 2026-08-22: .claude/personas/ is written by this repo's generators (5 in-repo references) and read by no host contract; the host's real subagent surface is .claude/agents/, which this package writes 1 file into. Reversal condition: a host publishing a personas contract, or a generator folding persona prose into an instruction file that IS read. Evidence: agents/evidence/analysis/uncounted-prose-corpora-load-semantics.md",
+      "contexts (src/agent-src/contexts, 58 files, ~114,042 tok) \u2014 measured ON-DEMAND 2026-08-22: 0 rules declare load_context_eager: (17 declare the lazy load_context:), and rule.schema.json:49 documents eager as the variant that counts against the per-rule budget. This records that no eager declaration exists, NOT that eager loading would be free \u2014 nobody has declared one, so nobody has measured it. Evidence: agents/evidence/analysis/uncounted-prose-corpora-load-semantics.md",
+      "skill bodies (src/skills/*/SKILL.md, 290 files, ~595,843 tok) \u2014 measured ON-DEMAND 2026-08-22: censusSkillsCatalog (preamble_byte_census.ts:216-234) builds the gated catalog bucket from `- name: description` per skill and reads no body byte, which is why 290 skills totalling ~595,843 tok report as ~14.4k standing. Corollary: the description cap is the WHOLE skill-side lever, not a fragment of it. Evidence: agents/evidence/analysis/uncounted-prose-corpora-load-semantics.md"
+    ],
+    "_bucket_classification_note": "All three additions above are EXCLUSIONS, not gated buckets, and that is the finding rather than a shortcut. A census bucket over a corpus measured at zero is a permanently green gate certifying nothing. The exclusions carry their measurement so the next pass that proposes one of these corpora as a token lever meets the number instead of the silence."
+  },
+  "baseline_tokens": 102520,
+  "baseline_history": [
+    {
+      "tokens": 102599,
+      "at": "2026-07-30",
+      "why": "registered with the gate"
     },
-    "reference_measurements": {
-        "measured_cold_start_median_tokens": 230930,
-        "c3_scope_dedup_reduction_pct": 38,
-        "c3_condition": "FIXTURE-ONLY as of 2026-07-31: the 38% was measured on a byte-identical two-scope fixture, and that condition is currently unreachable for every consumer because install.ts:2723/2725 stamp package:/source_path: into every installed rule while the in-repo projection stamps nothing. Aligning versions yields 0/110 twins, not 110/110. The figure is the mechanism's ceiling, NOT a realised saving, and this baseline therefore assumes no dedup. Reachability is the subject of road-to-dedup-reachability; run measure_scope_dedup for the live split.",
-        "_comment": "The measured median comes from Claude Code transcripts (deduped by message.id + requestId) and is context for the ratchet, never the gated number — it moves with the developer's own session history."
+    {
+      "tokens": 102520,
+      "at": "2026-07-31",
+      "why": "free tightening: the measured tree came in 79 tok under the registered baseline, so the ratchet walks down to meet it. Not a claimed reduction \u2014 nothing was optimised; the point of a ratchet is that a lower measurement becomes the new ceiling instead of becoming unused headroom."
     }
+  ],
+  "headroom_pct": 5,
+  "target_tokens": {
+    "median": 40000,
+    "p95": 50000,
+    "_comment": "The roadmap's candidate numbers, kept as the destination. Reaching them needs reductions this package has not built yet; scope-dedup (C-3) removes a redundant COPY at the consumer, it does not shrink the suite itself."
+  },
+  "target_schedule": {
+    "_comment": "road-to-inbox-harvest-2026-08-d-context-ledger Step 5.3. The target above was a destination with no route: the ratchet fails on GROWTH only, so the corpus can drift away from 40k indefinitely without any gate objecting. These milestones give the destination a schedule. They are DATES WITH NUMBERS, not a derivation - no measurement in this tree says the estate can reach 85k by a given day, and pretending otherwise would be the invented-threshold failure this file's own baseline_history is careful to avoid. What they buy is that a miss becomes a published fact with an owner instead of a silent drift.",
+    "owner": "maintainer",
+    "measured_at_registration": {
+      "tokens": 125593,
+      "at": "2026-08-15",
+      "note": "MEASURED total at registration time, from check_preamble_payload_budget. It is ~23k ABOVE both baseline_tokens (102520) and the derived ceiling, i.e. the gate is red on the tree as it stands. The baseline is deliberately NOT raised to meet it - raising a ratchet baseline to clear a failing check is the config-weakening move this repo blocks by construction. It is recorded here so the milestones below are planned against the real starting point rather than a stale one. Per-rule ranking: agents/evidence/analysis/rule-paths-coverage-census.md"
+    },
+    "milestones": [
+      {
+        "by": "2026-11-10",
+        "tokens": 102520,
+        "why": "Return to the registered baseline. This is a RECOVERY milestone, not progress toward 40k - it undoes drift rather than shrinking the estate. The date is the review_by both budget files already carry, so it needs no new calendar."
+      },
+      {
+        "by": "2027-02-10",
+        "tokens": 85000,
+        "why": "First real reduction. The rule-paths census shows 92.1% of rule weight sits in the auto tier and the top 20 files carry 35.5% of it, so a scoped tranche is the plausible mechanism - GATED on the paths-scoping consumer decision, which is a human call and may resolve against scoping entirely."
+      },
+      {
+        "by": "2027-05-10",
+        "tokens": 60000,
+        "why": "Second reduction. No mechanism is committed for this one; it exists so the destination keeps a date after the first tranche lands, and it is the milestone most likely to be revised on evidence."
+      }
+    ],
+    "on_miss": "A missed milestone is PUBLISHED - recorded here with the measured number and the reason - and never silently re-dated. Two consecutive misses mean the schedule was wrong or the destination is unreachable with the mechanisms available; either outcome is a decision to surface, not a date to move again.",
+    "revisit_if": "The paths-scoping decision resolves against scoping (removing the only named mechanism for the 85k milestone), or a measured reduction lands ahead of schedule and the remaining milestones are re-derived from it."
+  },
+  "reference_measurements": {
+    "measured_cold_start_median_tokens": 230930,
+    "c3_scope_dedup_reduction_pct": 38,
+    "c3_condition": "FIXTURE-ONLY as of 2026-07-31: the 38% was measured on a byte-identical two-scope fixture, and that condition is currently unreachable for every consumer because install.ts:2723/2725 stamp package:/source_path: into every installed rule while the in-repo projection stamps nothing. Aligning versions yields 0/110 twins, not 110/110. The figure is the mechanism's ceiling, NOT a realised saving, and this baseline therefore assumes no dedup. Reachability is the subject of road-to-dedup-reachability; run measure_scope_dedup for the live split.",
+    "_comment": "The measured median comes from Claude Code transcripts (deduped by message.id + requestId) and is context for the ratchet, never the gated number \u2014 it moves with the developer's own session history."
+  }
 }

package/src/scripts/ai_council/seating.ts

@@ -0,0 +1,211 @@
+/**
+ * Who is seated for a run, decided once and frozen.
+ *
+ * Selection today is config-static ask-all: every enabled member, every
+ * question, no per-question seating. This adds an OPTIONAL declaration of what
+ * a run wants from its seats, and computes the answer once.
+ *
+ * FAMILY DIVERSITY ONLY — no band ordering. `blocker: b-ladder-order-benchmark-spend`
+ * was resolved (b) on 2026-08-22: nothing in this tree establishes that a higher
+ * capability band reviews better, the archived benchmark substrate would have to
+ * be re-run to support it, and the council that would have decided otherwise had
+ * no quota. So `tier` keeps its single documented meaning — a capability rank
+ * read only as a chairman-selection input — and nothing here reads it. A seat
+ * declaration carries MISSION, never RANK.
+ *
+ * "Family" is the PROVIDER, not a capability band. For a council, diversity means
+ * independent providers: two Claude bands share a vendor, a training pipeline and
+ * a failure mode, so seating `opus` beside `sonnet` buys none of what a second
+ * opinion is for. (`MODEL_FAMILIES` in the orchestration-record hook enumerates
+ * Claude bands for a different purpose — token attribution — and is deliberately
+ * not reused here.)
+ *
+ * Absent declaration ⇒ today's behaviour, byte-identical. That is asserted by a
+ * test rather than intended.
+ */
+import type { MemberConfig } from './config.js';
+
+/** A member's provider family. The map key IS the provider in this config shape. */
+export function familyOf(member: MemberConfig): string {
+    return member.name;
+}
+
+/**
+ * Read the optional `seat_constraints:` block out of a raw council config.
+ *
+ * DELIBERATELY NOT A FIELD ON `CouncilConfig`, and the reason is a ratchet
+ * rather than a design preference. `config.ts` is 2,205 lines — 705 over the
+ * 1,500-line source-size line — and `check_source_size_budget` counts only the
+ * excess above that line, so the 39 lines this feature first added there were a
+ * straight +39 against a shrink-only baseline. The gate's own message is
+ * explicit that raising the baseline is "a defect, not a fix". Extraction is the
+ * sanctioned repair, and this file is 169 lines, so the same code costs nothing
+ * here.
+ *
+ * THE TRADE-OFF, stated rather than buried: validation moves from LOAD time to
+ * READ time. A malformed `min_families` no longer fails the moment the config
+ * is parsed; it fails when a caller asks for the constraints. Today that
+ * difference is unobservable — Phase 2 ships the DECLARATION and no caller
+ * reads it yet — but it is a real change in when a bad config is caught, and
+ * whoever wires the first caller should call this at run start so the failure
+ * lands before any seat is used.
+ *
+ * Fails CLOSED on a malformed value rather than falling back to absent: a run
+ * that declared a diversity floor and silently got none is the exact silent
+ * fallback the degradation line exists to prevent.
+ */
+export function readSeatConstraints(raw: unknown, label = 'seat_constraints'): SeatConstraints {
+    if (raw === null || raw === undefined) return {};
+    if (typeof raw !== 'object' || Array.isArray(raw)) {
+        throw new TypeError(`${label} must be a mapping (got ${typeof raw}).`);
+    }
+    const block = (raw as Record<string, unknown>)['seat_constraints'] ?? raw;
+    if (block === null || block === undefined) return {};
+    if (typeof block !== 'object' || Array.isArray(block)) {
+        throw new TypeError(`${label} must be a mapping (got ${typeof block}).`);
+    }
+    const mf = (block as Record<string, unknown>)['min_families'];
+    if (mf === null || mf === undefined) return {};
+    if (typeof mf !== 'number' || !Number.isInteger(mf) || mf < 1) {
+        throw new TypeError(`${label}.min_families must be an integer >= 1 when set (got ${String(mf)}).`);
+    }
+    return { min_families: mf };
+}
+
+export interface SeatConstraints {
+    /**
+     * Minimum distinct provider families the run wants seated.
+     *
+     * Absent (or 1) ⇒ no constraint and no degradation line: ask-all, unchanged.
+     */
+    readonly min_families?: number;
+}
+
+export interface Seating {
+    /** The seated members, in deterministic config order. */
+    readonly seats: readonly MemberConfig[];
+    /** Distinct families actually seated. */
+    readonly families: readonly string[];
+    /**
+     * Exactly ONE line when the constraint could not be met, `null` otherwise.
+     *
+     * One line, not a wall: a degradation nobody reads is the same as a silent
+     * fallback, and N warnings is how a reader learns to skip the header.
+     */
+    readonly degraded: string | null;
+}
+
+/**
+ * Compute the seating once.
+ *
+ * Deterministic and side-effect-free: the same members and constraints always
+ * produce the same seats, which is what makes freezing it meaningful. Seating
+ * that changed between round 1 and round 3 would silently invalidate the
+ * anonymised-peer-reply contract the council skill depends on — a "reviewer B"
+ * in round 3 that is not the "reviewer B" of round 1 makes every cross-reference
+ * in the synthesis wrong while looking fine.
+ */
+export function resolveSeating(
+    members: readonly MemberConfig[],
+    constraints: SeatConstraints = {},
+): Seating {
+    const enabled = members.filter((m) => m.enabled);
+    const families = [...new Set(enabled.map(familyOf))];
+    const want = constraints.min_families ?? 1;
+
+    if (want <= 1 || families.length >= want) {
+        return { seats: enabled, families, degraded: null };
+    }
+    return {
+        seats: enabled,
+        families,
+        degraded:
+            `tier-degraded: asked for ${String(want)} model families, seated ${String(families.length)} ` +
+            `(${families.join(', ')}). The run proceeds with what is enabled — a council that refused to ` +
+            `convene on a diversity shortfall would fail closed on the common single-provider install, ` +
+            `which is worse than a stated shortfall.`,
+    };
+}
+
+/**
+ * Freeze a seating so a later config mutation cannot change it.
+ *
+ * Returns a structurally frozen snapshot. This is the mechanism behind "resolve
+ * once per run": the caller resolves at run start, freezes, and passes the
+ * snapshot down — so there is no path by which round 3 re-reads the config.
+ */
+export function freezeSeating(s: Seating): Seating {
+    return Object.freeze({
+        seats: Object.freeze([...s.seats]),
+        families: Object.freeze([...s.families]),
+        degraded: s.degraded,
+    });
+}
+
+/**
+ * Vendor sentinels and "latest in band" aliases — an id that cannot go stale.
+ *
+ * Read from the providers' own CLI surfaces on 2026-08-22, never from recall:
+ * `claude --help` documents 'fable', 'opus' and 'sonnet' as aliases for the
+ * latest model in their band, and `codex-default` is the openai transport's
+ * documented "let the CLI choose".
+ */
+export const ADMISSIBLE_SENTINELS: ReadonlySet<string> = new Set([
+    'codex-default',
+    'fable',
+    'opus',
+    'sonnet',
+    'haiku',
+]);
+
+export interface AdmissibilityResult {
+    readonly admissible: boolean;
+    readonly reason: string | null;
+}
+
+/**
+ * Is this member's `model:` id from an admissible SOURCE?
+ *
+ * THE CRITERION AS WRITTEN COULD NOT BE IMPLEMENTED, and the deviation is
+ * recorded here rather than papered over. The roadmap step says a declared seat
+ * "resolves through the shipped `model_tier` bands; a model id that no tier maps
+ * to is rejected at config load". But `TIER_TO_CLAUDE_MODEL`
+ * (`_lib/model_tier.ts:36-41`) maps tiers onto CLAUDE aliases only — there is no
+ * entry any `gemini-*`, `grok-*` or `sonar-*` id could resolve through. Taken
+ * literally, that rule rejects every non-anthropic member in the shipped starter
+ * config, i.e. it fails closed on a valid config.
+ *
+ * What the step is actually protecting is stated in its own title: "including
+ * the host's own recall". The failure mode is a plausible-sounding model id
+ * TYPED FROM MEMORY, which is indistinguishable from a real one at review time
+ * and would silently undo the pin refresh. So admissibility is checked against
+ * the SOURCE of the id, over the two things this tree can actually verify:
+ *
+ *   1. a vendor sentinel or documented "latest in band" alias — cannot go stale,
+ *      and read from the provider's own surface; or
+ *   2. a dated pin carrying a `verified_at` stamp — which records that a human
+ *      looked at the provider's surface on a named date, and which
+ *      `check_council_pin_staleness` ages out.
+ *
+ * An id that is neither is exactly the recall case: a bare dated id nobody
+ * recorded checking.
+ */
+export function checkModelAdmissibility(member: MemberConfig): AdmissibilityResult {
+    const id = member.model.trim().toLowerCase();
+    if (ADMISSIBLE_SENTINELS.has(id)) {
+        return { admissible: true, reason: null };
+    }
+    if (member.verified_at !== null && member.verified_at !== undefined) {
+        return { admissible: true, reason: null };
+    }
+    return {
+        admissible: false,
+        reason:
+            `members.${member.name}.model is '${member.model}' — a dated id with no verified_at stamp. ` +
+            `An id must come from a source this tree can check: a vendor sentinel or documented ` +
+            `"latest in band" alias (${[...ADMISSIBLE_SENTINELS].join(', ')} — see src/scripts/_lib/model_tier.ts ` +
+            `for the tier vocabulary these bands come from), or a pin carrying verified_at: "YYYY-MM-DD" ` +
+            `recorded from the provider's own surface. A model id remembered rather than read is not an ` +
+            `admissible source, and is indistinguishable from a real one at review time.`,
+    };
+}