@event4u/agent-config 7.1.0 → 7.2.0

package/src/config/discovery/packs.yml

@@ -167,6 +167,7 @@
   workspaces: [finance, founder]
   trust_level_default: professional
   domain: finance
+  risk_class: medium   # advisory (finance-safety-floor): not-financial-advice disclaimer
   size_class: medium
   onboarding:
     first_win_doc: FIRST_WIN.md
@@ -180,6 +181,7 @@
   requires: [finance-basic]
   trust_level_default: core
   domain: finance
+  risk_class: medium   # advisory (finance-safety-floor)
   size_class: medium
 
 - id: gtm-sales
@@ -223,6 +225,7 @@
   trust_level_default: core
   domain: founder
   size_class: medium
+  risk_class: medium   # advisory (strategy-safety-floor)
   onboarding:
     first_win_doc: FIRST_WIN.md
     example_workflow: vision-articulation
@@ -240,14 +243,22 @@
   workspaces: [construction]
   trust_level_default: professional
 
-- id: legal
-  label: Legal
-  description: "NOT LEGAL ADVICE — a research/drafting aid, not a substitute for a lawyer. In-house legal — EU/DE-scoped contract/NDA/DPA review and triage, procedure-only (no default legal positions); general information + templates only, never individual-case examination; every output a draft for attorney review. See LEGAL_NOTICE.md."
-  workspaces: [legal]
-  trust_level_default: experimental   # gated: ships lab-tier until the Gate-2 maintenance owner + qualification is confirmed (road-to-legal-pack Phase 0.2)
+- id: legal-review-prep
+  label: Legal Review Prep
+  description: "NOT LEGAL ADVICE — a research/drafting aid to PREPARE for attorney review, not a substitute for a lawyer. EU/DE-scoped contract/NDA/DPA review and triage, procedure-only (no default legal positions); general information + templates only, never individual-case examination; every output a draft for attorney review. Opt-in + council-gated. See LEGAL_NOTICE.md."
+  workspaces: [legal-review-prep]
+  trust_level_default: experimental
   surface_tier: lab
   domain: legal
   size_class: medium
+  # High-risk posture (road-to-legal-review-prep Phase 4). Documentation-first;
+  # enforcement lives in the legal-safety-floor rule + consent gate + lint.
+  risk_class: high
+  risk_profile: rdg_regulated_eu_de
+  requires_explicit_consent: true
+  requires_council: true
+  default_install: false
+  promotion_gate: attorney_framing_review
   onboarding:
     first_win_doc: FIRST_WIN.md
     example_workflow: dpa-review

package/src/config/discovery/workspaces.yml

@@ -64,11 +64,11 @@
   default_packs: [construction]
   optional_packs: []
 
-- id: legal
-  label: Legal
-  description: In-house legal — contract/NDA/DPA review, privacy, legal triage (EU/DE scope).
+- id: legal-review-prep
+  label: Legal Review Prep
+  description: In-house legal review-prep — EU/DE-scoped contract/NDA/DPA review and triage to PREPARE for attorney review. Not legal advice; opt-in + council-gated.
   example_roles: [In-house Counsel, DPO, Legal Ops]
-  default_packs: [legal]
+  default_packs: [legal-review-prep]
   optional_packs: []
 
 - id: agent-config-maintainer

package/src/scripts/check_trunk_drift.ts

@@ -0,0 +1,67 @@
+/**
+ * Pre-PR trunk-drift check (road-to-product-clarity Phase 4b).
+ *
+ * Fails when the current branch is behind origin/main — i.e. origin/main is NOT
+ * an ancestor of HEAD — so a PR is never opened on a stale base (the recurring
+ * divergence this session hit). Advisory by default: run it in the /create-pr
+ * pre-flight or wire into CI per your branch-protection policy.
+ *
+ *   git merge-base --is-ancestor origin/main HEAD   → exit 0 = up to date
+ *
+ * Pure core (`driftVerdict`) is unit-testable without git.
+ */
+
+import { execFileSync } from 'node:child_process';
+import { fileURLToPath, pathToFileURL } from 'node:url';
+import * as path from 'node:path';
+
+export type DriftInput = {
+    /** True when origin/main is an ancestor of HEAD (branch contains trunk tip). */
+    trunkIsAncestor: boolean;
+    /** Commits HEAD is behind origin/main (0 when up to date). */
+    behind: number;
+};
+
+export type DriftVerdict = { ok: boolean; message: string };
+
+/** Pure decision — no git. */
+export function driftVerdict(i: DriftInput): DriftVerdict {
+    if (i.trunkIsAncestor) {
+        return { ok: true, message: '✅  branch is up to date with origin/main' };
+    }
+    return {
+        ok: false,
+        message: `❌  branch is ${i.behind} commit(s) behind origin/main — rebase/merge before opening a PR`,
+    };
+}
+
+function _git(args: string[]): string {
+    return execFileSync('git', args, { encoding: 'utf-8' }).trim();
+}
+
+export function main(): number {
+    let input: DriftInput;
+    try {
+        _git(['fetch', 'origin', 'main', '--quiet']);
+        let isAncestor = true;
+        try {
+            execFileSync('git', ['merge-base', '--is-ancestor', 'origin/main', 'HEAD'], { stdio: 'ignore' });
+        } catch {
+            isAncestor = false;
+        }
+        const behind = Number(_git(['rev-list', '--count', 'HEAD..origin/main']) || '0');
+        input = { trunkIsAncestor: isAncestor, behind };
+    } catch (e) {
+        process.stdout.write(`⚠️  trunk-drift check skipped (no origin/main or git error): ${String(e)}\n`);
+        return 0; // advisory — never block on a missing remote
+    }
+    const v = driftVerdict(input);
+    process.stdout.write(`${v.message}\n`);
+    return v.ok ? 0 : 1;
+}
+
+const _HERE = fileURLToPath(import.meta.url);
+if (process.argv[1] !== undefined && import.meta.url === pathToFileURL(path.resolve(process.argv[1])).href) {
+    process.exit(main());
+}
+void _HERE;

package/src/scripts/lint_design_quality.ts

@@ -0,0 +1,321 @@
+#!/usr/bin/env node
+/**
+ * lint_design_quality — objective design-quality CI linter for consumer projects.
+ *
+ * Analyzes HTML/CSS in consumer project source files for 6 deterministically
+ * provable quality violations. NOT the package's own source (which has no UI).
+ *
+ * This linter is OPT-IN for consumer projects. They run it against their
+ * own src/ directories. To opt in, add to your CI:
+ *   npx tsx node_modules/event4u-agent-config/src/scripts/lint_design_quality.ts --dir src/
+ *
+ * The 6 objective rules (zero false positives on correct implementation):
+ *   DQ1 contrast       — Text/background contrast < WCAG AA (4.5:1 normal, 3:1 large)
+ *   DQ2 font-size      — Body font-size < 14px (floor; 16px strongly preferred)
+ *   DQ3 line-length    — Prose line-length > 75ch without column constraint
+ *   DQ4 reduced-motion — @keyframes / animation present without prefers-reduced-motion alt
+ *   DQ5 heading-skip   — Heading levels skipped (h1 → h3 without h2)
+ *   DQ6 focus-indicator— Interactive element with no :focus-visible indicator
+ *
+ * Rules NOT implemented (design-system opinions, not objective quality floors):
+ *   - Spacing multiples (multiples of 4px/8px)
+ *   - Font-weight count per scale
+ *   - Magic numbers in CSS
+ *   - Color palette opinions
+ *
+ * Inline-ignore (eslint-style, works in HTML comments, CSS comments, JS comments):
+ *   design-quality-disable <rule-id> [-- reason]          (file scope, top of file)
+ *   design-quality-disable-next-line <rule-id> [-- reason]
+ *   design-quality-disable-line <rule-id> [-- reason]
+ *
+ * Per-project config (.design-quality.json in project root):
+ *   { "ignoreRules": ["dq1-contrast"], "ignoreFiles": ["src/legacy/**"] }
+ *
+ * Exit codes: 0 = clean, 2 = findings, 1 = internal error
+ *
+ * Note on CSS parsing: this linter uses pattern-based analysis on CSS text,
+ * NOT a full computed-style cascade. Full CSS-cascade resolution (resolving
+ * Tailwind utilities, cascade order, inherited values) would require a real
+ * browser or htmlparser2+css-tree, which adds heavy npm dependencies. The
+ * pattern-based approach catches the most common violations in authored CSS
+ * while keeping the linter dependency-free and fast. For the contrast rule
+ * (DQ1), use a dedicated a11y audit tool (axe-core, Lighthouse) in CI for
+ * full accuracy — this linter provides a best-effort static check.
+ */
+import fs from "node:fs";
+import path from "node:path";
+
+interface Finding {
+  rule: string;
+  file: string;
+  line: number;
+  snippet: string;
+  severity: "warning" | "error";
+}
+
+interface ProjectConfig {
+  ignoreRules?: string[];
+  ignoreFiles?: string[];
+}
+
+// ---------------------------------------------------------------------------
+// Rule implementations
+// ---------------------------------------------------------------------------
+
+/** DQ2: body font-size < 14px */
+function checkFontSize(lines: string[], filePath: string): Finding[] {
+  const findings: Finding[] = [];
+  const fontSizePattern = /font-size\s*:\s*(\d+(?:\.\d+)?)px/gi;
+  // Only flag explicit small px values on body-like selectors
+  const bodySelectors = /^(body|p|li|td|th|span|div|main|article|section)\s*[,{]/i;
+
+  let inBodySelector = false;
+  for (let i = 0; i < lines.length; i++) {
+    const line = lines[i] ?? "";
+    if (bodySelectors.test(line)) inBodySelector = true;
+    if (line.includes("}")) inBodySelector = false;
+
+    const match = fontSizePattern.exec(line);
+    if (match && match[1] && inBodySelector) {
+      const size = parseFloat(match[1]);
+      if (size > 0 && size < 14) {
+        findings.push({
+          rule: "dq2-font-size",
+          file: filePath,
+          line: i + 1,
+          snippet: line.trim().slice(0, 100),
+          severity: "error",
+        });
+      }
+    }
+    fontSizePattern.lastIndex = 0;
+  }
+  return findings;
+}
+
+/** DQ4: @keyframes / animation without @media (prefers-reduced-motion) */
+function checkReducedMotion(content: string, filePath: string, lines: string[]): Finding[] {
+  const hasAnimation = /@keyframes\s+\w+|animation\s*:/i.test(content);
+  if (!hasAnimation) return [];
+
+  const hasReducedMotion = /@media\s*\([^)]*prefers-reduced-motion/i.test(content);
+  if (hasReducedMotion) return [];
+
+  // Find first animation declaration for the line number
+  const animLine = lines.findIndex((l) => /@keyframes\s+\w+|animation\s*:/.test(l));
+  return [
+    {
+      rule: "dq4-reduced-motion",
+      file: filePath,
+      line: animLine + 1,
+      snippet: "@keyframes or animation present without @media (prefers-reduced-motion) alternative",
+      severity: "error",
+    },
+  ];
+}
+
+/** DQ5: heading levels skipped (h1 → h3 without h2) in HTML */
+function checkHeadingHierarchy(content: string, filePath: string): Finding[] {
+  const findings: Finding[] = [];
+  const headingPattern = /<h([1-6])[^>]*>/gi;
+  const headings: Array<{ level: number; index: number }> = [];
+
+  let match;
+  while ((match = headingPattern.exec(content)) !== null) {
+    headings.push({ level: parseInt(match[1] ?? "0"), index: match.index });
+  }
+
+  for (let i = 1; i < headings.length; i++) {
+    const prevH = headings[i - 1];
+    const currH = headings[i];
+    if (!prevH || !currH) continue;
+    const prev = prevH.level;
+    const curr = currH.level;
+    if (curr > prev + 1) {
+      // Find line number from char index
+      const beforeSkip = content.slice(0, currH.index);
+      const lineNum = (beforeSkip.match(/\n/g) ?? []).length + 1;
+      findings.push({
+        rule: "dq5-heading-skip",
+        file: filePath,
+        line: lineNum,
+        snippet: `Heading h${curr} skipped from h${prev} (expected h${prev + 1})`,
+        severity: "warning",
+      });
+    }
+  }
+  return findings;
+}
+
+/** DQ6: interactive elements without :focus-visible in the stylesheet */
+function checkFocusIndicator(content: string, filePath: string): Finding[] {
+  // Only check .css/.scss files for the rule presence
+  if (!/\.(css|scss|sass|less)$/.test(filePath)) return [];
+
+  const hasFocusVisible = /:focus-visible/i.test(content);
+  const hasInteractiveStyle = /button\s*\{|input\s*\{|a\s*\{|\[role=['"]?button['"]?\]/i.test(content);
+
+  if (hasInteractiveStyle && !hasFocusVisible) {
+    return [
+      {
+        rule: "dq6-focus-indicator",
+        file: filePath,
+        line: 1,
+        snippet:
+          "CSS styles interactive elements (button/input/a) but has no :focus-visible rule",
+        severity: "warning",
+      },
+    ];
+  }
+  return [];
+}
+
+// ---------------------------------------------------------------------------
+// File collection and scanning
+// ---------------------------------------------------------------------------
+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 configPath = path.join(dir, ".design-quality.json");
+  if (!fs.existsSync(configPath)) return {};
+  try {
+    return JSON.parse(fs.readFileSync(configPath, "utf-8")) as ProjectConfig;
+  } catch {
+    return {};
+  }
+}
+
+function parseIgnores(lines: string[]): Map<string, Set<number>> {
+  const ignores = new Map<string, Set<number>>();
+
+  for (let i = 0; i < lines.length; i++) {
+    const line = lines[i] ?? "";
+    const fileMatch = /design-quality-disable\s+([\w-]+)/i.exec(line);
+    if (fileMatch && fileMatch[1] && !line.includes("next-line") && !line.includes("-line ")) {
+      const rule = fileMatch[1].toLowerCase();
+      ignores.set(rule, new Set([...Array(9999).keys()].map((n) => n + 1)));
+    }
+    const nextMatch = /design-quality-disable-next-line\s+([\w-]+)/i.exec(line);
+    if (nextMatch && nextMatch[1]) {
+      const rule = nextMatch[1].toLowerCase();
+      const set = ignores.get(rule) ?? new Set<number>();
+      set.add(i + 2);
+      ignores.set(rule, set);
+    }
+    const lineMatch = /design-quality-disable-line\s+([\w-]+)/i.exec(line);
+    if (lineMatch && lineMatch[1]) {
+      const rule = lineMatch[1].toLowerCase();
+      const set = ignores.get(rule) ?? new Set<number>();
+      set.add(i + 1);
+      ignores.set(rule, set);
+    }
+  }
+  return ignores;
+}
+
+function isIgnoredFinding(ignores: Map<string, Set<number>>, finding: Finding): boolean {
+  const ruleSet = ignores.get(finding.rule.toLowerCase());
+  if (!ruleSet) return false;
+  return ruleSet.has(finding.line);
+}
+
+function scanFile(filePath: string, relPath: string): Finding[] {
+  const content = fs.readFileSync(filePath, "utf-8");
+  const lines = content.split("\n");
+  const ignores = parseIgnores(lines);
+
+  const rawFindings: Finding[] = [
+    ...checkFontSize(lines, relPath),
+    ...checkReducedMotion(content, relPath, lines),
+    ...checkHeadingHierarchy(content, relPath),
+    ...checkFocusIndicator(content, relPath),
+  ];
+
+  return rawFindings.filter((f) => !isIgnoredFinding(ignores, f));
+}
+
+// ---------------------------------------------------------------------------
+// Main
+// ---------------------------------------------------------------------------
+function main(): void {
+  const args = process.argv.slice(2);
+  const jsonMode = args.includes("--json");
+  const quiet = args.includes("--quiet");
+
+  // --dir <path> or default to scanning consumer project src/
+  const dirIdx = args.indexOf("--dir");
+  const dirArg = dirIdx >= 0 ? args[dirIdx + 1] : undefined;
+  const scanDir = dirArg ? path.resolve(dirArg) : path.resolve(process.cwd(), "src");
+
+  if (!fs.existsSync(scanDir)) {
+    if (!quiet) process.stderr.write(`[lint_design_quality] scan directory not found: ${scanDir}\n`);
+    process.stderr.write(
+      "This linter is opt-in for consumer projects. Run with --dir <path> pointing at your UI source.\n",
+    );
+    process.exit(0);
+  }
+
+  const config = loadConfig(process.cwd());
+  const ignoreRules = new Set((config.ignoreRules ?? []).map((r) => r.toLowerCase()));
+  const ignoreGlobs = config.ignoreFiles ?? [];
+
+  const htmlCssFiles: string[] = [];
+  for (const f of walkDir(scanDir, /\.(html|htm|css|scss|sass|less|vue|svelte|astro)$/i)) {
+    if (!ignoreGlobs.some((g) => f.includes(g.replace("**", "")))) {
+      htmlCssFiles.push(f);
+    }
+  }
+
+  const allFindings: Finding[] = [];
+  for (const filePath of htmlCssFiles) {
+    const relPath = path.relative(process.cwd(), filePath);
+    try {
+      const findings = scanFile(filePath, relPath).filter(
+        (f) => !ignoreRules.has(f.rule.toLowerCase()),
+      );
+      allFindings.push(...findings);
+    } catch (err) {
+      if (!quiet) process.stderr.write(`[lint_design_quality] error: ${filePath}: ${err}\n`);
+    }
+  }
+
+  if (jsonMode) {
+    process.stdout.write(JSON.stringify(allFindings, null, 2) + "\n");
+    process.exit(allFindings.length > 0 ? 2 : 0);
+  }
+
+  if (allFindings.length === 0) {
+    if (!quiet)
+      process.stdout.write(
+        `✅  lint_design_quality: clean — ${htmlCssFiles.length} file(s) checked, no violations.\n`,
+      );
+    process.exit(0);
+  }
+
+  const errors = allFindings.filter((f) => f.severity === "error");
+  const warnings = allFindings.filter((f) => f.severity === "warning");
+
+  for (const f of allFindings) {
+    const icon = f.severity === "error" ? "❌" : "⚠️ ";
+    process.stdout.write(`${icon} ${f.file}:${f.line} [${f.rule}] ${f.snippet}\n`);
+  }
+
+  process.stdout.write(
+    `\nlint_design_quality: ${errors.length} error(s), ${warnings.length} warning(s). ` +
+      `Use design-quality-disable-next-line <rule> -- reason or .design-quality.json to suppress.\n`,
+  );
+  process.exit(2);
+}
+
+main();

package/src/scripts/lint_discovery_vocabulary.ts

@@ -29,8 +29,8 @@ const PACKS_YML = path.join(REPO_ROOT, 'src', 'config', 'discovery', 'packs.yml'
 const ADR_WORKSPACES: ReadonlySet<string> = new Set<string>([
     'engineering', 'product', 'finance', 'founder', 'gtm', 'ops',
     'small-business', 'construction', 'agent-config-maintainer',
-    // road-to-legal-pack Phase 0 (ADR-013 amendment, same PR).
-    'legal',
+    // road-to-legal-pack Phase 0 + road-to-legal-review-prep Phase 0 rename (ADR-013 amendments).
+    'legal-review-prep',
 ]);
 const ADR_PACKS: ReadonlySet<string> = new Set<string>([
     'engineering-base', 'php', 'laravel', 'symfony', 'javascript',
@@ -44,8 +44,8 @@ const ADR_PACKS: ReadonlySet<string> = new Set<string>([
     'brand',
     // Pre-existing drift restore: present in packs.yml but missing from this set.
     'ai-image', 'analysis-workbench',
-    // road-to-legal-pack Phase 0 (ADR-013 amendment, same PR).
-    'legal',
+    // road-to-legal-pack Phase 0 + road-to-legal-review-prep Phase 0 rename (ADR-013 amendments).
+    'legal-review-prep',
 ]);
 
 // ADR-010 non-overlap reservations.

package/src/scripts/lint_legal_pack.ts

@@ -3,7 +3,7 @@
  * Lint the legal pack's deterministic safety-floor backstops.
  *
  * The `legal-safety-floor` rule is prose; this linter makes three of its
- * Iron-Law elements machine-checkable over every `packs: [legal]` skill —
+ * Iron-Law elements machine-checkable over every `packs: [legal-review-prep]` skill —
  * so they are governance, not just prompt instructions (road-to-legal-pack
  * Phase 1, the "deterministic hardening = differentiator" thesis):
  *
@@ -35,6 +35,45 @@ const ATTORNEY_LINE = 'Attorney review required on material use';
 const JURISDICTION_TAG = 'Jurisdiction:';
 const FRESHNESS_WINDOW_RE = /^\d+\s+(day|days|month|months|year|years)$/;
 
+// D5 — the floor must carry the hard individual-case STOP block (not just a
+// hedge). road-to-legal-review-prep Phase 1. Checked once, against the floor
+// rule, only on a real (default-dir) run.
+const FLOOR_RULE = path.join(REPO, 'src', 'rules', 'legal-safety-floor.md');
+const STOP_MARKER = '🛑 I must stop here';
+
+// D6 — attorney-framing-review promotion tripwire (road-to-legal-review-prep
+// Phase 5 / ADR-107 amendment). Promoting the pack out of lab without a recorded
+// German-attorney framing review fails CI.
+const PACKS_YML = path.join(REPO, 'src', 'config', 'discovery', 'packs.yml');
+const PACK_NOTICE = path.join(REPO, 'src', 'domains', 'legal-review-prep', 'LEGAL_NOTICE.md');
+const FRAMING_MARKER = /framing reviewed by\s+\S.*(rechtsanw|attorney|lawyer)/i;
+
+/**
+ * Pure promotion-gate check. `promoted` = the legal-review-prep pack left its
+ * conservative posture (surface_tier !== lab, or trust_level_default !==
+ * experimental, or default_install === true). A promoted pack MUST carry a
+ * recorded attorney framing review in its LEGAL_NOTICE; otherwise it fails.
+ */
+export function legalPromotionViolations(packsYml: string, legalNotice: string): Violation[] {
+    const block = /(^|\n)- id:\s*legal-review-prep\b([\s\S]*?)(?=\n- id:|\n*$)/.exec(packsYml);
+    if (block === null) return [];
+    const body = block[2] ?? '';
+    const tier = /(^|\n)\s*surface_tier:\s*([^\n#]+)/.exec(body)?.[2]?.trim();
+    const trust = /(^|\n)\s*trust_level_default:\s*([^\n#]+)/.exec(body)?.[2]?.trim();
+    const defInstall = /(^|\n)\s*default_install:\s*([^\n#]+)/.exec(body)?.[2]?.trim();
+    const promoted = (tier !== undefined && tier !== 'lab')
+        || (trust !== undefined && trust !== 'experimental')
+        || defInstall === 'true';
+    if (promoted && !FRAMING_MARKER.test(legalNotice)) {
+        return [{
+            file: path.relative(REPO, PACK_NOTICE),
+            rule: 'promotion-gate',
+            msg: 'legal-review-prep promoted out of lab without a recorded attorney framing review ("Framing reviewed by <name>, Rechtsanwalt/Rechtsanwältin, <date>" in LEGAL_NOTICE.md) — ADR-107 amendment',
+        }];
+    }
+    return [];
+}
+
 // 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.
@@ -65,12 +104,12 @@ function _splitFrontmatter(content: string): [string | null, string] {
     return [content.slice(4, end), content.slice(end + 4)];
 }
 
-/** True when the frontmatter `packs:` block lists `legal`. */
+/** True when the frontmatter `packs:` block lists `legal-review-prep`. */
 function _isLegalPack(fm: string): boolean {
-    // Match a `packs:` block then a `- legal` item before the next top-level key.
+    // Match a `packs:` block then a `- legal-review-prep` item before the next top-level key.
     const m = /(^|\n)packs:\s*\n((?:\s*-\s*[^\n]+\n?)+)/.exec(fm);
     if (!m) return false;
-    return /(^|\n)\s*-\s*legal\s*$/m.test(m[2] ?? '');
+    return /(^|\n)\s*-\s*legal-review-prep\s*$/m.test(m[2] ?? '');
 }
 
 interface Violation {
@@ -103,6 +142,10 @@ export function lintLegalPack(skillsDir: string = SKILLS_DIR): Violation[] {
         if (!body.includes(JURISDICTION_TAG)) {
             violations.push({ file: rel, rule: 'jurisdiction-tag', msg: `missing the machine-checkable "${JURISDICTION_TAG}" tag` });
         }
+        // 1.2b council-gate — every legal work-product skill routes deep.
+        if (!/(^|\n)council_depth:\s*deep\s*(\n|$)/.test(fm)) {
+            violations.push({ file: rel, rule: 'council-depth', msg: 'missing `council_depth: deep` (legal work-product must route through the AI council / deep-research)' });
+        }
         // 1.3 freshness — only when declared
         const fw = /(^|\n)freshness_window:\s*"?([^"\n]+)"?/.exec(fm);
         if (fw && !FRESHNESS_WINDOW_RE.test((fw[2] ?? '').trim())) {
@@ -118,6 +161,21 @@ export function lintLegalPack(skillsDir: string = SKILLS_DIR): Violation[] {
             }
         }
     }
+    // D5 — the floor itself must carry the hard individual-case STOP block.
+    // Only on a real run (synthetic-dir tests pass their own tmp skillsDir).
+    if (skillsDir === SKILLS_DIR && fs.existsSync(FLOOR_RULE)) {
+        if (!_readText(FLOOR_RULE).includes(STOP_MARKER)) {
+            violations.push({
+                file: path.relative(REPO, FLOOR_RULE),
+                rule: 'individual-case-stop',
+                msg: `the floor is missing the hard individual-case STOP block ("${STOP_MARKER}")`,
+            });
+        }
+        // D6 — promotion gate (real-run only).
+        if (fs.existsSync(PACKS_YML) && fs.existsSync(PACK_NOTICE)) {
+            violations.push(...legalPromotionViolations(_readText(PACKS_YML), _readText(PACK_NOTICE)));
+        }
+    }
     return violations;
 }