@event4u/agent-config 14.20.0 → 14.22.0

package/src/scripts/check_release_highlights.ts

@@ -71,18 +71,12 @@ import {
     collect_span_commits,
     derive_categories,
     parse_git_log,
-    mix_response_blockers,
-    previous_promise,
     previous_release_tag,
-    promise_readback_blockers,
     stale_draft_labels,
 } from './_lib/release_highlights.js';
-import { loadTaxonomy, measureRange } from './measure_release_mix.js';
 import {
     CURATED_HEAD_INSTRUCTION,
-    PROMISE_READBACK_MARKER,
     extract_changelog_section,
-    previous_changelog_version,
 } from './_lib/release_material.js';
 import { assertScanned, assertWatchlistResolves, DeadScopeError } from './_lib/scan_scope.js';
 
@@ -244,23 +238,6 @@ export function main(argv: readonly string[]): number {
         );
         return 1;
     }
-    // Hoisted above the curated-head branches on purpose. It used to sit inside
-    // `contradictions.length === 0`, so CI reached it only for a section that
-    // HAS a head, carries no unrewritten draft and contradicts nothing — while
-    // the local guards call the same predicate unconditionally. A section
-    // without a curated head was therefore refused locally and waved through by
-    // CI: one predicate, two different gatekeepers, which is the drift this
-    // change exists to remove.
-    const mix = check_governance_mix_response(section.body, from, to, version);
-    if (mix !== 0) {
-        return mix;
-    }
-
-    const readback = check_previous_promise_readback(changelogText, section.body, version);
-    if (readback !== 0) {
-        return readback;
-    }
-
     const curated = parse_curated_head(section.body);
     if (!curated) {
         process.stdout.write(`ℹ️  no curated head in the ${version} section — nothing to check\n`);
@@ -356,140 +333,6 @@ export function main(argv: readonly string[]): number {
     return 1;
 }
 
-/**
- * The governance-versus-product response, checked for PRESENCE, never for the
- * ratio (ADR-253).
- *
- * `measure_release_mix` publishes a level. This is the one place that level has
- * a consequence, and the consequence is deliberately about completeness of the
- * written answer: when governance-only commits strictly outnumber consumer-only
- * commits over the release span, the section under release must carry a written
- * response naming either the next cycle's consumer work or a maintainer
- * justification. No number is enforced, and no number can be — both council
- * seats refused a threshold on fewer than two readings, and a gate with no
- * threshold that blocks on the ratio is a smuggled threshold.
- *
- * The response lives OUTSIDE the curated head, as its own `> **Governance
- * mix:**` line, so it does not consume the head's ten-line cap and does not
- * become a sixth label every historical section would suddenly lack.
- *
- * Scope matches every other check here: only the section under release is read.
- *
- * A measurement failure DEGRADES to a printed warning rather than to a refusal.
- * This is a governance signal, not a correctness or security control, and a
- * shallow clone or a missing tag on the release path would otherwise turn an
- * unrelated environment fact into a blocked release.
- */
-export function check_governance_mix_response(
-    body: string,
-    from: string,
-    to: string,
-    version: string,
-): number {
-    let reading;
-    try {
-        reading = measureRange(from, to, loadTaxonomy(), version, REPO_ROOT);
-    } catch (err) {
-        process.stdout.write(
-            `⚠️   governance mix not measured for ${version}: ${(err as Error).message}\n`,
-        );
-        return 0;
-    }
-    const o = reading.response_obligation;
-    const level = `governance-only ${o.governance_only} vs consumer-only ${o.consumer_only} (taxonomy ${reading.taxonomy_version})`;
-    if (!o.triggered) {
-        process.stdout.write(`✅  governance mix for ${version}: ${level} — no response owed\n`);
-        return 0;
-    }
-    // ONE predicate, shared with `guard_release_branch_push` — see
-    // `mix_response_blockers`. This side prints and exits; the local side dies
-    // before anything leaves the machine. Neither owns the rule.
-    const blockers = mix_response_blockers(body, version, `\`release/${version}\``, {
-        triggered: true,
-        level,
-    });
-    if (blockers.length === 0) {
-        process.stdout.write(`✅  governance mix for ${version}: ${level} — response present\n`);
-        return 0;
-    }
-    process.stderr.write(
-        `❌  the ${version} section owes a governance-versus-product response: ${level}.\n` +
-            blockers.map((b) => `    - ${b}\n`).join('') +
-            '    Governance-only commits outnumber consumer-only commits over the release span, so\n' +
-            '    the section carries a written response naming either the next cycle\'s consumer work\n' +
-            '    or a maintainer justification (docs/contracts/CHANGELOG-conventions.md § Governance-\n' +
-            '    versus-product response; the decline this replaces is ADR-253).\n' +
-            '    Only that section is read; historical sections are out of scope. No ratio is\n' +
-            '    enforced — this blocks a MISSING answer, never a particular number.\n' +
-            '    Reproduce locally, before any push:\n' +
-            `        ./scripts-run src/scripts/check_release_highlights --version ${version}\n`,
-    );
-    return 1;
-}
-
-/**
- * The previous release's promise, read back at the next release.
- *
- * `_lib/release_material.ts` generates `Next cycle ships …` and, until this
- * check existed, nothing ever asked what became of it: 14.18.0 promised the MCP
- * bridge repair, and no gate in the tree would have noticed the same promise
- * being reprinted in 14.19.0 and 14.20.0. A commitment nothing reads back is
- * free to restate, and one that is free to restate is not a commitment.
- *
- * Only the section under release is read, and only the previous section's
- * governance-response block — the same scope every other check here uses, so a
- * historical section cannot red a future release.
- *
- * The check is about ANSWERING, never about having kept the promise. A gate
- * that refused an unkept promise would price honesty above silence and teach
- * the next author to promise nothing.
- */
-export function check_previous_promise_readback(
-    changelogText: string,
-    body: string,
-    version: string,
-): number {
-    const previousVersion = previous_changelog_version(changelogText, version);
-    if (previousVersion === null) {
-        process.stdout.write(`✅  no previous CHANGELOG section before ${version} — no promise to read back\n`);
-        return 0;
-    }
-    const promise = previous_promise(changelogText, previousVersion);
-    if (promise === null) {
-        process.stdout.write(
-            `✅  the ${previousVersion} section made no next-cycle promise — nothing owed by ${version}\n`,
-        );
-        return 0;
-    }
-    const blockers = promise_readback_blockers(
-        body,
-        version,
-        previousVersion,
-        promise,
-        `\`release/${version}\``,
-    );
-    if (blockers.length === 0) {
-        process.stdout.write(`✅  ${version} answers the ${previousVersion} next-cycle promise\n`);
-        return 0;
-    }
-    process.stderr.write(
-        `❌  the ${version} section owes an answer to the ${previousVersion} next-cycle promise.\n` +
-            blockers.map((b) => `    - ${b}\n`).join('') +
-            `    The ${previousVersion} promise reads:\n` +
-            promise
-                .split('\n')
-                .map((l) => `        ${l}\n`)
-                .join('') +
-            `    Answering it is one blockquote line under the curated head, e.g.\n` +
-            `        > ${PROMISE_READBACK_MARKER} the <promise> did not ship; <what happened>.\n` +
-            '    Shipped, did not ship, or withdrawn with a reason — the check refuses a MISSING\n' +
-            '    answer, never a particular outcome. An unkept promise answered honestly passes.\n' +
-            '    Reproduce locally, before any push:\n' +
-            `        ./scripts-run src/scripts/check_release_highlights --version ${version}\n`,
-    );
-    return 1;
-}
-
 const _isMain = (() => {
     const entry = process.argv[1];
     if (!entry) return false;

package/src/scripts/check_roadmap_trackable.ts

@@ -19,6 +19,16 @@
  * `skipped/`, template/README/open-questions) MUST:
  *   1. Be parseable by the dashboard's `PHASE_RE` (>= one `## Phase <id>`).
  *   2. Have at least one trackable checkbox under every parsed phase.
+ *   3. Not declare a RETIRED `status:` value.
+ *
+ * `status: draft` is the one exemption. It used to have a second, `carrier`,
+ * which ADR-262 deleted: a `status:` value never again decides whether an
+ * autonomous run may act on a roadmap, so a receiver of deferred work is now
+ * ordinary estate and passes normal trackability. A surviving `status: carrier`
+ * is REJECTED here with the migration diagnostic rather than silently ignored —
+ * deleting a vocabulary term quietly would leave old files wearing a value
+ * nothing reads, and the next author would infer a meaning from its presence.
+ * The retired set and its diagnostic live in `_lib/retired_status.ts`.
  *
  * Exit codes:
  *   0 — every active roadmap has parseable phases with >= 1 checkbox per phase.
@@ -31,6 +41,7 @@ import { fileURLToPath, pathToFileURL } from 'node:url';
 
 import { checkRatchet } from './_lib/gate_baseline.js';
 import { assertScanned, DeadScopeError } from './_lib/scan_scope.js';
+import { declaresRetiredStatus, retiredStatusDiagnostic } from './_lib/retired_status.js';
 
 const QUIET = process.argv.slice(2).includes('--quiet');
 
@@ -49,15 +60,6 @@ const PHASE_RE =
 // FRONTMATTER_RE = re.compile(r"\A---\n(.*?)\n---\s*\n", re.DOTALL)
 const FRONTMATTER_RE = /^---\n([\s\S]*?)\n---\s*\n/;
 const DRAFT_VALUES: ReadonlySet<string> = new Set(['draft']);
-/**
- * A carrier holds obligations deferred out of an archived parent. It is not
- * schedulable work — every item in it has an unmet resumption trigger — and it
- * has no `## Phase` headings by construction, so it is skipped exactly where a
- * draft is. It differs from a draft in what protects it: a draft may be deleted
- * freely, a carrier may not, and `lint_carrier_integrity` reds when one loses
- * its receiver.
- */
-const CARRIER_VALUES: ReadonlySet<string> = new Set(['carrier']);
 
 const EXCLUDE_NAMES: ReadonlySet<string> = new Set([
     'template.md',
@@ -101,11 +103,6 @@ function is_draft(fm: Map<string, string>): boolean {
     return DRAFT_VALUES.has((fm.get('status') ?? '').toLowerCase());
 }
 
-/** True for a `status: carrier` roadmap — see CARRIER_VALUES. */
-function is_carrier(fm: Map<string, string>): boolean {
-    return CARRIER_VALUES.has((fm.get('status') ?? '').toLowerCase());
-}
-
 /** Mirror update_roadmap_progress.is_roadmap_candidate (POSIX path parts). */
 function is_roadmap_candidate(p: string): boolean {
     const name = path.basename(p);
@@ -182,7 +179,7 @@ function find_active_roadmaps(root: string): string[] {
             continue;
         }
         const text = fs.readFileSync(p, 'utf-8');
-        if (is_draft(parse_frontmatter(text)) || is_carrier(parse_frontmatter(text))) {
+        if (is_draft(parse_frontmatter(text))) {
             continue;
         }
         out.push(p);
@@ -193,6 +190,13 @@ function find_active_roadmaps(root: string): string[] {
 /** Return human-readable violation strings for a single roadmap. */
 function violations_for(p: string): string[] {
     const text = fs.readFileSync(p, 'utf-8');
+    const retired = declaresRetiredStatus(text);
+    if (retired !== null) {
+        // Returned alone: a file wearing a deleted status has a migration to do
+        // before its phase structure is worth reporting on, and stacking phase
+        // findings on top would bury the one finding that has to be read first.
+        return [`${p}: ${retiredStatusDiagnostic(retired)}`];
+    }
     PHASE_RE.lastIndex = 0;
     const matches: Array<{ start: number; end: number; id: string; name: string | undefined }> =
         [];
@@ -359,7 +363,6 @@ export {
     CHECKBOX_RE,
     PHASE_RE,
     is_draft,
-    is_carrier,
     is_roadmap_candidate,
     parse_frontmatter,
     find_active_roadmaps,

package/src/scripts/check_rule_layer_partition.ts

@@ -8,7 +8,7 @@
  * ADR-236 decided that a rule is delivered from exactly one layer: package-only
  * rules stay in the project tree, everything else arrives from the host's global
  * directory and is withheld from the project tree. Measured in a freshly
- * generated worktree with `partitionActive: true`, it holds for one host in five:
+ * generated worktree with a verified host layer, it holds for one host in five:
  *
  * ```
  *   .claude/rules      13 files, 13 package-only,   0 global-only
@@ -51,7 +51,7 @@ import * as fs from 'node:fs';
 import * as os from 'node:os';
 import * as path from 'node:path';
 
-import { isExclusivelyPackageOnly, resolvePartitionVerdict } from '../install/partitionEligibility.js';
+import { isExclusivelyPackageOnly } from '../install/partitionEligibility.js';
 import { PROJECT_RULE_DIRS, globalRuleLayerNames, globalRuleLayerPath } from '../install/globalRuleLayers.js';
 import { GateLedger, UnaccountedTargetsError } from './_lib/gate_ledger.js';
 import { reportScanned } from './_lib/scan_scope.js';
@@ -333,7 +333,7 @@ function selfTest(): number {
 /**
  * `--prune`: delete exactly the files this gate reports as duplicated.
  *
- * ## Why a gate ships a repair at all
+ * **Why a gate ships a repair at all.**
  *
  * The documented repair is `task generate-tools`, and on this repository's own main
  * checkout that command is **structurally inert**: `agents/.agent-tools.yml` is
@@ -381,17 +381,39 @@ function prune(audit: PartitionAudit, root: string): number {
 }
 
 /**
- * Does a duplication in this projection mode mean an emitter FAILED, or that the
- * partition deliberately did not run?
+ * Does THIS directory's duplication mean an emitter failed, or that the
+ * per-directory fail-safe legitimately kept the full projection?
  *
- * Split out of `main` so both directions are testable without a lockfile on disk:
- * the un-injected path can only assert whatever the machine happens to be, and this
- * one bit differs between a maintainer checkout mid-release and a partitioned one —
- * the same environment-dependence `ruleLayerPartition.ts` records for its own
- * `active` override.
+ * **The discriminator, corrected 2026-09-07 after a neutral review.**
+ *
+ * It used to be the repo-wide host-layer verdict — first a `PartitionMode`
+ * string, then the `verified` boolean the 2026-09-07 change reduced it to. Both
+ * were wrong in BOTH directions once the withhold stopped reading
+ * `installed.lock`:
+ *
+ *   - FALSE NEGATIVE: an install one release behind makes `verified === false`
+ *     for the whole release window, so a genuine emitter failure — the defect
+ *     this gate exists to catch — printed and returned 0.
+ *   - FALSE POSITIVE: a verified layer that legitimately lacks ONE rule makes
+ *     `partitionRulesForDir` keep all ~104 by design (rules are all-or-nothing,
+ *     `ruleLayerPartition.ts`), and the gate exited 1 on a correct tree.
+ *     `rule_partition_per_host.test.ts` pins that state as legal.
+ *
+ * The right signal was already computed and never asked: `soleCarrier` — the
+ * global-scope rules this directory projects that its host layer does NOT hold.
+ * Non-empty means the fail-safe fired for a reason a reader can check; empty
+ * means the layer carries every withheld name and the emitter simply did not
+ * withhold. Per directory, from data on hand, and independent of any lockfile —
+ * so the verdict no longer differs between a maintainer machine mid-release and
+ * a CI checkout.
+ *
+ * Also note what a stale layer can NOT do under per-name withholding: if the
+ * layer holds the name, the project copy is withheld whatever its CONTENT. So
+ * staleness never produces a duplicate, and the old message's second
+ * justification was keyed on the wrong fact.
  */
-export function partitionEnforces(mode: string): boolean {
-    return mode === 'dual-layer/partitioned';
+export function partitionEnforces(dir: Pick<DirAudit, 'soleCarrier'>): boolean {
+    return dir.soleCarrier.length === 0;
 }
 
 export function main(argv: readonly string[] = process.argv.slice(2)): number {
@@ -485,34 +507,32 @@ export function main(argv: readonly string[] = process.argv.slice(2)): number {
     // partition gate and `check_bridge_derivation` deadlock, each red in the state
     // the other requires.
     //
-    // The block is structural rather than incidental: during ANY release the
-    // building version is ahead of the installed one, so `resolvePartitionVerdict`
-    // returns `standalone/full` on every maintainer machine for the whole release
-    // window. A gate that cannot be green while a release is in progress is not
-    // measuring the release.
+    // Split PER DIRECTORY, not on a repo-wide verdict — see `partitionEnforces` for
+    // why the verdict was wrong in both directions. A directory that is the sole
+    // carrier of at least one global-scope rule kept the full projection by design;
+    // one that carries none is an emitter that did not withhold.
     //
-    // Teeth are unchanged where the partition IS active: there a duplicate means an
-    // emitter failed to withhold what the partition selected, which is the defect
-    // this gate exists to catch. In CI both layers are absent, `offenders` is empty,
-    // and this branch is never reached — so nothing here relaxes the CI reading.
-    const verdict = resolvePartitionVerdict(root);
-    if (!partitionEnforces(verdict.mode)) {
-        for (const d of offenders) {
-            process.stdout.write(
-                `⚠️  ${d.dir}: ${String(d.duplicated.length)} rule(s) also present in ` +
-                    `${d.globalLayer ?? '(unknown)'}\n`,
-            );
-        }
+    // In CI both layers are absent, `offenders` is empty, and neither branch is
+    // reached — so nothing here changes the CI reading.
+    const failing = offenders.filter((d) => partitionEnforces(d));
+    for (const d of offenders.filter((d) => !partitionEnforces(d))) {
+        process.stdout.write(
+            `⚠️  ${d.dir}: ${String(d.duplicated.length)} rule(s) also present in ` +
+                `${d.globalLayer ?? '(unknown)'} — kept by design: this directory is the sole ` +
+                `carrier of ${String(d.soleCarrier.length)} global-scope rule(s) ` +
+                `(e.g. ${d.soleCarrier.slice(0, 3).join(', ')}), and the rule partition is ` +
+                `all-or-nothing per directory.\n`,
+        );
+    }
+    if (failing.length === 0) {
         process.stdout.write(
-            `⚠️  check_rule_layer_partition: partition INACTIVE (${verdict.reason}), so the ` +
-                `generators emit the full projection by design and this overlap is the fail-safe ` +
-                `working. Reported, not enforced — run \`agent-config install\` to activate the ` +
-                `partition here, then this gate has teeth again.\n`,
+            `✅  check_rule_layer_partition: every duplication is the per-directory fail-safe ` +
+                `working — no directory duplicates a rule its host layer fully carries.\n`,
         );
         return 0;
     }
 
-    for (const d of offenders) {
+    for (const d of failing) {
         process.stderr.write(
             `${report ? '⚠️ ' : '❌ '} ${d.dir}: ${String(d.duplicated.length)} rule(s) also present in ` +
                 `${d.globalLayer ?? '(unknown)'} — e.g. ${d.duplicated.slice(0, 5).join(', ')}\n`,

package/src/scripts/check_single_delivery.ts

@@ -34,15 +34,31 @@
  * fix, which teaches readers to ignore it — the exact failure this estate has
  * recorded twice already.
  *
- * The reason used to be that `road-to-single-delivery` Phase 2 was HALTED on
- * blocker `partition-current-layer-undecidable`. That is no longer true and the
- * sentence is corrected rather than left standing: the blocker reads
- * `**Status:** resolved`, its roadmap is archived, and the partition shipped
- * under ADR-236 Phase 2. What replaced the halt is a per-machine activation —
- * the partition withholds artefacts only where the host layer is verified
- * against `installed.lock`, so a machine whose install predates the fingerprint
- * keeps the full projection BY DESIGN and the overlap this gate reports there is
- * the fail-safe working, not a regression.
+ * The reason has been corrected twice rather than left standing. It was first
+ * that `road-to-single-delivery` Phase 2 was HALTED on blocker
+ * `partition-current-layer-undecidable` — no longer true; that blocker reads
+ * `**Status:** resolved` and the partition shipped under ADR-236 Phase 2. It was
+ * then a per-machine activation: the partition withheld only where the host layer
+ * verified against `installed.lock`, so an install one release behind kept the
+ * FULL projection by design and the overlap here was the fail-safe working.
+ *
+ * That second reason is void as of the ADR-236 amendment of 2026-09-07. The
+ * withhold no longer reads `installed.lock` at all — it reads each host
+ * directory's own contents, per NAME. An overlap this gate reports is therefore
+ * one of exactly two things now, and neither is a repo-wide fail-safe:
+ *
+ *   - an artefact the host layer genuinely does NOT hold, kept on its own merits
+ *     (the per-name fail-safe, and the right answer);
+ *   - an emitter that failed to withhold what the evidence said to withhold
+ *     (a defect).
+ *
+ * It still reports rather than enforcing, for the unchanged reason above. The
+ * second reason an earlier draft of this note gave — that the `commands` row's
+ * cluster-DIRECTORY key could read a correct tree as a collision — was true when
+ * written and was fixed in the same change: that row keys on the posix subpath
+ * now (see TYPES). Left recorded rather than deleted, because the argument is
+ * what justified `--enforce` staying opt-in and a reader should see that it no
+ * longer applies.
  *
  * WHERE THIS CHECK IS MEANINGFUL — read this before quoting one of its numbers
  * (road-to-session-closeout 3.3). It is a DEVELOPER-MACHINE check. It reads two
@@ -100,13 +116,23 @@ const REPO_ROOT = path.resolve(path.dirname(_HERE), '..', '..');
  * (`commands/<cluster>/<sub>.md`), so this gate's `commands` row compares cluster
  * DIRECTORY names — a coarser key than the thing the host registers.
  *
- * That gap is recorded rather than closed, and the reason is a measurement: since
- * `commandsWithheld` gates the colon-form generator, a machine with a verified
- * host layer projects ZERO commands, so there is no project-side name for the
- * coarse key to be wrong about. On a machine WITHOUT one, the project layer is
- * the only layer and there is nothing to compare. The key is therefore imprecise
- * exactly where it has no work to do. Closing it would mean reading each command
- * file's own slug — real work for a row whose overlap is 0 in both topologies.
+ * That gap USED to be recorded rather than closed, on a measurement: while the
+ * colon-form generator was gated by one repo-wide verdict, a machine with a
+ * verified host layer projected ZERO commands and a machine without one had
+ * nothing to compare — so the coarse key was imprecise exactly where it had no
+ * work to do.
+ *
+ * **The ADR-236 amendment of 2026-09-07 falsified that, and it was OBSERVED, not
+ * predicted.** Withholding per name leaves the project layer holding exactly the
+ * commands the host lacks, and those can share a cluster with commands the host
+ * has: measured the same day, `.claude/commands/analyze/` held `repo.md` and
+ * `roadmap-repos.md` while `~/.claude/commands/analyze/` held `inbox.md` and
+ * seven others. Zero duplication, and the directory key reported a collision.
+ *
+ * So the `commands` row now keys on the POSIX SUBPATH (`<cluster>/<sub>.md`),
+ * which is the host's own unit. `readLayer` takes a `recursive` flag for it;
+ * `shape` stays a top-level reading so the shape-mismatch line keeps comparing
+ * the same thing it always did.
  *
  * `personas` and `user-types` were added 2026-08-21 (closure correction). See
  * `unknownProjectFamilies` for what now prevents the next omission.
@@ -182,7 +208,7 @@ interface LayerReading {
     shape: LayerShape;
 }
 
-function readLayer(dir: string): LayerReading | null {
+function readLayer(dir: string, recursive = false): LayerReading | null {
     let entries: fs.Dirent[];
     try {
         if (!fs.statSync(dir).isDirectory()) return null;
@@ -191,7 +217,11 @@ function readLayer(dir: string): LayerReading | null {
         return null;
     }
     const shape: LayerShape = { symlinks: 0, dirs: 0, files: 0 };
-    for (const e of entries) {
+    // README.md is excluded from BOTH the names and the shape. Counting it in the
+    // shape while filtering it from the names printed a self-contradicting line
+    // (`personas global 31 · shape (l0/d2/f30)` — 32 entries, 31 names), caught by
+    // a second neutral review.
+    for (const e of entries.filter((x) => x.name !== 'README.md')) {
         // isSymbolicLink() is checked FIRST and deliberately: readdir with
         // withFileTypes does not follow links, but a reader who tested isDirectory
         // first would classify a symlink-to-directory as a directory and lose the
@@ -200,7 +230,41 @@ function readLayer(dir: string): LayerReading | null {
         else if (e.isDirectory()) shape.dirs += 1;
         else shape.files += 1;
     }
-    return { names: entries.map((e) => e.name).sort(), shape };
+    if (!recursive) {
+        // README.md excluded for EVERY family, not only commands. It was excluded
+        // on the recursive path from the start and nowhere else, so a README in
+        // both layers would have counted as one duplicated artefact for rules,
+        // skills, personas, user-types and agents and not for commands — a latent
+        // asymmetry a neutral review caught on 2026-09-07. It names no artefact in
+        // any family.
+        return { names: entries.map((e) => e.name).filter((n) => n !== 'README.md').sort(), shape };
+    }
+    return { names: _mdSubpaths(dir).sort(), shape };
+}
+
+/**
+ * Every `*.md` under `dir`, as a posix path relative to it.
+ *
+ * The identity key for the `commands` row — see the note on TYPES. `README.md` is
+ * excluded because both layers carry one and it names no command.
+ */
+function _mdSubpaths(dir: string): string[] {
+    const out: string[] = [];
+    const walk = (abs: string, rel: string): void => {
+        let kids: fs.Dirent[];
+        try {
+            kids = fs.readdirSync(abs, { withFileTypes: true });
+        } catch {
+            return;
+        }
+        for (const k of kids) {
+            const childRel = rel === '' ? k.name : `${rel}/${k.name}`;
+            if (k.isDirectory()) walk(path.join(abs, k.name), childRel);
+            else if (k.name.endsWith('.md') && k.name !== 'README.md') out.push(childRel);
+        }
+    };
+    walk(dir, '');
+    return out;
 }
 
 /**
@@ -230,8 +294,9 @@ export function declaresPaths(file: string): 'yes' | 'no' | 'unreadable' {
 export function readType(type: ArtefactType, globalRoot: string, projectRoot: string): TypeReading {
     const gDir = path.join(globalRoot, type);
     const pDir = path.join(projectRoot, type);
-    const gLayer = readLayer(gDir);
-    const pLayer = readLayer(pDir);
+    const recursive = type === 'commands';
+    const gLayer = readLayer(gDir, recursive);
+    const pLayer = readLayer(pDir, recursive);
     const globalNames = gLayer?.names ?? null;
     const projectNames = pLayer?.names ?? null;
     const globalShape = gLayer?.shape ?? null;
@@ -500,11 +565,12 @@ export function main(argv?: readonly string[]): number {
             process.stdout.write(
                 'usage: check_single_delivery [--global DIR] [--project DIR] [--enforce] [--quiet]\n' +
                     '\n' +
-                    'Reports by default and exits 0: the partition SHIPPED (ADR-236, Phase 2)\n' +
-                    'but activates per machine — only where a verified host layer exists, so a\n' +
-                    'checkout without one keeps the full projection BY DESIGN and reports overlap.\n' +
-                    '--enforce exits 1 on any overlap; registering it would fail every machine\n' +
-                    'that has not re-run `agent-config install`, which is why it stays opt-in.\n',
+                    'Reports by default and exits 0: since the ADR-236 amendment of\n' +
+                    '2026-09-07 the project layer withholds per ARTEFACT NAME on each host\n' +
+                    "directory's own contents, so an artefact the host layer does not hold is\n" +
+                    'kept BY DESIGN and reads as overlap here. --enforce exits 1 on any\n' +
+                    'overlap. It stays opt-in because a machine whose global layer is stale\n' +
+                    'cannot fix the overlap by regenerating — only by `agent-config install`.\n',
             );
             return 0;
         } else if (a !== undefined) {
@@ -626,11 +692,11 @@ export function main(argv?: readonly string[]): number {
     }
     process.stdout.write(
         `⚠️  check_single_delivery: ${detail}. Reported, not enforced — ` +
-            'the partition shipped (ADR-236 Phase 2) but activates per machine: it withholds ' +
-            'artefacts only where the host layer is verified against `installed.lock`, so a ' +
-            'machine whose install predates the fingerprint keeps the full projection BY DESIGN ' +
-            'and this overlap is the fail-safe working. Run `agent-config install` to enable it ' +
-            'here; use --enforce where every machine is known to be verified.\n',
+            'since the ADR-236 amendment of 2026-09-07 the project layer withholds per ' +
+            "ARTEFACT NAME on each host directory's own contents, never on a version in " +
+            '`installed.lock`. So an artefact the host layer does not hold is kept BY DESIGN ' +
+            'and appears here; a stale global layer is fixed by `agent-config install`. Use ' +
+            '--enforce where every layer is known current.\n',
     );
     return 0;
 }

package/src/scripts/check_update_banner.ts

@@ -157,10 +157,23 @@ async function main(argv: readonly string[] = process.argv.slice(2)): Promise<nu
     return 0;
 }
 
+// `build:delegate-aux` bundles this file with `--splitting`, which can move the
+// module body into a shared chunk: `import.meta.url` then names the CHUNK, the
+// URL comparison below never matches, and the entry silently no-ops. Inside that
+// bundle the invoked file name is the reliable signal (same pattern as
+// src/scripts/_cli/cmd_migrate.ts). Defined by that build only.
+declare const __AGENT_CONFIG_CLI_DELEGATE__: boolean | undefined;
 function _isCliEntry(): boolean {
     if (process.argv[1] === undefined) {
         return false;
     }
+    if (typeof __AGENT_CONFIG_CLI_DELEGATE__ !== 'undefined' && __AGENT_CONFIG_CLI_DELEGATE__) {
+        // A miss falls THROUGH to the URL comparison below, which is the
+        // symlinked-invocation case that fallback exists for.
+        if (path.basename(process.argv[1], '.js') === 'check_update_banner') {
+            return true;
+        }
+    }
     const argvUrl = pathToFileURL(path.resolve(process.argv[1])).href;
     if (import.meta.url === argvUrl) {
         return true;