@event4u/agent-config 7.4.0 → 8.0.0

package/src/scripts/lint_design_slop.ts

@@ -0,0 +1,245 @@
+#!/usr/bin/env node
+/**
+ * lint_design_slop — deterministic anti-slop DETECTOR for consumer projects.
+ *
+ * The aesthetic-PROVENANCE layer that `lint_design_quality` deliberately omits.
+ * It scans HTML/CSS/JSX/Markdown for the "AI tells" catalogued in
+ * `docs/guidelines/design-antipatterns.md` and emits structured findings
+ * (rule-id + catalog-id + severity P0–P3 + file:line). The rule registry lives
+ * in `design_slop_rules.ts`.
+ *
+ * FLAGS, NEVER A HARD BLOCK. Default exit is 0 regardless of findings — slop
+ * tells are rebuttable presumptions, not failures. CI opts into failing with
+ * `--fail-on <P0|P1|P2|P3>` (fails when any finding at or above that severity
+ * remains). This honours the council 2026-06-28 "flags not blocks" verdict.
+ *
+ * Zero runtime token cost: this runs in Node (CI / pre-commit / optional hook),
+ * never in the model's context. `design-review` cites the structured `--json`
+ * output instead of reloading the 12 KB prose catalog.
+ *
+ * Dependency-free pattern analysis (no postcss/@babel) — see the design note in
+ * design_slop_rules.ts. Same posture as lint_design_quality.
+ *
+ * Usage:
+ *   npx tsx lint_design_slop.ts --dir src/ [--json] [--fail-on P1] [--quiet]
+ *
+ * Context gate: a consumer DESIGN.md (project root or scan dir) that declares a
+ * pattern as intentional suppresses the matching rule (e.g. "warm-neutral" →
+ * C5 cream-palette is not flagged). Inline-ignore (eslint-style):
+ *   design-slop-disable <rule-id>            (file scope, top of file)
+ *   design-slop-disable-next-line <rule-id>
+ *   design-slop-disable-line <rule-id>
+ * Per-project config (.design-quality.json, shared with lint_design_quality):
+ *   { "ignoreRules": ["slop-c5-cream-palette"], "ignoreFiles": ["src/legacy/**"] }
+ *
+ * Exit codes: 0 = clean OR findings-below-threshold, 2 = findings at/above
+ * --fail-on threshold, 1 = internal error.
+ */
+import fs from "node:fs";
+import path from "node:path";
+import {
+  SLOP_RULES,
+  type DesignContext,
+  type Engine,
+  type Severity,
+} from "./design_slop_rules.js";
+
+interface Finding {
+  rule: string;
+  catalogId: string;
+  severity: Severity;
+  file: string;
+  line: number;
+  snippet: string;
+  message: string;
+}
+
+interface ProjectConfig {
+  ignoreRules?: string[];
+  ignoreFiles?: string[];
+}
+
+const SEVERITY_ORDER: Severity[] = ["P3", "P2", "P1", "P0"];
+const sevRank = (s: Severity): number => SEVERITY_ORDER.indexOf(s);
+
+// ext → which engine-classes a file of that type can contain
+function enginesForExt(ext: string): Set<Engine> {
+  if (/\.(css|scss|sass|less)$/i.test(ext)) return new Set<Engine>(["css"]);
+  if (/\.(html|htm|vue|svelte|astro)$/i.test(ext)) return new Set<Engine>(["css", "html", "copy"]);
+  if (/\.(jsx|tsx)$/i.test(ext)) return new Set<Engine>(["css", "jsx", "copy"]);
+  if (/\.(md|mdx)$/i.test(ext)) return new Set<Engine>(["copy"]);
+  return new Set<Engine>();
+}
+
+function* walkDir(dir: string, ext: RegExp): Generator<string> {
+  if (!fs.existsSync(dir)) return;
+  for (const entry of fs.readdirSync(dir, { withFileTypes: true })) {
+    const full = path.join(dir, entry.name);
+    if (entry.name.startsWith(".") || entry.name === "node_modules") continue;
+    if (entry.isDirectory()) yield* walkDir(full, ext);
+    else if (ext.test(entry.name)) yield full;
+  }
+}
+
+function loadConfig(dir: string): ProjectConfig {
+  const p = path.join(dir, ".design-quality.json");
+  if (!fs.existsSync(p)) return {};
+  try {
+    return JSON.parse(fs.readFileSync(p, "utf-8")) as ProjectConfig;
+  } catch {
+    return {};
+  }
+}
+
+/** Read DESIGN.md (scan dir, then project root) as the context-gate source. */
+export function loadDesignContext(scanDir: string): DesignContext {
+  const candidates = [
+    path.join(scanDir, "DESIGN.md"),
+    path.join(process.cwd(), "DESIGN.md"),
+    path.join(scanDir, "..", "DESIGN.md"),
+  ];
+  let raw = "";
+  for (const c of candidates) {
+    if (fs.existsSync(c)) {
+      raw = fs.readFileSync(c, "utf-8").toLowerCase();
+      break;
+    }
+  }
+  return {
+    raw,
+    has: (...keywords: string[]) => keywords.some((k) => raw.includes(k.toLowerCase())),
+  };
+}
+
+function parseIgnores(lines: string[]): Map<string, Set<number>> {
+  const ignores = new Map<string, Set<number>>();
+  const add = (rule: string, line: number) => {
+    const set = ignores.get(rule) ?? new Set<number>();
+    set.add(line);
+    ignores.set(rule, set);
+  };
+  for (let i = 0; i < lines.length; i++) {
+    const line = lines[i] ?? "";
+    const file = /design-slop-disable\s+([\w-]+)/i.exec(line);
+    if (file && file[1] && !/-line|-next-line/.test(line)) {
+      ignores.set(file[1].toLowerCase(), new Set([...Array(99999).keys()].map((n) => n + 1)));
+    }
+    const next = /design-slop-disable-next-line\s+([\w-]+)/i.exec(line);
+    if (next && next[1]) add(next[1].toLowerCase(), i + 2);
+    const cur = /design-slop-disable-line\s+([\w-]+)/i.exec(line);
+    if (cur && cur[1]) add(cur[1].toLowerCase(), i + 1);
+  }
+  return ignores;
+}
+
+export function scanFile(
+  content: string,
+  relPath: string,
+  ctx: DesignContext,
+): Finding[] {
+  const lines = content.split("\n");
+  const ext = path.extname(relPath).toLowerCase();
+  const fileEngines = enginesForExt(ext);
+  if (fileEngines.size === 0) return [];
+  const ignores = parseIgnores(lines);
+
+  const out: Finding[] = [];
+  for (const rule of SLOP_RULES) {
+    if (!rule.engines.some((e) => fileEngines.has(e))) continue;
+    if (rule.gated && rule.gated(ctx)) continue; // DESIGN.md declares intent → suppress
+    let hits;
+    try {
+      hits = rule.detect({ content, lines, ext, ctx });
+    } catch {
+      continue; // a single rule throwing never kills the scan
+    }
+    for (const h of hits) {
+      const ruleIgnore = ignores.get(rule.id.toLowerCase());
+      if (ruleIgnore && ruleIgnore.has(h.line)) continue;
+      out.push({
+        rule: rule.id,
+        catalogId: rule.catalogId,
+        severity: rule.severity,
+        file: relPath,
+        line: h.line,
+        snippet: h.snippet,
+        message: rule.message,
+      });
+    }
+  }
+  return out;
+}
+
+function main(): void {
+  const args = process.argv.slice(2);
+  const jsonMode = args.includes("--json");
+  const quiet = args.includes("--quiet");
+  const dirIdx = args.indexOf("--dir");
+  const scanDir = dirIdx >= 0 && args[dirIdx + 1] ? path.resolve(args[dirIdx + 1]!) : path.resolve(process.cwd(), "src");
+  const failIdx = args.indexOf("--fail-on");
+  const failOn = (failIdx >= 0 ? args[failIdx + 1] : undefined) as Severity | undefined;
+
+  if (!fs.existsSync(scanDir)) {
+    if (!quiet) {
+      process.stderr.write(`[lint_design_slop] scan directory not found: ${scanDir}\n`);
+      process.stderr.write("Opt-in for consumer projects. Run with --dir <path> at your UI source.\n");
+    }
+    process.exit(0);
+  }
+
+  const ctx = loadDesignContext(scanDir);
+  const config = loadConfig(process.cwd());
+  const ignoreRules = new Set((config.ignoreRules ?? []).map((r) => r.toLowerCase()));
+  const ignoreGlobs = config.ignoreFiles ?? [];
+
+  const files: string[] = [];
+  for (const f of walkDir(scanDir, /\.(html|htm|css|scss|sass|less|vue|svelte|astro|jsx|tsx|md|mdx)$/i)) {
+    if (!ignoreGlobs.some((g) => f.includes(g.replace("**", "")))) files.push(f);
+  }
+
+  const findings: Finding[] = [];
+  for (const fp of files) {
+    const rel = path.relative(process.cwd(), fp);
+    try {
+      const fileFindings = scanFile(fs.readFileSync(fp, "utf-8"), rel, ctx).filter(
+        (f) => !ignoreRules.has(f.rule.toLowerCase()),
+      );
+      findings.push(...fileFindings);
+    } catch (err) {
+      if (!quiet) process.stderr.write(`[lint_design_slop] error: ${fp}: ${err}\n`);
+    }
+  }
+
+  findings.sort((a, b) => sevRank(b.severity) - sevRank(a.severity));
+
+  const overThreshold = failOn
+    ? findings.filter((f) => sevRank(f.severity) >= sevRank(failOn))
+    : [];
+
+  if (jsonMode) {
+    process.stdout.write(JSON.stringify({ findings, failOn: failOn ?? null, overThreshold: overThreshold.length }, null, 2) + "\n");
+    process.exit(overThreshold.length > 0 ? 2 : 0);
+  }
+
+  if (findings.length === 0) {
+    if (!quiet) process.stdout.write(`✅  lint_design_slop: no anti-slop tells in ${files.length} file(s).\n`);
+    process.exit(0);
+  }
+
+  for (const f of findings) {
+    const icon = f.severity === "P0" || f.severity === "P1" ? "⚠️ " : "•";
+    process.stdout.write(`${icon} [${f.severity} ${f.catalogId}] ${f.file}:${f.line} (${f.rule}) — ${f.message}\n     ${f.snippet}\n`);
+  }
+  process.stdout.write(
+    `\nlint_design_slop: ${findings.length} tell(s) flagged (rebuttable — declare intent in DESIGN.md, ` +
+      `design-slop-disable-next-line <rule>, or .design-quality.json).` +
+      (failOn ? ` ${overThreshold.length} at/above ${failOn}.` : " Flags only; no CI failure (pass --fail-on to gate).") +
+      "\n",
+  );
+  process.exit(overThreshold.length > 0 ? 2 : 0);
+}
+
+// Run only when invoked directly (not when imported by the test guard).
+const invokedDirectly =
+  process.argv[1] !== undefined && /lint_design_slop\.ts$/.test(process.argv[1]);
+if (invokedDirectly) main();

package/src/scripts/lint_framework_leakage_allowlist.json

@@ -480,7 +480,7 @@
     {
       "file": ".agent-src.uncondensed/rules/architecture.md",
       "lines": [
-        71
+        69
       ],
       "reason": "Multi-framework module-system enumeration (Laravel, Turborepo, NestJS, Go) — comparative example, no project mandate"
     },
@@ -515,14 +515,14 @@
     {
       "file": ".agent-src.uncondensed/rules/architecture.md",
       "lines": [
-        76
+        74
       ],
       "reason": "Single Laravel-shape example showing how `{module_root}/*/{agent_folder}/` resolves on a Laravel HMVC project (road-to-configurable-modules Phase D)"
     },
     {
       "file": ".agent-src.uncondensed/rules/roadmap-ci-steps-policy.md",
       "lines": [
-        101
+        99
       ],
       "reason": "Single Laravel-shape example showing module-scoped roadmap path (road-to-configurable-modules Phase D)"
     },
@@ -598,6 +598,29 @@
         29
       ],
       "reason": "Cross-stack UI-stack enumeration (React, Blade, Tailwind)"
+    },
+    {
+      "file": "src/skills/code-review/SKILL.md",
+      "lines": [
+        79,
+        88,
+        90
+      ],
+      "reason": "Cross-stack security-review checklist rows naming Laravel/Symfony/NestJS/DTO peers side-by-side (allowed multi-ecosystem documentation, not a mandate)"
+    },
+    {
+      "file": "src/skills/context-document/SKILL.md",
+      "lines": [
+        83
+      ],
+      "reason": "Module-path resolution table citing the Laravel shape as one named example next to the generic modules.root_paths mechanism"
+    },
+    {
+      "file": "src/skills/verify-completion-evidence/SKILL.md",
+      "lines": [
+        183
+      ],
+      "reason": "Carve-out pointer to the quality-tools skill (the sanctioned one-line handoff shape from framework-neutrality-in-generic-skills)"
     }
   ]
 }

package/src/scripts/lint_knowledge_scale.ts

@@ -0,0 +1,250 @@
+#!/usr/bin/env tsx
+/**
+ * Warn-only scale + budget tripwires for the memory/knowledge substrate —
+ * road-to-second-brain Phase 0 (council 2026-07-07, see
+ * `agents/settings/contexts/second-brain-delta-verdict.md`).
+ *
+ * These tripwires REPLACE roadmap gates: each warning names its pre-decided
+ * activation path, so a firing tripwire is actionable without re-opening the
+ * decision. The script never fails the build.
+ *
+ * Tripwires:
+ *   - intake scale     — `agents/knowledge/intake/events-*.jsonl` > 2000 events
+ *                        → wire `fold_intake.ts` into post-session/CI
+ *   - sessions scale   — `agents/knowledge/sessions/` > 50 pages
+ *                        → design fold-through-consolidate-gate for tracked pages
+ *   - type scale       — any single memory/knowledge type > 200 files
+ *                        → build the pre-decided file-first in-memory BM25 CLI
+ *   - corpus scale     — > 500 files across all types
+ *                        → same BM25 activation path
+ *   - hot-context size — `agents/runtime/state/hot-context.md` > 600 tokens
+ *                        (estimated at 4 chars/token) → trim schema / fix the
+ *                        deterministic writer
+ *
+ * Usage: lint_knowledge_scale.ts [--dir <repo-root>] [--format text|json] [--quiet]
+ * Exit codes: 0 = ran cleanly (warnings never fail the build), 1 = usage
+ * error, 3 = internal error.
+ */
+import * as fs from 'node:fs';
+import * as path from 'node:path';
+import process from 'node:process';
+import { fileURLToPath } from 'node:url';
+
+const PROG = 'lint_knowledge_scale.ts';
+
+export const INTAKE_EVENTS_MAX = 2000;
+export const SESSIONS_PAGES_MAX = 50;
+export const TYPE_FILES_MAX = 200;
+export const CORPUS_FILES_MAX = 500;
+export const HOT_CONTEXT_TOKENS_MAX = 600;
+export const CHARS_PER_TOKEN = 4;
+
+const KNOWLEDGE_TYPED_DIRS = ['sessions', 'concepts', 'procedures', 'decisions'] as const;
+
+export interface Warning {
+    rule: string;
+    metric: string; // "<observed>/<threshold>"
+    message: string; // includes the pre-decided activation path
+}
+
+function listFiles(dir: string, exts: readonly string[]): string[] {
+    let entries: fs.Dirent[];
+    try {
+        entries = fs.readdirSync(dir, { withFileTypes: true });
+    } catch {
+        return [];
+    }
+    return entries
+        .filter((e) => e.isFile() && exts.some((x) => e.name.endsWith(x)))
+        .map((e) => path.join(dir, e.name));
+}
+
+function countJsonlLines(file: string): number {
+    let text: string;
+    try {
+        text = fs.readFileSync(file, 'utf-8');
+    } catch {
+        return 0;
+    }
+    return text.split('\n').filter((l) => l.trim().length > 0).length;
+}
+
+/** Collect per-type file counts across the knowledge + memory substrate. */
+export function collectTypeCounts(root: string): Map<string, number> {
+    const counts = new Map<string, number>();
+
+    // Knowledge cards (flat, top-level *.md except README/INDEX).
+    const cardsDir = path.join(root, 'agents', 'knowledge');
+    const cards = listFiles(cardsDir, ['.md']).filter((f) => {
+        const base = path.basename(f).toLowerCase();
+        return base !== 'readme.md' && base !== 'index.md';
+    });
+    counts.set('knowledge/cards', cards.length);
+
+    // Lifecycle-typed knowledge dirs.
+    for (const d of KNOWLEDGE_TYPED_DIRS) {
+        counts.set(`knowledge/${d}`, listFiles(path.join(cardsDir, d), ['.md']).length);
+    }
+
+    // Curated memory types: agents/memory/<type>/ dirs and <type>.yml files.
+    // The gitignored per-task scratch (`agents/memory/knowledge/`) is excluded —
+    // it is session state, not a curated type.
+    const memoryDir = path.join(root, 'agents', 'memory');
+    let memEntries: fs.Dirent[] = [];
+    try {
+        memEntries = fs.readdirSync(memoryDir, { withFileTypes: true });
+    } catch {
+        // no memory dir — fine
+    }
+    for (const e of memEntries) {
+        if (e.isDirectory()) {
+            if (e.name === 'knowledge' || e.name === 'intake' || e.name === 'archive') continue;
+            const n = listFiles(path.join(memoryDir, e.name), ['.md', '.yml', '.yaml']).length;
+            counts.set(`memory/${e.name}`, n);
+        } else if (e.isFile() && (e.name.endsWith('.yml') || e.name.endsWith('.yaml'))) {
+            counts.set(`memory/${e.name}`, 1);
+        }
+    }
+    return counts;
+}
+
+export function runChecks(root: string): Warning[] {
+    const warnings: Warning[] = [];
+
+    // 1. Intake scale.
+    const intakeDir = path.join(root, 'agents', 'knowledge', 'intake');
+    const intakeFiles = listFiles(intakeDir, ['.jsonl']).filter((f) =>
+        path.basename(f).startsWith('events-'),
+    );
+    const intakeEvents = intakeFiles.reduce((acc, f) => acc + countJsonlLines(f), 0);
+    if (intakeEvents > INTAKE_EVENTS_MAX) {
+        warnings.push({
+            rule: 'intake-scale',
+            metric: `${intakeEvents}/${INTAKE_EVENTS_MAX}`,
+            message:
+                `intake holds ${intakeEvents} events (> ${INTAKE_EVENTS_MAX}). ` +
+                'Activation path (pre-decided): wire `src/scripts/fold_intake.ts` into the post-session/CI cadence.',
+        });
+    }
+
+    // 2. Sessions scale.
+    const sessionsDir = path.join(root, 'agents', 'knowledge', 'sessions');
+    const sessionPages = listFiles(sessionsDir, ['.md']).length;
+    if (sessionPages > SESSIONS_PAGES_MAX) {
+        warnings.push({
+            rule: 'sessions-scale',
+            metric: `${sessionPages}/${SESSIONS_PAGES_MAX}`,
+            message:
+                `agents/knowledge/sessions/ holds ${sessionPages} pages (> ${SESSIONS_PAGES_MAX}). ` +
+                'Activation path (pre-decided): design fold-through-consolidate-gate for tracked pages — never fold tracked files without the gate.',
+        });
+    }
+
+    // 3 + 4. Type + corpus scale.
+    const typeCounts = collectTypeCounts(root);
+    let total = 0;
+    for (const [type, n] of typeCounts) {
+        total += n;
+        if (n > TYPE_FILES_MAX) {
+            warnings.push({
+                rule: 'type-scale',
+                metric: `${n}/${TYPE_FILES_MAX}`,
+                message:
+                    `type '${type}' holds ${n} files (> ${TYPE_FILES_MAX}). ` +
+                    'Activation path (pre-decided): build the file-first in-memory BM25 CLI (re-index at session start, no vectors, no service).',
+            });
+        }
+    }
+    if (total > CORPUS_FILES_MAX) {
+        warnings.push({
+            rule: 'corpus-scale',
+            metric: `${total}/${CORPUS_FILES_MAX}`,
+            message:
+                `memory/knowledge corpus holds ${total} files (> ${CORPUS_FILES_MAX}). ` +
+                'Activation path (pre-decided): build the file-first in-memory BM25 CLI (re-index at session start, no vectors, no service).',
+        });
+    }
+
+    // 5. Hot-context budget.
+    const hotContext = path.join(root, 'agents', 'runtime', 'state', 'hot-context.md');
+    let hotText = '';
+    try {
+        hotText = fs.readFileSync(hotContext, 'utf-8');
+    } catch {
+        // absent — fine (feature not active or fresh session)
+    }
+    if (hotText) {
+        const tokens = Math.ceil(hotText.length / CHARS_PER_TOKEN);
+        if (tokens > HOT_CONTEXT_TOKENS_MAX) {
+            warnings.push({
+                rule: 'hot-context-budget',
+                metric: `${tokens}/${HOT_CONTEXT_TOKENS_MAX}`,
+                message:
+                    `hot-context.md parses to ~${tokens} tokens (> ${HOT_CONTEXT_TOKENS_MAX}). ` +
+                    'Activation path (pre-decided): trim the schema sections or fix the deterministic writer cap.',
+            });
+        }
+    }
+
+    return warnings;
+}
+
+function main(argv: string[]): number {
+    let dir = '.';
+    let format = 'text';
+    let quiet = false;
+    for (let i = 0; i < argv.length; i++) {
+        const a = argv[i];
+        if (a === '--dir') {
+            dir = argv[++i] ?? '';
+            if (!dir) {
+                process.stderr.write(`${PROG}: error: --dir requires a value\n`);
+                return 1;
+            }
+        } else if (a === '--format') {
+            format = argv[++i] ?? '';
+            if (format !== 'text' && format !== 'json') {
+                process.stderr.write(`${PROG}: error: --format must be text|json\n`);
+                return 1;
+            }
+        } else if (a === '--quiet') {
+            quiet = true;
+        } else if (a === '-h' || a === '--help') {
+            process.stdout.write(
+                `usage: ${PROG} [--dir <repo-root>] [--format text|json] [--quiet]\n`,
+            );
+            return 0;
+        } else {
+            process.stderr.write(`${PROG}: error: unknown argument ${a}\n`);
+            return 1;
+        }
+    }
+
+    let warnings: Warning[];
+    try {
+        warnings = runChecks(path.resolve(dir));
+    } catch (exc) {
+        process.stderr.write(`${PROG}: internal error: ${String(exc)}\n`);
+        return 3;
+    }
+
+    if (format === 'json') {
+        process.stdout.write(JSON.stringify({ warnings }, null, 2) + '\n');
+    } else if (warnings.length === 0) {
+        if (!quiet) {
+            process.stdout.write(`${PROG}: all scale tripwires silent (warn-only)\n`);
+        }
+    } else {
+        for (const w of warnings) {
+            process.stdout.write(`⚠️  [${w.rule}] ${w.metric} — ${w.message}\n`);
+        }
+        process.stdout.write(
+            `${PROG}: ${warnings.length} tripwire(s) fired — warn-only, build not failed\n`,
+        );
+    }
+    return 0;
+}
+
+if (fileURLToPath(import.meta.url) === path.resolve(process.argv[1] ?? '')) {
+    process.exit(main(process.argv.slice(2)));
+}

package/src/scripts/lint_legal_pack.ts

@@ -74,6 +74,62 @@ export function legalPromotionViolations(packsYml: string, legalNotice: string):
     return [];
 }
 
+// D7 — reference-resolution gate for the floor rule itself. The
+// `legal-safety-floor` rule is authored in `src/rules/` but SHIPS/PROJECTS to
+// `dist/agent-src/rules/`; its relative links must resolve from that SHIPPED
+// projection root (7.5.0 shipped a `LEGAL_NOTICE.md` path that only resolved
+// from the projection — correct by design, but nothing asserted it, so a wrong
+// depth could silently regress). `check_references` does not catch this: it
+// only scans `dist/agent-src/` + `agents/` (never `src/`), and its PATH_PATTERN
+// matches only directory-rooted paths (`skills/…`, `docs/…`), so a bare
+// `../../../LEGAL_NOTICE.md` filename link is invisible to it. This gate is the
+// complementary backstop — every markdown link target in the floor rule must
+// resolve from the projected `dist/agent-src/rules/` location.
+const PROJECTED_FLOOR_DIR = path.join(REPO, 'dist', 'agent-src', 'rules');
+// Markdown inline link: [text](target). Captures the target.
+const MD_LINK_RE = /\[[^\]]*\]\(([^)]+)\)/g;
+
+/**
+ * Pure reference-resolution check for the floor rule. `ruleText` is the floor
+ * rule body (read from `src/rules/legal-safety-floor.md`); every relative
+ * markdown link target it contains MUST resolve from `projectedDir` (the
+ * shipped `dist/agent-src/rules/` location). External (http/anchor/mailto) and
+ * absolute targets are skipped. Returns a Violation per unresolvable link.
+ */
+export function legalFloorReferenceViolations(
+    ruleText: string,
+    projectedDir: string,
+    floorRel: string,
+): Violation[] {
+    const out: Violation[] = [];
+    const seen = new Set<string>();
+    MD_LINK_RE.lastIndex = 0;
+    let m: RegExpExecArray | null;
+    while ((m = MD_LINK_RE.exec(ruleText)) !== null) {
+        let target = (m[1] ?? '').trim();
+        // Strip a fragment/anchor and any title (`path "Title"`).
+        const titleSplit = target.match(/^(\S+)\s+["'(]/);
+        if (titleSplit) target = titleSplit[1] ?? target;
+        const hashIdx = target.indexOf('#');
+        if (hashIdx >= 0) target = target.slice(0, hashIdx);
+        if (!target) continue;
+        // Skip non-path targets: external URLs, mailto, in-page anchors,
+        // absolute paths (resolution root is the projection, not the FS root).
+        if (/^([a-z][a-z0-9+.-]*:|#|\/)/i.test(target)) continue;
+        if (seen.has(target)) continue;
+        seen.add(target);
+        const resolved = path.resolve(projectedDir, target);
+        if (!fs.existsSync(resolved)) {
+            out.push({
+                file: floorRel,
+                rule: 'floor-reference',
+                msg: `link target "${target}" does not resolve from the shipped projection (dist/agent-src/rules/) — fix the relative depth so it resolves from the projected rule location`,
+            });
+        }
+    }
+    return out;
+}
+
 // D4 — definitive-legal-language blocklist (the floor bans these; this is the
 // deterministic backstop over skill bodies). Narrow on purpose; the floor's
 // prompt layer is the primary enforcement.
@@ -175,6 +231,17 @@ export function lintLegalPack(skillsDir: string = SKILLS_DIR): Violation[] {
         if (fs.existsSync(PACKS_YML) && fs.existsSync(PACK_NOTICE)) {
             violations.push(...legalPromotionViolations(_readText(PACKS_YML), _readText(PACK_NOTICE)));
         }
+        // D7 — floor-rule reference gate: every link in the floor rule must
+        // resolve from its SHIPPED projection (dist/agent-src/rules/).
+        if (fs.existsSync(PROJECTED_FLOOR_DIR)) {
+            violations.push(
+                ...legalFloorReferenceViolations(
+                    _readText(FLOOR_RULE),
+                    PROJECTED_FLOOR_DIR,
+                    path.relative(REPO, FLOOR_RULE),
+                ),
+            );
+        }
     }
     return violations;
 }

package/src/scripts/lint_persona_governance.ts

@@ -26,10 +26,13 @@ const QUIET = process.argv.includes('--quiet');
 
 const _HERE = fileURLToPath(import.meta.url);
 const REPO = path.resolve(path.dirname(_HERE), '..', '..');
-const PERSONA_DIR = path.join(REPO, '.agent-src.uncondensed', 'personas');
+// Source of truth is `src/` (ADR-051); the old condensed-legacy source tree is
+// empty post-py2ts, so the previous path silently scanned zero personas and the
+// governance gate was inert. Scan the real source tree.
+const PERSONA_DIR = path.join(REPO, 'src', 'agent-src', 'personas');
 const SKILL_ROOTS: readonly string[] = [
-    path.join(REPO, '.agent-src.uncondensed', 'skills'),
-    path.join(REPO, '.claude', 'skills'),
+    path.join(REPO, 'src', 'skills'),
+    path.join(REPO, 'src', 'rules'),
 ];
 
 // Per-domain cap — mirrors persona-governance.md § Per-domain cap.
@@ -38,6 +41,8 @@ const DOMAIN_MAP: Record<string, string> = {
     'ai-video-technical-director': 'ai-video',
     'backend-architect': 'backend',
     'eloquent-tamer': 'backend',
+    'performance-engineer': 'performance',
+    'data-integrity': 'data',
     cmo: 'gtm',
     revops: 'gtm',
     'growth-pm': 'growth',

package/src/scripts/lint_regression.ts

@@ -114,6 +114,21 @@ function run_linter_json(ref: string | null, repo_root: string): LinterJson {
                 return { results: [], summary: {} };
             }
             const baselineArgs = ['--all', '--format', 'json', '--repo-root', tmpdir];
+            // Local python-skip guard (teardown D2): a historical `.py` baseline
+            // genuinely needs python3; when the runtime is absent, degrade to an
+            // empty baseline (same contract as a missing linter) instead of a
+            // spawn error — decouples the python-free-env shim retirement from
+            // porting pre-migration baselines to a frozen TS golden.
+            if (
+                baseline_linter.endsWith('.py') &&
+                spawnSync('python3', ['--version'], { encoding: 'utf8' }).status !== 0
+            ) {
+                process.stderr.write(
+                    `Warning: baseline '${ref}' is pre-migration (.py) and python3 is ` +
+                        `unavailable — baseline treated as empty.\n`,
+                );
+                return { results: [], summary: {} };
+            }
             const result = baseline_linter.endsWith('.ts')
                 ? (() => {
                       const inv = _resolve_tsx_invocation(baseline_linter, baselineArgs);