@event4u/agent-config 1.20.0 → 1.22.0

package/scripts/_p4_migrate.py

@@ -0,0 +1,199 @@
+#!/usr/bin/env python3
+"""P4.1 + P4.2 migration: rule → skill / guideline / command / contract stub.
+
+Replaces 25 rules with thin stubs declaring `triggers:` + `routes_to:`.
+For move-to-guideline, copies the rule body into a new guideline file.
+For move-to-skill / command / contract, the target already carries the
+procedure — stub keeps an Iron-Law one-liner only.
+"""
+from __future__ import annotations
+import re, sys, pathlib
+
+ROOT = pathlib.Path(__file__).resolve().parents[1]
+RULES = ROOT / ".agent-src.uncompressed" / "rules"
+GUIDELINES = ROOT / "docs" / "guidelines"
+
+# (rule_id, route, triggers, iron_law_one_liner)
+# route format: "kind:id"
+SKILL_MIGRATIONS = [
+    ("agent-docs", "skill:agent-docs-writing",
+     [("path_prefix", "agents/"), ("path_prefix", ".github/copilot-instructions"), ("keyword", "AGENTS.md"), ("keyword", "roadmap")],
+     "Read agent docs (`AGENTS.md`, `agents/`, module `agents/`) before work; update them after structural changes."),
+    ("analysis-skill-routing", "skill:analysis-skill-router",
+     [("keyword", "analyze"), ("keyword", "analysis"), ("phrase", "dig into the codebase")],
+     "Route analysis tasks to the narrowest matching `project-analysis-*` skill, not the broad fallback."),
+    ("capture-learnings", "skill:learning-to-rule-or-skill",
+     [("phrase", "after completing a task"), ("keyword", "learning"), ("keyword", "lesson")],
+     "After a task, capture repeated mistakes / successful patterns as a rule or skill — never lose the learning."),
+    ("cli-output-handling", "skill:rtk-output-filtering",
+     [("keyword", "git"), ("keyword", "phpstan"), ("keyword", "rector"), ("keyword", "phpunit"), ("keyword", "composer")],
+     "Wrap verbose CLI output with `rtk` when installed; fall back to `tail`/`grep` only when missing."),
+    ("commit-conventions", "skill:conventional-commits-writing",
+     [("keyword", "commit"), ("keyword", "branch"), ("phrase", "conventional commits")],
+     "Use Conventional Commits (`feat:`, `fix:`, `chore:` …); branches `<type>/<short-slug>`; never invent your own format."),
+    ("docker-commands", "skill:docker",
+     [("keyword", "docker"), ("keyword", "artisan"), ("keyword", "composer"), ("phrase", "inside the container")],
+     "Run PHP / artisan / composer / phpstan / rector / ecs / phpunit inside the project container, never on the host."),
+    ("docs-sync", "skill:agent-docs-writing",
+     [("path_prefix", ".agent-src.uncompressed/"), ("path_prefix", ".augment/"), ("keyword", "rename"), ("keyword", "delete")],
+     "On any add / rename / delete of skill / rule / command / guideline, update counts and cross-references in the same edit."),
+    ("e2e-testing", "command:e2e-heal",
+     [("keyword", "playwright"), ("keyword", "e2e"), ("phrase", "page object")],
+     "Playwright E2E: stable locators, no `waitForTimeout`, Page Objects for shared flows, fixtures over `beforeEach`."),
+    ("laravel-translations", "skill:laravel",
+     [("path_prefix", "lang/"), ("keyword", "translation"), ("keyword", "__()"), ("keyword", "trans(")],
+     "Use `__()`/`trans()` with language keys for every user-visible string; mirror keys across `lang/<locale>/` files."),
+    ("model-recommendation", "command:set-cost-profile",
+     [("phrase", "switch task"), ("phrase", "new task"), ("phrase", "which model")],
+     "On task / model switch, recommend the optimal model for the task complexity before any work begins."),
+    ("onboarding-gate", "command:onboard",
+     [("phrase", "first turn"), ("keyword", "onboarding"), ("path_prefix", ".agent-settings.yml")],
+     "First turn of a project: if `onboarding.onboarded` is false, prompt `/onboard` before executing any other request."),
+    ("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."),
+    ("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."),
+    ("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."),
+    ("slash-command-routing-policy", "skill:command-routing",
+     [("keyword", "/create-pr"), ("keyword", "/commit"), ("keyword", "/fix-ci"), ("phrase", "slash command")],
+     "On a slash-command invocation or pasted command body, route to the matching command file; never improvise."),
+    ("ui-audit-gate", "skill:existing-ui-audit",
+     [("path_prefix", "resources/views/"), ("path_prefix", "resources/js/"), ("keyword", "component"), ("keyword", "design token")],
+     "Before any non-trivial UI change, require `state.ui_audit` findings — gate, not suggestion."),
+    ("upstream-proposal", "skill:upstream-contribute",
+     [("phrase", "after creating"), ("phrase", "after improving"), ("keyword", "upstream")],
+     "After creating or significantly improving a skill / rule / guideline / command, ask whether to upstream it."),
+]
+
+GUIDELINE_MIGRATIONS = [
+    ("artifact-engagement-recording", "contract:artifact-engagement-flow",
+     [("phrase", "/implement-ticket"), ("phrase", "/work"), ("keyword", "telemetry")],
+     "After a `/implement-ticket` or `/work` phase-step, emit one `telemetry:record` call with consulted + applied ids when telemetry is enabled."),
+    ("augment-portability", "guideline:augment-portability-patterns",
+     [("path_prefix", ".augment/"), ("path_prefix", ".agent-src.uncompressed/"), ("keyword", "portable")],
+     "Files inside `.augment/` and `.agent-src.uncompressed/` MUST stay project-agnostic — no project names, domains, stacks."),
+    ("command-suggestion-policy", "contract:command-suggestion-flow",
+     [("phrase", "free-form prompt"), ("phrase", "command suggestion")],
+     "When a free-form prompt matches a command, surface matches as numbered options with as-is escape; never auto-execute."),
+    ("php-coding", "guideline:php/php-coding-patterns",
+     [("file_pattern", "*.php"), ("keyword", "phpstan"), ("keyword", "ecs")],
+     "PHP: strict types, named comparisons, early returns, Eloquent conventions — full pattern library in the guideline."),
+    ("roadmap-progress-sync", "guideline:agent-infra/roadmap-progress-mechanics",
+     [("path_prefix", "agents/roadmaps/")],
+     "Any touch to `agents/roadmaps/` regenerates the dashboard in the same response; archive the roadmap when 0 open items remain."),
+    ("rule-type-governance", "guideline:agent-infra/rule-type-governance",
+     [("path_prefix", ".agent-src.uncompressed/rules/")],
+     "Choose `always` vs `auto` per the governance table; over-broad `always` rules degrade the kernel budget."),
+    ("skill-quality", "guideline:agent-infra/skill-quality-checklist",
+     [("path_prefix", ".agent-src.uncompressed/skills/")],
+     "Every skill must be executable, validated, and self-contained — full checklist in the guideline."),
+]
+
+
+
+def yaml_triggers(triggers: list[tuple[str, str]]) -> str:
+    lines = []
+    for kind, val in triggers:
+        v = val.replace('"', '\\"')
+        lines.append(f'  - {kind}: "{v}"')
+    return "\n".join(lines)
+
+
+def parse_existing_frontmatter(text: str) -> tuple[dict, str]:
+    m = re.match(r"^---\n(.*?)\n---\n(.*)$", text, re.DOTALL)
+    if not m:
+        return {}, text
+    fm_text, body = m.group(1), m.group(2)
+    fm = {}
+    for line in fm_text.split("\n"):
+        if ":" not in line or line.startswith(" "):
+            continue
+        k, _, v = line.partition(":")
+        fm[k.strip()] = v.strip().strip('"')
+    return fm, body
+
+
+def build_stub(rule_id: str, route: str, triggers: list[tuple[str, str]],
+               iron_law: str, existing_fm: dict) -> str:
+    desc = existing_fm.get("description", "")
+    tier = existing_fm.get("tier", "3")
+    rtype = existing_fm.get("type", "auto")
+    source = existing_fm.get("source", "package")
+    new_tier = {"1": "tier-1", "2a": "tier-2", "2b": "tier-2", "3": "tier-2",
+                "mechanical-already": "tier-2", "mech": "tier-2"}.get(tier, "tier-2")
+    fm_lines = [
+        "---",
+        f'type: "{rtype}"',
+        f'tier: "{new_tier}"',
+        f'description: "{desc}"',
+        f'source: {source}',
+        "triggers:",
+        yaml_triggers(triggers),
+        "routes_to:",
+        f'  - "{route}"',
+        "---",
+        "",
+        f"# {rule_id.replace('-', ' ').title()}",
+        "",
+        f"**Iron Law.** {iron_law}",
+        "",
+        f"Body migrated to `{route}` (per P4 of `road-to-kernel-and-router.md`).",
+        "Trigger-set above activates this routing under the `balanced` and `full` profiles.",
+    ]
+    return "\n".join(fm_lines) + "\n"
+
+
+def write_guideline(rule_id: str, route: str, body: str, existing_fm: dict) -> pathlib.Path:
+    kind, _, gid = route.partition(":")
+    if kind == "guideline":
+        target = GUIDELINES / f"{gid}.md"
+    elif kind == "contract":
+        target = ROOT / "docs" / "contracts" / f"{gid}.md"
+    else:
+        raise ValueError(f"unsupported route kind for guideline migration: {kind}")
+    if target.exists():
+        return target
+    target.parent.mkdir(parents=True, exist_ok=True)
+    desc = existing_fm.get("description", "")
+    header = (f"# {rule_id.replace('-', ' ').title()}\n\n"
+              f"> {desc}\n\n"
+              f"_Origin: migrated from `.agent-src.uncompressed/rules/{rule_id}.md` "
+              f"per P4.2 of `road-to-kernel-and-router.md`._\n\n")
+    target.write_text(header + body.lstrip())
+    return target
+
+
+def main() -> int:
+    written = []
+    for rule_id, route, triggers, iron_law in SKILL_MIGRATIONS:
+        rule_path = RULES / f"{rule_id}.md"
+        if not rule_path.exists():
+            print(f"  ✗ MISSING rule: {rule_id}"); continue
+        fm, body = parse_existing_frontmatter(rule_path.read_text())
+        stub = build_stub(rule_id, route, triggers, iron_law, fm)
+        rule_path.write_text(stub)
+        written.append(("skill-stub", rule_id, route, len(stub)))
+    for rule_id, route, triggers, iron_law in GUIDELINE_MIGRATIONS:
+        rule_path = RULES / f"{rule_id}.md"
+        if not rule_path.exists():
+            print(f"  ✗ MISSING rule: {rule_id}"); continue
+        fm, body = parse_existing_frontmatter(rule_path.read_text())
+        write_guideline(rule_id, route, body, fm)
+        stub = build_stub(rule_id, route, triggers, iron_law, fm)
+        rule_path.write_text(stub)
+        written.append(("guideline", rule_id, route, len(stub)))
+    print(f"\nMigrated {len(written)} rules:")
+    for kind, rid, route, sz in written:
+        print(f"  {kind:14s} {rid:35s} → {route:55s} stub={sz}c")
+    return 0
+
+
+if __name__ == "__main__":
+    sys.exit(main())

package/scripts/_phase2_shim_helper.py

@@ -25,7 +25,7 @@ PHASE2_SHIMS: list[tuple[str, str]] = [
     ("propose-memory", "memory propose"),
     # roadmap cluster
     ("roadmap-create",  "roadmap create"),
-    ("roadmap-execute", "roadmap execute"),
+    ("roadmap-execute", "roadmap process-phase"),
     # module cluster
     ("module-create",  "module create"),
     ("module-explore", "module explore"),

package/scripts/_pilot_council_question.py

@@ -0,0 +1,57 @@
+"""Build the Phase-1 council question file (one-off)."""
+from pathlib import Path
+
+OUT = Path("/tmp/council-p1/question.md")
+OUT.parent.mkdir(parents=True, exist_ok=True)
+
+framing = """# Cross-check request — Phase 1 of "Road to Rule Kernel and Router"
+
+We are about to compress a 56-rule "always-active" set down to a small
+hard-capped kernel + a router-loaded auto bucket. Phase 1 is purely
+classification + projection — no source rules edited yet. Two contracts
+were produced. We want a neutral second opinion BEFORE Phase 2 ships
+compression to the actual rule files.
+
+## What we want from you
+
+1. **Disposition calls.** Look at the 56-rule classification. Are any
+   `keep-in-kernel` rules over-included (could safely become auto-tier)?
+   Are any `move-to-skill` / `move-to-guideline` calls wrong (e.g.
+   carrying an Iron Law that should stay always-on)? Cite the rule id
+   and the better disposition.
+2. **Kernel inclusion criteria.** Section 1 of `kernel-membership.md`
+   lists 4 criteria (Iron-Law floor / mode-independent / pre-action
+   gate / cross-cutting). Are these the right gates? Is anything
+   missing or redundant?
+3. **Compression-rate r = 0.742.** Three pilots gave r-values 0.677 /
+   0.712 / 0.838. We locked the **mean**. Reasonable, or should we use
+   median (0.712) / max (0.838) as a more conservative budget cushion?
+   Note: pilot range straddles the typical 0.6-0.75 band; max came
+   from the shortest rule (already-lean floor effect).
+4. **The 1.5k per-rule cap with ADR-override.** Two of the three pilots
+   land >1.5k post-compression and would need an `iron-law-override`
+   ADR. Is the per-rule cap realistic, or should we raise the per-rule
+   ceiling (e.g. 2.5k or 3.5k) and lower the bucket cap (e.g. from 25k
+   to 20k)? What's the failure mode you'd be most worried about?
+5. **Anything we missed.** Risks, blind spots, sequencing problems.
+
+Be specific. Cite the rule id or the section number. We will reject
+generic "looks good" reviews.
+
+---
+
+## Contract 1 — docs/contracts/rule-classification.md
+
+"""
+
+OUT.write_text(framing)
+with OUT.open("a") as fh:
+    fh.write(Path("docs/contracts/rule-classification.md").read_text())
+    fh.write("\n\n---\n\n## Contract 2 — docs/contracts/kernel-membership.md\n\n")
+    fh.write(Path("docs/contracts/kernel-membership.md").read_text())
+    fh.write("\n\n---\n\n## Pilot inputs (compressed bodies, for reference)\n")
+    for rid in ("agent-authority", "direct-answers", "language-and-tone"):
+        fh.write(f"\n### Pilot — {rid}\n\n")
+        fh.write(Path(f"docs/contracts/pilot/{rid}.md").read_text())
+
+print(f"wrote {OUT} — {OUT.stat().st_size} bytes")

package/scripts/_pilot_measure.py

@@ -0,0 +1,53 @@
+"""Pilot compression ratio + Iron-Law checksum verification (one-off, not CI)."""
+import sys, re, hashlib, statistics
+from pathlib import Path
+
+sys.path.insert(0, "scripts")
+from measure_rule_budget import strip_frontmatter
+
+FENCE_RE = re.compile(r"```(?:[^\n]*\n)([\s\S]*?)```")
+
+
+def iron_law_sha(body: str) -> str:
+    blocks = FENCE_RE.findall(body)
+    norm = "".join(re.sub(r"\s+", " ", b).strip().upper() for b in blocks)
+    return hashlib.sha256(norm.encode()).hexdigest()[:16]
+
+
+pairs = [
+    ("agent-authority",   ".agent-src.uncompressed/rules/agent-authority.md",   "docs/contracts/pilot/agent-authority.md"),
+    ("direct-answers",    ".agent-src.uncompressed/rules/direct-answers.md",    "docs/contracts/pilot/direct-answers.md"),
+    ("language-and-tone", ".agent-src.uncompressed/rules/language-and-tone.md", "docs/contracts/pilot/language-and-tone.md"),
+]
+
+header = f"{'rule':25s} {'orig':>6s}  {'pilot':>6s}  {'r':>6s}  {'budget':>7s}  {'sha-orig':>16s}  {'sha-pilot':>16s}  {'IL':>3s}"
+print(header)
+print("-" * len(header))
+
+ratios = []
+for rid, orig_path, pilot_path in pairs:
+    orig_body, _  = strip_frontmatter(Path(orig_path).read_text())
+    pilot_body, _ = strip_frontmatter(Path(pilot_path).read_text())
+    o, p = len(orig_body), len(pilot_body)
+    r = p / o
+    ratios.append(r)
+    sha_o = iron_law_sha(orig_body)
+    sha_p = iron_law_sha(pilot_body)
+    match = "OK" if sha_o == sha_p else "FAIL"
+    budget = "OK" if p <= 1500 else f"+{p - 1500}"
+    print(f"{rid:25s} {o:6d}  {p:6d}  {r:6.3f}  {budget:>7s}  {sha_o:>16s}  {sha_p:>16s}  {match:>3s}")
+
+mean   = sum(ratios) / len(ratios)
+median = statistics.median(ratios)
+print()
+print(f"r-values : {[round(x, 3) for x in ratios]}")
+print(f"mean   r = {mean:.3f}")
+print(f"median r = {median:.3f}")
+print(f"max    r = {max(ratios):.3f}")
+print(f"min    r = {min(ratios):.3f}")
+print()
+
+TOTAL = 32403
+print(f"Projected always-bucket @ r=mean ({mean:.3f})  : {int(TOTAL * mean):>6d}  (target ≤ 25000)")
+print(f"Projected always-bucket @ r=max  ({max(ratios):.3f})  : {int(TOTAL * max(ratios)):>6d}  (target ≤ 25000)")
+print(f"Projected always-bucket @ r=med  ({median:.3f})  : {int(TOTAL * median):>6d}  (target ≤ 25000)")

package/scripts/ai_council/session.py

@@ -35,9 +35,15 @@ from scripts.ai_council.orchestrator import render
 
 REPO_ROOT = Path(__file__).resolve().parents[2]
 SESSIONS_DIR = REPO_ROOT / "agents" / "council-sessions"
+QUESTIONS_DIR = REPO_ROOT / "agents" / "council-questions"
+RESPONSES_DIR = REPO_ROOT / "agents" / "council-responses"
 SETTINGS_FILE = REPO_ROOT / ".agent-settings.yml"
 
-DEFAULT_RETENTION_DAYS = 14
+# Default retention for all council artefacts (questions, responses,
+# sessions). Overridden by `ai_council.session_retention_days`
+# in `.agent-settings.yml`. Council files are local-only scratch — short
+# retention keeps the working tree from accumulating dead weight.
+DEFAULT_RETENTION_DAYS = 7
 _TS_RE = re.compile(r"^(\d{4})-(\d{2})-(\d{2})T(\d{2})-(\d{2})-(\d{2})Z$")
 
 
@@ -152,6 +158,92 @@ def prune_old_sessions(
     return removed
 
 
+def prune_old_artifacts(
+    artifact_dir: Path,
+    retention_days: int,
+    *,
+    now: _dt.datetime | None = None,
+) -> list[Path]:
+    """Delete files and timestamp-less directories older than `retention_days`.
+
+    mtime-based — used for `agents/council-questions/`,
+    `agents/council-responses/`, and root-level files in
+    `agents/council-sessions/` that don't match the
+    timestamp-subdir convention handled by `prune_old_sessions`.
+
+    Walks the directory non-recursively. For files: deletes when
+    mtime predates the cutoff. For sub-directories without a
+    timestamp name: deletes recursively when mtime predates the
+    cutoff. Never raises — disk failures log to stderr.
+
+    Returns the list of deleted paths. `retention_days <= 0`
+    disables pruning and returns an empty list.
+    """
+    if retention_days <= 0 or not artifact_dir.exists():
+        return []
+    cutoff = (now or _dt.datetime.now(_dt.timezone.utc)) - _dt.timedelta(days=retention_days)
+    cutoff_ts = cutoff.timestamp()
+    removed: list[Path] = []
+    try:
+        entries = list(artifact_dir.iterdir())
+    except OSError as exc:  # noqa: BLE001 - never block the report
+        print(f"[council:session] artifact iterdir failed: {exc}", file=sys.stderr)
+        return removed
+    for entry in entries:
+        # Timestamp subdirs are owned by prune_old_sessions; skip them
+        # so the two pruners don't race.
+        if entry.is_dir() and _parse_session_timestamp(entry.name) is not None:
+            continue
+        try:
+            mtime = entry.stat().st_mtime
+        except OSError as exc:  # noqa: BLE001 - never block the report
+            print(f"[council:session] artifact stat failed for {entry}: {exc}",
+                  file=sys.stderr)
+            continue
+        if mtime >= cutoff_ts:
+            continue
+        try:
+            if entry.is_dir():
+                shutil.rmtree(entry)
+            else:
+                entry.unlink()
+            removed.append(entry)
+        except OSError as exc:  # noqa: BLE001 - never block the report
+            print(f"[council:session] artifact remove failed for {entry}: {exc}",
+                  file=sys.stderr)
+    return removed
+
+
+def prune_all_council_artifacts(
+    retention_days: int | None = None,
+    *,
+    repo_root: Path | None = None,
+    now: _dt.datetime | None = None,
+) -> dict[str, list[Path]]:
+    """Prune every council artefact dir under `repo_root` in one pass.
+
+    Reads `retention_days` from settings if not supplied. Used by the
+    `task council-prune` target and by `save()`. Never raises.
+
+    Returns a dict keyed by directory label — `sessions`,
+    `questions`, `responses` — each mapped to the list of
+    paths actually removed.
+    """
+    root = repo_root or REPO_ROOT
+    days = _load_retention_days() if retention_days is None else retention_days
+    sessions = root / "agents" / "council-sessions"
+    questions = root / "agents" / "council-questions"
+    responses = root / "agents" / "council-responses"
+    return {
+        "sessions": (
+            prune_old_sessions(sessions, days, now=now)
+            + prune_old_artifacts(sessions, days, now=now)
+        ),
+        "questions": prune_old_artifacts(questions, days, now=now),
+        "responses": prune_old_artifacts(responses, days, now=now),
+    }
+
+
 def save(
     *,
     manifest: SessionManifest,
@@ -167,10 +259,12 @@ def save(
     - `Iterable[list[CouncilResponse]]` — multi-round, one list per
       round in execution order.
 
-    `retention_days` controls auto-pruning of older sibling sessions
-    after the new one is written. `None` reads the value from
-    `.agent-settings.yml` (`ai_council.session_retention_days`,
-    default `14`); `0` disables pruning.
+    `retention_days` controls auto-pruning of older council artefacts
+    after the new one is written — sibling sessions plus, when
+    `sessions_dir` is not overridden, files in `council-questions/`
+    and `council-responses/`. `None` reads the value
+    from `.agent-settings.yml` (`ai_council.session_retention_days`,
+    default `7`); `0` disables pruning.
 
     Disk-write failures are surfaced via a stderr line but do not
     raise; the caller's text report is the source of truth.
@@ -232,5 +326,13 @@ def save(
 
     days = _load_retention_days() if retention_days is None else retention_days
     prune_old_sessions(base, days)
+    prune_old_artifacts(base, days)
+    # In production (no sessions_dir override), also prune the sibling
+    # council artefact dirs so questions/responses aren't left as dead
+    # weight. Tests that pass an explicit sessions_dir stay isolated
+    # from the wider tree.
+    if sessions_dir is None:
+        prune_old_artifacts(QUESTIONS_DIR, days)
+        prune_old_artifacts(RESPONSES_DIR, days)
 
     return session_dir

package/scripts/build_linear_digest.py

@@ -76,15 +76,13 @@ WORKSPACE: list[RuleEntry] = [
     RuleEntry("reviewer-awareness"),
     RuleEntry("scope-control"),
     RuleEntry("security-sensitive-stop"),
-    RuleEntry("think-before-action", "degraded",
-              strip_sections=["Consult memory before editing"]),
+    RuleEntry("think-before-action"),
     RuleEntry("verify-before-complete"),
-    RuleEntry("cli-output-handling", "degraded",
-              strip_sections=["Iron Law — rtk first, tail/grep fallback"]),
+    RuleEntry("cli-output-handling"),
     RuleEntry("downstream-changes"),
     RuleEntry("improve-before-implement"),
     RuleEntry("language-and-tone", "degraded",
-              strip_sections=["`.md` files are ALWAYS English — no exceptions"]),
+              strip_sections=["`.md` files — ALWAYS English"]),
     RuleEntry("missing-tool-handling"),
     RuleEntry("token-efficiency"),
     RuleEntry("user-interaction"),

package/scripts/check_always_budget.py

@@ -47,6 +47,26 @@ FAIL_THRESHOLD = 0.90
 CONCENTRATION_SINGLE_PCT = 0.12
 CONCENTRATION_TOP3_PCT = 0.30
 
+# Transitional concentration allowlist — non-safety-floor rules whose
+# extended share exceeds CONCENTRATION_SINGLE_PCT after the kernel-trim
+# refactor (commit 4e771da `refactor(kernel): compress 8 kernel rules
+# per P2.2 playbook + lock kernel`). Trimming safety-floor rules shrank
+# the denominator, mechanically lifting non-floor rules' percentage
+# share even though their absolute size did not grow. Each entry pins
+# the measured extended-size ceiling at the day road-to-path-fixes was
+# closed; growth above the ceiling regresses CI. Future kernel-aware
+# trimming work retires entries here.
+KNOWN_CONCENTRATION_BREACHES: dict[str, int] = {
+    "language-and-tone.md": 3_985,
+    "no-cheap-questions.md": 3_530,
+}
+# Top-3 non-floor concentration ceiling — same rationale as the
+# per-rule allowlist above. The current top-3 sum (language-and-tone +
+# scope-control-allowlisted + non-destructive-allowlisted) clears the
+# 30 % cap; the entry below pins the measured ceiling. Future trim
+# work drops this back to None (default 30 %).
+KNOWN_TOP3_CONCENTRATION_CEILING: int | None = 10_900
+
 # Q3=A locked safety-floor rules — out of scope for slimming and for the
 # concentration check. Their size is intentional (Iron Laws + obligation
 # surface), not drift. See road-to-structural-optimization Phase 5.
@@ -221,6 +241,12 @@ def _concentration_check(
     Returns (single-rule breaches, top-3 breach or None). Q3=A locked
     safety-floor rules are excluded from both numerator and the top-3
     selection — their size is intentional, not drift.
+
+    Allowlisted rules in `KNOWN_CONCENTRATION_BREACHES` are exempted
+    from the per-rule cap as long as their extended size does not
+    exceed the recorded ceiling (regression guard). The top-3 cap is
+    relaxed to `KNOWN_TOP3_CONCENTRATION_CEILING` while that ceiling
+    is non-None.
     """
     non_floor = [
         (name, raw, ext) for name, raw, ext in sizes
@@ -229,15 +255,22 @@ def _concentration_check(
     single_cap = total_ext * CONCENTRATION_SINGLE_PCT
     top3_cap = total_ext * CONCENTRATION_TOP3_PCT
 
-    single_breaches = [
-        (name, ext, ext / total_ext)
-        for name, _, ext in non_floor
-        if ext > single_cap
-    ]
+    single_breaches: list[tuple[str, int, float]] = []
+    for name, _, ext in non_floor:
+        if ext <= single_cap:
+            continue
+        ceiling = KNOWN_CONCENTRATION_BREACHES.get(name)
+        if ceiling is not None and ext <= ceiling:
+            continue
+        single_breaches.append((name, ext, ext / total_ext))
+
     top3_sum = sum(ext for _, _, ext in non_floor[:3])
+    effective_top3_cap = top3_cap
+    if KNOWN_TOP3_CONCENTRATION_CEILING is not None:
+        effective_top3_cap = max(top3_cap, KNOWN_TOP3_CONCENTRATION_CEILING)
     top3_breach = (
         (top3_sum, top3_sum / total_ext)
-        if top3_sum > top3_cap else None
+        if top3_sum > effective_top3_cap else None
     )
     return single_breaches, top3_breach