@event4u/agent-config 1.23.0 → 1.25.0

package/scripts/measure_augment_budget.py

@@ -0,0 +1,208 @@
+#!/usr/bin/env python3
+"""Measure the Augment workspace-guidelines budget (Phase 1.1 of
+road-to-augment-limit-fit).
+
+Mirrors Augment's accounting model for the workspace prompt:
+
+1. `AGENTS.md` body (full file, including frontmatter) injected verbatim.
+2. `always`-type rules under `.augment/rules/` — full body injected.
+3. `auto`-type rules — only a registry stub is injected per rule:
+
+       If the user prompt matches the description "<desc>", read the
+       file located in <path>
+
+   The body of an `auto` rule is NOT counted; only the stub line is.
+
+The 49,512-char ceiling is the empirical limit observed against the
+Augment Code workspace prompt (2026-05-08 baseline). This script emits
+a per-component breakdown plus the total against that ceiling.
+
+Output:
+- Default: stdout summary (totals + per-component breakdown).
+- `--json`: deterministic JSON.
+- `--trend-append`: append a snapshot record to
+  `agents/.augment-budget-history.jsonl`.
+
+Exit codes: 0 = under fail threshold, 1 = at/above fail threshold,
+3 = internal error.
+"""
+
+from __future__ import annotations
+
+import argparse
+import datetime as _dt
+import json
+import re
+import sys
+from pathlib import Path
+
+REPO_ROOT = Path(__file__).resolve().parent.parent
+AGENTS_MD = REPO_ROOT / "AGENTS.md"
+RULES_DIR = REPO_ROOT / ".augment" / "rules"
+TREND_FILE = REPO_ROOT / "agents" / ".augment-budget-history.jsonl"
+
+# Augment workspace-guidelines ceiling — empirical 2026-05-08.
+TOTAL_CAP = 49_512
+WARN_THRESHOLD = 0.85
+FAIL_THRESHOLD = 0.95
+
+# Stub template Augment injects for `type: auto` rules. Measured by
+# subtracting variable-length fields (description, path) from a real
+# rendered stub in the host system prompt.
+STUB_TEMPLATE = (
+    'If the user prompt matches the description "{desc}", '
+    "read the file located in {path}"
+)
+
+
+def parse_frontmatter(text: str) -> tuple[dict[str, str], str]:
+    if not text.startswith("---\n"):
+        return {}, text
+    end = text.find("\n---", 4)
+    if end < 0:
+        return {}, text
+    fm_block = text[4:end]
+    body = text[end + 4 :].lstrip("\n")
+    fm: dict[str, str] = {}
+    for line in fm_block.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, body
+
+
+def measure() -> dict:
+    components: dict[str, dict] = {}
+
+    # 1. AGENTS.md
+    agents_text = AGENTS_MD.read_text() if AGENTS_MD.exists() else ""
+    components["agents_md"] = {
+        "path": str(AGENTS_MD.relative_to(REPO_ROOT)),
+        "chars": len(agents_text),
+    }
+
+    # 2 + 3. Rules under .augment/rules/.
+    always_total = 0
+    always_rules: list[dict] = []
+    auto_total = 0
+    auto_rules: list[dict] = []
+
+    for rule_path in sorted(RULES_DIR.glob("*.md")):
+        text = rule_path.read_text()
+        fm, _body = parse_frontmatter(text)
+        rtype = fm.get("type", "")
+        rel = str(rule_path.relative_to(REPO_ROOT))
+        if rtype == "always":
+            chars = len(text)
+            always_total += chars
+            always_rules.append({"path": rel, "chars": chars})
+        elif rtype == "auto":
+            desc = fm.get("description", "")
+            stub = STUB_TEMPLATE.format(desc=desc, path=rel)
+            chars = len(stub)
+            auto_total += chars
+            auto_rules.append(
+                {"path": rel, "desc_chars": len(desc), "stub_chars": chars}
+            )
+
+    components["always_rules"] = {
+        "count": len(always_rules),
+        "chars": always_total,
+        "rules": sorted(always_rules, key=lambda r: -r["chars"]),
+    }
+    components["auto_rules"] = {
+        "count": len(auto_rules),
+        "chars": auto_total,
+        "rules": sorted(auto_rules, key=lambda r: -r["stub_chars"]),
+    }
+
+    total = (
+        components["agents_md"]["chars"]
+        + always_total
+        + auto_total
+    )
+    return {
+        "ts": _dt.datetime.now(_dt.timezone.utc).strftime("%Y-%m-%dT%H:%M:%SZ"),
+        "total": total,
+        "cap": TOTAL_CAP,
+        "utilisation": round(total / TOTAL_CAP, 4),
+        "components": components,
+    }
+
+
+def render_text(data: dict) -> str:
+    total = data["total"]
+    cap = data["cap"]
+    util = data["utilisation"]
+    a = data["components"]["agents_md"]["chars"]
+    ar = data["components"]["always_rules"]
+    aur = data["components"]["auto_rules"]
+    lines = [
+        f"Augment workspace-guidelines budget — cap {cap:,} chars",
+        "",
+        f"  AGENTS.md          {a:>6,} chars  ({a/cap*100:5.1f}%)",
+        f"  always-rules ({ar['count']:>2})  {ar['chars']:>6,} chars  ({ar['chars']/cap*100:5.1f}%)",
+        f"  auto-rule stubs ({aur['count']:>2}) {aur['chars']:>6,} chars  ({aur['chars']/cap*100:5.1f}%)",
+        "  " + "-" * 50,
+        f"  TOTAL              {total:>6,} chars  ({util*100:5.1f}%)",
+        "",
+    ]
+    if util >= 1.0:
+        lines.append(f"❌  OVER CAP by {total - cap:,} chars")
+    elif util >= FAIL_THRESHOLD:
+        lines.append(f"❌  FAIL — utilisation {util*100:.1f}% ≥ {FAIL_THRESHOLD*100:.0f}%")
+    elif util >= WARN_THRESHOLD:
+        lines.append(f"⚠️   WARN — utilisation {util*100:.1f}% ≥ {WARN_THRESHOLD*100:.0f}%")
+    else:
+        lines.append(f"✅  OK — utilisation {util*100:.1f}%")
+    return "\n".join(lines)
+
+
+def main() -> int:
+    parser = argparse.ArgumentParser(description=__doc__)
+    parser.add_argument("--json", action="store_true", help="Emit JSON")
+    parser.add_argument(
+        "--trend-append",
+        action="store_true",
+        help="Append a snapshot record to agents/.augment-budget-history.jsonl",
+    )
+    parser.add_argument(
+        "--check",
+        action="store_true",
+        help="Exit non-zero when utilisation ≥ FAIL_THRESHOLD or over cap",
+    )
+    args = parser.parse_args()
+
+    data = measure()
+
+    if args.trend_append:
+        TREND_FILE.parent.mkdir(parents=True, exist_ok=True)
+        rec = {
+            "ts": data["ts"],
+            "total": data["total"],
+            "cap": data["cap"],
+            "utilisation": data["utilisation"],
+            "agents_md": data["components"]["agents_md"]["chars"],
+            "always_rules": data["components"]["always_rules"]["chars"],
+            "auto_rules": data["components"]["auto_rules"]["chars"],
+        }
+        with TREND_FILE.open("a") as fh:
+            fh.write(json.dumps(rec, sort_keys=True) + "\n")
+
+    if args.json:
+        print(json.dumps(data, indent=2, sort_keys=True))
+    else:
+        print(render_text(data))
+
+    if args.check:
+        if data["utilisation"] >= 1.0 or data["utilisation"] >= FAIL_THRESHOLD:
+            return 1
+    return 0
+
+
+if __name__ == "__main__":
+    try:
+        sys.exit(main())
+    except Exception as exc:  # pragma: no cover - defensive top-level guard
+        print(f"❌  measure_augment_budget: internal error: {exc}", file=sys.stderr)
+        sys.exit(3)

package/scripts/measure_markitdown_lift.py

@@ -0,0 +1,127 @@
+#!/usr/bin/env python3
+"""Measure markitdown's token-saving lift on the bundled corpus.
+
+Runs against `tests/fixtures/markitdown-corpus/`. By default (no flags) the
+script computes the baseline-only — raw byte size and a tokens-per-4-bytes
+estimate — without calling `markitdown-mcp`. With `--convert`, the script
+tries to invoke `markitdown` (CLI binary) via subprocess and computes the
+converted-Markdown token estimate plus the ratio per file.
+
+Stdlib-only. Never installs anything. Never invokes a network host. Never
+calls `markitdown-mcp` over HTTP — only through the `markitdown` CLI on
+the user's PATH (peer-side install per the skill's Step 1 recipes).
+
+Exit codes:
+  0  — baseline produced (always, when fixtures exist)
+  2  — corpus not found
+  3  — `--convert` was requested but `markitdown` is not on PATH
+"""
+
+from __future__ import annotations
+
+import argparse
+import shutil
+import subprocess
+import sys
+from pathlib import Path
+
+REPO_ROOT = Path(__file__).resolve().parent.parent
+CORPUS = REPO_ROOT / "tests" / "fixtures" / "markitdown-corpus"
+TOKEN_PER_BYTES = 4  # rough OpenAI/Anthropic tokenizer-of-thumb
+
+
+def _baseline_tokens(p: Path) -> int:
+    return max(1, p.stat().st_size // TOKEN_PER_BYTES)
+
+
+def _converted_tokens(p: Path, *, binary: str) -> int | None:
+    try:
+        out = subprocess.run(
+            [binary, str(p)],
+            capture_output=True,
+            check=False,
+            text=True,
+            timeout=30,
+        )
+    except (OSError, subprocess.TimeoutExpired):
+        return None
+    if out.returncode != 0:
+        return None
+    chars = len(out.stdout)
+    if chars == 0:
+        return None
+    return max(1, chars // TOKEN_PER_BYTES)
+
+
+def _format_ratio(baseline: int, converted: int | None) -> str:
+    if converted is None or converted == 0:
+        return "—"
+    ratio = baseline / converted
+    return f"{ratio:.1f}×"
+
+
+def main() -> int:
+    parser = argparse.ArgumentParser(description="Measure markitdown lift on the bundled corpus.")
+    parser.add_argument(
+        "--convert",
+        action="store_true",
+        help="Invoke `markitdown <fixture>` per file and compute the converted-token ratio.",
+    )
+    parser.add_argument(
+        "--binary",
+        default="markitdown",
+        help="Name or path of the markitdown CLI binary (default: markitdown).",
+    )
+    args = parser.parse_args()
+
+    if not CORPUS.is_dir():
+        print(f"ERROR: corpus not found at {CORPUS}", file=sys.stderr)
+        print(
+            "Generate it: python3 tests/fixtures/markitdown-corpus/_generate.py",
+            file=sys.stderr,
+        )
+        return 2
+
+    fixtures = sorted(p for p in CORPUS.iterdir() if p.is_file() and p.suffix in {".pdf", ".pptx", ".docx", ".xlsx"})
+    if not fixtures:
+        print(f"ERROR: no fixtures in {CORPUS}", file=sys.stderr)
+        return 2
+
+    binary_path: str | None = None
+    if args.convert:
+        binary_path = shutil.which(args.binary)
+        if binary_path is None:
+            print(
+                f"ERROR: --convert requested but `{args.binary}` not on PATH.\n"
+                "Install peer-side per the skill's Step 1 recipes "
+                "(Docker / pipx / uv) and re-run.",
+                file=sys.stderr,
+            )
+            return 3
+
+    print(f"Corpus: {CORPUS.relative_to(REPO_ROOT)}  ({len(fixtures)} files)")
+    print(f"Mode:   {'convert (peer markitdown CLI)' if binary_path else 'baseline-only'}")
+    if binary_path:
+        print(f"Binary: {binary_path}")
+    print()
+    header = f"{'fixture':<32} {'bytes':>7} {'baseline tok':>13} {'converted tok':>14} {'ratio':>7}"
+    print(header)
+    print("-" * len(header))
+    for p in fixtures:
+        size = p.stat().st_size
+        base = _baseline_tokens(p)
+        converted = _converted_tokens(p, binary=binary_path) if binary_path else None
+        ratio = _format_ratio(base, converted)
+        conv_str = f"{converted}" if converted is not None else "—"
+        print(f"{p.name:<32} {size:>7} {base:>13} {conv_str:>14} {ratio:>7}")
+    print()
+    if not binary_path:
+        print(
+            "Re-run with --convert (after installing markitdown-mcp peer-side per the skill's "
+            "Step 1 recipes) for the actual ratio."
+        )
+    return 0
+
+
+if __name__ == "__main__":
+    sys.exit(main())

package/scripts/schemas/rule.schema.json

@@ -9,7 +9,8 @@
   "properties": {
     "type": {
       "type": "string",
-      "enum": ["always", "auto"]
+      "enum": ["always", "auto", "manual"],
+      "description": "`always` = injected verbatim every turn (kernel). `auto` = description stub injected, body loaded on trigger match. `manual` = no auto-injection (zero workspace-budget cost); file remains as a reference document linkable from skills/contexts. Introduced by ADR-004 to demote thin pointer-rules without breaking cross-references."
     },
     "source": {
       "type": "string",

package/scripts/skill_linter.py

@@ -115,7 +115,7 @@ ORDERED_STEP_PATTERN = re.compile(r"^(?:\s*|\#{1,4}\s*)(\d+)\.\s+", re.MULTILINE
 SECTION_PATTERN = re.compile(r"^##\s+(.+?)\s*$", re.MULTILINE)
 FRONTMATTER_PATTERN = re.compile(r"^---\n(.*?)\n---\n", re.DOTALL)
 DESCRIPTION_PATTERN = re.compile(r'^description:\s*"?(.*?)"?\s*$', re.MULTILINE)
-TYPE_PATTERN = re.compile(r'^type:\s*"?(always|auto)"?\s*$', re.MULTILINE)
+TYPE_PATTERN = re.compile(r'^type:\s*"?(always|auto|manual)"?\s*$', re.MULTILINE)
 SOURCE_PATTERN = re.compile(r'^source:\s*"?(package|project)"?\s*$', re.MULTILINE)
 STATUS_PATTERN = re.compile(r'^status:\s*"?(active|deprecated|superseded)"?\s*$', re.MULTILINE)
 REPLACED_BY_PATTERN = re.compile(r'^replaced_by:\s*"?([\w-]+)"?\s*$', re.MULTILINE)
@@ -133,7 +133,7 @@ SENIOR_OUTPUT_PATTERN = re.compile(r"^##\s+Output\s*$", re.MULTILINE)
 H1_PATTERN = re.compile(r"^# .+", re.MULTILINE)
 DOUBLE_BLANK_PATTERN = re.compile(r"\n{3,}")
 
-VALID_RULE_TYPES = {"always", "auto"}
+VALID_RULE_TYPES = {"always", "auto", "manual"}
 VALID_RULE_SOURCES = {"package", "project"}
 VALID_STATUSES = {"active", "deprecated", "superseded"}
 
@@ -683,6 +683,12 @@ def lint_router_frontmatter(rule_id: str, frontmatter: str,
     triggers = _parse_yaml_list(frontmatter, "triggers")
     routes_to = _parse_yaml_list(frontmatter, "routes_to")
 
+    # Manual rules are reference-only — not auto-injected, not router-routed
+    # (ADR-004). Skip router validation so legacy triggers/routes_to fields
+    # remain documented in the rule body without forcing maintenance.
+    if rule_type == "manual":
+        return issues
+
     is_kernel = rule_id in KERNEL_RULE_IDS or rule_type == "always"
 
     if is_kernel:
@@ -961,9 +967,9 @@ def lint_rule(path: Path, text: str) -> LintResult:
         # type field
         rule_type = extract_frontmatter_field(frontmatter, TYPE_PATTERN)
         if rule_type is None:
-            issues.append(Issue("error", "missing_type", "Frontmatter missing 'type' field (must be 'always' or 'auto')"))
+            issues.append(Issue("error", "missing_type", "Frontmatter missing 'type' field (must be 'always', 'auto', or 'manual')"))
         elif rule_type not in VALID_RULE_TYPES:
-            issues.append(Issue("error", "invalid_type", f"Invalid type '{rule_type}'; must be 'always' or 'auto'"))
+            issues.append(Issue("error", "invalid_type", f"Invalid type '{rule_type}'; must be 'always', 'auto', or 'manual'"))
 
         # source field
         rule_source = extract_frontmatter_field(frontmatter, SOURCE_PATTERN)

package/scripts/spotcheck_thin_root.py

@@ -0,0 +1,134 @@
+#!/usr/bin/env python3
+"""Phase 6.6 platform spot-check via AI council.
+
+Sends the refactored package-root AGENTS.md and the consumer template
+to Sonnet 4.5 + gpt-4o, asks each member to answer five questions
+that simulate a fresh agent landing on the file. Records qualitative
+verdicts in agents/reports/thin-root-platform-spotcheck.md.
+"""
+from __future__ import annotations
+
+import json
+import sys
+from pathlib import Path
+
+ROOT = Path(__file__).resolve().parent.parent
+sys.path.insert(0, str(ROOT))
+
+from scripts.ai_council.clients import (  # noqa: E402
+    AnthropicClient,
+    OpenAIClient,
+    load_anthropic_key,
+    load_openai_key,
+)
+from scripts.ai_council.orchestrator import (  # noqa: E402
+    CostBudget,
+    CouncilQuestion,
+    consult,
+)
+from scripts.ai_council.pricing import load_prices  # noqa: E402
+
+QUESTIONS = """
+You are evaluating whether the AGENTS.md file below is a sufficient
+entry point for an AI coding agent landing on this repository for
+the first time. You see only the AGENTS.md content; you do NOT have
+file-system access. Answer the following five questions in JSON
+shape `{"q1": {...}, ..., "q5": {...}}` where each value is
+`{"answer": <string>, "confidence": "high"|"medium"|"low",
+"pointer_used": <one of the linked paths from AGENTS.md, or null>}`.
+
+Q1. Where do I edit content in this repo / project? (a path)
+Q2. What command do I run to verify everything is green before opening a PR?
+Q3. Where would I find the always-active behavioural rules?
+Q4. If only this file is reachable, what five things must I assume to be true to act safely? (cite the emergency-triage block)
+Q5. What outboard target document would I open to learn the package-self-orientation / the consumer-fill-out guide? (a path)
+
+After the JSON, add a short prose verdict (≤ 5 sentences) on:
+- Whether the pointer-following worked (could you cite a path for Q1, Q3, Q5?)
+- Whether the emergency-triage block answered Q4 unambiguously.
+- One concrete improvement you'd make to the AGENTS.md.
+
+Do not invent file paths. If a question cannot be answered from the
+file alone, set `"pointer_used": null` and lower confidence.
+""".strip()
+
+
+def main() -> int:
+    package_root = (ROOT / "AGENTS.md").read_text(encoding="utf-8")
+    consumer_template = (
+        ROOT / ".agent-src.uncompressed" / "templates" / "AGENTS.md"
+    ).read_text(encoding="utf-8")
+
+    artefact = (
+        "## Artefact A — package-root AGENTS.md\n\n"
+        f"```markdown\n{package_root}\n```\n\n"
+        "## Artefact B — consumer-template AGENTS.md\n\n"
+        f"```markdown\n{consumer_template}\n```\n\n"
+        f"{QUESTIONS}\n"
+    )
+
+    members = [
+        AnthropicClient(model="claude-sonnet-4-5", api_key=load_anthropic_key()),
+        OpenAIClient(model="gpt-4o", api_key=load_openai_key()),
+    ]
+
+    question = CouncilQuestion(
+        mode="files",
+        user_prompt=artefact,
+        max_tokens=1500,
+    )
+    budget = CostBudget(max_total_usd=2.00, max_calls=4)
+    table = load_prices()
+
+    print("Running spot-check council …", file=sys.stderr)
+    responses = consult(members, question, budget, table=table, rounds=1)
+
+    out_dir = ROOT / "agents" / "reports"
+    out_dir.mkdir(parents=True, exist_ok=True)
+    md_path = out_dir / "thin-root-platform-spotcheck.md"
+    json_path = out_dir / "thin-root-platform-spotcheck.json"
+
+    md_lines = [
+        "# Thin-Root platform spot-check (Phase 6.6)",
+        "",
+        "> AI-council proxy for the manual platform spot-check. Two",
+        "> external reviewers (Sonnet 4.5, gpt-4o) simulate a fresh",
+        "> agent landing on the refactored AGENTS.md and answer five",
+        "> orientation questions from the file alone.",
+        "",
+        "## Verdicts",
+        "",
+    ]
+
+    raw = []
+    for r in responses:
+        body = r.text or f"<error: {r.error}>"
+        raw.append({
+            "provider": r.provider,
+            "model": r.model,
+            "tokens_in": r.input_tokens,
+            "tokens_out": r.output_tokens,
+            "latency_ms": r.latency_ms,
+            "error": r.error,
+            "text": body,
+        })
+        md_lines.append(f"### {r.provider} ({r.model})")
+        md_lines.append("")
+        md_lines.append(f"- tokens in: {r.input_tokens} · out: {r.output_tokens} · latency: {r.latency_ms}ms")
+        if r.error:
+            md_lines.append(f"- error: `{r.error}`")
+        md_lines.append("")
+        md_lines.append("```")
+        md_lines.append(body[:8000])
+        md_lines.append("```")
+        md_lines.append("")
+
+    md_path.write_text("\n".join(md_lines), encoding="utf-8")
+    json_path.write_text(json.dumps(raw, indent=2), encoding="utf-8")
+    print(f"✅  Wrote {md_path}", file=sys.stderr)
+    print(f"✅  Wrote {json_path}", file=sys.stderr)
+    return 0
+
+
+if __name__ == "__main__":
+    raise SystemExit(main())

package/scripts/update_counts.py

@@ -67,16 +67,12 @@ TARGETS: list[tuple[str, list[tuple[str, str]]]] = [
             # the raw file count this script computes.
         ],
     ),
-    (
-        "AGENTS.md",
-        [
-            (r"(skills/\s+\()(\d+)( skills\))", "skills"),
-            (r"(rules/\s+\()(\d+)( rules\))", "rules"),
-            (r"(commands/\s+\()(\d+)( commands\))", "commands"),
-            (r"(guidelines/\s+\()(\d+)( guidelines\))", "guidelines"),
-            (r"(personas/\s+\()(\d+)( personas\))", "personas"),
-        ],
-    ),
+    # Note: AGENTS.md previously held the per-directory count annotations
+    # (`skills/ (N skills)`, `rules/ (N rules)`, ...). The Thin-Root
+    # refactor (Phase 6, road-to-augment-limit-fit, 2026-05-08) made
+    # AGENTS.md a navigation-only surface — counts now live in README.md
+    # and docs/architecture.md. The corresponding pytest sentinel lives
+    # in tests/test_readme_hero_counts.py::test_agents_md_is_thin_root_navigation_surface.
     (
         "docs/getting-started.md",
         [

package/.agent-src/rules/no-council-references.md

@@ -1,76 +0,0 @@
----
-type: "auto"
-tier: "mechanical-already"
-description: "Linking a specific file in agents/council-{questions,responses,sessions}/ from any artifact — council files are gitignored, local-only, auto-pruned; inline the convergence instead"
-alwaysApply: false
-source: package
-triggers:
-  - path_prefix: "agents/council-questions/"
-  - path_prefix: "agents/council-responses/"
-  - path_prefix: "agents/council-sessions/"
-  - intent: "link to council artefact"
-routes_to:
-  - "skill:ai-council"
-validator_ignore:
-  - type: "substring"
-    pattern: ".agent-src.uncompressed/"
-    reason: "Rule references the authoring tree when contrasting transient council files."
----
-
-# No Council References from Any Artifact
-
-Council artefacts under `agents/council-{questions,responses,sessions}/`
-are **gitignored, local-only, and auto-pruned** after
-`ai_council.session_retention_days` (default 7). They are
-disposable scratch — never part of the repo, never visible to a
-reviewer who clones, never durable across the retention window.
-
-A link to a specific council file rots three ways: gitignored
-(not in cloned repo), pruned after retention window (gone even
-locally), and the installed `.augment/` projection cannot follow a
-path that does not exist in the consumer.
-
-## The Iron Law
-
-```
-NEVER LINK TO A SPECIFIC FILE INSIDE
-agents/council-{questions,responses,sessions}/
-FROM ANY ARTIFACT — ROADMAPS INCLUDED.
-INLINE THE CONVERGENCE WITH DATE + MEMBERS, NEVER THE PATH.
-```
-
-Applies to **every** artifact. Council artefacts are more transient
-than roadmaps — the local copy disappears too.
-
-## Forbidden vs allowed
-
-**Forbidden** in any `*.md` / `*.yml` / `*.json` / `*.py`:
-`agents/council-questions/<file>.md`,
-`agents/council-responses/<file>.json`,
-`agents/council-sessions/<file>.json` or `<timestamp>/...`.
-
-**Allowed**: directory mentions (talking about the output convention,
-not a specific file); the `ai-council` skill and `/council:*` commands
-documenting the output path schema; inline convergence summary —
-e.g. *"Council (claude-sonnet-4-5 + gpt-4o, 2026-05-06) converged
-on …"* with date + members, no filepath.
-
-## What to do instead
-
-Identify the durable conclusion (decision, contract, lesson),
-inline a convergence-summary block (members, date, cost if relevant
-— see `ai-council` § Output format), and optionally promote the
-lesson to `agents/contexts/`. The context is durable; the council
-file was the catalyst.
-
-Failure mode: *"I'll just link to the session JSON, it's evidence."*
-The session is gone in 7 days. **Inline first, link never.**
-
-## See also
-
-- [`no-roadmap-references`](no-roadmap-references.md) — sibling rule
-  for the roadmap layer
-- [`augment-source-of-truth`](augment-source-of-truth.md) — edit
-  `.agent-src.uncompressed/`
-- [`ai-council`](../skills/ai-council/SKILL.md) — output path
-  convention and convergence-summary format

package/.agent-src/rules/review-routing-awareness.md

@@ -1,19 +0,0 @@
----
-type: "auto"
-tier: "2a"
-description: "When routing reviewers or flagging risk hotspots — consult ownership-map and historical-bug-patterns before suggesting reviewers or claiming a change is safe"
-source: package
-triggers:
-  - keyword: "reviewer"
-  - phrase: "risk hotspot"
-  - phrase: "ownership map"
-routes_to:
-  - "skill:review-routing"
----
-
-# Review Routing Awareness
-
-**Iron Law.** Consult ownership-map and historical-bug-patterns before suggesting reviewers or claiming a change is safe.
-
-Body migrated to `skill:review-routing` (per P4 of `road-to-kernel-and-router.md`).
-Trigger-set above activates this routing under the `balanced` and `full` profiles.