@event4u/agent-config 1.24.0 → 1.26.0

package/scripts/_p4_migrate.py

@@ -52,12 +52,12 @@ SKILL_MIGRATIONS = [
     ("package-ci-checks", "skill:lint-skills",
      [("phrase", "task ci"), ("phrase", "before push"), ("phrase", "before pr")],
      "Run `task ci` locally and confirm green before pushing or opening a PR in this package."),
-    ("review-routing-awareness", "skill:review-routing",
-     [("keyword", "reviewer"), ("phrase", "risk hotspot"), ("phrase", "ownership map")],
-     "Consult ownership-map and historical-bug-patterns before suggesting reviewers or claiming a change is safe."),
+    # review-routing-awareness was merged into reviewer-awareness on 2026-05-08
+    # (see agents/contexts/adr-auto-rule-consolidation.md) as part of the
+    # Augment literal-budget relief work — Lever D consolidation.
     ("reviewer-awareness", "skill:review-routing",
-     [("keyword", "reviewer"), ("phrase", "suggest reviewers")],
-     "Anchor reviewer choice in paths and risk, never seniority; medium / high risk requires primary + secondary role."),
+     [("keyword", "reviewer"), ("phrase", "suggest reviewers"), ("phrase", "risk hotspot"), ("phrase", "ownership map")],
+     "Anchor reviewer choice in paths and risk, never seniority; consult ownership-map + historical-bug-patterns; medium / high risk requires primary + secondary role."),
     ("skill-improvement-trigger", "skill:skill-improvement-pipeline",
      [("phrase", "after completing"), ("keyword", "improvement"), ("keyword", "pipeline")],
      "After a meaningful task, trigger the post-task learning capture if `pipelines.skill_improvement` is enabled."),

package/scripts/audit_auto_rules.py

@@ -0,0 +1,159 @@
+#!/usr/bin/env python3
+"""Audit auto-rules for the Rule-Governance pass (Phase 5.1 of
+road-to-augment-limit-fit).
+
+Walk `.agent-src.uncompressed/rules/*.md`, collect per-rule frontmatter
+(`description`, `triggers`, `routes_to`, `tier`), measure body and
+registry-stub costs, and emit:
+
+- `agents/reports/auto-rules-audit.json` — deterministic, machine-readable.
+- `agents/reports/auto-rules-audit.md`   — ranked summary for review.
+
+The registry-stub cost mirrors `scripts/measure_augment_budget.py`'s
+accounting model: only the stub line is injected into the Augment
+workspace-guidelines budget for `type: auto` rules. The body cost is
+informational — it ships in the projected `.augment/rules/` tree but
+does NOT count against the 49,512-char ceiling.
+"""
+
+from __future__ import annotations
+
+import json
+import sys
+from pathlib import Path
+
+import yaml
+
+REPO_ROOT = Path(__file__).resolve().parent.parent
+SRC_RULES = REPO_ROOT / ".agent-src.uncompressed" / "rules"
+PROJECTED_RULES = REPO_ROOT / ".augment" / "rules"
+REPORT_DIR = REPO_ROOT / "agents" / "reports"
+JSON_OUT = REPORT_DIR / "auto-rules-audit.json"
+MD_OUT = REPORT_DIR / "auto-rules-audit.md"
+
+# Stub Augment injects per auto-rule. Mirrors measure_augment_budget.STUB_TEMPLATE.
+STUB_TEMPLATE = (
+    'If the user prompt matches the description "{desc}", '
+    "read the file located in {path}"
+)
+
+
+def _split_frontmatter(text: str) -> tuple[dict, str]:
+    if not text.startswith("---\n"):
+        return {}, text
+    end = text.find("\n---", 4)
+    if end < 0:
+        return {}, text
+    fm = yaml.safe_load(text[4:end]) or {}
+    body = text[end + 4 :].lstrip("\n")
+    return fm, body
+
+
+def _trigger_summary(triggers: list) -> dict:
+    paths: list[str] = []
+    keywords: list[str] = []
+    intents: list[str] = []
+    for entry in triggers or []:
+        if not isinstance(entry, dict):
+            continue
+        if "path_prefix" in entry:
+            paths.append(str(entry["path_prefix"]))
+        if "keyword" in entry:
+            keywords.append(str(entry["keyword"]))
+        if "intent" in entry:
+            intents.append(str(entry["intent"]))
+    return {"path_prefixes": paths, "keywords": keywords, "intents": intents}
+
+
+def collect() -> list[dict]:
+    rules: list[dict] = []
+    for path in sorted(SRC_RULES.glob("*.md")):
+        text = path.read_text(encoding="utf-8")
+        fm, body = _split_frontmatter(text)
+        if fm.get("type") != "auto":
+            continue
+        desc = (fm.get("description") or "").strip()
+        rel_projected = f".augment/rules/{path.name}"
+        stub = STUB_TEMPLATE.format(desc=desc, path=rel_projected)
+        triggers = _trigger_summary(fm.get("triggers") or [])
+        routes_to = list(fm.get("routes_to") or [])
+        rules.append(
+            {
+                "name": path.stem,
+                "src_path": str(path.relative_to(REPO_ROOT)),
+                "tier": fm.get("tier"),
+                "description": desc,
+                "description_chars": len(desc),
+                "triggers": triggers,
+                "trigger_count": (
+                    len(triggers["path_prefixes"])
+                    + len(triggers["keywords"])
+                    + len(triggers["intents"])
+                ),
+                "routes_to": routes_to,
+                "body_chars": len(body),
+                "file_chars": len(text),
+                "stub_chars": len(stub),
+            }
+        )
+    return rules
+
+
+def render_markdown(rules: list[dict]) -> str:
+    total_stub = sum(r["stub_chars"] for r in rules)
+    total_body = sum(r["body_chars"] for r in rules)
+    total_desc = sum(r["description_chars"] for r in rules)
+    lines = [
+        "# Auto-Rule Audit",
+        "",
+        "Generated by `scripts/audit_auto_rules.py` for Phase 5 of",
+        "`agents/roadmaps/road-to-augment-limit-fit.md`. Re-run after",
+        "any rule add/merge/deprecate to refresh the baseline.",
+        "",
+        "## Totals",
+        "",
+        f"- auto-rules: **{len(rules)}**",
+        f"- registry-stub cost (counts against 49,512 cap): **{total_stub:,}** chars",
+        f"- description chars (subset of stub cost): **{total_desc:,}** chars",
+        f"- body chars (informational, NOT in budget): **{total_body:,}** chars",
+        "",
+        "## Ranked by registry-stub cost",
+        "",
+        "| # | Rule | Tier | Desc | Stub | Body | Triggers | Routes |",
+        "|---|------|------|------|------|------|----------|--------|",
+    ]
+    for i, r in enumerate(sorted(rules, key=lambda x: -x["stub_chars"]), 1):
+        triggers = (
+            f"{len(r['triggers']['path_prefixes'])}p / "
+            f"{len(r['triggers']['keywords'])}k / "
+            f"{len(r['triggers']['intents'])}i"
+        )
+        routes = ", ".join(r["routes_to"]) or "—"
+        lines.append(
+            f"| {i} | `{r['name']}` | {r['tier'] or '—'} | "
+            f"{r['description_chars']} | {r['stub_chars']} | "
+            f"{r['body_chars']} | {triggers} | {routes} |"
+        )
+    lines.append("")
+    lines.append("Trigger key: `Np` = path-prefix, `Nk` = keyword, `Ni` = intent.")
+    lines.append("")
+    return "\n".join(lines)
+
+
+def main() -> int:
+    if not SRC_RULES.is_dir():
+        print(f"❌  Missing source dir: {SRC_RULES}", file=sys.stderr)
+        return 1
+    rules = collect()
+    REPORT_DIR.mkdir(parents=True, exist_ok=True)
+    payload = {"rule_count": len(rules), "rules": rules}
+    JSON_OUT.write_text(json.dumps(payload, indent=2, sort_keys=True), encoding="utf-8")
+    MD_OUT.write_text(render_markdown(rules), encoding="utf-8")
+    print(f"✅  Audited {len(rules)} auto-rules.")
+    print(f"   JSON: {JSON_OUT.relative_to(REPO_ROOT)}")
+    print(f"   MD:   {MD_OUT.relative_to(REPO_ROOT)}")
+    return 0
+
+
+if __name__ == "__main__":
+    sys.exit(main())

package/scripts/audit_likelihood.py

@@ -0,0 +1,148 @@
+#!/usr/bin/env python3
+"""Activation-likelihood heuristic for the Rule-Governance pass
+(Phase 5.3 of road-to-augment-limit-fit).
+
+For every auto-rule from `agents/reports/auto-rules-audit.json`:
+
+1. Build a token set from `description`, `triggers[].keyword`,
+   `triggers[].intent`, and the rule name itself.
+2. Index a corpus of skills (`SKILL.md`), contexts
+   (`agents/contexts/**/*.md`), guidelines, and command files.
+3. Score `corpus_hits = sum(1 for token in tokens if token in corpus)`.
+4. Flag rules with `< 2` corpus hits as "low-likelihood" (their trigger
+   surface is so generic that the host LLM is unlikely to find a
+   project-local file the rule was written to bridge to).
+
+Result is a JSON dump + Markdown section appended to
+`agents/reports/auto-rules-audit.md`.
+"""
+
+from __future__ import annotations
+
+import json
+import re
+import sys
+from collections import Counter
+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"
+LIKELIHOOD_JSON = REPORT_DIR / "auto-rules-likelihood.json"
+
+CORPUS_GLOBS = [
+    ".agent-src.uncompressed/skills/**/SKILL.md",
+    ".agent-src.uncompressed/commands/**/*.md",
+    "agents/contexts/**/*.md",
+    "docs/guidelines/**/*.md",
+]
+
+LOW_LIKELIHOOD_HITS = 2
+
+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", "rule", "rules",
+    "skill", "skills", "command", "commands", "files", "file", "doc",
+    "docs", "md", "txt",
+}
+
+
+def tokens(text: str) -> set[str]:
+    raw = re.findall(r"[A-Za-z][A-Za-z0-9_-]{2,}", text.lower())
+    return {t for t in raw if t not in STOPWORDS and len(t) > 3}
+
+
+def build_corpus() -> Counter:
+    counter: Counter = Counter()
+    for glob in CORPUS_GLOBS:
+        for path in REPO_ROOT.glob(glob):
+            if not path.is_file():
+                continue
+            try:
+                text = path.read_text(encoding="utf-8")
+            except UnicodeDecodeError:
+                continue
+            for tok in tokens(text):
+                counter[tok] += 1
+    return counter
+
+
+def score(rule: dict, corpus: Counter) -> dict:
+    rule_tokens = (
+        tokens(rule["description"])
+        | tokens(rule["name"].replace("-", " "))
+        | tokens(" ".join(rule["triggers"]["keywords"]))
+        | tokens(" ".join(rule["triggers"]["intents"]))
+    )
+    hits = {t: corpus[t] for t in rule_tokens if corpus[t] > 0}
+    return {
+        "name": rule["name"],
+        "tokens": sorted(rule_tokens),
+        "hits": dict(sorted(hits.items(), key=lambda x: -x[1])[:8]),
+        "hit_count": len(hits),
+        "total_hit_volume": sum(hits.values()),
+        "low_likelihood": len(hits) < LOW_LIKELIHOOD_HITS,
+    }
+
+
+def render_md(scores: list[dict]) -> str:
+    flagged = [s for s in scores if s["low_likelihood"]]
+    lines = [
+        "",
+        "## Phase 5.3 — Activation likelihood (corpus-keyword)",
+        "",
+        f"Corpus: skills + commands + contexts + guidelines.",
+        f"Low-likelihood threshold: `< {LOW_LIKELIHOOD_HITS}` distinct corpus hits.",
+        "",
+        f"Rules flagged: **{len(flagged)} / {len(scores)}**.",
+        "",
+        "### Low-likelihood rules",
+        "",
+    ]
+    if not flagged:
+        lines += ["_None._", ""]
+    else:
+        lines += ["| Rule | Hits | Tokens (top) |", "|------|------|--------------|"]
+        for s in sorted(flagged, key=lambda x: x["hit_count"]):
+            toks = ", ".join(f"`{t}`" for t in s["tokens"][:6]) or "—"
+            lines.append(f"| `{s['name']}` | {s['hit_count']} | {toks} |")
+        lines.append("")
+    lines += [
+        "### Full ranking (lowest hit-count first, top 20)",
+        "",
+        "| Rule | Distinct hits | Total hit volume |",
+        "|------|---------------|------------------|",
+    ]
+    for s in sorted(scores, key=lambda x: (x["hit_count"], x["total_hit_volume"]))[:20]:
+        lines.append(f"| `{s['name']}` | {s['hit_count']} | {s['total_hit_volume']} |")
+    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
+    rules = json.loads(AUDIT_JSON.read_text(encoding="utf-8"))["rules"]
+    corpus = build_corpus()
+    scores = [score(r, corpus) for r in rules]
+    LIKELIHOOD_JSON.write_text(
+        json.dumps({"corpus_size": len(corpus), "scores": scores}, indent=2),
+        encoding="utf-8",
+    )
+    md = AUDIT_MD.read_text(encoding="utf-8") if AUDIT_MD.exists() else ""
+    if "## Phase 5.3 — Activation likelihood" in md:
+        md = md.split("## Phase 5.3 — Activation likelihood")[0].rstrip() + "\n"
+    AUDIT_MD.write_text(md + render_md(scores), encoding="utf-8")
+    flagged = [s for s in scores if s["low_likelihood"]]
+    print(f"✅  Likelihood scored: {len(scores)} rules, {len(flagged)} low-likelihood.")
+    print(f"   JSON: {LIKELIHOOD_JSON.relative_to(REPO_ROOT)}")
+    return 0
+
+
+if __name__ == "__main__":
+    sys.exit(main())

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"