@event4u/agent-config 14.12.0 → 14.14.0

package/src/scripts/release.ts

@@ -126,10 +126,10 @@ import {
 } from './_lib/release_highlights.js';
 import {
     NEXT_SECTION_RE,
+    RELEASE_HEAD_DEFAULT,
     extract_changelog_section,
     pr_body_from_section,
     release_notes_from_section,
-    tag_message_from_section,
 } from './_lib/release_material.js';
 
 // `__doc__.splitlines()[0]` in `_parse_args` — the argparse description. Kept
@@ -144,6 +144,8 @@ import {
     AUGMENT_MARKETPLACE_JSON,
     AUGMENT_PLUGIN_JSON,
     CHANGELOG,
+    _set_changelog_reader,
+    read_changelog_text,
     CalledProcessError,
     GH_PR_BODY_LIMIT,
     GH_RELEASE_NOTES_LIMIT,
@@ -188,6 +190,8 @@ import {
     _tag_exists_local,
     _tag_exists_remote,
     _target_from_branch,
+    create_and_push_annotated_tag,
+    guard_publication,
     die,
     gh,
     git,
@@ -269,24 +273,7 @@ const RELEASE_HEAD_SECTIONS: ReadonlyArray<string> = HEAD_LABELS;
  * (`_lib/changelog_eras.ts`, 250 lines per era), so an unbounded head would
  * quietly consume it.
  */
-export const RELEASE_HEAD_CAP_LINES = 10;
-
-/**
- * The fallback value of a head line the span does not substantiate.
- *
- * `_none_` and not a placeholder token: where nothing was derived it is the
- * **true** answer, and a release that genuinely changed no defaults should say
- * so rather than carry an unfilled marker.
- *
- * It is a fallback and no longer a blanket default. Writing `_none_` into
- * every field made the generator assert five things it had not checked, and
- * `check_release_highlights` rejected exactly that assertion the moment the
- * span contradicted it — which for this package is every release, because every
- * release touches `src/rules/` or `src/scripts/schemas/`. Substantiated labels
- * are now pre-filled from the span (`_derive_head_prefill`), so the tool states
- * only what it can support and `_none_` means what it says.
- */
-const HEAD_DEFAULT = '_none_';
+export { RELEASE_HEAD_CAP_LINES } from './_lib/release_material.js';
 
 /**
  * Pre-fill values for the curated head from the release span.
@@ -313,20 +300,21 @@ function _derive_head_prefill(prev: string | null): Record<string, string> {
 /**
  * Render the curated head. Emitted by the generator on every release so it
  * cannot be forgotten; edited by the maintainer before merge.
+ *
+ * **The authoring instruction is NOT emitted here** (2026-09-01, roadmap
+ * `road-to-publication-integrity-hard-fail` § Phase 2, Option A). This writer
+ * used to append `CURATED_HEAD_INSTRUCTION`, nothing removed it at release
+ * time, and it published twice in `package/CHANGELOG.md`. The reminder now
+ * rides in the release-PR body's PR-only region — never published — see
+ * `pr_body_from_section` in `_lib/release_material.ts`.
  */
 export function render_release_head(
     filled: Readonly<Record<string, string>> = {},
 ): string[] {
-    const lines: string[] = [
-        '### Release highlights',
-        '',
-        '<!-- Curated head: fill before merge, keep it under ' +
-            `${RELEASE_HEAD_CAP_LINES} lines, and leave \`${HEAD_DEFAULT}\` where it is ` +
-            'genuinely the answer. The generated log below is unchanged. -->',
-    ];
+    const lines: string[] = ['### Release highlights', ''];
     for (const label of RELEASE_HEAD_SECTIONS) {
         const value = (filled[label] ?? '').trim();
-        lines.push(`- **${label}:** ${value === '' ? HEAD_DEFAULT : value}`);
+        lines.push(`- **${label}:** ${value === '' ? RELEASE_HEAD_DEFAULT : value}`);
     }
     return lines;
 }
@@ -1179,6 +1167,7 @@ function _step(n: number, total: number, msg: string): void {
     process.stdout.write(`[${n}/${total}] ${msg}\n`);
 }
 
+
 function execute(
     plan: Plan,
     opts: { wait_for_checks: boolean; dry_run: boolean; resume?: boolean; ci?: boolean },
@@ -1342,7 +1331,7 @@ function execute(
         // Derive the PR body from the CHANGELOG section step 2 just wrote —
         // the file is the single source; the in-memory plan is only its
         // author (release-truth Phase 1).
-        const section = extract_changelog_section(fs.readFileSync(CHANGELOG, 'utf-8'), plan.target);
+        const section = extract_changelog_section(read_changelog_text(), plan.target);
         if (!section) {
             die(`CHANGELOG.md carries no section for ${plan.target} — cannot derive PR body`);
         }
@@ -1388,6 +1377,7 @@ function execute(
             _step(8, total, `Tag ${plan.target} already on ${REMOTE} — skip`);
         } else {
             _step(8, total, `Tag ${plan.target} exists locally — push only`);
+            guard_publication(plan.target, 'tag push (resumed)');
             _push_tag(plan.target);
         }
     } else {
@@ -1398,15 +1388,7 @@ function execute(
         // tag replaces the previous lightweight one so tag metadata is a
         // fourth surface carrying the same single-source content.
         _step(8, total, `Tag merge commit (annotated, from merged CHANGELOG) and push ${plan.target}`);
-        const merged = extract_changelog_section(fs.readFileSync(CHANGELOG, 'utf-8'), plan.target);
-        if (!merged) {
-            die(
-                `CHANGELOG.md on ${MAIN_BRANCH} carries no section for ${plan.target} — ` +
-                    'refusing to tag a release whose changelog entry is missing',
-            );
-        }
-        run(['git', 'tag', '-a', plan.target, '-m', tag_message_from_section(merged!.body, plan.target)]);
-        _push_tag(plan.target);
+        create_and_push_annotated_tag(plan.target);
     }
 
     // ─── 9. GitHub Release ──────────────────────────────────────────────────
@@ -1436,6 +1418,7 @@ function execute(
             GH_RELEASE_NOTES_LIMIT,
             '`CHANGELOG.md`',
         );
+        guard_publication(plan.target, 'GitHub Release notes');
         gh(['release', 'create', plan.target, '--title', plan.target, '--notes', notes]);
 
         // ─── 9b. dispatch-chain the tag-triggered workflows (--ci only) ──────
@@ -2014,6 +1997,7 @@ export {
     // Drill seam (release_drill.ts) — the step machinery under a simulated
     // git/gh world, so orchestration bugs surface in vitest, not mid-release.
     execute,
+    _set_changelog_reader,
     _set_exec_override,
     push_release_branch,
     merge_release_pr,

package/src/scripts/release_drill.ts

@@ -31,11 +31,13 @@ import { fileURLToPath, pathToFileURL } from 'node:url';
 
 import {
     _MERGE_UPDATE_ROUNDS,
+    _set_changelog_reader,
     _set_exec_override,
     execute,
     Plan,
     SystemExitError,
 } from './release.js';
+import { DERIVED_MARKER } from './_lib/release_highlights.js';
 
 const _HERE = fileURLToPath(import.meta.url);
 const REPO_ROOT = path.resolve(path.dirname(_HERE), '..', '..');
@@ -92,6 +94,34 @@ interface WorldConfig {
      * removes.
      */
     changelog?: string;
+    /**
+     * Content the WORKING-TREE read returns — `read_changelog_text()`, used by
+     * step 5 (PR body) and step 8 (annotated-tag message).
+     *
+     * Added 2026-09-01 with the publication guard (roadmap § 3.1). `changelog`
+     * above only covers `git show <tag>:CHANGELOG.md`; the working tree was
+     * still the REAL file, whose `14.13.0` section carries four
+     * `_auto-derived, rewrite before merge:_` lines. A guard at the tag call
+     * site therefore refused every scenario for a reason unrelated to what the
+     * scenario tested — the same coupling `changelog` was introduced to
+     * remove, on the other read.
+     *
+     * Defaults to `defaultChangelogFixture(target)`, which is policy-valid by
+     * construction.
+     */
+    changelog_file?: string;
+    /**
+     * The tag already exists locally and was never pushed — the § 3.2 resume
+     * state, which reached `_push_tag` having read no changelog at all.
+     */
+    tag_created_unpushed?: boolean;
+    /**
+     * The tag is already on the remote, so step 8 skips entirely and step 9 —
+     * the GitHub Release body — is the FIRST irreversible transition the run
+     * reaches. The only state in which the Release guard can be exercised on
+     * its own, because a marker otherwise stops the run at step 8.
+     */
+    tag_already_remote?: boolean;
 }
 
 /**
@@ -122,6 +152,21 @@ export function defaultChangelogFixture(target: string): string {
     ].join('\n');
 }
 
+/**
+ * `defaultChangelogFixture` with one head line still carrying the generator's
+ * draft marker — the exact state five released sections shipped in.
+ *
+ * Built from `DERIVED_MARKER` rather than from a literal string: a fixture
+ * that hardcodes the marker text keeps passing after the marker is renamed,
+ * which is a guard policing a population of zero.
+ */
+export function markedChangelogFixture(target: string): string {
+    return defaultChangelogFixture(target).replace(
+        '- fixture entry for the release drill',
+        `### Release highlights\n\n- **Behaviour changes:** ${DERIVED_MARKER} rule/schema diffs in abc1234.\n\n- fixture entry for the release drill`,
+    );
+}
+
 /**
  * A scriptable stand-in for every git/gh/task command execute() issues.
  * Stateful where the real world is: checkouts move HEAD, `git tag` makes the
@@ -144,6 +189,8 @@ class FakeWorld {
     private merge_fails_hard: boolean;
     private checks_fail: boolean;
     private readonly changelog: string;
+    /** Working-tree content; see `WorldConfig.changelog_file`. */
+    readonly changelog_file: string;
 
     constructor(
         readonly branch: string,
@@ -152,6 +199,9 @@ class FakeWorld {
     ) {
         this.push_rejections = cfg.push_rejections ?? 0;
         this.changelog = cfg.changelog ?? defaultChangelogFixture(target);
+        this.changelog_file = cfg.changelog_file ?? defaultChangelogFixture(target);
+        this.tag_local = (cfg.tag_created_unpushed ?? false) || (cfg.tag_already_remote ?? false);
+        this.tag_remote = cfg.tag_already_remote ?? false;
         this.behind_probes = cfg.behind_probes ?? 0;
         this.merge_races_once = cfg.merge_races_once ?? false;
         this.merge_fails_hard = cfg.merge_fails_hard ?? false;
@@ -325,6 +375,95 @@ function _count(world: FakeWorld, needle: string): number {
 }
 
 const SCENARIOS: Record<string, Scenario> = {
+    'marker-refuses-before-tag': {
+        summary:
+            'step 8: a draft marker in the merged section refuses BEFORE the annotated tag is created',
+        config: { changelog_file: markedChangelogFixture(current_version()) },
+        expect_success: false,
+        verify: (w, err) => {
+            const f: string[] = [];
+            _expect(
+                (err ?? '').includes('refusing to publish the annotated tag'),
+                `died for the wrong reason: ${err ?? '(no error)'}`,
+                f,
+            );
+            // The load-bearing assertion, and it is about ORDER, not about the
+            // message: nothing irreversible may run after the refusal.
+            _expect(
+                !w.calls.some((c) => c.startsWith('git tag -a ')),
+                'an annotated tag was created after the refusal',
+                f,
+            );
+            _expect(!w.tag_local && !w.tag_remote, 'a tag exists after the refusal', f);
+            _expect(!w.release_created, 'a GitHub Release was created after the refusal', f);
+            return f;
+        },
+    },
+    'marker-refuses-resumed-tag-push': {
+        summary:
+            'step 8 (§ 3.2): a tag created but never pushed is NOT pushed when its section carries the marker',
+        config: {
+            tag_created_unpushed: true,
+            changelog_file: markedChangelogFixture(current_version()),
+        },
+        expect_success: false,
+        verify: (w, err) => {
+            const f: string[] = [];
+            _expect(
+                (err ?? '').includes('refusing to publish the tag push (resumed)'),
+                `died for the wrong reason: ${err ?? '(no error)'}`,
+                f,
+            );
+            // The recorded bypass: this path read no changelog at all, so the
+            // push was the FIRST thing that happened. It must now be the thing
+            // that does not happen.
+            _expect(!w.tag_remote, 'the tag was pushed after the refusal', f);
+            _expect(
+                !w.calls.includes(`git push origin ${w.target}`),
+                'a tag push ran after the refusal',
+                f,
+            );
+            _expect(!w.release_created, 'a GitHub Release was created after the refusal', f);
+            return f;
+        },
+    },
+    'marker-refuses-github-release': {
+        summary:
+            'step 9: with the tag already pushed, a marker in the TAGGED section refuses before the Release is created',
+        config: {
+            tag_already_remote: true,
+            changelog: markedChangelogFixture(current_version()),
+            changelog_file: markedChangelogFixture(current_version()),
+        },
+        expect_success: false,
+        verify: (w, err) => {
+            const f: string[] = [];
+            _expect(
+                (err ?? '').includes('refusing to publish the GitHub Release notes'),
+                `died for the wrong reason: ${err ?? '(no error)'}`,
+                f,
+            );
+            _expect(!w.release_created, 'the GitHub Release was created after the refusal', f);
+            _expect(
+                !w.calls.some((c) => c.startsWith(`gh release create ${w.target}`)),
+                'gh release create ran after the refusal',
+                f,
+            );
+            return f;
+        },
+    },
+    'clean-section-still-publishes': {
+        summary:
+            'the guard is scoped to a real defect: a policy-valid section tags and releases as before',
+        config: {},
+        expect_success: true,
+        verify: (w, _err) => {
+            const f: string[] = [];
+            _expect(w.tag_remote, 'tag never pushed', f);
+            _expect(w.release_created, 'GitHub Release never created', f);
+            return f;
+        },
+    },
     'happy-resume': {
         summary: 'resume with everything green runs checkout → checks → merge → tag → release',
         config: {},
@@ -472,6 +611,9 @@ function run_scenario(name: string): ScenarioOutcome {
         return true;
     };
     _set_exec_override((args) => world.exec(args));
+    // The working-tree read, faked for the same reason the command layer is.
+    // Without this the drill's step 8 reads the repository's real CHANGELOG.md.
+    _set_changelog_reader(() => world.changelog_file);
     try {
         execute(plan, { wait_for_checks: true, dry_run: false, resume: true });
     } catch (err) {
@@ -482,6 +624,7 @@ function run_scenario(name: string): ScenarioOutcome {
         }
     } finally {
         _set_exec_override(null);
+        _set_changelog_reader(null);
         process.stdout.write = orig_out;
         process.stderr.write = orig_err;
     }

package/src/scripts/release_env.ts

@@ -91,6 +91,39 @@ const PROJECT_TEMPLATE = path.join(
     'agent-project-settings.example.yml',
 );
 const CHANGELOG = path.join(REPO_ROOT, 'CHANGELOG.md');
+
+/**
+ * Overridable reader for the WORKING-TREE changelog.
+ *
+ * Mirrors `_set_exec_override` in `release_publication.ts`, and exists for the
+ * same reason: `execute()` reads `CHANGELOG.md` off disk at two points (the PR
+ * body and the annotated-tag message), and the release drill fakes commands
+ * but not the filesystem. Before this seam the drill's step 8 read the
+ * repository's REAL changelog — whose current section carries four
+ * `_auto-derived, rewrite before merge:_` lines at `14.13.0` — so a
+ * publication guard added at that call site refused every drill scenario for a
+ * reason that had nothing to do with what the scenario was testing.
+ *
+ * That is the failure mode the `WorldConfig.changelog` fixture already removed
+ * for `git show`, and the AI council of 2026-08-23 (2/2 convergent) chose a
+ * controlled fixture over a policy exemption when it removed it. This is the
+ * same choice applied to the other read: the drill supplies policy-valid
+ * content and exercises the real parsing and guarding path, rather than being
+ * exempted from it.
+ *
+ * `null` restores the real filesystem read. Test-only; nothing in production
+ * sets it.
+ */
+let _changelog_reader: ((file: string) => string) | null = null;
+
+function _set_changelog_reader(fn: ((file: string) => string) | null): void {
+    _changelog_reader = fn;
+}
+
+/** The working-tree changelog text, through the seam above. */
+function read_changelog_text(): string {
+    return _changelog_reader ? _changelog_reader(CHANGELOG) : fs.readFileSync(CHANGELOG, 'utf-8');
+}
 const MAIN_BRANCH = 'main';
 const REMOTE = 'origin';
 const REPO_SLUG = 'event4u-app/agent-config';
@@ -282,6 +315,8 @@ export {
     _cap_body,
     CHANGELOG,
     CalledProcessError,
+    _set_changelog_reader,
+    read_changelog_text,
     GH_PR_BODY_LIMIT,
     GH_RELEASE_NOTES_LIMIT,
     MAIN_BRANCH,

package/src/scripts/release_publication.ts

@@ -16,12 +16,14 @@
  * import path changes.
  */
 import { spawnSync } from 'node:child_process';
+import { publication_blockers } from './_lib/release_highlights.js';
 import * as fs from 'node:fs';
 import process from 'node:process';
 
 import { gh_argv_label, gh_retry } from './_lib/gh_transient.js';
 import {
     extract_changelog_section,
+    tag_message_from_section,
     pr_body_from_section,
 } from './_lib/release_material.js';
 
@@ -34,6 +36,7 @@ import {
     REPO_ROOT,
     SystemExitError,
     _cap_body,
+    read_changelog_text,
 } from './release_env.js';
 
 function die(msg: string, code = 2): never {
@@ -718,3 +721,84 @@ export {
     run,
     watch_pr_checks,
 };
+
+/**
+ * Refuse an irreversible publication whose section is not publishable.
+ *
+ * Called at the THREE call sites that publish, never inside a formatter:
+ * annotated-tag creation, the resumed push of a tag created but never pushed,
+ * and the GitHub Release body. A pure formatter has no notion of whether it is
+ * actually publishing, which is why an earlier attempt at that placement was
+ * refused; the call site does, and it is the one that can still stop.
+ *
+ * **The resumed push is the bypass worth naming.** The changelog is read only
+ * in the tag-CREATION branch, so a resume over a tag that was created but never
+ * pushed reached `_push_tag` having read nothing. A guard covering creation
+ * alone misses exactly that path, and pushing a tag is as irreversible as
+ * creating it.
+ *
+ * `die` throws before the command runs, so nothing irreversible fires after a
+ * refusal — an ordering asserted against the drill's recorded command list
+ * rather than by reading this comment.
+ *
+ * Lives here rather than in `release.ts` because that file is 2000+ lines and
+ * every line above 1500 is charged by the source-size growth ratchet, while
+ * this module is far below it and already owns `die`. Behaviour unchanged.
+ */
+export function _refuse_unpublishable(sectionBody: string, version: string, surface: string): void {
+    const blockers = publication_blockers(sectionBody, version);
+    if (blockers.length === 0) {
+        return;
+    }
+    die(
+        `refusing to publish the ${surface} for ${version} — ` +
+            `${String(blockers.length)} publication blocker(s):\n` +
+            blockers.map((b) => `    - ${b}`).join('\n'),
+    );
+}
+
+/**
+ * Read the section under release and refuse if it is not publishable.
+ *
+ * One helper for all three publish sites so the read, the missing-section
+ * refusal and the blocker refusal cannot drift apart between them — the
+ * resumed-push path drifted exactly that way before this existed, reaching
+ * `_push_tag` having read nothing.
+ */
+export function guard_publication(version: string, surface: string): void {
+    const section = extract_changelog_section(read_changelog_text(), version);
+    if (!section) {
+        die(
+            `CHANGELOG.md on ${MAIN_BRANCH} carries no section for ${version} — ` +
+                `refusing to publish the ${surface}`,
+        );
+        return;
+    }
+    _refuse_unpublishable(section.body, version, surface);
+}
+
+/**
+ * Derive the tag message from the MERGED changelog, refuse if unpublishable,
+ * create the annotated tag and push it.
+ *
+ * The three steps are one function because they are one irreversible act with
+ * one precondition, and splitting them across call sites is what let the
+ * resumed-push path reach `_push_tag` having read nothing. Sequencing is
+ * load-bearing (release-truth Phase 1, council 2026-08-03): merge FIRST, pull
+ * main, THEN derive the message — tagging before the merge reads a section that
+ * does not exist yet. The annotated tag replaces the previous lightweight one so
+ * tag metadata is a fourth surface carrying the same single-source content.
+ */
+export function create_and_push_annotated_tag(version: string): void {
+    const merged = extract_changelog_section(read_changelog_text(), version);
+    if (!merged) {
+        die(
+            `CHANGELOG.md on ${MAIN_BRANCH} carries no section for ${version} — ` +
+                'refusing to tag a release whose changelog entry is missing',
+        );
+        return;
+    }
+    _refuse_unpublishable(merged.body, version, 'annotated tag');
+    run(['git', 'tag', '-a', version, '-m', tag_message_from_section(merged.body, version)]);
+    _push_tag(version);
+}

package/src/scripts/render_benchmark_md.ts

@@ -617,7 +617,7 @@ export function render(quiet = false): number {
     const parts = [
         '# Package-Impact A/B Benchmark',
         '',
-        '> Generated by `scripts/render_benchmark_md.py`. Source of truth: ' +
+        '> Generated by `render_benchmark_md`. Do not edit. Source of truth: ' +
             '`internal/bench/reports/ab/`. Re-render anytime with `task bench:ab:diff`.',
         '',
         render_headline(trackA, trackB, trackBRdp),

package/src/scripts/rule_activation_census.ts

@@ -58,6 +58,7 @@ import * as fs from 'node:fs';
 import * as path from 'node:path';
 import { fileURLToPath, pathToFileURL } from 'node:url';
 
+import { isExclusivelyPackageOnly } from '../install/partitionEligibility.js';
 import { _claude_paths_plan, _has_non_path_trigger, _parse_frontmatter } from './condense.js';
 
 const RULES_DIR = path.join('src', 'rules');
@@ -83,6 +84,13 @@ export interface RuleActivation {
     emitted_globs: string[];
     /** Patterns the emitter deliberately drops, with the reason it records. */
     dropped: { pattern: string; reason: string }[];
+    /**
+     * Scoped to this package alone, so ADR-236 withholds it from every global
+     * host layer. Load-bearing for the projection comparison: a package-only
+     * rule is counted by the source verdict and is absent from a delivered
+     * tree by design, not by drift.
+     */
+    package_only: boolean;
     /**
      * The emitter's verdict in one word.
      * `scoped` — loads on a path match · `unconditional` — loads every session ·
@@ -111,7 +119,11 @@ function _declares(meta: Record<string, unknown>, keys: readonly string[]): bool
 }
 
 /** Classify one rule file through the emitter's own exported decision path. */
-export function classify_rule(id: string, content: string): RuleActivation {
+export function classify_rule(
+    id: string,
+    content: string,
+    package_only = false,
+): RuleActivation {
     const [meta] = _parse_frontmatter(content);
     const plan = _claude_paths_plan(meta);
     const has_path_trigger = _declares(meta, PATH_TRIGGER_KEYS);
@@ -139,6 +151,7 @@ export function classify_rule(id: string, content: string): RuleActivation {
         emitted_globs: plan.globs,
         dropped: plan.dropped.map((d) => ({ pattern: d.pattern, reason: d.reason })),
         verdict,
+        package_only,
     };
 }
 
@@ -150,7 +163,11 @@ export function census(root: string): RuleActivation[] {
         .map((e) => e.name)
         .sort();
     return files.map((f) =>
-        classify_rule(f.replace(/\.md$/, ''), fs.readFileSync(path.join(dir, f), 'utf8')),
+        classify_rule(
+            f.replace(/\.md$/, ''),
+            fs.readFileSync(path.join(dir, f), 'utf8'),
+            isExclusivelyPackageOnly(path.join(dir, f)),
+        ),
     );
 }
 
@@ -223,10 +240,14 @@ export function main(): number {
 
     const rows = census(root);
     const sum = summarize(rows);
+    const resolved_projection_dir =
+        projection_dir === undefined || projection_dir === null || projection_dir === ''
+            ? ''
+            : path.isAbsolute(projection_dir)
+              ? projection_dir
+              : path.join(root, projection_dir);
     const projection = projection_dir
-        ? projection_reading(path.isAbsolute(projection_dir)
-            ? projection_dir
-            : path.join(root, projection_dir))
+        ? projection_reading(resolved_projection_dir)
         : null;
 
     if (as_json) {
@@ -259,11 +280,51 @@ export function main(): number {
             `\n  host projection at ${projection_dir} — reported SEPARATELY, not merged:\n` +
                 `    files ${projection.files} · declaring paths: ${projection.with_paths}\n`,
         );
-        if (projection.with_paths !== sum.scoped) {
+        // The source verdict counts EVERY rule in `src/rules/`. A GLOBAL host
+        // layer does not carry the package-only ones: ADR-236 partitions them to
+        // the project layer, so such a tree is expected to be short by exactly
+        // that many. Comparing the raw counts reported a divergence on every
+        // partitioned install forever — the emitter was right and the
+        // comparator was not subtracting.
+        //
+        // But the subtraction is NOT unconditional, and making it so was its own
+        // regression (completion review, 2026-08-30): a full or project-layer
+        // projection — which is also the fail-safe default `partitionEligibility`
+        // returns on a fresh checkout, an absent install record, or a version or
+        // fingerprint mismatch — DOES carry those rules, and for this repo's own
+        // project layer `source-of-truth` is the one rule delivered there and the
+        // only one declaring `paths:`. Subtracting it there inverts the line.
+        //
+        // So the partition is DETECTED from the projection rather than assumed:
+        // if a package-only rule's file is present, this is not a global layer.
+        const pkg_only_ids = rows.filter((r) => r.package_only).map((r) => r.id);
+        const partitioned = !pkg_only_ids.some((id) =>
+            fs.existsSync(path.join(resolved_projection_dir, `${id}.md`)),
+        );
+        const scoped_pkg_only = partitioned
+            ? rows.filter((r) => r.verdict === 'scoped' && r.package_only)
+            : [];
+        const expected = sum.scoped - scoped_pkg_only.length;
+        if (scoped_pkg_only.length > 0) {
+            process.stdout.write(
+                `    source scopes ${sum.scoped}; ${scoped_pkg_only.length} of those ` +
+                    `${scoped_pkg_only.length === 1 ? 'is' : 'are'} package-only and never\n` +
+                    `      delivered (${scoped_pkg_only.map((r) => r.id).join(', ')}), so a ` +
+                    `partitioned projection is\n      expected to declare ${expected}.\n`,
+            );
+        }
+        if (projection.with_paths !== expected) {
+            process.stdout.write(
+                `    ⚠️  diverges from the source verdict (${expected} expected` +
+                    `${scoped_pkg_only.length > 0 ? `, ${sum.scoped} before the package-only partition` : ''}).\n` +
+                    `        A projection carries no record of the scope or commit it was generated\n` +
+                    `        at, so this is a reason to regenerate it — never a reading of the\n` +
+                    `        emitter.\n`,
+            );
+        } else {
             process.stdout.write(
-                `    ⚠️  diverges from the source verdict (${sum.scoped} scoped). A projection\n` +
-                    `        carries no record of the scope or commit it was generated at, so this\n` +
-                    `        is a reason to regenerate it — never a reading of the emitter.\n`,
+                `    ✅  consistent with the source verdict (${expected} expected, ` +
+                    `${projection.with_paths} found).\n`,
             );
         }
     } else if (projection_dir) {

package/src/scripts/rule_backlinks.ts

@@ -228,7 +228,7 @@ export function render(
     validation: ValidationResult = validate_targets(byTarget),
 ): string {
     const L: string[] = [];
-    L.push('<!-- GENERATED by src/scripts/rule_backlinks.ts — do NOT hand-edit.');
+    L.push('<!-- GENERATED by rule_backlinks — do NOT hand-edit.');
     L.push('     Regenerate after each P4 migration batch. Report-only. -->');
     L.push('');
     L.push('# Rule backlinks — which rules route here');