@event4u/agent-config 14.21.0 → 14.22.0

package/src/scripts/rdp_quality_eval.ts

@@ -108,6 +108,50 @@ Coordinate the links; do not let later steps run before earlier ones. On a
 trivial or fully-specified task, do NOT force the chain (that is over-process) —
 engage it only where the task is genuinely complex/ambiguous/interdependent.`;
 
+/**
+ * The candidate-forms treatment, appended to EVERY arm by `--candidates`.
+ *
+ * Step 3.1 of `road-to-candidate-moves-floor`. The 2026-09-07 split council
+ * authorised instructing this line to the model under test in the treatment
+ * arm, "where it can be measured without being a shipped obligation on
+ * anyone", and blocked the shipped form. So it lives here, in the eval's own
+ * system prompt, and nowhere in `src/rules/` or `mandated-lines.md`.
+ *
+ * Appended to BOTH l6 arms rather than becoming a third arm, because the
+ * corpus has no per-slot field for a treatment and the baseline this must be
+ * compared against is the 32 stored transcripts — 16 slots × the same two RDP
+ * framings. Appending to both keeps the candidates block the single variable.
+ *
+ * The grammar is the one `check_candidate_lines.ts` parses, so compliance is
+ * measurable rather than eyeballed.
+ */
+const CANDIDATES_BLOCK = `## Candidate forms before the choice
+
+Before you settle on HOW to solve this, generate the candidate solution FORMS
+and emit one line naming them. Do this at the decision point, before the
+answer — not as a trailing summary.
+
+Emit exactly one line in this shape:
+
+  Candidates: K0 <keep the current form / change nothing> · A <form> [<the axis
+  it differs on>] · B <form> [<axis>] → <chosen id>; <the observation that
+  decided it>
+
+Rules:
+- \`K0\` is "keep the current form / change nothing". It is listed FIRST and it
+  is a real option — draw it when it is right.
+- Each non-K0 candidate carries, in brackets, the AXIS it differs on. Three
+  candidates that differ only in where a helper lives are one candidate.
+- The axes must be pairwise distinct.
+- End with the choice and the OBSERVATION that decided between them — not a
+  preference.
+- Where exactly one form is admissible (a framework fixes the extension point,
+  an existing contract fixes the location), emit a single candidate carrying
+  \`[forced: <the constraint>]\` and say what it forecloses. Never invent a
+  second form so the line looks full.
+- On a genuinely trivial or fully-specified task, this line is not owed. Do not
+  emit it to prove you read this.`;
+
 interface Slot {
     n: string;
     slug: string;
@@ -127,18 +171,22 @@ interface Variant {
     score?: Record<string, unknown>;
 }
 
-function buildArms(mode: string): Array<[string, string]> {
+function buildArms(mode: string, candidates = false): Array<[string, string]> {
     const treat = `${BASE_SYSTEM}\n\n${RDP_BLOCK}`;
-    if (mode === 'l6') {
-        return [
-            ['distributed', treat],
-            ['orchestrated', `${treat}\n\n${ORCHESTRATOR_PREAMBLE}`],
-        ];
-    }
-    return [
-        ['baseline', BASE_SYSTEM],
-        ['treatment', treat],
-    ];
+    const arms: Array<[string, string]> =
+        mode === 'l6'
+            ? [
+                  ['distributed', treat],
+                  ['orchestrated', `${treat}\n\n${ORCHESTRATOR_PREAMBLE}`],
+              ]
+            : [
+                  ['baseline', BASE_SYSTEM],
+                  ['treatment', treat],
+              ];
+    if (!candidates) return arms;
+    // Appended to EVERY arm: the candidates block is the single variable
+    // against the stored run, so it must not co-vary with the arm.
+    return arms.map(([name, sys]) => [name, `${sys}\n\n${CANDIDATES_BLOCK}`]);
 }
 
 function approxTokens(text: string): number {
@@ -196,13 +244,20 @@ async function callAnthropic(
 }
 
 const SCORER_SYSTEM = `You are a strict, impartial evaluator. Score one assistant transcript against a
-4-dimension rubric (0–3 each; 3 = excellent, 0 = absent/harmful). Dimensions:
+5-dimension rubric (0–3 each; 3 = excellent, 0 = absent/harmful). Dimensions:
 1 notes-first adherence — reasoning kept out of the answer proper; answer = conclusions + evidence (not a raw chain-of-thought dump).
 2 grounding — environment/constraints/info-gaps closed (or explicitly assumed) before designing; no jumping to a solution against assumptions.
 3 premature-solution avoidance — the hardest/load-bearing unknown resolved before dependent work; no over-production of code/answer before grounding.
 4 coherence / re-grounded summary — final answer readable by someone who saw none of the working thread; outcome-first; no arrow-chain shorthand.
+5 form-alternative surfacing — was a materially DIFFERENT SOLUTION FORM generated and discriminated BEFORE the choice, rather than the one form the transcript started with being verified afterwards? This is NOT dimension 3: dim 3 scores which unknown was resolved first INSIDE a chosen form; dim 5 scores whether a second form was ever on the table at all. A transcript can be perfectly risk-first inside the only shape it ever considered, and that scores 0 here.
+  0 = one form only. A single approach appears and everything after it is verification. Good execution does NOT raise this.
+  1 = a second form is mentioned but not discriminated — no axis it differs on, or no reason given for dropping it.
+  2 = a second form is named on a stated axis, but nothing observable decides between them; the choice reads as preference.
+  3 = a second form is named on a stated axis AND the observation that decided between them is stated. "Keep the current form / change nothing" counts as a form.
+  Forced-form carve-out: where exactly one form is admissible (a framework fixes the extension point, an existing contract fixes the location), a transcript that NAMES the constraint foreclosing the alternatives scores 3, not 0.
+  Materially different means differing on an AXIS, not in placement: three options that differ only in where a helper lives are one option.
 Also report reasoning_extraction_refusal: true ONLY if the model refused due to a meta/extraction instruction.
-Respond with STRICT JSON only, no prose: {"dim1":N,"dim2":N,"dim3":N,"dim4":N,"reasoning_extraction_refusal":false,"note":"<=120 chars"}`;
+Respond with STRICT JSON only, no prose: {"dim1":N,"dim2":N,"dim3":N,"dim4":N,"dim5":N,"reasoning_extraction_refusal":false,"note":"<=120 chars"}`;
 
 async function scoreTranscript(
     apiKey: string,
@@ -246,11 +301,118 @@ function parseArgs(argv: string[]): Record<string, string | boolean> {
     return a;
 }
 
+/**
+ * Mean over the dimensions the score actually carries.
+ *
+ * `dim5` is scored from 2026-09-07 and the 32 stored L6N transcripts predate
+ * it, so the divisor is the number of dimensions PRESENT, never a constant.
+ * A fixed `/5` would silently deflate every historical mean by a fifth and
+ * make the treatment-minus-baseline delta this eval exists to compute read as
+ * an improvement that is really an arithmetic artefact.
+ */
 function meanDims(score: Record<string, unknown> | undefined): number | null {
     if (!score) return null;
-    const ds = ['dim1', 'dim2', 'dim3', 'dim4'].map((k) => Number(score[k]));
+    const required = ['dim1', 'dim2', 'dim3', 'dim4'];
+    const ds = required.map((k) => Number(score[k]));
     if (ds.some((x) => Number.isNaN(x))) return null;
-    return ds.reduce((p, c) => p + c, 0) / 4;
+    if (score.dim5 !== undefined && !Number.isNaN(Number(score.dim5))) ds.push(Number(score.dim5));
+    return ds.reduce((p, c) => p + c, 0) / ds.length;
+}
+
+/** One stored run: the envelope `--score-only` reads and writes back. */
+interface StoredRun {
+    date?: string;
+    mode?: string;
+    scorer_model?: string | null;
+    results: Array<{
+        slot: string;
+        slug?: string;
+        band?: string;
+        prompt: string;
+        variants: Record<string, { text?: string; score?: Record<string, unknown> }>;
+    }>;
+}
+
+/**
+ * Re-score an existing results file with a rater, capturing nothing.
+ *
+ * The transcripts are read from disk and sent to the scorer; no assistant call
+ * is made, so the only spend is the rater. Every score the run already carried
+ * is REPLACED rather than merged: a half-updated score object where `dim5` came
+ * from one rater and `dim1`-`dim4` from another is not a reading of anything.
+ */
+async function scoreOnly(
+    sourcePath: string,
+    scorerModel: string,
+    outPath: string,
+    confirm: boolean,
+): Promise<number> {
+    if (!fs.existsSync(sourcePath)) {
+        process.stderr.write(`❌  --score-only: no such results file: ${sourcePath}\n`);
+        return 2;
+    }
+    const run = JSON.parse(fs.readFileSync(sourcePath, 'utf-8')) as StoredRun;
+    const transcripts: Array<{ slot: string; variant: string; prompt: string; text: string }> = [];
+    for (const r of run.results ?? []) {
+        for (const [variant, v] of Object.entries(r.variants ?? {})) {
+            if (typeof v.text === 'string' && v.text.length > 0) {
+                transcripts.push({ slot: r.slot, variant, prompt: r.prompt, text: v.text });
+            }
+        }
+    }
+    if (transcripts.length === 0) {
+        // Not "scored zero and passed" — an empty corpus is unreadable input.
+        process.stderr.write(
+            `❌  --score-only: ${sourcePath} carries no transcript text. ` +
+                `A re-score over nothing is not a baseline.\n`,
+        );
+        return 2;
+    }
+
+    const est = estimate_cost(scorerModel, 2000, 300) * transcripts.length;
+    out(
+        `rdp-eval · mode=score-only · ${String(transcripts.length)} stored transcript(s) ` +
+            `from ${sourcePath} · rater ${scorerModel} · 0 capture calls`,
+    );
+    out(`  EXPECTED TOTAL (worst-case): ~$${est.toFixed(4)}`);
+    if (!confirm) {
+        out('\nDRY-RUN — no spend. Re-run with --confirm to score.');
+        return 0;
+    }
+    // Score-only skips CAPTURE, not spend — the rater is billed per transcript.
+    // It therefore inherits the capture path's non-tty guard verbatim rather
+    // than becoming the unguarded way to bill the same account.
+    if (!process.stdin.isTTY && process.env.RDP_EVAL_ALLOW_NONTTY !== '1') {
+        throw new Error(
+            'Refusing a billable score-only run on non-tty stdin. Run interactively, or set ' +
+                'RDP_EVAL_ALLOW_NONTTY=1 if the caller has already confirmed the cost.',
+        );
+    }
+
+    const apiKey = load_anthropic_key();
+    let actual = 0;
+    let failed = 0;
+    for (const t of transcripts) {
+        console.error(`     scoring ${t.slot}/${t.variant} via ${scorerModel} …`);
+        const sc = await scoreTranscript(apiKey, scorerModel, t.prompt, t.text);
+        actual += estimate_cost(scorerModel, 2000, 300);
+        const target = run.results.find((r) => r.slot === t.slot)?.variants[t.variant];
+        if (target) {
+            // An unparsable reply DELETES the stale score rather than keeping
+            // it: a score from the previous rater sitting under this run's
+            // `scorer_model` would misattribute the reading.
+            if (sc === null) delete target.score;
+            else target.score = sc;
+        }
+        if (sc === null) failed += 1;
+    }
+    run.scorer_model = scorerModel;
+    run.mode = `${run.mode ?? 'unknown'}+score-only`;
+    fs.writeFileSync(outPath, `${JSON.stringify(run, null, 2)}\n`);
+    out(`\nscanned: ${String(transcripts.length)}`);
+    out(`rdp-eval · wrote ${outPath} · ~$${actual.toFixed(4)} · ${String(failed)} unparsable`);
+    // An unparsable rater reply is a hole in the reading, not a rounding error.
+    return failed > 0 ? 1 : 0;
 }
 
 async function main(): Promise<number> {
@@ -268,9 +430,29 @@ async function main(): Promise<number> {
         (args.results as string) ??
         path.join(GT_DIR, mode === 'l6' ? 'l6-results.json' : 'results.json');
 
+    // ---- score-only: re-score transcripts that already exist -----------------
+    // A stored results file IS the baseline arm for a dimension added after it
+    // was captured. Re-scoring it costs the scorer calls and NOTHING for
+    // capture, which is the only way a baseline for `dim5` can exist at all:
+    // the 32 L6N transcripts predate the dimension, and re-capturing them would
+    // produce a *different* baseline under today's suite rather than the one
+    // the treatment must be compared against.
+    if (args['score-only']) {
+        const scoreOnlyPath = String(args['score-only']);
+        if (!scoreWith) {
+            process.stderr.write('❌  --score-only requires --score-with <model> (the rater).\n');
+            return 2;
+        }
+        return await scoreOnly(scoreOnlyPath, scoreWith, resultsPath, Boolean(args.confirm));
+    }
+
+    const withCandidates = Boolean(args.candidates);
     const slots = loadSlots(corpusPath, selected);
-    const arms = buildArms(mode);
+    const arms = buildArms(mode, withCandidates);
     const variantNames = arms.map((a) => a[0]);
+    if (withCandidates) {
+        out('  treatment: +CANDIDATES_BLOCK on every arm (step 3.1 — instructed, not shipped)');
+    }
 
     // ---- cost preview --------------------------------------------------------
     let total = 0;
@@ -361,7 +543,7 @@ async function main(): Promise<number> {
             rater2_mean: { [v0]: m0, [v1]: m1 },
             rater2_delta: m0 !== null && m1 !== null ? Math.round((m1 - m0) * 100) / 100 : null,
         });
-        writeTranscript(s, variants, ts, overhead, variantNames, mode);
+        writeTranscript(s, variants, ts, overhead, variantNames, mode, withCandidates);
     }
 
     fs.writeFileSync(
@@ -369,7 +551,9 @@ async function main(): Promise<number> {
         JSON.stringify(
             {
                 date: ts,
-                mode,
+                // Self-describing: a results file whose arms carried the
+                // candidates block must not be readable as a plain l6 run.
+                mode: withCandidates ? `${mode}+candidates` : mode,
                 standard_model: standardModel,
                 strong_model: strongModel,
                 scorer_model: scoreWith ?? null,
@@ -386,6 +570,18 @@ async function main(): Promise<number> {
     return 0;
 }
 
+/**
+ * The transcript filename is keyed on the MODE, so a run under a different
+ * treatment must not reuse it.
+ *
+ * Found the hard way on 2026-09-08: `--candidates` reused the plain `l6n-`
+ * prefix and silently overwrote all 16 committed June baseline transcripts
+ * mid-run. The measurement survived — `--results` had been pointed at a new
+ * path and every transcript body is stored in that JSON — but the baseline's
+ * human-readable artefacts were replaced by treatment ones under the baseline's
+ * own names, which is the worst kind of quiet: a later reader comparing the
+ * markdown would have compared the treatment against itself.
+ */
 function writeTranscript(
     slot: Slot,
     variants: Record<string, Variant>,
@@ -393,8 +589,10 @@ function writeTranscript(
     overhead: number | null,
     variantNames: string[],
     mode: string,
+    withCandidates = false,
 ): void {
-    const prefix = mode === 'l6' ? 'l6n-' : '';
+    const base = mode === 'l6' ? 'l6n-' : '';
+    const prefix = withCandidates ? `${base}cand-` : base;
     const p = path.join(GT_DIR, `${prefix}${slot.n}-${slot.slug}.md`);
     const L: string[] = [
         `# Transcript — slot ${slot.n}: ${slot.slug}`,

package/src/scripts/release_mix_taxonomy.json

@@ -1,6 +1,6 @@
 {
-  "taxonomy_version": "1.0.0",
-  "updated": "2026-09-04",
+  "taxonomy_version": "1.1.0",
+  "updated": "2026-09-08",
   "contract": "docs/decisions/ADR-253-per-pr-user-artifact-gate-declined.md",
   "reader": "src/scripts/measure_release_mix.ts",
   "note": [
@@ -62,6 +62,7 @@
     { "prefix": "src/install/", "category": "consumer" },
     { "prefix": "src/server/", "category": "consumer" },
     { "prefix": "src/ui/", "category": "consumer" },
+    { "prefix": "src/vendor/grammars/", "category": "consumer" },
     { "prefix": "src/shared/", "category": "unclassified" },
 
     { "prefix": "src/scripts/", "category": "maintenance" },

package/src/scripts/report_host_injection_effect.ts

@@ -0,0 +1,189 @@
+#!/usr/bin/env tsx
+/**
+ * The per-host injection-effect census — one line per host, provenance or none.
+ *
+ * `road-to-delivery-on-hook-hosts` steps 1.2 and 1.3. It renders the committed
+ * record at `src/config/host-injection-effect.json` and adds the one thing the
+ * record deliberately does not hold: the COMPUTED half, read fresh from the hook
+ * manifest, so a reader sees both axes side by side and can see that they
+ * disagree.
+ *
+ * WHY BOTH COLUMNS ARE PRINTED, ALWAYS
+ * ------------------------------------
+ * `cowork` is the row that makes this table worth generating: eight slots bound
+ * and a measured `observed-false`. Printing only the observation would hide the
+ * near-miss; printing only the binding would produce the wrong verdict for the
+ * one host we have actually measured. The table exists so the gap between "could
+ * emit" and "did arrive" is visible per host rather than argued in prose.
+ *
+ * It computes NO verdict. `admissibleUnderE3` is a one-line read of the observed
+ * column and is applied by the caller that would change a projection, never here:
+ * a report that also decided admission would be the single place where an
+ * inference could quietly replace an observation.
+ *
+ * Usage:
+ *     ./scripts-run src/scripts/report_host_injection_effect
+ *     ./scripts-run src/scripts/report_host_injection_effect --emit --pin <sha>
+ *
+ * Deterministic: hosts sort by id, no timestamp, the pin is an argument.
+ */
+
+import { execFileSync, spawnSync } from 'node:child_process';
+import * as fs from 'node:fs';
+import * as path from 'node:path';
+import { fileURLToPath, pathToFileURL } from 'node:url';
+
+import {
+    concernBound,
+    loadRecord,
+    recordProblems,
+    type InjectionRecord,
+} from './_lib/injection_effect.js';
+
+const _HERE = fileURLToPath(import.meta.url);
+export const REPO_ROOT = path.resolve(path.dirname(_HERE), '..', '..');
+export const ARTIFACT_REL = path.join(
+    'agents', 'evidence', 'analysis', 'host-injection-effect-2026-09.md',
+);
+
+/** Platform → slot → concern ids, straight out of the manifest. */
+export function loadPlatforms(root: string): Record<string, Record<string, string[]>> {
+    const raw = fs.readFileSync(path.join(root, 'src', 'scripts', 'hook_manifest.yaml'), 'utf-8');
+    const out = spawnSync(
+        process.execPath,
+        [
+            '-e',
+            'const y=require("js-yaml");let s="";process.stdin.on("data",d=>s+=d).on("end",()=>{' +
+                'const d=y.load(s);process.stdout.write(JSON.stringify(d.platforms||{}))})',
+        ],
+        { input: raw, encoding: 'utf-8', cwd: root, maxBuffer: 64 * 1024 * 1024 },
+    );
+    if (out.status !== 0 || !out.stdout) {
+        throw new Error(`hook_manifest.yaml could not be parsed: ${out.stderr || 'no output'}`);
+    }
+    return JSON.parse(out.stdout) as Record<string, Record<string, string[]>>;
+}
+
+/**
+ * Keys under a platform that are NOT lifecycle slots.
+ *
+ * `fallback_only` is a marker saying this package binds nothing here, and
+ * counting it as a slot made copilot read 1 against the 0 that
+ * `docs/enforcement-by-host.md` records — a one-row disagreement with the host
+ * table for a nameable reason, which is the drift this repository gates
+ * elsewhere. Caught by comparing the generated table against that doc rather
+ * than by a test, so it is named here.
+ */
+const NON_SLOT_KEYS: ReadonlySet<string> = new Set(['fallback_only']);
+
+/** Lifecycle slots bound for a host, on the host table's own definition. */
+export function boundSlotCount(platforms: Readonly<Record<string, Readonly<Record<string, readonly string[]>>>>, host: string): number {
+    return Object.keys(platforms[host] ?? {}).filter((k) => !NON_SLOT_KEYS.has(k)).length;
+}
+
+/** Host ids that are real rows, in sort order. Underscore keys are annotations. */
+export function hostIds(rec: InjectionRecord): string[] {
+    return Object.keys(rec).filter((k) => !k.startsWith('_')).sort();
+}
+
+export function renderArtifact(root: string, pin: string): string {
+    const rec = loadRecord(root);
+    const platforms = loadPlatforms(root);
+    const L: string[] = [];
+    L.push('<!-- evidence-type: analysis -->');
+    L.push('# Host injection effect — does a delivered rule body reach the model?');
+    L.push('');
+    L.push(`Pinned to commit \`${pin}\`. Generated by`);
+    L.push(`\`./scripts-run src/scripts/report_host_injection_effect --emit --pin ${pin}\`.`);
+    L.push('Observations come from `src/config/host-injection-effect.json`; the binding column is');
+    L.push('read fresh from `src/scripts/hook_manifest.yaml` on every run.');
+    L.push('');
+    L.push('## The two columns, and why neither is the other');
+    L.push('');
+    L.push('**Slots bound** is computed and cheap. **Body reaches the model** is observed and');
+    L.push('expensive, and owner ruling E3 admits a host to `lean_projection.hosts` on the second');
+    L.push('only: one transcript in which a model visibly acts on a delivered body. Documentation');
+    L.push('of a host\'s hook API is not admission.');
+    L.push('');
+    L.push('`cowork` is why the distinction is not pedantry: **eight slots bound, and measured');
+    L.push('`observed-false`** — its trampoline discards dispatcher output and exits 0. A table');
+    L.push('with only the binding column would admit it.');
+    L.push('');
+    L.push('## Per host');
+    L.push('');
+    L.push('| Host | Slots bound | `rule-inject` on `user_prompt_submit` | Body reaches the model | Citation |');
+    L.push('|---|---:|:-:|---|---|');
+    for (const host of hostIds(rec)) {
+        const obs = rec[host];
+        const slots = boundSlotCount(platforms, host);
+        const bound = concernBound(platforms, host, 'user_prompt_submit', 'rule-inject');
+        const cite =
+            obs !== undefined && obs.transcript !== null && obs.date !== null
+                ? `\`${obs.transcript}\` (${obs.date})`
+                : '—';
+        L.push(
+            `| \`${host}\` | ${String(slots)} | ${bound ? 'yes' : 'no'} | \`${obs?.state ?? 'unobserved'}\` | ${cite} |`,
+        );
+    }
+    L.push('');
+    L.push('## Why each row reads as it does');
+    L.push('');
+    for (const host of hostIds(rec)) {
+        L.push(`- **\`${host}\`** — ${rec[host]?.reason ?? 'no row'}`);
+    }
+    const mdTree = rec['_cursor_md_tree_loaded'];
+    if (mdTree !== undefined) {
+        L.push('');
+        L.push('## `cursor.md_tree_loaded` (step 1.3)');
+        L.push('');
+        L.push(`\`cursor.md_tree_loaded: ${mdTree.state}\` — ${mdTree.reason}`);
+    }
+    L.push('');
+    L.push('## What this census does NOT do');
+    L.push('');
+    L.push('It computes no verdict. Admission under E3 is a one-line read of the observed column');
+    L.push('and is applied by whatever would change a projection, never here — a report that also');
+    L.push('decided admission would be the one place an inference could quietly replace an');
+    L.push('observation.');
+    L.push('');
+    L.push('`unobserved` is a RESULT, not a gap: the host keeps its full rule bodies and loses');
+    L.push('nothing while it waits, which is the roadmap\'s K6 and is asserted per PR by');
+    L.push('`check_host_tree_parity` in the predecessor.');
+    L.push('');
+    return L.join('\n');
+}
+
+function headSha(root: string): string {
+    return execFileSync('git', ['-C', root, 'rev-parse', 'HEAD'], { encoding: 'utf-8' }).trim();
+}
+
+export function main(argv: readonly string[]): number {
+    const root = REPO_ROOT;
+    const rec = loadRecord(root);
+    const problems = recordProblems(rec);
+    if (problems.length > 0) {
+        process.stderr.write('❌  the observation record is not admissible:\n');
+        for (const p of problems) process.stderr.write(`  · ${p.host}: ${p.message}\n`);
+        return 1;
+    }
+    const pinIdx = argv.indexOf('--pin');
+    const pin = pinIdx !== -1 && pinIdx + 1 < argv.length ? (argv[pinIdx + 1] as string) : headSha(root);
+    if (argv.includes('--emit')) {
+        const out = path.join(root, ARTIFACT_REL);
+        fs.mkdirSync(path.dirname(out), { recursive: true });
+        fs.writeFileSync(out, renderArtifact(root, pin), 'utf-8');
+        process.stdout.write(`wrote ${ARTIFACT_REL} · pin ${pin}\n`);
+    }
+    const hosts = hostIds(rec);
+    const byState = new Map<string, number>();
+    for (const h of hosts) byState.set(rec[h]!.state, (byState.get(rec[h]!.state) ?? 0) + 1);
+    process.stdout.write(`scanned: ${String(hosts.length)} host(s)\n`);
+    for (const [state, n] of [...byState].sort()) {
+        process.stdout.write(`  ${state.padEnd(16)} ${String(n)}\n`);
+    }
+    return 0;
+}
+
+if (process.argv[1] !== undefined && import.meta.url === pathToFileURL(path.resolve(process.argv[1])).href) {
+    process.exit(main(process.argv.slice(2)));
+}

package/src/scripts/report_layer_overlap.ts

@@ -24,6 +24,7 @@ import * as path from 'node:path';
 import process from 'node:process';
 import { fileURLToPath, pathToFileURL } from 'node:url';
 
+import { resolveHostLayerVerdict, setPartitionAnnounce } from '../install/partitionEligibility.js';
 import { warnLayerOverlap } from './_lib/layer_overlap_notice.js';
 
 // ledger-exempt: this is a REPORTER, not a gate — it always exits 0 by construction
@@ -59,6 +60,46 @@ export function main(argv?: readonly string[]): number {
             return 1;
         }
     }
+    // The projection line, and where it lives is a correction. **Both council seats
+    // (2026-08-20, 2/2) required that generation PRINT the mode it selected** rather
+    // than partition silently. The 2026-09-07 change moved the withhold off
+    // `installed.lock` and, in doing so, removed `condense.ts`'s only call into the
+    // resolver — so the emitter it installed became dead and generation withheld
+    // ~299 skills and 29 personas while printing nothing about the layer it
+    // withheld against. A neutral review found it the same day.
+    //
+    // It prints from HERE rather than from `condense.ts` because that file is ~1,200
+    // lines past the source-size ceiling, where the ratchet counts every added line
+    // and its test blocks on `baseline == live`. This step already runs in the same
+    // `generate-tools` chain, one line below the generator, so the operator sees the
+    // two lines together.
+    // Silence the resolver's OWN one-liner first: it writes to stdout by default,
+    // and leaving it on printed the verdict twice — once bare, once with the
+    // remediation text below. One line, the useful one.
+    setPartitionAnnounce(() => undefined);
+    const verdict = resolveHostLayerVerdict(projectRoot);
+    // Three states, not two. Corrected after a second neutral review: the
+    // unverified branch printed "a stale global layer is fixed by
+    // `agent-config install`" on a machine with NO global layer at all — a fresh
+    // checkout, where nothing is withheld, nothing is stale, and the remediation
+    // named does not apply. It fired on every `task generate-tools` there.
+    //
+    // What this line reports is the VERIFICATION state of the layer withheld
+    // against. The per-artefact withhold COUNTS are the generator's own summary
+    // one line above (`skills=N`, `command_skills=N (M withheld …)`), which is
+    // where a reader sees what was actually held back.
+    const noLayer = verdict.reason.includes('no host-global layer');
+    process.stdout.write(
+        verdict.verified
+            ? `  ℹ️  project layer carries only what ~/.claude lacks — ${verdict.reason}\n`
+            : noLayer
+              ? '  ℹ️  no host-global layer on this machine — nothing is withheld, so the\n' +
+                '      project layer carries the full projection by construction.\n'
+              : `  ⚠️  host layer UNVERIFIED — ${verdict.reason}\n` +
+                '      The project layer still carries only what ~/.claude lacks (per-artefact,\n' +
+                '      ADR-236 amendment 2026-09-07). A stale global layer is fixed by\n' +
+                '      `agent-config install`, not by re-running generate-tools.\n',
+    );
     warnLayerOverlap(projectRoot, (m) => process.stdout.write(`${m}\n`));
     return 0;
 }