@event4u/agent-config 14.22.0 → 14.23.0

package/src/scripts/check_host_tree_parity.ts

@@ -0,0 +1,291 @@
+#!/usr/bin/env tsx
+/**
+ * A host outside `lean_projection.hosts` receives EXACTLY what `eager-all` writes.
+ *
+ * `road-to-delivery-for-every-host` step 1.4, and the gate behind its AC-2.
+ *
+ * WHY A SEPARATE GATE FROM `check_rule_projection_integrity`
+ * ---------------------------------------------------------
+ * That gate reads the trees AS THEY STAND — no regeneration, by design, because
+ * its job is to catch a STALE tree and regenerating erases the evidence. Its 1.3
+ * host axis therefore asks a content question about the entries that exist:
+ * "is any of these a stub in a tree that should hold bodies?"
+ *
+ * That is necessary and it is not sufficient. It cannot see a projector change
+ * that alters a non-delivery host's output in some way OTHER than stubbing it —
+ * a different frontmatter rewrite, a dropped rule, an added byte. The AC is
+ * byte-identity, and byte-identity can only be established by producing both
+ * trees and comparing them.
+ *
+ * So this gate GENERATES, twice, into a temporary root it owns:
+ *
+ *   1. `mode: eager-all`            → the reference trees
+ *   2. `mode: delivery`, the configured `hosts:` → the trees under test
+ *
+ * and requires every tree whose host is NOT in `hosts` to be byte-identical
+ * across the two runs. It never writes into the repository: the fixture root is
+ * a `mkdtemp` directory, seeded from `dist/agent-src/rules`, and removed on exit.
+ *
+ * WHAT IT DELIBERATELY DOES NOT DO
+ * --------------------------------
+ * It does not assert that the DELIVERY host's tree changed. A flip that thins
+ * nothing is a different defect and `check_rule_projection_integrity` plus the
+ * unit corpus already cover it; asserting it here would make this gate fail on a
+ * legitimate `hosts: []`, which is the safe configuration.
+ *
+ * AND IT ASSERTS NOTHING WHEN EVERY THINNABLE HOST IS ENROLLED. With
+ * `hosts: [claude-code, cursor, cline]` there is no non-delivery tree, so the
+ * comparison has no subject. That case now prints a `⚠️  NOTHING COMPARED` line
+ * naming the gate that does carry the question, instead of the `✅ … 0 …
+ * byte-identical` line it printed until 2026-09-08 (R2 finding 12) — a green
+ * sentence for an assertion that was never made.
+ *
+ * IT ALSO DOES NOT CONSULT `lean_projection.mode`, and the divergence from
+ * `check_rule_projection_integrity._lean_projection_settings_for` — which
+ * checks the mode FIRST so "a `hosts:` list left behind after a rollback
+ * exempts nothing" — is deliberate. Recorded 2026-09-08 because R2 finding 13
+ * read it as an oversight, and running the mode-first variant here reddens the
+ * gate on this repository's own settings, which carry no `lean_projection`
+ * block at all.
+ *
+ * The two gates ask different questions. The sibling asks a question ABOUT THE
+ * CURRENT TREE — "is any entry on disk a stub in a tree with no delivery
+ * slot?" — so the live mode is part of its subject. This gate asks a
+ * COUNTERFACTUAL ABOUT THE PROJECTOR — "under a thinning mode with the
+ * configured hosts, would every other host's tree still be byte-identical?" —
+ * and supplies `mode: delivery` to its own test fixture to ask it. Reading the
+ * live mode would make the exemption set and the fixture disagree: with the
+ * mode off, `configured` would be empty while the fixture still thinned, and
+ * every stub in the delivery host's tree would be reported as a parity break.
+ *
+ * The consequence the finding names is real and is not a hole: after a rollback
+ * to `eager-all`, a leftover `hosts: [claude-code]` still excludes
+ * `.claude/rules` from THIS comparison. Nothing is hidden by that, because
+ * under `eager-all` nothing is thinned and the on-disk state is the sibling
+ * gate's subject.
+ *
+ * It also does not read the repository's own `.claude/rules` etc. Those are
+ * gitignored and absent on a fresh CI checkout, and a gate that silently passes
+ * when its subject is missing is the shape this repository's scan-scope
+ * discipline exists to reject — hence the fixture root, which always exists.
+ *
+ * Exit: 0 parity holds · 1 a non-delivery host's tree differs · 2 the gate could
+ * not run (no rule corpus to seed from).
+ */
+
+import * as fs from 'node:fs';
+import * as os from 'node:os';
+import * as path from 'node:path';
+import { fileURLToPath, pathToFileURL } from 'node:url';
+
+import { GateLedger, UnaccountedTargetsError } from './_lib/gate_ledger.js';
+import { leanProjectionHostsRaw } from './_lib/hook_settings.js';
+import { resolveLeanProjectionHosts } from './_lib/lean_projection_mode.js';
+import { reportScanned } from './_lib/scan_scope.js';
+import {
+    _getStateForTest,
+    _resetStateForTest as _pointCondenseAt,
+    generate_rule_symlinks,
+} from './condense.js';
+
+const _HERE = path.resolve(fileURLToPath(import.meta.url));
+export const REPO_ROOT = path.resolve(path.dirname(_HERE), '..', '..');
+
+/** The tool dirs this gate compares, and the host each belongs to. */
+export const TREES: Readonly<Record<string, string>> = {
+    '.claude/rules': 'claude-code',
+    '.cursor/rules': 'cursor',
+    '.clinerules': 'cline',
+};
+
+/** Every entry in `dir` as `name -> content`, reading through symlinks. */
+export function treeContents(root: string, rel: string): Record<string, string> {
+    const dir = path.join(root, rel);
+    const out: Record<string, string> = {};
+    if (!fs.existsSync(dir)) return out;
+    for (const name of fs.readdirSync(dir).sort()) {
+        if (name === 'README.md') continue;
+        try {
+            out[name] = fs.readFileSync(path.join(dir, name), 'utf-8');
+        } catch {
+            out[name] = '<unreadable>';
+        }
+    }
+    return out;
+}
+
+/** Copy the rule corpus into a fresh fixture root carrying `settings`. */
+function seedFixture(repoRoot: string, tmp: string, label: string, settings: string): string {
+    const root = path.join(tmp, label);
+    const dist = path.join(root, 'dist', 'agent-src', 'rules');
+    fs.mkdirSync(dist, { recursive: true });
+    const src = path.join(repoRoot, 'dist', 'agent-src', 'rules');
+    for (const name of fs.readdirSync(src).filter((f) => f.endsWith('.md'))) {
+        fs.copyFileSync(path.join(src, name), path.join(dist, name));
+    }
+    fs.writeFileSync(path.join(root, '.agent-settings.yml'), settings, 'utf-8');
+    return root;
+}
+
+export interface ParityFinding {
+    readonly tree: string;
+    readonly host: string;
+    readonly rule: string;
+    readonly reason: string;
+}
+
+/** Compare two generated trees, reporting every difference in a non-delivery host's tree. */
+export function compareTrees(
+    eagerRoot: string,
+    testRoot: string,
+    deliveryHosts: readonly string[],
+): ParityFinding[] {
+    const out: ParityFinding[] = [];
+    for (const [tree, host] of Object.entries(TREES)) {
+        if (deliveryHosts.includes(host)) continue;
+        const a = treeContents(eagerRoot, tree);
+        const b = treeContents(testRoot, tree);
+        for (const name of new Set([...Object.keys(a), ...Object.keys(b)])) {
+            const left = a[name];
+            const right = b[name];
+            if (left === right) continue;
+            const reason =
+                left === undefined
+                    ? 'present under the thinning mode and absent under eager-all'
+                    : right === undefined
+                      ? 'written by eager-all and MISSING under the thinning mode'
+                      : `content differs (${String(left.length)} vs ${String(right.length)} bytes)`;
+            out.push({ tree, host, rule: name, reason });
+        }
+    }
+    return out;
+}
+
+/**
+ * The notice for a comparison with NO SUBJECT, or `null` when there is one.
+ *
+ * R2 finding 12: with every thinnable host in `lean_projection.hosts` there is
+ * no non-delivery tree left, so this gate's assertion is VACUOUS — and it used
+ * to say so inside the same `✅ … byte-identical` sentence it prints when the
+ * assertion actually held. Zero compared is not a pass; it is an absence of
+ * subject, and the reader has to be told which gate carries the question
+ * instead.
+ *
+ * Deliberately NOT an exit-1: enrolling all three hosts is a legal
+ * configuration, and reddening a legal configuration is how a gate gets
+ * switched off. Pure and exported so the wording is under test without running
+ * the two-fixture generation.
+ */
+export function parityScopeNotice(configured: readonly string[]): string | null {
+    const comparable = Object.entries(TREES).filter(([, h]) => !configured.includes(h));
+    if (comparable.length > 0) return null;
+    return (
+        `⚠️  check_host_tree_parity: NOTHING COMPARED — every thinnable host is in ` +
+        `lean_projection.hosts [${configured.join(', ') || '(none)'}], so no non-delivery tree ` +
+        `exists and this gate asserts nothing about this configuration. A stub in a tree with ` +
+        `no bound delivery slot is reported by check_rule_projection_integrity's host axis ` +
+        `(thinnedTreeFindings); the byte-identity question here has no subject.\n`
+    );
+}
+
+export function main(argv: readonly string[] = []): number {
+    const root = REPO_ROOT;
+    const dist = path.join(root, 'dist', 'agent-src', 'rules');
+    if (!fs.existsSync(dist) || fs.readdirSync(dist).filter((f) => f.endsWith('.md')).length === 0) {
+        process.stderr.write(
+            `❌  check_host_tree_parity: no rule corpus at dist/agent-src/rules — run \`task sync\` first.\n`,
+        );
+        return 2;
+    }
+    const configured = resolveLeanProjectionHosts(leanProjectionHostsRaw(root)).hosts;
+    const hostList = configured.join(', ') || '(none)';
+
+    const saved = _getStateForTest();
+    const savedHome = process.env['HOME'];
+    const tmp = fs.mkdtempSync(path.join(os.tmpdir(), 'host-parity-'));
+    let findings: ParityFinding[];
+    try {
+        // An empty HOME: user-scope dedup must find no twin, or the two runs
+        // would differ for a reason that has nothing to do with the host axis.
+        const home = path.join(tmp, 'home');
+        fs.mkdirSync(home, { recursive: true });
+        process.env['HOME'] = home;
+
+        const eagerRoot = seedFixture(root, tmp, 'eager', 'lean_projection:\n  mode: eager-all\n');
+        _pointCondenseAt(eagerRoot);
+        generate_rule_symlinks();
+
+        const hostsBlock = configured.length === 0 ? '' : `  hosts: [${configured.join(', ')}]\n`;
+        const testRoot = seedFixture(root, tmp, 'test', `lean_projection:\n  mode: delivery\n${hostsBlock}`);
+        _pointCondenseAt(testRoot);
+        generate_rule_symlinks();
+
+        findings = compareTrees(eagerRoot, testRoot, configured);
+    } finally {
+        _pointCondenseAt(saved.PROJECT_ROOT);
+        if (savedHome === undefined) delete process.env['HOME'];
+        else process.env['HOME'] = savedHome;
+        fs.rmSync(tmp, { recursive: true, force: true });
+    }
+
+    const compared = Object.entries(TREES).filter(([, h]) => !configured.includes(h)).length;
+    reportScanned({
+        gate: 'check_host_tree_parity',
+        scanned: compared,
+        units: 'non-delivery host rule tree(s)',
+        roots: Object.keys(TREES),
+    });
+
+    // One ledger target per non-delivery tree, not per entry: the assertion is
+    // about a TREE being byte-identical, and a per-entry ledger would report
+    // 200-odd completed targets for what is three yes/no questions.
+    const ledger = new GateLedger('check_host_tree_parity');
+    const compareable = Object.entries(TREES).filter(([, h]) => !configured.includes(h)).map(([t]) => t);
+    ledger.plan(compareable);
+    const broken = new Set(findings.map((f) => f.tree));
+    for (const tree of compareable) {
+        if (broken.has(tree)) ledger.fail(tree, 'differs from the eager-all projection');
+        else ledger.complete(tree);
+    }
+    try {
+        if (argv.includes('--quiet')) ledger.finalize();
+        else ledger.report();
+    } catch (exc) {
+        if (exc instanceof UnaccountedTargetsError) {
+            process.stderr.write(`❌  ${exc.message}\n`);
+            return 1;
+        }
+        throw exc;
+    }
+
+    if (findings.length > 0) {
+        process.stderr.write(
+            `❌  check_host_tree_parity: ${String(findings.length)} entry(ies) differ between ` +
+                `eager-all and delivery on a host that is NOT in lean_projection.hosts [${hostList}]:\n`,
+        );
+        for (const f of findings) {
+            process.stderr.write(`  · ${f.tree}/${f.rule} (${f.host}) — ${f.reason}\n`);
+        }
+        process.stderr.write(
+            '\nA host outside `lean_projection.hosts` must receive exactly what `eager-all` writes ' +
+                '(K3, and the completeness invariant). Fix the projector, never the expectation.\n',
+        );
+        return 1;
+    }
+    const notice = parityScopeNotice(configured);
+    if (notice !== null) {
+        process.stderr.write(notice);
+        return 0;
+    }
+    if (!argv.includes('--quiet')) {
+        process.stdout.write(
+            `✅  check_host_tree_parity: ${String(compared)} non-delivery host tree(s) byte-identical to ` +
+                `eager-all · delivery hosts [${hostList}]\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/check_preamble_payload_budget.ts

@@ -18,7 +18,24 @@
  * bucket has no local source at all — the census reports that one as an explicit
  * residual rather than pretending to measure it.
  *
- * Exit codes: 0 within budget · 1 over budget · 2 misuse / unreadable budget.
+ * THE BOUND IS SHRINK-ONLY, AND NOW CHECKED
+ * ------------------------------------------
+ * `ci_delivery.why_a_grace_ceiling` says of the grace ceiling *"It may never
+ * move UP"*, and `grace_ceiling_history` in the same file records it moving up
+ * twice. ADR-264 resolved that against the practice — the sentence stands — and
+ * left the sentence unenforced, which is exactly the state that produced both
+ * raises. `_lib/standing_bound_ratchet.ts` is the enforcement: the effective
+ * ceiling is compared against the one at the base ref and a rise refuses the run,
+ * whether it arrived by editing the config or by passing a bigger `--ceiling`.
+ *
+ * It is also ALL that `road-to-a-standing-budget-with-headroom` step 1.3 ships.
+ * That step designed a 128-token Iron Law reserve; an AI council refused to
+ * activate it 2/2 on 2026-09-08 because the verifier is inside the change under
+ * review, so a protected approval record grants nothing. ADR-265 carries the
+ * verdict and the activation prerequisites.
+ *
+ * Exit codes: 0 within budget · 1 over budget or the bound rose · 2 misuse /
+ * unreadable budget.
  */
 import { execFileSync } from 'node:child_process';
 import * as fs from 'node:fs';
@@ -29,6 +46,13 @@ import { assertScanned, DeadScopeError } from './_lib/scan_scope.js';
 import { censusClaudeMdHierarchy, censusRuleDir, censusSkillsCatalog } from './preamble_byte_census.js';
 import { PREFIX_STABLE_SURFACES, prefixStableRoots } from './_lib/prefix_stable_surfaces.js';
 import { attributeGrowth, buildLedger, renderAttribution } from './_lib/asset_delivery_ledger.js';
+import { resolveBaseRef } from './_lib/ratchet_base_ref.js';
+import {
+    assertBoundsDidNotRise,
+    type BoundsRatchetVerdict,
+    type GitRunner,
+    realGit,
+} from './_lib/standing_bound_ratchet.js';
 
 const HERE = path.dirname(new URL(import.meta.url).pathname);
 const REPO_ROOT = path.resolve(HERE, '..', '..');
@@ -38,6 +62,15 @@ interface Budget {
     baseline_tokens: number;
     headroom_pct: number;
     target_tokens: { median: number; p95: number };
+    /**
+     * `ci_delivery.grace_ceiling`, or `null` when the file carries none.
+     *
+     * Read here only so the shrink-only ratchet has a head-side value on a local
+     * run that passes no `--ceiling`. The number the payload is COMPARED against
+     * still arrives through the flag, so this does not become a second home for
+     * the ceiling.
+     */
+    grace_ceiling: number | null;
 }
 
 export interface BudgetVerdict {
@@ -60,10 +93,13 @@ export function readBudget(file: string = BUDGET_FILE): Budget {
         throw new Error(`${file}: baseline_tokens and headroom_pct must both be numbers`);
     }
     const target = (raw['target_tokens'] ?? {}) as Record<string, unknown>;
+    const delivery = (raw['ci_delivery'] ?? {}) as Record<string, unknown>;
+    const grace = Number(delivery['grace_ceiling']);
     return {
         baseline_tokens: baseline,
         headroom_pct: headroom,
         target_tokens: { median: Number(target['median']), p95: Number(target['p95']) },
+        grace_ceiling: Number.isFinite(grace) ? grace : null,
     };
 }
 
@@ -142,6 +178,47 @@ export function evaluate(repoRoot?: string, budgetFile?: string, overrideCeiling
     return { measured, baseline: budget.baseline_tokens, ceiling, withinBudget: measured <= ceiling, buckets };
 }
 
+/**
+ * The measurement plus the shrink-only bound check.
+ *
+ * `evaluate` above answers "how big is the tree" and touches no ref;
+ * this answers "may this tree ship" and needs the base one. They stay separate
+ * because a census that silently depended on a remote ref would behave
+ * differently in a shallow clone, and the census is the half other callers use.
+ */
+export interface Decision {
+    verdict: BudgetVerdict;
+    bounds: BoundsRatchetVerdict;
+    /** False when the payload is over the ceiling, or the ceiling itself rose. */
+    ok: boolean;
+}
+
+export interface DecideOptions {
+    repoRoot?: string;
+    budgetFile?: string;
+    overrideCeiling?: number;
+    env?: NodeJS.ProcessEnv;
+    git?: GitRunner;
+    /** Test seam: pin the base ref instead of resolving it. `null` = none resolved. */
+    baseRef?: string | null;
+}
+
+export function decide(opts: DecideOptions = {}): Decision {
+    const repoRoot = opts.repoRoot ?? REPO_ROOT;
+    const git = opts.git ?? realGit;
+    const budget = readBudget(opts.budgetFile);
+    const verdict = evaluate(repoRoot, opts.budgetFile, opts.overrideCeiling);
+    const baseRef =
+        opts.baseRef !== undefined ? opts.baseRef : resolveBaseRef(repoRoot, opts.env ?? process.env, git);
+    const bounds = assertBoundsDidNotRise({
+        repoRoot,
+        baseRef,
+        git,
+        headGraceCeiling: opts.overrideCeiling ?? budget.grace_ceiling ?? 0,
+    });
+    return { verdict, bounds, ok: bounds.ok && verdict.withinBudget };
+}
+
 /**
  * Per-asset attribution for a refusal, against the merge-base tree.
  *
@@ -203,6 +280,26 @@ function attributeGrowthAgainstBase(): string[] | null {
     }
 }
 
+/**
+ * The bound check, rendered for a human — on BOTH paths, green and red.
+ *
+ * A check that only speaks when it fails is a check nobody audits until it is
+ * already load-bearing. Printing the compared ref and the earlier bound on the
+ * passing path is also the only way a reader can tell "verified and unchanged"
+ * from "skipped because no base ref resolved", which are different facts.
+ */
+function renderBounds(b: BoundsRatchetVerdict): string {
+    if (b.note !== null) {
+        return `  ${'grace ceiling ratchet'.padEnd(38)} ${'SKIPPED'.padStart(8)} — ${b.note}\n`;
+    }
+    const base = b.baseGraceCeiling === null ? 'n/a' : String(b.baseGraceCeiling);
+    const state = b.ok ? 'ok' : 'ROSE';
+    return (
+        `  ${'grace ceiling ratchet'.padEnd(38)} ${state.padStart(8)} — ` +
+        `${base} at ${b.baseRef ?? 'n/a'}, shrink-only (ADR-264)\n`
+    );
+}
+
 export function main(argv: string[] = process.argv.slice(2)): number {
     const json = argv.includes('--format=json') || argv.includes('--json');
     // `--ceiling <n>`: the grace ceiling the CI step reads out of
@@ -211,13 +308,14 @@ export function main(argv: string[] = process.argv.slice(2)): number {
     // tighter-than-design value is IGNORED rather than honoured — see `evaluate`.
     const ci = argv.indexOf('--ceiling');
     const override = ci !== -1 && argv[ci + 1] !== undefined ? Number(argv[ci + 1]) : undefined;
-    let verdict: BudgetVerdict;
+    let decision: Decision;
     try {
-        verdict = evaluate(undefined, undefined, override);
+        decision = decide(override === undefined ? {} : { overrideCeiling: override });
     } catch (err) {
         process.stderr.write(`❌  preamble-payload budget: ${(err as Error).message}\n`);
         return 2;
     }
+    const verdict = decision.verdict;
 
     // A ratchet over a measurement of nothing always passes: move
     // `dist/agent-src/` and every census returns zero, which is trivially under
@@ -239,8 +337,24 @@ export function main(argv: string[] = process.argv.slice(2)): number {
     }
 
     if (json) {
-        process.stdout.write(JSON.stringify(verdict, null, 2) + '\n');
-        return verdict.withinBudget ? 0 : 1;
+        process.stdout.write(
+            JSON.stringify(
+                {
+                    ...verdict,
+                    ok: decision.ok,
+                    bound_ratchet: {
+                        ok: decision.bounds.ok,
+                        base_ref: decision.bounds.baseRef,
+                        base_grace_ceiling: decision.bounds.baseGraceCeiling,
+                        note: decision.bounds.note,
+                        violations: decision.bounds.violations,
+                    },
+                },
+                null,
+                2,
+            ) + '\n',
+        );
+        return decision.ok ? 0 : 1;
     }
 
     for (const b of verdict.buckets) {
@@ -252,6 +366,20 @@ export function main(argv: string[] = process.argv.slice(2)): number {
         `  ${'measured total'.padEnd(38)} ${String(verdict.measured).padStart(8)} tok ` +
             `(baseline ${verdict.baseline}, ${sign}${delta}; ceiling ${verdict.ceiling})\n`,
     );
+    process.stdout.write(renderBounds(decision.bounds));
+
+    // The bound is checked BEFORE the size question and independently of it. A
+    // change that lifts its own ceiling has already defeated the gate, and
+    // reporting that as "within budget" would be the config-weakening move
+    // wearing a green checkmark.
+    if (!decision.bounds.ok) {
+        process.stderr.write(
+            '❌  the standing-payload ceiling rose in this change:\n' +
+                decision.bounds.violations.map((v) => `      · ${v}\n`).join(''),
+        );
+        return 1;
+    }
+
     if (!verdict.withinBudget) {
         // road-to-delivered-cost-truth 2.2 — a gate names its own "no". The
         // ceiling message alone states a fact and leaves the reader to find the
@@ -268,8 +396,9 @@ export function main(argv: string[] = process.argv.slice(2)): number {
         process.stderr.write(
             `❌  per-spawn preamble payload grew past the ratchet: ${verdict.measured} > ${verdict.ceiling} tok.\n` +
                 `    Every rule and skill description here is re-written on EVERY subagent spawn, so growth\n` +
-                `    is paid per spawn, not once. Either shrink the addition, or raise baseline_tokens in\n` +
-                `    src/config/preamble-payload-budget.json with the reason in the same commit.\n`,
+                `    is paid per spawn, not once. Shrink the addition, or migrate the prose out of the\n` +
+                `    standing rule. The grace ceiling may NOT be raised to fit it: ADR-264, enforced by\n` +
+                `    the shrink-only ratchet above.\n`,
         );
         // Three distinct states, and conflating the last two is a diagnostic
         // defect rather than a cosmetic one: "I could not look" and "I looked

package/src/scripts/check_rule_projection_integrity.ts

@@ -98,6 +98,13 @@ import { fileURLToPath, pathToFileURL } from 'node:url';
 import { GateLedger, UnaccountedTargetsError } from './_lib/gate_ledger.js';
 import { assertScanned, DeadScopeError } from './_lib/scan_scope.js';
 import { _resetStateForTest as _pointCondenseAt, projected_rule_trees } from './condense.js';
+import { leanProjectionHostsRaw, leanProjectionModeRaw } from './_lib/hook_settings.js';
+import {
+    normalizeLeanProjectionMode,
+    resolveLeanProjectionHosts,
+    writesThinFiles,
+} from './_lib/lean_projection_mode.js';
+import { is_thin_entry } from './project_thin_rules.js';
 
 const _HERE = path.resolve(fileURLToPath(import.meta.url));
 const REPO_ROOT = path.resolve(path.dirname(_HERE), '..', '..');
@@ -105,7 +112,24 @@ const REPO_ROOT = path.resolve(path.dirname(_HERE), '..', '..');
 /** Where the projected rules are condensed to — the freshness comparison's left side. */
 const DIST_RULES = path.join('dist', 'agent-src', 'rules');
 
-export type ProjectionFindingKind = 'missing' | 'stale' | 'dangling';
+export type ProjectionFindingKind = 'missing' | 'stale' | 'dangling' | 'thinned';
+
+/**
+ * Tool dir → the host id whose tree it is.
+ *
+ * Mirrors `condense._DIR_TOOL_ID` for the three dirs this gate covers. It is a
+ * second spelling of a mapping `condense` already owns, which is a real cost —
+ * accepted because `_DIR_TOOL_ID` is module-private and exporting it would widen
+ * `condense`'s surface for one consumer, in a file already ~1,200 lines past the
+ * source-size ceiling where every added line is one unit of ratchet debt.
+ * `thinnedTreeFindings` fails CLOSED on an unmapped dir (see there), so a dir
+ * added upstream and missed here is reported rather than silently exempted.
+ */
+export const TREE_HOST_ID: Readonly<Record<string, string>> = {
+    '.claude/rules': 'claude-code',
+    '.cursor/rules': 'cursor',
+    '.clinerules': 'cline',
+};
 
 export interface ProjectionFinding {
     /** Repo-relative tool dir, e.g. `.claude/rules`. */
@@ -138,9 +162,59 @@ function _lstatOrNull(p: string): fs.Stats | null {
  * computed here so the caller controls which root the generator's emit plan was
  * derived from, and so a test can pin an expectation without a settings file.
  */
+/**
+ * The host axis (road-to-delivery-for-every-host 1.3).
+ *
+ * A stub is a COMPLETE projection for a host inside `lean_projection.hosts` —
+ * that is what delivery mode means, and failing it there would make the mode
+ * unusable. For every other host a stub is the D1 defect: the body left the
+ * tree and no concern is bound to bring it back, so the rule reaches that host
+ * at no scope at all while every file-count check still passes.
+ *
+ * Fails CLOSED in two directions, both deliberate:
+ *   · a tool dir absent from `TREE_HOST_ID` maps to `''`, which is in no host
+ *     list, so an unmapped dir is treated as NOT a delivery host and its stubs
+ *     are reported. A new dir is then a loud finding rather than a silent
+ *     exemption.
+ *   · an unreadable entry is skipped rather than guessed at — `missing` and
+ *     `dangling` already own that case, and inventing a third verdict from a
+ *     failed read would double-report one defect.
+ */
+export function thinnedTreeFindings(
+    repoRoot: string,
+    expected: Readonly<Record<string, readonly string[]>>,
+    deliveryHosts: readonly string[],
+): ProjectionFinding[] {
+    const out: ProjectionFinding[] = [];
+    for (const [tree, rules] of Object.entries(expected)) {
+        const hostId = TREE_HOST_ID[tree] ?? '';
+        if (deliveryHosts.includes(hostId)) continue;
+        for (const rule of rules) {
+            let text: string;
+            try {
+                text = fs.readFileSync(path.join(repoRoot, tree, rule), 'utf-8');
+            } catch {
+                continue;
+            }
+            if (!is_thin_entry(text)) continue;
+            out.push({
+                tree,
+                rule,
+                kind: 'thinned',
+                message:
+                    `pointer stub in a tree whose host (${hostId === '' ? 'unmapped' : hostId}) is not in ` +
+                    `lean_projection.hosts — the body reaches this host at no scope, and no concern ` +
+                    `is bound to deliver it back`,
+            });
+        }
+    }
+    return out;
+}
+
 export function auditRuleProjection(
     repoRoot: string,
     expected: Readonly<Record<string, readonly string[]>>,
+    deliveryHosts: readonly string[] = [],
 ): ProjectionAudit {
     const ledger = new GateLedger('check_rule_projection_integrity');
     const findings: ProjectionFinding[] = [];
@@ -248,9 +322,34 @@ export function auditRuleProjection(
         }
     }
 
+    // Appended after the completeness/freshness pass rather than folded into it:
+    // a stub entry EXISTS and is FRESH, so it is legitimately `complete` on the
+    // ledger. The host axis is a separate question about the entry's CONTENT,
+    // and conflating the two would make a delivery host's stub a ledger failure.
+    findings.push(...thinnedTreeFindings(repoRoot, expected, deliveryHosts));
+
     return { findings, treePresent, ledger };
 }
 
+/**
+ * The `lean_projection` block as it stands under `root`.
+ *
+ * Read with the HOOK-side indentation reader rather than a YAML parse, on
+ * purpose: this gate runs first in the pre-push chain and on a fresh CI
+ * checkout, and a parser failure there must not fail a rule audit for a reason
+ * unrelated to rules. `_lib/lean_projection_mode.ts` owns what the values MEAN,
+ * so this gate and the projector cannot disagree.
+ *
+ * `mode` is checked before `hosts`: with the mode off no host is a delivery
+ * host, so a `hosts:` list left behind after a rollback exempts nothing and
+ * every stub in every tree is reported.
+ */
+function _lean_projection_settings_for(root: string): { hosts: readonly string[] } {
+    const mode = normalizeLeanProjectionMode(leanProjectionModeRaw(root));
+    if (!writesThinFiles(mode)) return { hosts: [] };
+    return { hosts: resolveLeanProjectionHosts(leanProjectionHostsRaw(root)).hosts };
+}
+
 /** Group findings by tree, preserving rule order, for a report a reader can act on. */
 export function renderFindings(audit: ProjectionAudit): string[] {
     const lines: string[] = [];
@@ -297,7 +396,8 @@ export function main(argv?: readonly string[]): number {
 
     let audit: ProjectionAudit;
     try {
-        audit = auditRuleProjection(root, projected_rule_trees());
+        const lean = _lean_projection_settings_for(root);
+        audit = auditRuleProjection(root, projected_rule_trees(), lean.hosts);
     } catch (exc) {
         if (exc instanceof DeadScopeError) {
             process.stderr.write(`❌  ${exc.message}\n`);