@event4u/agent-config 9.8.0 → 9.10.0

package/src/scripts/check_context_paths.ts

@@ -9,7 +9,7 @@
  * scan trees / order / locked sub-trees / grandfathered files, same
  * orphan self-reference subtraction (latent: substring replace).
  *
- * Validates that every `*.md` under `.agent-src.uncondensed/contexts/`:
+ * Validates that every `*.md` under `src/agent-src/contexts/`:
  *   1. Lives in a locked sub-tree (or is a grandfathered root file).
  *   2. Does not collide on basename with another context in another sub-tree.
  *   3. Is referenced by at least one rule, skill, command, or other context.
@@ -24,8 +24,8 @@ import { fileURLToPath, pathToFileURL } from 'node:url';
 
 const _HERE = fileURLToPath(import.meta.url);
 const ROOT = path.resolve(path.dirname(_HERE), '..', '..');
-const CONTEXTS_ROOT = path.join(ROOT, '.agent-src.uncondensed', 'contexts');
-// Logical relpath of the contexts root under ROOT (e.g. ".agent-src.uncondensed/contexts").
+const CONTEXTS_ROOT = path.join(ROOT, 'src', 'agent-src', 'contexts');
+// Logical relpath of the contexts root under ROOT (e.g. "src/agent-src/contexts").
 const CONTEXTS_REL = path.relative(ROOT, CONTEXTS_ROOT).split(path.sep).join('/');
 
 const LOCKED_SUBTREES = [
@@ -49,11 +49,21 @@ const GRANDFATHERED_ROOT_FILES: ReadonlySet<string> = new Set([
     'subagent-configuration.md',
 ]);
 
+// Retargeted 2026-07-29 — see the note in check_no_roadmap_refs: these pointed at
+// the tree emptied by ADR-051, so only `agents/roadmaps` was ever scanned.
+//
+// `src/domains` is NOT a 1:1 rename of an old entry — it is a root that did not
+// exist in the pre-migration layout and holds pack command definitions that cite
+// contexts. A straight four-for-four remap produced three false "orphan" verdicts
+// (research-schema, host-capability-manifest, non-interactive-contract — each in
+// fact referenced 8/11/12 times) because their citations live under src/domains.
+// A retarget has to follow where the references moved, not just where the files did.
 const REFERENCE_SCAN_DIRS = [
-    '.agent-src.uncondensed/rules',
-    '.agent-src.uncondensed/skills',
-    '.agent-src.uncondensed/commands',
-    '.agent-src.uncondensed/contexts',
+    'src/rules',
+    'src/skills',
+    'src/agent-src/commands',
+    'src/agent-src/contexts',
+    'src/domains',
     'agents/roadmaps',
 ] as const;
 
@@ -198,6 +208,10 @@ function _build_reference_corpus(root: string): string {
             }
         }
     }
+    // Gate-coverage contract (src/config/gate-coverage.yml): the reference corpus
+    // size IS this gate's scan count — an empty corpus makes every "unreferenced"
+    // verdict vacuous, which is exactly how the dead root went unnoticed.
+    process.stdout.write(`scanned: ${String(chunks.length)}\n`);
     return chunks.join('\n');
 }
 
@@ -212,11 +226,26 @@ function _replaceAll(haystack: string, needle: string): string {
 function _check_orphans(contexts: string[], corpus: string, root: string): Violation[] {
     const out: Violation[] = [];
     for (const ctx of contexts) {
-        const rel_src = _relToPosix(ctx, root); // .agent-src.uncondensed/contexts/...
+        const rel_src = _relToPosix(ctx, root); // src/agent-src/contexts/...
         const rel_short = rel_src.includes('contexts/')
             ? rel_src.slice(rel_src.indexOf('contexts/') + 'contexts/'.length)
             : rel_src;
-        const candidates = [rel_src, `contexts/${rel_short}`, rel_short];
+        // Sibling contexts link each other by BARE BASENAME —
+        // `[`x`](x.md)` — which none of the three path-qualified candidates
+        // below can see. That gap was invisible until 2026-07-29: the old
+        // contexts scan root was the ADR-051-emptied tree, so context→context
+        // references were never in the corpus at all, and no orphan verdict
+        // ever depended on them. Matched as a LINK TARGET (`](…)`) rather than
+        // a loose substring, so a prose mention of the filename does not count
+        // as a reference.
+        const base = path.basename(ctx);
+        const candidates = [
+            rel_src,
+            `contexts/${rel_short}`,
+            rel_short,
+            `](${base})`,
+            `](./${base})`,
+        ];
         let own_text = '';
         try {
             own_text = fs.readFileSync(ctx, 'utf-8');

package/src/scripts/check_evaluator_budgets.ts

@@ -0,0 +1,99 @@
+#!/usr/bin/env tsx
+/**
+ * check_evaluator_budgets — enforce the outside-in evaluator budgets
+ * (road-to-credible-install Phase 6) against a measurements JSON.
+ *
+ * Two failure modes per metric:
+ *   1. absolute:   measured > budgets[metric].max
+ *   2. regression: measured > last_measured * (1 + regression_pct/100)
+ *      — fails EVEN WHEN still under the absolute budget (the >10%
+ *      creep rule), so slow rot cannot hide under a generous cap.
+ *
+ * Usage:
+ *   ./scripts-run src/scripts/check_evaluator_budgets --measurements <file.json>
+ *   (measurements: flat { metric: number } — produced by evaluator_umbrella.sh)
+ *
+ * Exit codes: 0 green · 1 budget/regression exceeded · 2 internal error.
+ */
+import * as fs from 'node:fs';
+import * as path from 'node:path';
+import { fileURLToPath } from 'node:url';
+
+const REPO_ROOT = path.resolve(fileURLToPath(import.meta.url), '..', '..', '..');
+const BUDGETS_PATH = path.join(REPO_ROOT, 'src', 'config', 'evaluator-budgets.json');
+
+interface BudgetEntry {
+    max: number;
+    last_measured: number;
+    method: string;
+    /** Per-metric creep override — wall-clock timings get a loose one
+     * (absolute cap is their real gate); sizes/counts keep the tight
+     * global default. */
+    regression_pct?: number;
+}
+interface BudgetsDoc {
+    regression_pct: number;
+    budgets: Record<string, BudgetEntry>;
+}
+
+export function evaluate(
+    budgetsDoc: BudgetsDoc,
+    measurements: Record<string, number>,
+): string[] {
+    const errors: string[] = [];
+    for (const [metric, entry] of Object.entries(budgetsDoc.budgets)) {
+        const measured = measurements[metric];
+        if (measured === undefined || Number.isNaN(measured)) {
+            errors.push(`${metric}: no measurement supplied (method: ${entry.method})`);
+            continue;
+        }
+        if (measured > entry.max) {
+            errors.push(`${metric}: measured ${measured} exceeds budget ${entry.max}`);
+            continue;
+        }
+        const pct = entry.regression_pct ?? budgetsDoc.regression_pct;
+        const ceiling = entry.last_measured * (1 + pct / 100);
+        if (entry.last_measured > 0 && measured > ceiling) {
+            errors.push(
+                `${metric}: measured ${measured} regressed >${pct}% vs ` +
+                    `last_measured ${entry.last_measured} (ceiling ${ceiling.toFixed(2)}) — ` +
+                    'fails even under the absolute budget',
+            );
+        }
+    }
+    return errors;
+}
+
+export function main(argv: string[] = process.argv.slice(2)): number {
+    const idx = argv.indexOf('--measurements');
+    if (idx < 0 || argv[idx + 1] === undefined) {
+        process.stderr.write('usage: check_evaluator_budgets --measurements <file.json>\n');
+        return 2;
+    }
+    let budgetsDoc: BudgetsDoc;
+    let measurements: Record<string, number>;
+    try {
+        budgetsDoc = JSON.parse(fs.readFileSync(BUDGETS_PATH, 'utf-8')) as BudgetsDoc;
+        measurements = JSON.parse(fs.readFileSync(argv[idx + 1] as string, 'utf-8')) as Record<
+            string,
+            number
+        >;
+    } catch (e) {
+        process.stderr.write(`check_evaluator_budgets: ${(e as Error).message}\n`);
+        return 2;
+    }
+    const errors = evaluate(budgetsDoc, measurements);
+    if (errors.length > 0) {
+        for (const e of errors) process.stderr.write(`❌  evaluator budget: ${e}\n`);
+        return 1;
+    }
+    process.stdout.write(
+        `✅  evaluator budgets met (${Object.keys(budgetsDoc.budgets).length} metrics)\n`,
+    );
+    return 0;
+}
+
+const _selfPath = fileURLToPath(import.meta.url);
+if (process.argv[1] !== undefined && path.resolve(process.argv[1]) === path.resolve(_selfPath)) {
+    process.exit(main());
+}

package/src/scripts/check_gate_coverage.ts

@@ -0,0 +1,299 @@
+#!/usr/bin/env tsx
+/**
+ * Meta-gate: verify that the repo's gates actually inspect something.
+ *
+ * A gate that scans nothing exits 0 and certifies coverage that does not exist.
+ * That is strictly worse than having no gate, because the green is believed. On
+ * 2026-07-29 a sweep found three such gates in CI, each pointing at a tree
+ * emptied by the ADR-051 flat-`src/` migration; one of them printed the literal
+ * count `0` in its own output for as long as it was broken.
+ *
+ * This guard reads `src/config/gate-coverage.yml`, runs each listed gate with the
+ * CI-identical arguments declared there, reads the `scanned: <N>` line the gate
+ * emits, and fails when N falls below the declared floor.
+ *
+ * Three design rules, each traceable to a concrete failure — see the manifest
+ * header for the full rationale:
+ *   1. Gates emit a machine-readable count; the guard never parses human output.
+ *   2. Invocations mirror CI exactly (a bare probe produced a false alarm during
+ *      the sweep).
+ *   3. The check is a baseline floor, not `> 0` (428 → 3 is also a collapse).
+ *
+ * Self-honesty: this guard must not become the thing it catches. It fails when
+ * the manifest is empty or unreadable, and it REPORTS `pending` gates (listed but
+ * not yet emitting a count) instead of skipping them silently.
+ *
+ * CLI:
+ *   ./scripts-run src/scripts/check_gate_coverage            # enforce
+ *   ./scripts-run src/scripts/check_gate_coverage --list     # show the manifest
+ *   ./scripts-run src/scripts/check_gate_coverage --format json
+ *
+ * Exit codes: 0 all enforced gates cleared their floor · 1 a gate is blind,
+ * collapsed, or silent · 2 the manifest itself is missing/empty/malformed.
+ */
+import { spawnSync } from 'node:child_process';
+import * as fs from 'node:fs';
+import * as path from 'node:path';
+import process from 'node:process';
+import { fileURLToPath, pathToFileURL } from 'node:url';
+
+import yaml from 'js-yaml';
+
+const _HERE = fileURLToPath(import.meta.url);
+const REPO_ROOT = path.resolve(path.dirname(_HERE), '..', '..');
+const MANIFEST = path.join(REPO_ROOT, 'src/config/gate-coverage.yml');
+
+/** The one line a gate must emit. Deliberately narrow: no format guessing. */
+const SCANNED_RE = /^\s*scanned:\s*(\d+)\s*$/m;
+
+export interface GateSpec {
+  id: string;
+  argv: string[];
+  min_scanned: number;
+  corpus: string;
+  status: 'enforced' | 'pending';
+  /**
+   * Exit code meaning "my prerequisite is absent, so I inspected nothing" — e.g.
+   * check_site_links exits 2 when the site is unbuilt or stale. Without this the
+   * guard reads that as `silent` and fails, which would make it red on every machine
+   * lacking a build artefact: a gate that blocks for an environmental reason teaches
+   * people to ignore it, which is worse than no gate. Reported as `unavailable`
+   * rather than skipped, so the partial coverage stays visible — the same reason
+   * `pending` is reported instead of hidden.
+   */
+  unavailable_exit?: number;
+  note?: string;
+}
+
+export type Verdict = 'ok' | 'below_floor' | 'silent' | 'crashed' | 'pending' | 'unavailable';
+
+export interface GateResult {
+  id: string;
+  status: GateSpec['status'];
+  verdict: Verdict;
+  scanned: number | null;
+  min_scanned: number;
+  message: string;
+}
+
+function _require_int(v: unknown, id: string, i: number): number {
+  const n = Number(v);
+  if (!Number.isInteger(n)) {
+    throw new Error(`gates[${String(i)}] (${id}): unavailable_exit must be an integer exit code`);
+  }
+  return n;
+}
+
+/** Parse + validate the manifest. Throws on anything that would make the guard
+ * silently vacuous — an empty gate list is a hard error, not an empty pass. */
+export function load_manifest(file = MANIFEST): GateSpec[] {
+  if (!fs.existsSync(file)) {
+    throw new Error(`manifest not found: ${path.relative(REPO_ROOT, file)}`);
+  }
+  const doc = yaml.load(fs.readFileSync(file, 'utf-8')) as { gates?: unknown[] };
+  const raw = Array.isArray(doc?.gates) ? doc.gates : [];
+  if (raw.length === 0) {
+    throw new Error('manifest declares zero gates — a coverage guard over an empty set is vacuous');
+  }
+  return raw.map((entry, i) => {
+    const e = entry as Record<string, unknown>;
+    const id = String(e['id'] ?? '');
+    if (id === '') throw new Error(`gates[${i}]: missing id`);
+    const min = Number(e['min_scanned']);
+    if (!Number.isInteger(min) || min < 0) {
+      throw new Error(`gates[${i}] (${id}): min_scanned must be a non-negative integer`);
+    }
+    const status = String(e['status'] ?? 'enforced');
+    if (status !== 'enforced' && status !== 'pending') {
+      throw new Error(`gates[${i}] (${id}): status must be 'enforced' or 'pending'`);
+    }
+    return {
+      id,
+      argv: Array.isArray(e['argv']) ? e['argv'].map(String) : [],
+      min_scanned: min,
+      corpus: String(e['corpus'] ?? ''),
+      status,
+      ...(e['unavailable_exit'] === undefined
+        ? {}
+        : { unavailable_exit: _require_int(e['unavailable_exit'], id, i) }),
+      ...(e['note'] === undefined ? {} : { note: String(e['note']) }),
+    };
+  });
+}
+
+/** Extract the contract line. Returns null when the gate emitted no count. */
+export function parse_scanned(output: string): number | null {
+  const m = SCANNED_RE.exec(output);
+  return m === null ? null : Number(m[1]);
+}
+
+/** Classify one gate's run against its declared floor. Pure — testable without
+ * spawning anything. */
+export function classify(
+  spec: GateSpec,
+  scanned: number | null,
+  crashed: boolean,
+  exit_code?: number | null,
+): GateResult {
+  const base = { id: spec.id, status: spec.status, scanned, min_scanned: spec.min_scanned };
+  if (spec.status === 'pending') {
+    return {
+      ...base,
+      verdict: 'pending',
+      message:
+        scanned === null
+          ? `not yet emitting 'scanned:' — listed as pending, NOT enforced (coverage gap is visible, not hidden)`
+          : `reports ${String(scanned)}; floor ${String(spec.min_scanned)} not enforced while pending`,
+    };
+  }
+  if (crashed) {
+    return { ...base, verdict: 'crashed', message: 'gate could not be executed' };
+  }
+  if (
+    spec.unavailable_exit !== undefined &&
+    exit_code !== undefined &&
+    exit_code !== null &&
+    exit_code === spec.unavailable_exit
+  ) {
+    return {
+      ...base,
+      verdict: 'unavailable',
+      message:
+        `exited ${String(exit_code)} — prerequisite absent, nothing inspected. ` +
+        `Coverage unverified here; CI is where this gate has its inputs`,
+    };
+  }
+  if (scanned === null) {
+    return {
+      ...base,
+      verdict: 'silent',
+      message: `emitted no 'scanned: <N>' line — an enforced gate must report what it inspected`,
+    };
+  }
+  if (scanned < spec.min_scanned) {
+    return {
+      ...base,
+      verdict: 'below_floor',
+      message:
+        `scanned ${String(scanned)}, floor ${String(spec.min_scanned)} (${spec.corpus}) — ` +
+        `a gate inspecting this little cannot certify the corpus`,
+    };
+  }
+  return { ...base, verdict: 'ok', message: `scanned ${String(scanned)} ≥ ${String(spec.min_scanned)}` };
+}
+
+function run_gate(spec: GateSpec): { scanned: number | null; crashed: boolean; exit_code: number | null } {
+  const runner = path.join(REPO_ROOT, 'scripts-run');
+  const r = spawnSync(runner, [`src/scripts/${spec.id}`, ...spec.argv], {
+    cwd: REPO_ROOT,
+    encoding: 'utf8',
+  });
+  if (r.error !== undefined || r.status === null) return { scanned: null, crashed: true, exit_code: null };
+  // A gate may legitimately exit non-zero (it found real violations) and still
+  // have scanned plenty — coverage and verdict are different questions.
+  return { scanned: parse_scanned(`${r.stdout}\n${r.stderr}`), crashed: false, exit_code: r.status };
+}
+
+const ICON: Record<Verdict, string> = {
+  ok: '✅',
+  below_floor: '❌',
+  silent: '❌',
+  crashed: '❌',
+  pending: '⚠️',
+  unavailable: '⚠️',
+};
+
+export function main(argv: readonly string[]): number {
+  const wantJson = argv.includes('--format') && argv[argv.indexOf('--format') + 1] === 'json';
+  const listOnly = argv.includes('--list');
+
+  let specs: GateSpec[];
+  try {
+    specs = load_manifest();
+  } catch (e) {
+    process.stderr.write(`❌  gate-coverage manifest: ${(e as Error).message}\n`);
+    return 2;
+  }
+
+  if (listOnly) {
+    for (const s of specs) {
+      process.stdout.write(
+        `  ${s.status === 'enforced' ? '[enforced]' : '[pending] '} ${s.id} ` +
+          `argv=[${s.argv.join(' ')}] floor=${String(s.min_scanned)}\n`,
+      );
+    }
+    process.stdout.write(`scanned: ${String(specs.length)}\n`);
+    return 0;
+  }
+
+  const results = specs.map((s) => {
+    if (spec_is_pending(s)) {
+      const { scanned, crashed } = probe_pending(s);
+      return classify(s, scanned, crashed);
+    }
+    const { scanned, crashed, exit_code } = run_gate(s);
+    return classify(s, scanned, crashed, exit_code);
+  });
+
+  if (wantJson) {
+    process.stdout.write(`${JSON.stringify({ generated_by: 'check_gate_coverage', results }, null, 2)}\n`);
+  } else {
+    for (const r of results) {
+      process.stdout.write(`  ${ICON[r.verdict]} ${r.id}: ${r.message}\n`);
+    }
+  }
+
+  const failed = results.filter((r) => r.verdict === 'below_floor' || r.verdict === 'silent' || r.verdict === 'crashed');
+  const pending = results.filter((r) => r.verdict === 'pending');
+  const unavailable = results.filter((r) => r.verdict === 'unavailable');
+
+  // The guard reports its OWN coverage. Hiding a pending gate behind a green
+  // summary is exactly the failure mode this file exists to prevent.
+  process.stdout.write(
+    `\nscanned: ${String(results.length)}\n` +
+      `  enforced ${String(results.length - pending.length)} · pending ${String(pending.length)} · ` +
+      `unavailable ${String(unavailable.length)} · failing ${String(failed.length)}\n`,
+  );
+  if (unavailable.length > 0) {
+    process.stdout.write(
+      `⚠️  ${String(unavailable.length)} gate(s) could not run here (prerequisite absent) — ` +
+        `their coverage is unverified locally, not proven.\n`,
+    );
+  }
+  if (pending.length > 0) {
+    process.stdout.write(
+      `⚠️  ${String(pending.length)} gate(s) are listed but NOT enforced — this guard's coverage is partial by declaration.\n`,
+    );
+  }
+  if (failed.length > 0) {
+    process.stdout.write(`❌  ${String(failed.length)} gate(s) failed the coverage floor.\n`);
+    return 1;
+  }
+  process.stdout.write('✅  every enforced gate cleared its coverage floor.\n');
+  return 0;
+}
+
+function spec_is_pending(s: GateSpec): boolean {
+  return s.status === 'pending';
+}
+
+/** Pending gates are still probed (so the report shows what they currently do),
+ * but their count never fails the build. */
+function probe_pending(s: GateSpec): { scanned: number | null; crashed: boolean } {
+  return run_gate(s);
+}
+
+function _isCliEntry(): boolean {
+  if (process.argv[1] === undefined) return false;
+  const argvUrl = pathToFileURL(path.resolve(process.argv[1])).href;
+  if (argvUrl === import.meta.url) return true;
+  try {
+    return pathToFileURL(fs.realpathSync(path.resolve(process.argv[1]))).href === import.meta.url;
+  } catch {
+    return false;
+  }
+}
+
+if (_isCliEntry()) {
+  process.exit(main(process.argv.slice(2)));
+}

package/src/scripts/check_iron_law_prominence.ts

@@ -28,6 +28,8 @@ import * as fs from 'node:fs';
 import * as path from 'node:path';
 import { fileURLToPath, pathToFileURL } from 'node:url';
 
+import { assertScanned } from './_lib/scan_scope.js';
+
 const HEADING_RE = /^(#{1,6})\s+(.+?)\s*$/;
 const IRON_LAW_RE = /\biron\s+laws?\b/i;
 const FENCE_RE = /^\s*```/;
@@ -247,7 +249,11 @@ function parse_args(argv: readonly string[]): Args {
         i++;
     }
     return {
-        paths: paths.length ? paths : ['.agent-src.uncondensed/rules'],
+        // ADR-051 moved rule authoring to `src/rules`. Until 2026-07-29 this
+        // default still named the retired container, so both CI call sites
+        // (consistency.yml + ci-fast.yml) resolved 0 targets and printed
+        // "✅ Iron Law prominence clean (0 file(s) scanned)" forever.
+        paths: paths.length ? paths : ['src/rules'],
         format,
         quiet,
     };
@@ -257,6 +263,21 @@ export function main(argv?: readonly string[]): number {
     const args = parse_args(argv ?? process.argv.slice(2));
 
     const targets = _resolve_targets(args.paths);
+
+    // Scope assertion: 0 targets means the root moved, not that the tree is
+    // clean. Without this the gate reported success while reading nothing.
+    try {
+        assertScanned({
+            gate: 'check_iron_law_prominence',
+            scanned: targets.length,
+            units: 'rule file(s)',
+            roots: args.paths,
+        });
+    } catch (exc) {
+        process.stderr.write(`❌  ${exc instanceof Error ? exc.message : String(exc)}\n`);
+        return 2;
+    }
+
     const all_violations: Violation[] = [];
     for (const p of targets) {
         if (!_exists(p)) {

package/src/scripts/check_knowledge_sharing.ts

@@ -66,8 +66,19 @@ export function checkSharing(staged: StagedFile[], readContent: (path: string) =
     const blocked: string[] = [];
     const warnings: string[] = [];
 
+    // The intake DIRECTORY SKELETON is tracked so the write path exists on a
+    // fresh clone (road-to-reachable-code-memory Phase 4); only the signal
+    // CONTENT (JSONL etc.) is local scratch that must never be committed.
+    const INTAKE_SKELETON = new Set([
+        'agents/memory/intake/.gitkeep',
+        'agents/memory/intake/README.md',
+        'agents/knowledge/intake/.gitkeep',
+        'agents/knowledge/intake/README.md',
+    ]);
     const intakeFiles = staged.filter(
-        (f) => f.path.startsWith('agents/memory/intake/') || f.path.startsWith('agents/knowledge/intake/'),
+        (f) =>
+            (f.path.startsWith('agents/memory/intake/') || f.path.startsWith('agents/knowledge/intake/')) &&
+            !INTAKE_SKELETON.has(f.path),
     );
     for (const f of intakeFiles) {
         blocked.push(`${f.path}: gitignored intake staged — intake is local scratch, never committed`);

package/src/scripts/check_no_external_sources.ts

@@ -21,7 +21,7 @@
  * - Vendored Apache/MIT code keeps its license-required attribution.
  * - Recommendation/registry docs may name registries (Smithery/Glama).
  * - A retained source link must be stored encrypted via
- *   src/scripts/_lib/link_crypto.py, never in plaintext.
+ *   src/scripts/_lib/link_crypto.ts, never in plaintext.
  *
  * Exit codes: 0 = clean, 1 = at least one denied token in a non-skipped tracked
  * file, 2 = usage / config error.
@@ -318,7 +318,7 @@ function main(argv: readonly string[]): number {
             process.stdout.write(
                 '\nThese name an external inspiration/harvest source. Remove the name,\n' +
                     'or — if a real source link must be retained — encrypt it via\n' +
-                    'src/scripts/_lib/link_crypto.py. Legitimate carve-outs (vendored code,\n' +
+                    'src/scripts/_lib/link_crypto.ts. Legitimate carve-outs (vendored code,\n' +
                     'registry recommendations) belong in external_sources_denylist.json\n' +
                     'skip_paths. See rule: source-confidentiality.\n',
             );

package/src/scripts/check_no_new_legacy_path.ts

@@ -1,6 +1,6 @@
 #!/usr/bin/env tsx
 /**
- * Regression guard: no NEW `.agent-src.uncondensed/` references in `src/`.
+ * Regression guard: no NEW dead-root references in `src/` or `tests/`.
  *
  * Ported from the retired Python `src/scripts/check_no_new_legacy_path.py` (ADR-200,
  * Phase 4 / Wave 4c). The CLI contract is pinned — `--base`
@@ -104,12 +104,22 @@ function find_offenders(diffText: string, twinCheck: TwinCheck = _is_faithful_tw
             continue;
         }
         if (line.startsWith('+') && !line.startsWith('+++')) {
-            // src/-scoped: a full diff (e.g. `gh pr diff`) carries every path;
-            // only added lines under src/ (minus the exempt detectors and
-            // faithful TS twins) count.
+            // Scoped to src/ + tests/: a full diff (e.g. `gh pr diff`) carries
+            // every path; only added lines under those roots (minus the exempt
+            // detectors and faithful TS twins) count.
+            //
+            // tests/ added 2026-07-29. Four separate tests were found pinning the
+            // dead root — two via fixture paths, one via a `resolve_entry`
+            // expectation, one asserting that a missing root exits 0 — and each
+            // kept a gate's blindness green because test and implementation agreed
+            // on a tree reality had abandoned. A FULL-tree lint over tests/ is the
+            // wrong shape (44 files / 213 hits, most of them legitimate: the
+            // legacy detectors' own tests, validator_ignore substrings, and
+            // synthetic fixtures under tmpdir()). Diff-scoping is what makes this
+            // tractable — existing debt stays, growth stops, no allowlist.
             if (
                 curFile &&
-                curFile.startsWith('src/') &&
+                (curFile.startsWith('src/') || curFile.startsWith('tests/')) &&
                 !EXEMPT.has(curFile) &&
                 line.includes(LEGACY) &&
                 !twinCheck(curFile)
@@ -135,7 +145,7 @@ function main(): number {
         // additions (robust locally and where the working tree is the branch tip).
         let proc: ReturnType<typeof spawnSync>;
         try {
-            proc = spawnSync('git', ['diff', base, '--', 'src/'], {
+            proc = spawnSync('git', ['diff', base, '--', 'src/', 'tests/'], {
                 encoding: 'utf-8',
             });
         } catch (exc) {