@event4u/agent-config 1.23.0 → 1.25.0

package/scripts/audit_overlap.py

@@ -0,0 +1,145 @@
+#!/usr/bin/env python3
+"""Trigger-overlap analysis for the Rule-Governance pass (Phase 5.2 of
+road-to-augment-limit-fit).
+
+Reads `agents/reports/auto-rules-audit.json` (produced by
+`audit_auto_rules.py`) and computes:
+
+- path-prefix Jaccard similarity (per pair of rules);
+- description-keyword overlap fraction (per pair of rules).
+
+Pairs scoring `path_jaccard >= 0.5` OR `keyword_overlap >= 0.4` are
+flagged as merge candidates. Output is appended to
+`agents/reports/auto-rules-audit.md` and a structured JSON list is
+written to `agents/reports/auto-rules-overlap.json` for downstream
+consumers (Phase 5.3 likelihood, 5.4 council walk).
+"""
+
+from __future__ import annotations
+
+import json
+import re
+import sys
+from itertools import combinations
+from pathlib import Path
+
+REPO_ROOT = Path(__file__).resolve().parent.parent
+REPORT_DIR = REPO_ROOT / "agents" / "reports"
+AUDIT_JSON = REPORT_DIR / "auto-rules-audit.json"
+AUDIT_MD = REPORT_DIR / "auto-rules-audit.md"
+OVERLAP_JSON = REPORT_DIR / "auto-rules-overlap.json"
+
+PATH_THRESHOLD = 0.5
+KEYWORD_THRESHOLD = 0.4
+
+STOPWORDS = {
+    "the", "and", "for", "with", "when", "use", "or", "of", "to", "a",
+    "an", "is", "in", "on", "by", "be", "at", "as", "it", "if", "are",
+    "this", "that", "from", "but", "not", "can", "any", "all", "no",
+    "after", "before", "during", "user", "agent", "code", "project",
+    "via", "into", "onto", "even", "without", "naming",
+}
+
+
+def keyword_set(text: str) -> set[str]:
+    tokens = re.findall(r"[A-Za-z][A-Za-z0-9_-]{2,}", text.lower())
+    return {t for t in tokens if t not in STOPWORDS and not t.isdigit()}
+
+
+def jaccard(a: set, b: set) -> float:
+    if not a and not b:
+        return 0.0
+    return len(a & b) / len(a | b)
+
+
+def overlap_fraction(a: set, b: set) -> float:
+    """Symmetric overlap as fraction of smaller set."""
+    if not a or not b:
+        return 0.0
+    return len(a & b) / min(len(a), len(b))
+
+
+def analyse(rules: list[dict]) -> list[dict]:
+    pairs: list[dict] = []
+    for r in rules:
+        r["_paths"] = set(r["triggers"]["path_prefixes"])
+        r["_keywords"] = (
+            keyword_set(r["description"])
+            | keyword_set(" ".join(r["triggers"]["keywords"]))
+            | keyword_set(" ".join(r["triggers"]["intents"]))
+        )
+
+    for a, b in combinations(rules, 2):
+        pj = jaccard(a["_paths"], b["_paths"])
+        ko = overlap_fraction(a["_keywords"], b["_keywords"])
+        flagged = pj >= PATH_THRESHOLD or ko >= KEYWORD_THRESHOLD
+        if not flagged:
+            continue
+        pairs.append(
+            {
+                "rule_a": a["name"],
+                "rule_b": b["name"],
+                "path_jaccard": round(pj, 3),
+                "keyword_overlap": round(ko, 3),
+                "shared_paths": sorted(a["_paths"] & b["_paths"]),
+                "shared_keywords": sorted(a["_keywords"] & b["_keywords"])[:12],
+                "rule_a_desc": a["description"],
+                "rule_b_desc": b["description"],
+            }
+        )
+
+    return sorted(
+        pairs, key=lambda p: -(p["path_jaccard"] + p["keyword_overlap"])
+    )
+
+
+def render_md(pairs: list[dict]) -> str:
+    lines = [
+        "",
+        "## Phase 5.2 — Trigger overlap (Jaccard + keyword)",
+        "",
+        f"Pairs flagged: **{len(pairs)}** "
+        f"(thresholds: path-Jaccard ≥ {PATH_THRESHOLD}, "
+        f"keyword-overlap ≥ {KEYWORD_THRESHOLD}).",
+        "",
+    ]
+    if not pairs:
+        lines.append("_No pairs over threshold._")
+        lines.append("")
+        return "\n".join(lines)
+    lines += [
+        "| # | Rule A | Rule B | Path-J | Keyword-O | Shared keywords |",
+        "|---|--------|--------|--------|-----------|-----------------|",
+    ]
+    for i, p in enumerate(pairs, 1):
+        kw = ", ".join(f"`{k}`" for k in p["shared_keywords"][:6]) or "—"
+        lines.append(
+            f"| {i} | `{p['rule_a']}` | `{p['rule_b']}` | "
+            f"{p['path_jaccard']:.2f} | {p['keyword_overlap']:.2f} | {kw} |"
+        )
+    lines.append("")
+    return "\n".join(lines)
+
+
+def main() -> int:
+    if not AUDIT_JSON.exists():
+        print(f"❌  Run audit_auto_rules.py first: missing {AUDIT_JSON}", file=sys.stderr)
+        return 1
+    data = json.loads(AUDIT_JSON.read_text(encoding="utf-8"))
+    pairs = analyse(data["rules"])
+    OVERLAP_JSON.write_text(
+        json.dumps({"pair_count": len(pairs), "pairs": pairs}, indent=2),
+        encoding="utf-8",
+    )
+    md_existing = AUDIT_MD.read_text(encoding="utf-8") if AUDIT_MD.exists() else ""
+    if "## Phase 5.2 — Trigger overlap" in md_existing:
+        md_existing = md_existing.split("## Phase 5.2 — Trigger overlap")[0].rstrip() + "\n"
+    AUDIT_MD.write_text(md_existing + render_md(pairs), encoding="utf-8")
+    print(f"✅  Overlap analysis: {len(pairs)} pairs flagged.")
+    print(f"   JSON: {OVERLAP_JSON.relative_to(REPO_ROOT)}")
+    print(f"   MD appended: {AUDIT_MD.relative_to(REPO_ROOT)}")
+    return 0
+
+
+if __name__ == "__main__":
+    sys.exit(main())

package/scripts/build_rule_trigger_matrix.py

@@ -117,11 +117,9 @@ add("agent-docs.md", "file-edit on agents/docs/, AGENTS.md", "hook",
     "tool-call", "medium", "2a", notes="Path-pattern based marker")
 add("upstream-proposal.md", "skill/rule create event", "hook", "output",
     "medium", "2a", notes="Marker after new artifact lands")
-add("review-routing-awareness.md", "PR-prep / risk flagging", "hook",
-    "output", "medium", "2a",
-    notes="Marker when /create-pr or risk-tagging keywords detected")
-add("reviewer-awareness.md", "PR-prep", "hook", "output",
-    "medium", "2a", notes="Reviewer-suggestion marker at PR creation")
+add("reviewer-awareness.md", "PR-prep / reviewer-suggestion / risk flagging",
+    "hook", "output", "medium", "2a",
+    notes="Reviewer-suggestion + risk-tagging marker at PR creation; consolidates former review-routing-awareness")
 add("security-sensitive-stop.md", "file-edit on auth/billing/secrets paths",
     "hook", "tool-call", "low", "2a",
     notes="Path-pattern based marker — strong candidate for low-cost hook")

package/scripts/check_augment_description_cap.py

@@ -0,0 +1,79 @@
+#!/usr/bin/env python3
+"""Auto-rule description-length CI gate (Phase 1.3 of
+road-to-augment-limit-fit).
+
+For every `type: auto` rule under `.agent-src.uncompressed/rules/`,
+fail CI when the frontmatter `description:` exceeds DESC_CAP chars.
+
+Why: Augment injects each auto-rule's description into the
+workspace-guidelines registry stub. Empirical 2026-05-08 budget
+analysis showed this channel consuming 25 % of the 49,512-char
+ceiling. Capping descriptions guards future drift.
+
+Source of truth: `.agent-src.uncompressed/rules/`. The compressed
+projection is regenerated; the source dictates what ships.
+
+Exit codes: 0 = pass, 1 = at least one rule over cap.
+"""
+
+from __future__ import annotations
+
+import re
+import sys
+from pathlib import Path
+
+REPO_ROOT = Path(__file__).resolve().parent.parent
+RULES_DIR = REPO_ROOT / ".agent-src.uncompressed" / "rules"
+DESC_CAP = 150
+
+
+def parse_frontmatter(text: str) -> dict[str, str]:
+    if not text.startswith("---\n"):
+        return {}
+    end = text.find("\n---", 4)
+    if end < 0:
+        return {}
+    fm: dict[str, str] = {}
+    for line in text[4:end].splitlines():
+        m = re.match(r"^([A-Za-z_][A-Za-z0-9_-]*):\s*(.*)$", line)
+        if m:
+            fm[m.group(1)] = m.group(2).strip().strip('"').strip("'")
+    return fm
+
+
+def main() -> int:
+    failures: list[tuple[str, int, str]] = []
+    checked = 0
+
+    for path in sorted(RULES_DIR.glob("*.md")):
+        text = path.read_text()
+        fm = parse_frontmatter(text)
+        if fm.get("type") != "auto":
+            continue
+        desc = fm.get("description", "")
+        checked += 1
+        if len(desc) > DESC_CAP:
+            failures.append((path.name, len(desc), desc))
+
+    if failures:
+        print(
+            f"❌  {len(failures)} auto-rule description(s) exceed {DESC_CAP} chars:\n",
+            file=sys.stderr,
+        )
+        for name, dlen, desc in sorted(failures, key=lambda x: -x[1]):
+            print(f"  [{dlen:>3}] {name}", file=sys.stderr)
+            print(f"        {desc}", file=sys.stderr)
+        print(
+            f"\n  Guard rationale: each char in an auto-rule description "
+            f"costs one char in the\n  Augment workspace-guidelines budget "
+            f"(cap 49,512). Trim to ≤ {DESC_CAP}.",
+            file=sys.stderr,
+        )
+        return 1
+
+    print(f"✅  All {checked} auto-rule descriptions ≤ {DESC_CAP} chars.")
+    return 0
+
+
+if __name__ == "__main__":
+    sys.exit(main())

package/scripts/check_council_references.py

@@ -1,5 +1,5 @@
 #!/usr/bin/env python3
-"""CI guard for the `no-council-references` rule.
+"""CI guard for the council clause of the `no-roadmap-references` rule.
 
 Council artefacts under `agents/council-{questions,responses,sessions}/`
 are gitignored, local-only, and auto-pruned. A link to a specific
@@ -68,7 +68,7 @@ ALLOWLIST_PREFIXES: tuple[str, ...] = (
     # the SKIP_DIRS contract in scripts/check_references.py).
     "agents/analysis/",
     # The rule itself documents forbidden vs. allowed forms.
-    ".agent-src.uncompressed/rules/no-council-references.md",
+    ".agent-src.uncompressed/rules/no-roadmap-references.md",
     # ai-council skill documents the output-path schema.
     ".agent-src.uncompressed/skills/ai-council/",
     # Council commands document the output-path schema.
@@ -134,7 +134,7 @@ def main() -> int:
     for path, ln, ref in violations:
         print(f"  - {path.as_posix()}:{ln}: {ref}")
     print(
-        "\nRule: .agent-src/rules/no-council-references.md\n"
+        "\nRule: .agent-src/rules/no-roadmap-references.md (council clause)\n"
         "Fix: inline the convergence summary (members + date) instead of\n"
         "linking the file. Append "
         "<!-- council-ref-allowed: <reason> --> on the same line to\n"

package/scripts/check_kernel_rule_bundle.py

@@ -0,0 +1,151 @@
+#!/usr/bin/env python3
+"""check_kernel_rule_bundle — Phase 4.2 of road-to-always-budget-relief.
+
+Fails when a single PR (or commit range) modifies more than one
+kernel rule under `.agent-src.uncompressed/rules/`. Override via the
+PR label `bundled-always-rules-acknowledged`.
+
+Kernel set is the locked 9-rule list in
+`docs/contracts/rule-classification.md` § 3.1, mirrored as
+`KERNEL_RULES` below. The list is short and stable; on kernel-set
+change, update both files in the same PR.
+
+Inputs:
+  --base-ref REF   git ref to diff against (default: origin/main, then main)
+  --label NAME     PR label that overrides the gate (default:
+                   bundled-always-rules-acknowledged)
+  --event-path P   GitHub event JSON (defaults to $GITHUB_EVENT_PATH)
+  --files F [F …]  override changed-file list (testing only)
+
+Exit codes: 0 = pass · 1 = fail (> 1 kernel rule, no override) ·
+3 = internal error.
+
+Source: `agents/contexts/adr-always-budget-relief-strategy.md`.
+"""
+from __future__ import annotations
+
+import argparse
+import json
+import os
+import subprocess
+import sys
+from pathlib import Path
+
+KERNEL_RULES = frozenset({
+    "agent-authority.md",
+    "ask-when-uncertain.md",
+    "commit-policy.md",
+    "direct-answers.md",
+    "language-and-tone.md",
+    "no-cheap-questions.md",
+    "non-destructive-by-default.md",
+    "scope-control.md",
+    "verify-before-complete.md",
+})
+
+KERNEL_DIR = ".agent-src.uncompressed/rules"
+DEFAULT_LABEL = "bundled-always-rules-acknowledged"
+
+
+def _git_changed_files(base_ref: str) -> list[str]:
+    try:
+        out = subprocess.check_output(
+            ["git", "diff", "--name-only", f"{base_ref}...HEAD"],
+            stderr=subprocess.STDOUT,
+            text=True,
+        )
+    except subprocess.CalledProcessError as exc:
+        print(f"❌  git diff failed: {exc.output.strip()}", file=sys.stderr)
+        return []
+    return [line for line in out.splitlines() if line.strip()]
+
+
+def _resolve_base_ref(explicit: str | None) -> str:
+    if explicit:
+        return explicit
+    for candidate in ("origin/main", "origin/master", "main", "master"):
+        try:
+            subprocess.check_output(
+                ["git", "rev-parse", "--verify", candidate],
+                stderr=subprocess.DEVNULL,
+            )
+            return candidate
+        except subprocess.CalledProcessError:
+            continue
+    return "HEAD~1"
+
+
+def _pr_labels(event_path: str | None) -> list[str]:
+    path = event_path or os.environ.get("GITHUB_EVENT_PATH")
+    if not path or not Path(path).exists():
+        return []
+    try:
+        data = json.loads(Path(path).read_text(encoding="utf-8"))
+    except (OSError, json.JSONDecodeError):
+        return []
+    pr = data.get("pull_request") or {}
+    return [lbl.get("name", "") for lbl in pr.get("labels", []) if lbl.get("name")]
+
+
+def _kernel_changes(files: list[str]) -> list[str]:
+    hits: list[str] = []
+    for path in files:
+        if not path.startswith(f"{KERNEL_DIR}/"):
+            continue
+        name = Path(path).name
+        if name in KERNEL_RULES:
+            hits.append(path)
+    return sorted(set(hits))
+
+
+def main(argv: list[str] | None = None) -> int:
+    ap = argparse.ArgumentParser(description=__doc__.split("\n", 1)[0])
+    ap.add_argument("--base-ref", default=None)
+    ap.add_argument("--label", default=DEFAULT_LABEL)
+    ap.add_argument("--event-path", default=None)
+    ap.add_argument("--files", nargs="*", default=None)
+    args = ap.parse_args(argv)
+
+    files = args.files or _git_changed_files(_resolve_base_ref(args.base_ref))
+    hits = _kernel_changes(files)
+
+    if len(hits) <= 1:
+        if hits:
+            print(f"✅  OK  kernel-rule bundle: 1 rule touched ({hits[0]})")
+        else:
+            print("✅  OK  kernel-rule bundle: no kernel rule touched")
+        return 0
+
+    labels = _pr_labels(args.event_path)
+    if args.label in labels:
+        print(
+            f"✅  OK  kernel-rule bundle: {len(hits)} rules touched but "
+            f"label '{args.label}' present"
+        )
+        for h in hits:
+            print(f"   · {h}")
+        return 0
+
+    print(
+        f"❌  FAIL  kernel-rule bundle: {len(hits)} kernel rules touched in "
+        f"one PR — slow-rollout requires one-rule-per-PR.",
+        file=sys.stderr,
+    )
+    print("   Touched:", file=sys.stderr)
+    for h in hits:
+        print(f"   · {h}", file=sys.stderr)
+    print(
+        f"   Override: add the label '{args.label}' on the PR and "
+        f"document the bundle rationale in the PR body.",
+        file=sys.stderr,
+    )
+    print(
+        "   Source: agents/contexts/adr-always-budget-relief-strategy.md "
+        "(Phase 4.2).",
+        file=sys.stderr,
+    )
+    return 1
+
+
+if __name__ == "__main__":
+    sys.exit(main())

package/scripts/check_references.py

@@ -228,6 +228,10 @@ def check_file(filepath: Path, artifacts: dict[str, set[str]], root: Path) -> Li
             ))
 
     in_code_block = False
+    # Track whether we are inside an unchecked-TODO bullet (multi-line
+    # roadmap items wrap continuation text under the `- [ ]` line and
+    # those continuation lines must inherit the forward-ref exemption).
+    in_unchecked_todo = False
     for i, line in enumerate(text.splitlines(), 1):
         stripped = line.strip()
         if stripped.startswith("```"):
@@ -237,9 +241,25 @@ def check_file(filepath: Path, artifacts: dict[str, set[str]], root: Path) -> Li
             continue
 
         # Unchecked TODO checkboxes document future work — their refs are
-        # forward-looking and will not resolve yet.
+        # forward-looking and will not resolve yet. Track multi-line bullets:
+        # any `- [ ]` opens a TODO context; a new top-level bullet, heading,
+        # or blank line closes it.
         if UNCHECKED_TODO_PATTERN.match(line):
+            in_unchecked_todo = True
             continue
+        if in_unchecked_todo:
+            if not stripped:
+                in_unchecked_todo = False
+                continue
+            # A new bullet (checked or unchecked) or a heading closes the
+            # current TODO context. An indented continuation line keeps it.
+            if re.match(r"^[-*+]\s+\[", line) or stripped.startswith("#"):
+                in_unchecked_todo = False
+            elif line[:1] in (" ", "\t"):
+                # Indented continuation of the unchecked TODO — skip.
+                continue
+            else:
+                in_unchecked_todo = False
 
         # File path references
         for m in PATH_PATTERN.finditer(line):

package/scripts/compile_router.py

@@ -125,6 +125,9 @@ def _collect(rules_dir: Path) -> dict:
             if not COMPILE_TIME_TOGGLES[rule_id](settings):
                 continue
         rule_type = str(fm.get("type", "auto"))
+        # Manual rules are reference-only (ADR-004) — no router emission.
+        if rule_type == "manual":
+            continue
         tier = _resolve_tier(rule_type, fm.get("tier", ""))
         if tier not in ALLOWED_TIERS:
             continue

package/scripts/install.sh

@@ -728,7 +728,6 @@ main() {
     #    into consumer projects.
     copy_if_missing "$SOURCE_PAYLOAD/templates/AGENTS.md" "$TARGET_DIR/AGENTS.md"
     copy_if_missing "$SOURCE_PAYLOAD/templates/copilot-instructions.md" "$TARGET_DIR/.github/copilot-instructions.md"
-    copy_if_missing "$SOURCE_PAYLOAD/templates/copilot-review-instructions.md" "$TARGET_DIR/.github/copilot-review-instructions.md"
 
     # 3. Create tool-specific symlinks
     create_tool_symlinks "$TARGET_DIR"

package/scripts/lint_agents_md.py

@@ -0,0 +1,168 @@
+#!/usr/bin/env python3
+"""Thin-Root contract linter for AGENTS.md files (Phase 7).
+
+Enforces caps + pointer-ratio + pointer-anatomy + emergency-triage
+contract from `.agent-src.uncompressed/skills/agents-md-thin-root/SKILL.md`:
+
+  (a) total char-count under FAIL/WARN budgets per file class
+  (b) substantive-pointer ratio >= 0.40
+  (c) every pointer's *why* clause >= 60 chars
+  (d) every pointer target resolves on disk (anchor validity)
+  (e) emergency-triage section present with the five canonical questions
+
+Exit non-zero on any (a) FAIL, (b)–(e) error. WARN is informational.
+"""
+from __future__ import annotations
+
+import re
+import sys
+from dataclasses import dataclass
+from pathlib import Path
+
+ROOT = Path(__file__).resolve().parent.parent
+QUIET = "--quiet" in sys.argv
+
+LINK_RE = re.compile(r"\[([^\]]+)\]\(([^)]+)\)")
+TRIAGE_KEYWORDS = (
+    "what is this repo",
+    "what language",
+    "where do i edit",
+    "lint / test / sync",
+    "where do the always",
+)
+
+
+@dataclass
+class Target:
+    path: Path
+    label: str
+    fail_at: int
+    warn_at: int
+    template: bool  # consumer template — relax pointer-target resolution
+
+
+TARGETS = [
+    Target(ROOT / "AGENTS.md", "package-root", 3000, 2800, template=False),
+    Target(
+        ROOT / ".agent-src.uncompressed" / "templates" / "AGENTS.md",
+        "consumer-template", 2500, 2300, template=True,
+    ),
+]
+
+
+def _strip_links(line: str) -> str:
+    return LINK_RE.sub(lambda m: m.group(1), line)
+
+
+def _resolve(target_str: str, template: bool) -> bool:
+    raw = target_str.split("#", 1)[0].strip()
+    if raw.startswith("http://") or raw.startswith("https://"):
+        return True
+    candidates = [ROOT / raw]
+    if template and raw.startswith(".augment/"):
+        candidates.append(ROOT / raw.replace(".augment/", ".agent-src.uncompressed/", 1))
+        candidates.append(ROOT / raw.replace(".augment/", ".agent-src/", 1))
+    if raw.startswith(".agent-src/"):
+        candidates.append(ROOT / raw.replace(".agent-src/", ".agent-src.uncompressed/", 1))
+    return any(c.exists() for c in candidates)
+
+
+def lint_file(t: Target) -> tuple[bool, list[str], list[str]]:
+    """Return (ok, errors, warnings)."""
+    errors: list[str] = []
+    warnings: list[str] = []
+    if not t.path.exists():
+        return False, [f"{t.label}: {t.path} not found"], []
+
+    text = t.path.read_text(encoding="utf-8")
+    size = len(text.encode("utf-8"))
+
+    # (a) size
+    if size > t.fail_at:
+        errors.append(f"{t.label}: {size} chars > FAIL cap {t.fail_at}")
+    elif size > t.warn_at:
+        warnings.append(f"{t.label}: {size} chars > WARN cap {t.warn_at}")
+
+    # Filter out structural lines that are not "prose" the contract
+    # asks us to replace with pointers: headings, code fences + content,
+    # HTML comments, and Markdown table rows.
+    lines = text.splitlines()
+    in_fence = False
+    in_comment = False
+    prose: list[str] = []
+    for ln in lines:
+        s = ln.strip()
+        if not s:
+            continue
+        if s.startswith("```"):
+            in_fence = not in_fence
+            continue
+        if in_fence:
+            continue
+        if "<!--" in s:
+            in_comment = True
+        if in_comment:
+            if "-->" in s:
+                in_comment = False
+            continue
+        if s.startswith("#"):  # heading
+            continue
+        if s.startswith("|"):  # markdown table row / separator
+            continue
+        prose.append(ln)
+
+    non_blank = prose
+    pointer_lines = 0
+
+    for ln in non_blank:
+        m = LINK_RE.search(ln)
+        if not m:
+            continue
+        target = m.group(2)
+        # (d) target resolves
+        if not _resolve(target, t.template):
+            errors.append(f"{t.label}: broken pointer target `{target}` in line: {ln.strip()[:100]}")
+        # (c) why-clause length: line minus link syntax
+        why = _strip_links(ln).strip()
+        if len(why) >= 60:
+            pointer_lines += 1
+        # else line has a link but no real why-clause — does not count
+
+    # (b) ratio
+    ratio = pointer_lines / max(len(non_blank), 1)
+    if ratio < 0.40:
+        errors.append(
+            f"{t.label}: substantive-pointer ratio {ratio:.2f} < 0.40 "
+            f"({pointer_lines}/{len(non_blank)} non-blank lines)"
+        )
+
+    # (e) emergency-triage block
+    lower = text.lower()
+    missing = [k for k in TRIAGE_KEYWORDS if k not in lower]
+    if missing:
+        errors.append(f"{t.label}: emergency-triage block missing keywords: {missing}")
+    if "emergency triage" not in lower:
+        errors.append(f"{t.label}: missing 'Emergency triage' section heading")
+
+    return not errors, errors, warnings
+
+
+def main() -> int:
+    rc = 0
+    for t in TARGETS:
+        ok, errors, warnings = lint_file(t)
+        if not QUIET or errors or warnings:
+            print(f"== {t.label} ({t.path.relative_to(ROOT)}) ==")
+        for w in warnings:
+            print(f"  ⚠️  {w}")
+        for e in errors:
+            print(f"  ❌  {e}")
+        if ok and not warnings and not QUIET:
+            print(f"  ✅  ok ({t.path.stat().st_size} bytes)")
+        if not ok:
+            rc = 1
+    return rc
+
+
+if __name__ == "__main__":
+    raise SystemExit(main())