@event4u/agent-config 9.20.0 → 9.22.0

package/src/scripts/check_discovery_determinism.ts

@@ -19,6 +19,8 @@ import * as path from 'node:path';
 import * as fs from 'node:fs';
 import { fileURLToPath, pathToFileURL } from 'node:url';
 
+import { assertScanned, DeadScopeError } from './_lib/scan_scope.js';
+
 const _HERE = fileURLToPath(import.meta.url);
 const ROOT = path.resolve(path.dirname(_HERE), '..', '..');
 const SCANNER = path.join(ROOT, 'src', 'scripts', 'build_discovery_manifest.ts');
@@ -76,6 +78,30 @@ class ExitError extends Error {}
 function main(): number {
     const a = _normalise(_run());
     const b = _normalise(_run());
+
+    // Determinism over an EMPTY manifest is vacuously true: if the scanner's
+    // artefact roots moved, both runs emit zero artefacts, the two payloads
+    // compare equal, and this gate reports "OK: deterministic" having compared
+    // nothing. Assert the corpus the comparison ran over, not the comparison.
+    // Deletion test: wiping the artefact tree would give 0 — which is blindness
+    // here, never success — so no `allowEmpty`. Exit 1 is this pinned CLI's
+    // only failure code (the scanner-failed path also exits 1, via ExitError).
+    const artefacts = a['artefacts'];
+    try {
+        assertScanned({
+            gate: 'check_discovery_determinism',
+            scanned: Array.isArray(artefacts) ? artefacts.length : 0,
+            units: 'manifest artefact(s)',
+            roots: ['src/scripts/build_discovery_manifest.ts → manifest.artefacts'],
+        });
+    } catch (exc) {
+        if (exc instanceof DeadScopeError) {
+            process.stderr.write(`${exc.message}\n`);
+            return 1;
+        }
+        throw exc;
+    }
+
     const sa = _dumps(a);
     const sb = _dumps(b);
     if (sa !== sb) {

package/src/scripts/check_enforcement_coverage.ts

@@ -37,6 +37,8 @@ import * as fs from 'node:fs';
 import * as path from 'node:path';
 import { fileURLToPath, pathToFileURL } from 'node:url';
 
+import { assertScanned, DeadScopeError } from './_lib/scan_scope.js';
+
 const _HERE = path.dirname(fileURLToPath(import.meta.url));
 const REPO_ROOT = path.resolve(_HERE, '..', '..');
 const RULES_DIR = path.join(REPO_ROOT, 'src', 'rules');
@@ -478,6 +480,24 @@ function main(argv: string[]): number {
     }
 
     const rows = collect();
+    // Count every rule read, not the declared subset: with an empty rules dir
+    // the report renders "0/0 rules (0%)" and exits green, and `summarise`
+    // special-cases the zero denominator rather than rejecting it. Exit 2 is
+    // the code the missing-rules-dir guard above already uses for this class.
+    try {
+        assertScanned({
+            gate: 'check_enforcement_coverage',
+            scanned: rows.length,
+            units: 'rule file(s)',
+            roots: ['src/rules'],
+        });
+    } catch (exc) {
+        if (exc instanceof DeadScopeError) {
+            process.stderr.write(`❌  ${exc.message}\n`);
+            return 2;
+        }
+        throw exc;
+    }
     const summary = summarise(rows);
 
     if (as_json) {

package/src/scripts/check_evaluator_budgets.ts

@@ -40,6 +40,8 @@ import * as fs from 'node:fs';
 import * as path from 'node:path';
 import { fileURLToPath } from 'node:url';
 
+import { assertScanned, DeadScopeError } from './_lib/scan_scope.js';
+
 const REPO_ROOT = path.resolve(fileURLToPath(import.meta.url), '..', '..', '..');
 const BUDGETS_PATH = path.join(REPO_ROOT, 'src', 'config', 'evaluator-budgets.json');
 
@@ -230,6 +232,27 @@ export function main(argv: string[] = process.argv.slice(2)): number {
         return 2;
     }
 
+    // The budget document IS the corpus: every finding below is produced by
+    // iterating it, so a budgets file that parses to no entries reports
+    // "✅ evaluator budgets met (0 metrics)" — green over nothing, the exact
+    // shape this harness exists to end. A missing `budgets` key counts as 0 for
+    // the same reason. Exit 2 (documented internal error — the gate could not
+    // run), never 1, which means a metric actually breached.
+    try {
+        assertScanned({
+            gate: 'check_evaluator_budgets',
+            scanned: Object.keys(budgetsDoc.budgets ?? {}).length,
+            units: 'budgeted metric(s)',
+            roots: ['src/config/evaluator-budgets.json (budgets)'],
+        });
+    } catch (e) {
+        if (e instanceof DeadScopeError) {
+            process.stderr.write(`❌  ${e.message}\n`);
+            return 2;
+        }
+        throw e;
+    }
+
     // The committed record is optional: a fresh checkout before the first
     // nightly has none, and a missing record must not fake a green drift check.
     const recordPath = argValue(argv, '--recorded') ?? path.join(REPO_ROOT, RECORD_REL);

package/src/scripts/check_finding_dispositions.ts

@@ -34,6 +34,8 @@ import * as path from 'node:path';
 import process from 'node:process';
 import { fileURLToPath } from 'node:url';
 
+import { assertScanned, DeadScopeError } from './_lib/scan_scope.js';
+
 const _HERE = fileURLToPath(import.meta.url);
 const REPO_ROOT = path.resolve(path.dirname(_HERE), '..', '..');
 
@@ -235,6 +237,33 @@ function main(argv: readonly string[]): number {
         }
     }
 
+    // Scope declaration, not a scope guard. The ledger is written per release by
+    // `--ingest`, so "no <release>.json" is the normal state of a release whose
+    // self-review reported nothing — the gate's own success line says so. That
+    // makes an absent file indistinguishable from a moved ledger dir here, and
+    // the honest reading is that the corpus count cannot carry that signal: the
+    // durable trigger for an un-ingested finding is `--pr` mode, which compares
+    // the ledger against what the self-review actually reported.
+    try {
+        assertScanned({
+            gate: 'check_finding_dispositions',
+            scanned: ledger.findings.length,
+            units: 'recorded finding(s)',
+            roots: [path.relative(REPO_ROOT, ledgerPath)],
+            allowEmpty:
+                'EMPTY_VALID: zero recorded findings IS the pass state for a release whose '
+                + 'self-review reported none — the ledger file is created on first --ingest, so a '
+                + 'clean release legitimately has no <version>.json. Un-ingested findings are '
+                + 'caught by --pr (unrecorded_findings), never by this count.',
+        });
+    } catch (exc) {
+        if (exc instanceof DeadScopeError) {
+            process.stderr.write(`❌  ${exc.message}\n`);
+            return 1;
+        }
+        throw exc;
+    }
+
     const problems = missing_dispositions(ledger.findings);
     if (pr) {
         const reported = parse_comment_findings(_gh_comment_bodies(pr));

package/src/scripts/check_gate_coverage.ts

@@ -51,6 +51,8 @@ import { fileURLToPath, pathToFileURL } from 'node:url';
 import * as yaml from 'js-yaml';
 import { checkRatchet } from './_lib/gate_baseline.js';
 import { runCountedProbe } from './_lib/counted_probe.js';
+import { listGateScripts } from './_lib/gate_population.js';
+import { assertScanned } from './_lib/scan_scope.js';
 
 const _HERE = fileURLToPath(import.meta.url);
 const REPO_ROOT = path.resolve(path.dirname(_HERE), '..', '..');
@@ -260,6 +262,18 @@ export function main(argv: readonly string[]): number {
   let specs: GateSpec[];
   try {
     specs = load_manifest();
+    // This guard's own scan scope is the manifest. It already refused an empty
+    // gate list ("a coverage guard over an empty set is vacuous"), but as a
+    // bespoke throw — invisible to the very population test below, which is how
+    // the meta-gate ended up outside its own definition of hardened. Routing the
+    // same condition through the shared assertion is the honest fix: no new
+    // behaviour, one shape for "this gate read nothing".
+    assertScanned({
+      gate: 'check_gate_coverage',
+      scanned: specs.length,
+      units: 'manifest gate(s)',
+      roots: [path.relative(REPO_ROOT, MANIFEST)],
+    });
   } catch (e) {
     process.stderr.write(`❌  gate-coverage manifest: ${(e as Error).message}\n`);
     return 2;
@@ -358,33 +372,66 @@ export function report_hardening_ratchet(): number {
 }
 
 /**
- * Gate scripts that neither assert their scan scope nor publish a count — the
- * population still able to report success over an empty corpus.
+ * Manifest ids whose `scanned:` line is actually ENFORCED against a floor.
  *
- * A gate counts as hardened when it routes through `_lib/scan_scope` (the
- * assertion that turns a zero scan into a red exit) OR emits the machine-
- * readable `scanned:` line the coverage guard reads. Either one makes a dead
- * root visible; neither is satisfiable by a gate that read nothing.
+ * A `pending` entry, or an enforced one with `min_scanned: 0`, reads the line
+ * without being able to fail on it — so it cannot make a gate hardened either.
+ * Read best-effort: an unreadable manifest yields an empty set, which pushes
+ * every emit-only gate back into the unhardened count. That direction is
+ * deliberate — a coverage guard that cannot read its own manifest should
+ * over-report exposure, never under-report it.
  */
-export function list_unhardened_gates(dir = path.join(REPO_ROOT, 'src/scripts')): string[] {
-  let entries: string[];
+export function enforced_manifest_ids(file = MANIFEST): Set<string> {
   try {
-    entries = fs.readdirSync(dir);
+    return new Set(
+      load_manifest(file)
+        .filter((s) => s.status === 'enforced' && s.min_scanned >= 1)
+        .map((s) => s.id),
+    );
   } catch {
-    return [];
+    return new Set<string>();
   }
-  const gates = entries.filter((f) => /^(lint|check|audit)_.*\.ts$/.test(f) && !f.endsWith('.d.ts'));
+}
+
+/**
+ * Gate scripts that neither assert their scan scope nor publish an ENFORCED
+ * count — the population still able to report success over an empty corpus.
+ *
+ * ```
+ * hardened ⇔ routes through _lib/scan_scope
+ *          ∨ (emits `scanned:` ∧ registered enforced in gate-coverage.yml with a floor)
+ * ```
+ *
+ * The second clause used to be a bare "emits `scanned:`". Measured 2026-08-04
+ * while chartering the conversion of the remaining 189: a printed count is only
+ * a *guard* for the gates this file actually runs against a floor. For an
+ * unregistered gate the line is decoration — it can print `scanned: 0` out of a
+ * deleted root and still exit 0, with nobody reading it. That made the cheapest
+ * route to a green ratchet (add one write per gate) also the route that changes
+ * nothing, while "pad the manifest" is an explicit non-goal of the conversion
+ * roadmap. Requiring registration closes the loop: to harden by emitting you
+ * must accept a floor, and everything else asserts.
+ *
+ * The tightening cost the existing population nothing — all 14 emit-only gates
+ * were already registered enforced — which is why it is a drift repair against
+ * this guard's own charter ("asserts its scan scope … or carries a justified
+ * `allowEmpty`") rather than a moved goalpost.
+ */
+export function list_unhardened_gates(
+  dir = path.join(REPO_ROOT, 'src/scripts'),
+  registered: ReadonlySet<string> = enforced_manifest_ids(),
+): string[] {
   const out: string[] = [];
-  for (const f of gates) {
+  for (const id of listGateScripts(dir, (d) => fs.readdirSync(d))) {
     let src: string;
     try {
-      src = fs.readFileSync(path.join(dir, f), 'utf8');
+      src = fs.readFileSync(path.join(dir, `${id}.ts`), 'utf8');
     } catch {
       continue;
     }
-    const asserts = /assertScanned\(|assertWatchlistResolves\(/.test(src);
+    const asserts = /assertScanned\(|assertWatchlistResolves\(|reportScanned\(/.test(src);
     const emits = /(?:process\.(?:stdout|stderr)\.write|lines\.push)\(\s*`scanned: /.test(src);
-    if (!asserts && !emits) out.push(f.replace(/\.ts$/, ''));
+    if (!asserts && !(emits && registered.has(id))) out.push(id);
   }
   return out.sort();
 }
@@ -637,13 +684,7 @@ export function render_ledger(
 
 /** Count of gate-shaped scripts, for the honest denominator in the ledger. */
 export function count_gate_scripts(dir = path.join(REPO_ROOT, 'src/scripts')): number {
-  try {
-    return fs
-      .readdirSync(dir)
-      .filter((f) => /^(lint|check|audit)_.*\.ts$/.test(f) && !f.endsWith('.d.ts')).length;
-  } catch {
-    return 0;
-  }
+  return listGateScripts(dir, (d) => fs.readdirSync(d)).length;
 }
 
 function run_canary_mode(specs: readonly GateSpec[], argv: readonly string[]): number {

package/src/scripts/check_gate_paths.ts

@@ -20,7 +20,9 @@
  * synchronous. No behaviour changes.
  *
  * Exit codes: 0 = all enforced targets resolve under the source tree ·
- * 1 = at least one missing / out-of-tree target · 2 = a gate failed to import.
+ * 1 = at least one missing / out-of-tree target · 2 = a gate failed to import
+ * (which now includes a dead scan scope — zero enforced targets across the
+ * whole GATES list — reported through `_lib/scan_scope`).
  */
 
 import { spawnSync } from 'node:child_process';
@@ -28,6 +30,8 @@ import * as fs from 'node:fs';
 import * as path from 'node:path';
 import { fileURLToPath, pathToFileURL } from 'node:url';
 
+import { assertScanned, DeadScopeError } from './_lib/scan_scope.js';
+
 const _HERE = fileURLToPath(import.meta.url);
 const REPO_ROOT = path.resolve(path.dirname(_HERE), '..', '..');
 
@@ -190,6 +194,31 @@ function main(): number {
         process.stderr.write(`❌  check-gate-paths: ${msg}\n`);
         return 2;
     }
+    let total = 0;
+    for (const v of named.values()) {
+        total += v.length;
+    }
+    // The enforced targets ARE the corpus. A per-gate empty GATE_CORE_PATHS is
+    // already exit 2 inside the subprocess, but an emptied GATES list is not:
+    // it yields zero targets, zero failures, and a green "0 enforced target(s)
+    // … resolve" — the path-integrity gate certifying that nothing is enforced.
+    try {
+        assertScanned({
+            gate: 'check_gate_paths',
+            scanned: total,
+            units: 'enforced target(s)',
+            roots: ['src/scripts (GATE_CORE_PATHS of the GATES list)'],
+        });
+    } catch (exc) {
+        if (exc instanceof DeadScopeError) {
+            // Exit 2, not 1: 1 means "a declared target failed to resolve" (a
+            // finding), while 2 is this file's existing "a gate cannot be
+            // checked" code — which is exactly what an empty target set is.
+            process.stderr.write(`❌  ${exc.message}\n`);
+            return 2;
+        }
+        throw exc;
+    }
     const failures = check_paths(named);
     if (failures.length > 0) {
         process.stdout.write(
@@ -202,10 +231,6 @@ function main(): number {
         process.stdout.write('  GATE_CORE_PATHS or the move.\n');
         return 1;
     }
-    let total = 0;
-    for (const v of named.values()) {
-        total += v.length;
-    }
     process.stdout.write(
         `✅  check-gate-paths: ${total} enforced target(s) across ` +
             `${named.size} gate(s) resolve under the source tree.\n`,

package/src/scripts/check_generated_artefact_headers.ts

@@ -15,6 +15,8 @@ import * as fs from 'node:fs';
 import * as path from 'node:path';
 import { fileURLToPath, pathToFileURL } from 'node:url';
 
+import { assertWatchlistResolves, DeadScopeError } from './_lib/scan_scope.js';
+
 const _HERE = fileURLToPath(import.meta.url);
 const REPO_ROOT = path.join(path.dirname(_HERE), '..', '..');
 
@@ -55,6 +57,25 @@ function main(argv?: readonly string[]): number {
     const args = argv ?? process.argv.slice(2);
     const quiet = args.includes('--quiet');
 
+    // Every artefact is skipped when absent, so all three moving at once prints
+    // "✅ All 3 generated artefacts carry the freshness marker" over zero reads.
+    // The per-file skip below stays — a single gitignored artefact is a real
+    // state; none of them existing is a moved root. 1 is the only failure code
+    // this gate has, so "could not run" and "found something" share it.
+    try {
+        assertWatchlistResolves({
+            gate: 'check_generated_artefact_headers',
+            candidates: GENERATED_ARTEFACTS.map((e) => e.path),
+            repoRoot: REPO_ROOT,
+        });
+    } catch (err) {
+        if (err instanceof DeadScopeError) {
+            process.stderr.write(`❌  ${err.message}\n`);
+            return 1;
+        }
+        throw err;
+    }
+
     const errors: string[] = [];
     const warnings: string[] = [];
 

package/src/scripts/check_generator_output_coverage.ts

@@ -18,6 +18,8 @@ import * as fs from 'node:fs';
 import * as path from 'node:path';
 import { fileURLToPath, pathToFileURL } from 'node:url';
 
+import { assertScanned, DeadScopeError } from './_lib/scan_scope.js';
+
 const _HERE = fileURLToPath(import.meta.url);
 const REPO_ROOT = path.join(path.dirname(_HERE), '..', '..');
 
@@ -103,6 +105,27 @@ function main(argv?: readonly string[]): number {
             .filter((l) => Boolean(l) && !l.startsWith('#')),
     );
 
+    // The registry below is the corpus — the manifest and .gitignore are only
+    // what each root is checked AGAINST, and both already fail closed above. An
+    // emptied registry (a refactor that moves the list, a bad merge) leaves the
+    // loop with nothing to classify and prints "✅ All 0 generator output roots
+    // are classified". Exit 2, the code this gate already uses for "a required
+    // input is not there", never 1, which means a root is unclassified.
+    try {
+        assertScanned({
+            gate: 'check_generator_output_coverage',
+            scanned: GENERATOR_OUTPUT_ROOTS.length,
+            units: 'generator output root(s)',
+            roots: ['src/scripts/check_generator_output_coverage.ts (GENERATOR_OUTPUT_ROOTS)'],
+        });
+    } catch (err) {
+        if (err instanceof DeadScopeError) {
+            process.stderr.write(`❌  ${err.message}\n`);
+            return 2;
+        }
+        throw err;
+    }
+
     const unclassified: typeof GENERATOR_OUTPUT_ROOTS[number][] = [];
     for (const entry of GENERATOR_OUTPUT_ROOTS) {
         if (!isClassified(entry.root, manifestPaths, gitignoreLines)) {

package/src/scripts/check_gitignore_freshness.ts

@@ -17,6 +17,8 @@ import * as fs from 'node:fs';
 import * as path from 'node:path';
 import { fileURLToPath, pathToFileURL } from 'node:url';
 
+import { assertScanned, DeadScopeError } from './_lib/scan_scope.js';
+
 const _HERE = fileURLToPath(import.meta.url);
 const REPO_ROOT = path.join(path.dirname(_HERE), '..', '..');
 
@@ -83,6 +85,27 @@ function main(argv?: readonly string[]): number {
     const blockLines = new Set(blockText.split('\n').map((l) => l.trim()).filter(Boolean));
 
     const entries = parseManifest(manifestText);
+    // Counted on the whole parse, not on the consumer-scoped subset the loop
+    // judges: `_isFile` above only proves the manifest exists, and a shape change
+    // that makes `- path:` stop matching yields zero entries, zero missing paths,
+    // and "✅ covers all 0 consumer-scoped ignored paths". Exit 2 (documented
+    // "invalid args or missing file" — the gate could not run), not 1, which
+    // means the block is genuinely missing a path.
+    try {
+        assertScanned({
+            gate: 'check_gitignore_freshness',
+            scanned: entries.length,
+            units: 'manifest entr(y|ies)',
+            roots: ['src/config/agents-paths.yml'],
+        });
+    } catch (err) {
+        if (err instanceof DeadScopeError) {
+            process.stderr.write(`❌  ${err.message}\n`);
+            return 2;
+        }
+        throw err;
+    }
+
     const missing: string[] = [];
 
     for (const e of entries) {

package/src/scripts/check_host_loadability.ts

@@ -16,10 +16,14 @@ import * as path from 'node:path';
 
 import { parse as parseYaml } from 'yaml';
 
-export function check_claude_skills(root: string, errors: string[]): void {
+import { assertScanned, DeadScopeError } from './_lib/scan_scope.js';
+
+/** @returns how many skill directories were examined. */
+export function check_claude_skills(root: string, errors: string[]): number {
     const dir = path.join(root, '.claude', 'skills');
-    if (!fs.existsSync(dir)) return;
-    for (const name of fs.readdirSync(dir)) {
+    if (!fs.existsSync(dir)) return 0;
+    const names = fs.readdirSync(dir);
+    for (const name of names) {
         const skillMd = path.join(dir, name, 'SKILL.md');
         if (!fs.existsSync(skillMd)) {
             errors.push(`${skillMd}: missing SKILL.md`);
@@ -35,13 +39,17 @@ export function check_claude_skills(root: string, errors: string[]): void {
         else if (meta['name'] !== name) errors.push(`${skillMd}: name '${meta['name']}' != dir '${name}'`);
         if (typeof meta['description'] !== 'string' || !meta['description']) errors.push(`${skillMd}: missing description`);
     }
+    return names.length;
 }
 
-export function check_cursor_rules(root: string, errors: string[]): void {
+/** @returns how many `.mdc` rule files were examined. */
+export function check_cursor_rules(root: string, errors: string[]): number {
     const dir = path.join(root, '.cursor', 'rules');
-    if (!fs.existsSync(dir)) return;
+    if (!fs.existsSync(dir)) return 0;
+    let scanned = 0;
     for (const name of fs.readdirSync(dir)) {
         if (!name.endsWith('.mdc')) continue;
+        scanned += 1;
         const p = path.join(dir, name);
         const src = fs.readFileSync(p, 'utf-8');
         const m = src.match(/^---\n([\s\S]*?)\n---/);
@@ -57,12 +65,22 @@ export function check_cursor_rules(root: string, errors: string[]): void {
         try { parseYaml(lenient); }
         catch (e) { errors.push(`${p}: frontmatter YAML invalid (${(e as Error).message})`); }
     }
+    return scanned;
 }
 
 export function run(root: string): string[] {
     const errors: string[] = [];
-    check_claude_skills(root, errors);
-    check_cursor_rules(root, errors);
+    // Both host trees are generated and gitignored, and each checker returns
+    // early when its tree is absent — so "no malformed artefacts" and "no
+    // artefacts" are the same green. Thrown, not returned: `errors` names
+    // malformed files, and an unprojected tree is not one.
+    const scanned = check_claude_skills(root, errors) + check_cursor_rules(root, errors);
+    assertScanned({
+        gate: 'check_host_loadability',
+        scanned,
+        units: 'host artefact(s)',
+        roots: ['.claude/skills', '.cursor/rules'],
+    });
     return errors;
 }
 
@@ -71,7 +89,15 @@ const isMain = process.argv[1] !== undefined
 if (isMain) {
     const rootIdx = process.argv.indexOf('--root');
     const root = rootIdx !== -1 ? process.argv[rootIdx + 1] ?? '.' : '.';
-    const errors = run(root);
+    let errors: string[];
+    try {
+        errors = run(root);
+    } catch (exc) {
+        if (!(exc instanceof DeadScopeError)) throw exc;
+        // Exit 1 is this gate's only failure code.
+        process.stderr.write(`❌  ${exc.message}\n`);
+        process.exit(1);
+    }
     if (errors.length > 0) {
         for (const e of errors) process.stderr.write(`❌  ${e}\n`);
         process.exit(1);

package/src/scripts/check_installer_import_purity.ts

@@ -59,6 +59,8 @@ import { fileURLToPath } from 'node:url';
 
 import ts from 'typescript';
 
+import { assertWatchlistResolves, DeadScopeError } from './_lib/scan_scope.js';
+
 const _HERE = path.dirname(fileURLToPath(import.meta.url));
 const REPO_ROOT = path.resolve(_HERE, '..', '..');
 
@@ -208,14 +210,6 @@ function parse(file: string): ts.SourceFile | null {
  */
 function auditEntry(entryRel: string, root: string = REPO_ROOT): Finding[] {
     const entryAbs = path.join(root, entryRel);
-    if (!fs.existsSync(entryAbs)) {
-        process.stderr.write(
-            `check-installer-import-purity: entry ${entryRel} does not exist — ` +
-                'update BUNDLE_ENTRIES\n',
-        );
-        process.exitCode = 1;
-        return [];
-    }
     const findings: Finding[] = [];
     const seen = new Set<string>([entryAbs]);
     // BFS so the reported chain is a shortest path — the least confusing one.
@@ -245,6 +239,26 @@ function auditEntry(entryRel: string, root: string = REPO_ROOT): Finding[] {
 }
 
 function main(): number {
+    // BUNDLE_ENTRIES is the whole scan scope — every module examined is reached
+    // from one of them. This REPLACES the per-entry existence guard in
+    // `auditEntry`, which could not fail: it set `process.exitCode = 1` and
+    // returned no findings, and `process.exit(main())` then overwrote that with
+    // main's 0, so a moved entry printed "✅ … reach no module-level
+    // process.exit()". 1 is the only failure code this gate has.
+    try {
+        assertWatchlistResolves({
+            gate: 'check_installer_import_purity',
+            candidates: BUNDLE_ENTRIES,
+            repoRoot: REPO_ROOT,
+        });
+    } catch (err) {
+        if (err instanceof DeadScopeError) {
+            process.stderr.write(`❌  ${err.message}\n`);
+            return 1;
+        }
+        throw err;
+    }
+
     const all: Finding[] = [];
     for (const entry of BUNDLE_ENTRIES) {
         all.push(...auditEntry(entry));

package/src/scripts/check_kernel_prefix_stability.ts

@@ -37,6 +37,8 @@ import * as path from 'node:path';
 import process from 'node:process';
 import { fileURLToPath, pathToFileURL } from 'node:url';
 
+import { assertScanned, DeadScopeError } from './_lib/scan_scope.js';
+
 const _HERE = fileURLToPath(import.meta.url);
 const REPO_ROOT = path.resolve(path.dirname(_HERE), '..', '..');
 const ROUTER = path.join(REPO_ROOT, 'dist/router.json');
@@ -96,7 +98,17 @@ function _live_prefix(): KernelPrefix | null {
   const router = _readJson(ROUTER);
   if (router === null) return null;
   const ids = kernel_ids(router);
-  if (ids.length === 0) return null;
+  // Scope only — the baseline and the comparison are untouched. An empty kernel
+  // list used to collapse into the same `null` as an unreadable router, so a
+  // router that compiled to zero kernel rules was reported as a missing file;
+  // it is a dead scan scope, and a digest over no bodies is a constant that
+  // would then look byte-stable forever.
+  assertScanned({
+    gate: 'check_kernel_prefix_stability',
+    scanned: ids.length,
+    units: 'kernel rule(s)',
+    roots: ['dist/router.json (kernel)', 'dist/agent-src/rules'],
+  });
   return compute_prefix(ids, (id) => fs.readFileSync(path.join(RULES_DIR, `${id}.md`), 'utf-8'));
 }
 
@@ -118,6 +130,12 @@ function main(argv: string[]): number {
   try {
     current = _live_prefix();
   } catch (e) {
+    // 1 is the documented "file error" code — the gate could not run. 2 is
+    // reserved for drift, i.e. a prefix that was read and did change.
+    if (e instanceof DeadScopeError) {
+      process.stderr.write(`error: ${e.message}\n`);
+      return 1;
+    }
     process.stderr.write(`error: cannot read kernel bodies: ${(e as Error).message}\n`);
     return 1;
   }

package/src/scripts/check_kernel_rule_bundle.ts

@@ -37,6 +37,7 @@ import * as path from 'node:path';
 import { fileURLToPath, pathToFileURL } from 'node:url';
 import { KERNEL_RULE_FILENAMES } from './_lib/kernel_rules.js';
 import { runCountedProbe } from './_lib/counted_probe.js';
+import { assertWatchlistResolves, DeadScopeError } from './_lib/scan_scope.js';
 
 const KERNEL_RULES: ReadonlySet<string> = KERNEL_RULE_FILENAMES;
 
@@ -55,6 +56,8 @@ const KERNEL_RULES: ReadonlySet<string> = KERNEL_RULE_FILENAMES;
  */
 const KERNEL_DIR = 'src/rules';
 const DEFAULT_LABEL = 'bundled-always-rules-acknowledged';
+// src/scripts/check_kernel_rule_bundle.ts → two levels up is the repo root.
+const REPO = path.resolve(path.dirname(fileURLToPath(import.meta.url)), '..', '..');
 
 function _git_changed_files(base_ref: string): string[] {
     // Bounded read: a truncated diff would shrink the change set and let the
@@ -188,6 +191,26 @@ function parse_args(argv: readonly string[]): Args {
 export function main(argv?: readonly string[]): number {
     const args = parse_args(argv ?? process.argv.slice(2));
 
+    // This gate has no corpus — it matches changed paths against a fixed set of
+    // 9 kernel rules, so its scope IS that watch list. It has already been
+    // inert once for exactly this reason (see KERNEL_DIR above): a prefix that
+    // no longer exists never matches, and every kernel-rule edit scored
+    // "no kernel rule touched". Exit 3 (internal error) over 1 (bundle
+    // violated) — a phantom watch list means the gate could not run.
+    try {
+        assertWatchlistResolves({
+            gate: 'check_kernel_rule_bundle',
+            candidates: [...KERNEL_RULES].sort().map((name) => `${KERNEL_DIR}/${name}`),
+            repoRoot: REPO,
+        });
+    } catch (exc) {
+        if (exc instanceof DeadScopeError) {
+            process.stderr.write(`❌  ${exc.message}\n`);
+            return 3;
+        }
+        throw exc;
+    }
+
     // Python: args.files or _git_changed_files(...). An empty list from
     // `--files` (no values) is falsy in Python → falls through to git diff.
     const files =