@event4u/agent-config 16.2.0 → 16.4.0

package/src/scripts/check_memory.ts

@@ -607,7 +607,13 @@ function _checkAppendOnly(base: string | null, findings: Finding[]): void {
         '--no-color',
         ref,
         '--',
-        'agents/memory/intake/',
+        // The JSONL drops, not the directory. `INTAKE_GLOB`, this module's
+        // docstring and every fixture in the suite all scope this check to
+        // `*.jsonl`; asking git for the directory made it govern the tracked
+        // skeleton too, so editing the README that documents the append-only
+        // rule was reported as a violation of it. `:(glob)` is explicit rather
+        // than relying on the default pathspec magic.
+        ':(glob)agents/memory/intake/*.jsonl',
     ]);
     if (rc !== 0) {
         findings.push(new Finding(INTAKE_GLOB, 0, 'warning', `append-only: git diff failed vs ${ref}`));

package/src/scripts/check_pack_size.ts

@@ -332,7 +332,7 @@ export function payloadFingerprint(entryPath: string, size: number): string {
  * convention and the class is empty by observation.
  */
 const BOUND_PAYLOAD_EXCEPTIONS: readonly BoundPayloadException[] = [
-    { fingerprint: '47e4328e71652a0375ade7eb4dac8a3e4b6df1c6e4e74caa75287266676cc9a6', path: 'agents/templates/.ai-council.yml.example', size: 30561, why: 'shipped council config TEMPLATE — a dotfile because the file it is copied to is one. RE-PINNED 2026-09-07, 29,872 -> 30,561 bytes: the exception is path-AND-size-bound by design, so this branch adding a `disabled_reason` honest-null block to the gemini seat in the template invalidated it and the gate refused the entry as unaccounted. The re-pin excepts the SAME path for the SAME reason at its measured new size — it does not widen the class, raise a cap, or except anything the gate was not already carrying.' },
+    { fingerprint: '6de9a60d02af4883ab8f09171673a44924ca78ddadd55518f743e95651d3d257', path: 'agents/templates/.ai-council.yml.example', size: 31548, why: 'shipped council config TEMPLATE — a dotfile because the file it is copied to is one. RE-PINNED 2026-10-06, 30,561 -> 31,548 bytes: the exception is path-AND-size-bound by design, so step 3.1 of road-to-a-spend-bound-only-where-one-was-set moving the template cost_budget and debate ceilings to 0 (ADR-279), removing the stale "always asks before invoking" sentence and explaining both invalidated it and the gate refused the entry as unaccounted. The re-pin excepts the SAME path for the SAME reason at its measured new size — it does not widen the class, raise a cap, or except anything the gate was not already carrying. (Previously RE-PINNED 2026-09-07, 29,872 -> 30,561 bytes, for a `disabled_reason` honest-null block on the gemini seat.)' },
     { fingerprint: 'd36a53951c184db7481139235056e90b53a853714b3a68b31ba1349ecb95ac1d', path: 'agents/templates/.ai-video.xml.example', size: 9209, why: 'shipped video-provider config template — same reason as the council template' },
     { fingerprint: 'f83229412cf8cceaadd0cb1934140a0c7c8277df43edc590f370572f6df6da98', path: 'dist/agent-src/templates/agents/.gitattributes.fragment', size: 2140, why: 'gitattributes fragment the installer appends to a consumer repo' },
     { fingerprint: 'a4f51dba3a66c0f2c3548e77961271ed4d7b5ec8a6661ea359ff044758f0d921', path: 'src/templates/minimal/.agent-settings.yml', size: 1042, why: 'the minimal-install settings template; the dot is the consumer-side filename' },

package/src/scripts/check_release_highlights.ts

@@ -79,6 +79,7 @@ import {
     CURATED_HEAD_INSTRUCTION,
     extract_changelog_section,
 } from './_lib/release_material.js';
+import { coverageLimitationNote, ledgerCoverageLabel } from './_lib/review_coverage.js';
 import { assertScanned, assertWatchlistResolves, DeadScopeError } from './_lib/scan_scope.js';
 
 const _HERE = fileURLToPath(import.meta.url);
@@ -339,6 +340,15 @@ export function main(argv: readonly string[]): number {
     const contradictions = highlight_contradictions(curated, derived);
     if (contradictions.length === 0) {
         process.stdout.write(`✅  curated head plausible for ${version} (span ${from}..${to})\n`);
+        // How much of the change the self-review read, printed where the head's
+        // Known-limitations field is decided. Partial coverage IS a known
+        // limitation of the record, and the ledger was the only place it was
+        // written down. A label, not a floor — the exit code above is already
+        // fixed at 0 by the time this runs, deliberately.
+        const covNote = coverageLimitationNote(ledgerCoverageLabel(REPO_ROOT, version));
+        if (covNote !== null) {
+            process.stdout.write(`${covNote}\n`);
+        }
         // Risk 2 of the roadmap that made `Known limitations` derivable, paid
         // where it lands rather than in a comment: a self-declared residual is
         // only detectable when somebody WROTE IT DOWN, so a derived `_none_`

package/src/scripts/check_release_manifest_content.ts

@@ -0,0 +1,189 @@
+#!/usr/bin/env tsx
+/**
+ * Release-manifest content check — the content half beside
+ * `check_release_pr_shape`.
+ *
+ * The shape check lets a release PR carry `package.json`, `package-lock.json`
+ * and the three plugin manifests, and it reads only their NAMES. Smoke is
+ * skipped on release heads (`docs/contracts/release-pr-gating.md`), so an added
+ * script, a new dependency or a changed `bin` path could ride a release PR with
+ * no gate reading it. This compares each manifest against the base and fails on
+ * any difference outside the version fields the release writes.
+ *
+ * Version fields are named per file, never matched by key name anywhere: in
+ * `package-lock.json` every dependency also has a `version`, and a key-name
+ * rule would wave a dependency bump through as a version bump.
+ *
+ * Usage: check_release_manifest_content [--base REF] [--root DIR]
+ *   --base REF   ref the head is compared against (default: origin/main)
+ *   --root DIR   repository root to read the head and run git in (testing)
+ *
+ * Exit codes: 0 = only version fields differ · 1 = other difference · 2 = usage/env.
+ */
+
+import { spawnSync } from 'node:child_process';
+import * as fs from 'node:fs';
+import * as path from 'node:path';
+import { fileURLToPath, pathToFileURL } from 'node:url';
+
+import { DeadScopeError, reportScanned } from './_lib/scan_scope.js';
+
+const _HERE = fileURLToPath(import.meta.url);
+const REPO_ROOT = path.resolve(path.dirname(_HERE), '..', '..');
+
+type Segment = string;
+/** A JSON path pattern; `*` matches any array index. */
+type Pattern = readonly Segment[];
+
+/** The manifests a release PR may carry, and the fields the release writes in each. */
+export const VERSION_FIELDS: Readonly<Record<string, readonly Pattern[]>> = {
+    'package.json': [['version']],
+    'package-lock.json': [['version'], ['packages', '', 'version']],
+    '.claude-plugin/marketplace.json': [['version'], ['metadata', 'version'], ['plugins', '*', 'version']],
+    '.augment-plugin/plugin.json': [['version']],
+    '.augment-plugin/marketplace.json': [['version'], ['metadata', 'version'], ['plugins', '*', 'version']],
+};
+
+function _matches(p: readonly Segment[], pat: Pattern): boolean {
+    if (p.length !== pat.length) return false;
+    return pat.every((seg, i) => seg === p[i] || (seg === '*' && /^\d+$/u.test(p[i] ?? '')));
+}
+
+function _render(p: readonly Segment[]): string {
+    return p.length === 0 ? '(root)' : p.map((s) => (/^\d+$/u.test(s) ? `[${s}]` : JSON.stringify(s))).join('.');
+}
+
+function _isObject(v: unknown): v is Record<string, unknown> {
+    return v !== null && typeof v === 'object' && !Array.isArray(v);
+}
+
+/** Every JSON path at which `a` and `b` differ, leaf-first where both are containers. */
+function _diffPaths(a: unknown, b: unknown, at: Segment[] = []): Segment[][] {
+    if (Array.isArray(a) && Array.isArray(b)) {
+        if (a.length !== b.length) return [at];
+        return a.flatMap((v, i) => _diffPaths(v, b[i], [...at, String(i)]));
+    }
+    if (_isObject(a) && _isObject(b)) {
+        const keys = new Set([...Object.keys(a), ...Object.keys(b)]);
+        const out: Segment[][] = [];
+        for (const k of keys) {
+            if (!(k in a) || !(k in b)) {
+                out.push([...at, k]);
+                continue;
+            }
+            out.push(..._diffPaths(a[k], b[k], [...at, k]));
+        }
+        return out;
+    }
+    return JSON.stringify(a) === JSON.stringify(b) ? [] : [at];
+}
+
+/**
+ * The differences between `base` and `head` text of one manifest that are NOT a
+ * version-string change in a declared version field. Empty means in shape.
+ */
+export function manifestDifferences(file: string, base: string | null, head: string | null): string[] {
+    if (base === null && head === null) return [];
+    if (base === null) return [`${file}: added — absent at the base`];
+    if (head === null) return [`${file}: removed — present at the base`];
+    let a: unknown;
+    let b: unknown;
+    try {
+        a = JSON.parse(base);
+        b = JSON.parse(head);
+    } catch (err) {
+        return [`${file}: not parseable JSON (${(err as Error).message})`];
+    }
+    const allowed = VERSION_FIELDS[file] ?? [];
+    const out: string[] = [];
+    for (const p of _diffPaths(a, b)) {
+        const atVersion = allowed.some((pat) => _matches(p, pat));
+        let before: unknown = a;
+        let after: unknown = b;
+        for (const s of p) {
+            before = (before as Record<string, unknown> | undefined)?.[s];
+            after = (after as Record<string, unknown> | undefined)?.[s];
+        }
+        if (atVersion && typeof before === 'string' && typeof after === 'string') continue;
+        out.push(`${file}: ${_render(p)} differs outside the version fields`);
+    }
+    return out;
+}
+
+function _git(args: readonly string[], cwd: string): { status: number; stdout: string } {
+    const r = spawnSync('git', args, { cwd, encoding: 'utf8' });
+    return { status: r.status ?? 1, stdout: r.stdout ?? '' };
+}
+
+function _readHead(root: string, file: string): string | null {
+    const abs = path.join(root, file);
+    return fs.existsSync(abs) ? fs.readFileSync(abs, 'utf8') : null;
+}
+
+export function main(argv: readonly string[] = process.argv.slice(2)): number {
+    let base = 'origin/main';
+    let root = REPO_ROOT;
+    for (let i = 0; i < argv.length; i += 1) {
+        const a = argv[i];
+        if (a === '--base' || a === '--root') {
+            const v = argv[i + 1];
+            if (v === undefined || v === '') {
+                process.stderr.write(`error: ${a} needs a value\n`);
+                return 2;
+            }
+            if (a === '--base') base = v;
+            else root = path.resolve(v);
+            i += 1;
+            continue;
+        }
+        process.stderr.write(`error: unknown argument ${String(a)}\n`);
+        return 2;
+    }
+    if (_git(['rev-parse', '--verify', `${base}^{commit}`], root).status !== 0) {
+        process.stderr.write(`error: base \`${base}\` does not resolve to a commit in ${root}\n`);
+        return 2;
+    }
+
+    const findings: string[] = [];
+    let scanned = 0;
+    for (const file of Object.keys(VERSION_FIELDS)) {
+        const shown = _git(['show', `${base}:${file}`], root);
+        const before = shown.status === 0 ? shown.stdout : null;
+        const after = _readHead(root, file);
+        if (before !== null || after !== null) scanned += 1;
+        findings.push(...manifestDifferences(file, before, after));
+    }
+    try {
+        reportScanned({ gate: 'check_release_manifest_content', scanned, units: 'manifests', roots: [root] });
+    } catch (err) {
+        if (err instanceof DeadScopeError) {
+            process.stderr.write(`${err.message}\n`);
+            return 2;
+        }
+        throw err;
+    }
+    if (findings.length > 0) {
+        process.stdout.write(
+            `❌  release manifests differ from ${base} outside their version fields:\n` +
+                findings.map((f) => `  · ${f}`).join('\n') +
+                '\n  A release PR carries version bumps only. Land the other change on main via its own PR.\n',
+        );
+        return 1;
+    }
+    process.stdout.write(`✅  release manifests differ from ${base} in version fields only (${String(scanned)} read)\n`);
+    return 0;
+}
+
+function _isCliEntry(): boolean {
+    if (process.argv[1] === undefined) return false;
+    if (import.meta.url === pathToFileURL(path.resolve(process.argv[1])).href) return true;
+    try {
+        return fs.realpathSync(_HERE) === fs.realpathSync(path.resolve(process.argv[1]));
+    } catch {
+        return false;
+    }
+}
+
+if (_isCliEntry()) {
+    process.exit(main());
+}

package/src/scripts/check_release_pr_shape.ts

@@ -45,6 +45,16 @@ const ALLOWLIST_GLOBS = [
     // be able to carry the dispositions of its own self-review findings; the
     // finding-dispositions gate is red until blocking ones are recorded here.
     'agents/evidence/release-findings/*.json',
+    // Evidence-temperature census — `taskfiles/content.yml` § release-prepare
+    // writes one per release, so without this entry the pipeline generates a
+    // file its own shape step refuses. Digit classes rather than `?`: fnmatch
+    // `?` compiles to `.` under the `s` flag, so it matches any character AND
+    // crosses `/` — `????-??-??` admits `evidence-temperature-x/yz-ab-cd.md`,
+    // which `[0-9]` cannot. Two reports can appear in one release PR, and
+    // both are in shape: `--resume` re-runs release-prepare, so a release
+    // carried across UTC midnight writes a second census. What that one
+    // contains is the census's business, not this gate's.
+    'agents/evidence/analysis/evidence-temperature-[0-9][0-9][0-9][0-9]-[0-9][0-9]-[0-9][0-9].md', // code-comment-allow provenance-comment -- the glob IS this gate's operand, not where the code came from
     // Project-settings template pin — bumped by release.ts set_template_pin and
     // its regenerated dist twin (kept in lockstep with package.json.version).
     'src/agent-src/templates/agents/agent-project-settings.example.yml',
@@ -52,16 +62,26 @@ const ALLOWLIST_GLOBS = [
 ] as const;
 
 /**
- * Translate a Python `fnmatch` shell pattern to a RegExp, mirroring
- * `fnmatch.translate`. fnmatch is case-sensitive on POSIX (fnmatchcase
- * semantics on the normalized path); `*` and `?` do NOT cross path
- * separators is NOT a property of fnmatch — `*` matches everything
- * including `/`. The allowlist relies on that (e.g. nested-file rejection
- * in the test works because none of the globs end with the file).
+ * Translate a Python `fnmatch` shell pattern to a RegExp, following
+ * `fnmatch.translate` for the constructs the allowlist actually uses: `*` and
+ * `[0-9]`. No entry uses `?`, and bracket handling beyond that one class is
+ * unverified against CPython — see the note at the bracket branch.
+ *
+ * Matching is case-sensitive, as `fnmatchcase` on a normalized path.
+ *
+ * THE PROPERTY THE WILDCARD ENTRIES TURN ON — the literal paths are unaffected:
+ * in fnmatch, `*` and `?` DO cross path separators.
+ * `*` becomes `.*` and `?` becomes `.`, both under the `s` flag, so each matches
+ * `/` like any other character. Glob syntax elsewhere (shells, .gitignore) stops
+ * `*` at a segment boundary; this does not. So the pack entry admits any depth
+ * beneath `src/packs/`, and the census entry uses digit classes precisely
+ * because they cannot match a separator. Both sides are pinned in
+ * `check_release_pr_shape.test.ts`.
  */
 function _fnmatchToRegExp(pat: string): RegExp {
-    // Mirror Python fnmatch.translate: `*` → `.*`, `?` → `.`, `[seq]` kept,
-    // everything else escaped. The full pattern is anchored with `(?s:...)\Z`.
+    // `*` → `.*`, `?` → `.`, a bracket class kept, everything else escaped.
+    // CPython does more inside a class (hyphen and set-operator escaping, `(?!)`
+    // for an empty one) and this does not — see the bracket branch below.
     let i = 0;
     const n = pat.length;
     let res = '';
@@ -87,12 +107,13 @@ function _fnmatchToRegExp(pat: string): RegExp {
                 res += '\\[';
             } else {
                 let stuff = pat.slice(i, j);
-                if (!stuff.includes('-')) {
-                    stuff = stuff.replace(/\\/g, '\\\\');
-                } else {
-                    // Rare; not used by the allowlist. Keep simple escape.
-                    stuff = stuff.replace(/\\/g, '\\\\');
-                }
+                // The two arms this replaces were byte-identical, so the branch
+                // implemented nothing. Bracket handling here is checked against
+                // `[0-9]`, the only class the allowlist uses; anything else is
+                // untested against CPython, whose behaviour also varies by
+                // version. Add a bracket glob and verify it rather than assuming
+                // this mirrors `fnmatch.translate` beyond that one case.
+                stuff = stuff.replace(/\\/g, '\\\\');
                 i = j + 1;
                 if (stuff.startsWith('!')) {
                     stuff = '^' + stuff.slice(1);
@@ -105,7 +126,9 @@ function _fnmatchToRegExp(pat: string): RegExp {
             res += c.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
         }
     }
-    // Python uses `(?s:%s)\Z` — dotAll + full match.
+    // Full match with dotAll. Python spells the same thing `(?s:%s)\Z`; in JS
+    // `$` without the `m` flag does not match before a trailing newline, so
+    // `^(?:…)$` is equivalent rather than merely similar.
     return new RegExp(`^(?:${res})$`, 's');
 }
 

package/src/scripts/check_standing_rule_delivery.ts

@@ -31,26 +31,47 @@
  * Exit codes: `0` under cap · `1` over cap or an unstated cap raise · `2` usage
  * error · `3` dead scan scope.
  *
- * ## This is deliberately NOT a CI gate
+ * THIS IS DELIBERATELY NOT A CI GATE, AND THE REASON IS NARROWER THAN IT WAS.
  *
- * Both inputs are machine-local by construction. `.claude/rules/` is gitignored
- * (`.gitignore:123` — it is generated by `task sync` / `task generate-tools`),
- * and no CI workflow performs a user-scope install, so on a fresh runner
- * **neither** layer exists. Wired into `ci` it would either red on a dead scope
- * or, with the empty case allowed, sit permanently green while certifying a
- * property it cannot observe — the exact failure `src/config/gate-coverage.yml`
- * was written to end. It is therefore registered as a local / doctor-surface
- * check and is absent from `gate-coverage.yml`, whose contract is CI-identical
- * invocation.
+ * **Corrected 2026-10-05 (step 0.1 of
+ * `road-to-a-rule-carrier-that-works-outside-the-repo`).** This section used to
+ * say "no CI workflow performs a user-scope install, so on a fresh runner
+ * **neither** layer exists", and then concluded that making the measurement
+ * CI-observable "needs the `InstructionsLoaded` record committed from a real
+ * session, which is a different piece of work". The first clause describes a
+ * workflow inventory; the second turns it into a capability claim, and that
+ * step does not hold. A runner CAN stage a user-scope install: the installer
+ * reads `HOME` from the environment, and
+ * `tests/install/global_install_hooks_smoke.test.ts` already drives
+ * `src/scripts/install --global --tools=claude-code` against a `mkdtemp` HOME
+ * and asserts the tree it produced. Nothing about the `InstructionsLoaded`
+ * event is required to observe the FILESYSTEM half, which is what this script's
+ * `filesystem` input reads.
  *
- * What that costs, stated plainly: the duplicate-delivery defect is not
+ * What stays true, and is the real reason this is not in `gate-coverage.yml`:
+ * **this gate measures THIS machine**, by design. `main()` resolves
+ * `os.homedir()` and `REPO_ROOT`, and the question it answers — "how much is
+ * the developer in front of me actually loading" — is about a machine, not
+ * about a commit. A CI run of it would measure the runner, which is a tree
+ * nobody works in, so the number would be real and uninteresting. The
+ * `measureStandingDelivery` function underneath takes both directories as
+ * PARAMETERS and is therefore already temp-HOME-capable; what is missing is a
+ * reason to point it at a runner, not a way to.
+ *
+ * The honest cost is unchanged: the duplicate-delivery defect is not
  * mechanically caught for anyone who never runs this locally. The enforced layer
  * is the installer gate (`install.ts::_gate_rule_layer_overlap`), which refuses
  * to CREATE the doubled state; this script measures a state that already exists.
- * Making the measurement CI-observable needs the `InstructionsLoaded` record
- * committed from a real session, which is a different piece of work.
+ *
+ * `_lib/installed_layer.ts` is the step-0.1 library that takes the same reading
+ * per host rule directory with every input as a parameter, and
+ * `installed_layer_report.ts` is its report. The two measure different things —
+ * that one counts characters after the frontmatter and block-comment strip,
+ * this one counts tokens over whole files against a cap — and neither number
+ * converts into the other.
  */
 
+import { createHash } from 'node:crypto';
 import * as fs from 'node:fs';
 import * as os from 'node:os';
 import * as path from 'node:path';
@@ -60,6 +81,8 @@ import { fileURLToPath } from 'node:url';
 import { assertScanned, DeadScopeError, reportScanned } from './_lib/scan_scope.js';
 import { measure, method_note } from './_lib/token_count.js';
 import * as rule_layer_overlap from './_lib/rule_layer_overlap.js';
+import { lawText, ruleBody } from './_lib/rule_law_section.js';
+import { is_thin_entry, lawDigest, STUB_LAW_OPEN } from './_lib/thin_rules.js';
 
 const PROG = 'check_standing_rule_delivery';
 const _HERE = fileURLToPath(import.meta.url);
@@ -185,6 +208,80 @@ export function measureStandingDelivery(
     };
 }
 
+/** One installed rule, compared against the source it was installed from. */
+export interface ReinstallRow {
+    readonly layer: string;
+    readonly id: string;
+    /** What the two digests are of — named, so a reader knows what "differs" means. */
+    readonly compared: 'body' | 'law' | 'none';
+    readonly installed: string;
+    readonly source: string;
+    readonly status: 'current' | 'pending reinstall' | 'no source';
+}
+
+function bodyDigest(text: string): string {
+    return createHash('sha256').update(ruleBody(text), 'utf-8').digest('hex').slice(0, 16);
+}
+
+/**
+ * Per installed rule: its digest against the CURRENT source digest
+ * (`road-to-a-default-install-served-once` step 1.2).
+ *
+ * The cap above measures installed directories only, by design, so a source
+ * rule that got smaller is invisible until a reinstall. This names every rule
+ * whose installed copy no longer matches its source as `pending reinstall`.
+ * It REPORTS and fails nothing — every source edit makes an older install
+ * differ, and that is a state to act on, not an error.
+ *
+ * What is compared depends on the installed form, and the row says which:
+ *
+ * - **body** — a full-bodied copy: sha256 of the body after the frontmatter
+ *   and comment strip, because the installer rewrites the frontmatter into
+ *   host form and the body is what the host reads.
+ * - **law** — a stub carrying a copied law: the digest the stub recorded
+ *   against the digest of the source's law section today.
+ * - **none** — a stub with no copied text: its body is read from the package
+ *   at delivery, so nothing installed can go stale.
+ */
+export function reinstallRows(
+    layer: string,
+    installed_dir: string,
+    source_dir: string,
+): ReinstallRow[] {
+    const l = rule_layer_overlap.readRuleLayer(installed_dir);
+    if (l === null) return [];
+    const rows: ReinstallRow[] = [];
+    for (const [name, text] of l.files) {
+        const id = name.replace(/\.md$/, '');
+        let src: string | null;
+        try {
+            src = fs.readFileSync(path.join(source_dir, name), 'utf-8');
+        } catch {
+            src = null;
+        }
+        let compared: ReinstallRow['compared'] = 'body';
+        let installed = bodyDigest(text);
+        let source = src === null ? '-' : bodyDigest(src);
+        if (is_thin_entry(text)) {
+            const at = text.indexOf(STUB_LAW_OPEN);
+            if (at === -1) {
+                compared = 'none';
+                installed = '-';
+                source = '-';
+            } else {
+                compared = 'law';
+                installed = text.slice(at + STUB_LAW_OPEN.length).split(' ')[0] ?? '';
+                const law = src === null ? null : lawText(ruleBody(src));
+                source = law === null ? '-' : lawDigest(law);
+            }
+        }
+        const status: ReinstallRow['status'] =
+            src === null ? 'no source' : installed === source ? 'current' : 'pending reinstall';
+        rows.push({ layer, id, compared, installed, source, status });
+    }
+    return rows;
+}
+
 /**
  * Where the loaded-instruction record would live if the host wrote one.
  *
@@ -311,6 +408,25 @@ export function main(argv: readonly string[] = process.argv.slice(2)): number {
         );
     }
 
+    // Step 1.2 — the installed copy against the current source, per rule.
+    // Reported, never failed: see `reinstallRows`.
+    const source_dir = path.join(REPO_ROOT, 'dist', 'agent-src', 'rules');
+    const rows = [
+        ...reinstallRows('global', path.join(os.homedir(), '.claude', 'rules'), source_dir),
+        ...reinstallRows('project', path.join(REPO_ROOT, '.claude', 'rules'), source_dir),
+    ];
+    const pending = rows.filter((r) => r.status === 'pending reinstall');
+    out(
+        `  reinstall ${pending.length} of ${rows.length} installed rule(s) differ from `
+            + `${path.relative(REPO_ROOT, source_dir)} (installed digest vs current source digest)\n`,
+    );
+    for (const r of rows) {
+        out(
+            `    ${r.layer.padEnd(8)} ${r.id.padEnd(40)} ${r.compared.padEnd(5)} `
+                + `${r.installed.padEnd(16)} ${r.source.padEnd(16)} ${r.status}\n`,
+        );
+    }
+
     const pct = total / budget.total_cap_tokens;
     out(
         `  TOTAL    ${String(total).padStart(13)} tok / ${budget.total_cap_tokens} cap `

package/src/scripts/check_suppression_hygiene.ts

@@ -264,11 +264,8 @@ export const SUPPRESSION_INVENTORY: readonly SuppressionSpec[] = [
         file: 'src/config/conformance-claim-baseline.json',
         listKey: 'undeclared',
         tier: 'string_list',
-        // Absent at the base ref because this change introduces it. Remove the
-        // flag on the next change once the introducing commit is an ancestor of
-        // main — the scan below fails while it is set and the file resolves,
-        // so the flag closes itself rather than needing to be remembered.
-        newInThisChange: true,
+        // `newInThisChange` removed: the baseline resolves at the base ref since
+        // 9a013fac5, and the scan reported the stale flag as designed.
         what: 'skill and rule artefacts carrying a standard-conformance claim with no enforced_by declaration',
     },
 ];