@event4u/agent-config 1.20.0 → 1.21.0

package/docs/contracts/rule-classification.md

@@ -0,0 +1,170 @@
+---
+stability: beta
+---
+
+
+# Rule Classification — Phase 1.2 of road-to-kernel-and-router
+
+> **Status:** active · **Stability:** beta · **Owner:** road-to-kernel-and-router P1.2
+> · **Source of truth:** `.agent-src.uncompressed/rules/*.md`
+
+Migration plan for all 56 source rules. **No edits land here** — this
+document is the disposition map P2 / P4 will execute against.
+
+## § 1 — Disposition codes
+
+| code | meaning |
+|---|---|
+| `keep-in-kernel` | Iron Law floor / behaviour / safety / tone / ask-policy. Loaded every session. Compressed to ≤ 2.5k chars (P2.2; raised from 1.5k per Council R2). |
+| `compress-and-keep` | Behavioural rule that stays in `rules/` as auto-tier. Compressed in place per the P2.2 playbook. Loaded by router on trigger match. |
+| `move-to-skill:<id>` | Procedural how-to content. Body migrates into the named skill (P4.1); rule shrinks to Iron Law one-liner + `routes_to:`. |
+| `move-to-guideline:<id>` | Reference / examples / mechanics tables. Body migrates into `docs/guidelines/<id>.md` (P4.2); rule keeps Iron Law + pointer. |
+
+## § 2 — Baseline numbers (measured 2026-05-06)
+
+| bucket | rules | chars | target after roadmap |
+|---|---:|---:|---|
+| always (kernel proxy) | 9 | 32 403 | ≤ 25 000 hard, ≤ 20 000 target |
+| auto | 47 | 142 297 | ≤ 60 000 |
+| **total** | **56** | **174 700** | **≤ 85 000** |
+
+Source: `python3 scripts/measure_rule_budget.py`.
+
+## § 3 — Disposition table
+
+Sorted by current `type` then `id`. `chars` = body chars after
+frontmatter strip. Disposition is the migration call, **not** an edit
+yet.
+
+### § 3.1 — always-rules (kernel candidates)
+
+| id | chars | disposition | rationale |
+|---|---:|---|---|
+| agent-authority | 1217 | `keep-in-kernel` | Priority index for the four authority rules; routes-of-routers |
+| ask-when-uncertain | 4096 | `keep-in-kernel` | Iron Law: one-question-per-turn, mirror the user, vague-trigger list |
+| commit-policy | 2972 | `keep-in-kernel` | Iron Law (safety-floor): NEVER commit / NEVER ask about committing |
+| direct-answers | 3991 | `keep-in-kernel` | Three Iron Laws (no flattery, no invented facts, brevity) |
+| language-and-tone | 5318 | `keep-in-kernel` | Iron Law: mirror the user's language; .md always English |
+| no-cheap-questions | 3875 | `keep-in-kernel` | Iron Law: no-cheap-questions self-check; mode-independent |
+| non-destructive-by-default | 4222 | `keep-in-kernel` | Iron Law (safety-floor): Hard Floor for prod / push / bulk-destructive |
+| scope-control | 4368 | `keep-in-kernel` | Iron Law (safety-floor): no unsolicited refactors / git-ops gate |
+| verify-before-complete | 2344 | `keep-in-kernel` | Iron Law: no completion claims without fresh verification |
+
+**Always-bucket total: 32 403 chars.** Pilot compression rate `r`
+locked at **median 0.712** (P1.3, Council R2 amendment); projection
+sum = 23 071 chars, under the 25k hard cap with 1 929 chars headroom.
+Per-rule cap raised to ≤ 2.5k (Council R2). Iron-Law-override ADRs
+may lift individual rules above 2.5k where Iron-Law density forbids
+further compression — currently 2 expected (`direct-answers` +342,
+`language-and-tone` +1286). See `kernel-membership.md` § 5.
+
+> **Council swap ADR (P2.1 input).** Sonnet 4.5 flagged
+> `agent-authority` as a routing index (no Iron-Law fence; should
+> demote to auto-tier-3) and `autonomous-execution` (currently
+> `compress-and-keep` below) as a mode-independent Band-4 authority
+> that should promote to kernel. Swap accepted ⇒ +1213 chars over
+> the 25k cap. Decision deferred to P2.1 ADR; current dispositions
+> below remain locked until the ADR resolves.
+
+### § 3.2 — auto-rules: compress-and-keep (22)
+
+Behavioural rules with too much Iron-Law content for migration; compress
+in place per P2.2 playbook. Loaded by router on trigger match.
+
+| id | chars | tier | rationale |
+|---|---:|---|---|
+| architecture | 2491 | 3 | Behavioural; project-organization gates |
+| artifact-drafting-protocol | 2957 | 2a | Iron-Law-shaped Understand→Research→Draft sequence |
+| augment-source-of-truth | 2439 | 1 | Behavioural Iron Law: never edit generated dirs |
+| autonomous-execution | 5631 | 3 | Trivial-vs-blocking decision; tier-1 on `balanced` |
+| context-hygiene | 3811 | 1 | Behavioural Iron Law: 3-failure stop, fresh-chat trigger |
+| downstream-changes | 2940 | 2b | Behavioural: every code edit |
+| guidelines | 4184 | 3 | Meta-rule: consult guidelines before code |
+| improve-before-implement | 3838 | 2b | Behavioural: validate before building |
+| markdown-safe-codeblocks | 535 | 2b | Already small; behavioural |
+| minimal-safe-diff | 3324 | 2a | Behavioural Iron Law: smallest change |
+| missing-tool-handling | 2633 | 2a | Behavioural Iron Law: ask, don't install silently |
+| no-attribution-footers | 1462 | 3 | Iron Law (recently trimmed); within budget |
+| no-roadmap-references | 2502 | mech | Scoped Iron Law: no stable→roadmap refs |
+| preservation-guard | 3825 | 2b | Quality gate during merges/refactors |
+| role-mode-adherence | 1682 | 2a | Behavioural: mode-marker contract |
+| runtime-safety | 1133 | 2b | Safety policy for execution metadata |
+| security-sensitive-stop | 3004 | 2a | Safety Iron Law: stop+threat-model |
+| size-enforcement | 865 | mech | Budget enforcement (ties into P5 CI gate) |
+| think-before-action | 5298 | 2b | Behavioural Iron Law: analyze first |
+| token-efficiency | 3885 | 2a | Behavioural: redirect verbose output |
+| tool-safety | 1242 | 2b | Safety: allowlist, deny-by-default |
+| user-interaction | 7657 | 3 | Numbered-options Iron Law |
+
+### § 3.3 — auto-rules: move-to-skill (18)
+
+Procedural how-to. Rule body migrates into named skill (P4.1); rule
+shrinks to Iron-Law one-liner + `routes_to:`. Skill IDs reference
+existing skills under `.agent-src.uncompressed/skills/`.
+
+| id | chars | target skill | rationale |
+|---|---:|---|---|
+| agent-docs | 2575 | `agent-docs-writing` | Procedural: how to author agent-docs |
+| analysis-skill-routing | 1325 | `analysis-skill-router` | Routing procedure |
+| capture-learnings | 2820 | `learning-to-rule-or-skill` | Capture procedure |
+| cli-output-handling | 1801 | `rtk-output-filtering` | Tool-wrapping procedure |
+| commit-conventions | 1938 | `conventional-commits-writing` | Format procedure |
+| docker-commands | 1830 | `docker` | Stack-specific procedure |
+| docs-sync | 3131 | `agent-docs-writing` | Mechanical sync procedure |
+| e2e-testing | 1807 | `e2e-heal` | Procedural; project-specific |
+| laravel-translations | 995 | `laravel` | Stack-specific |
+| model-recommendation | 2909 | `set-cost-profile` | Routing procedure |
+| onboarding-gate | 4881 | `onboard` | Mechanical: meta-rule about /onboard |
+| package-ci-checks | 1342 | `lint-skills` | Repo-specific procedure |
+| review-routing-awareness | 4220 | `review-routing` | Skill exists; large overlap |
+| reviewer-awareness | 3573 | `review-routing` | Merges with above into one skill |
+| skill-improvement-trigger | 1597 | `skill-improvement-pipeline` | Trigger procedure |
+| slash-command-routing-policy | 3218 | `command-routing` | Routing procedure |
+| ui-audit-gate | 3285 | `existing-ui-audit` | Audit procedure |
+| upstream-proposal | 2424 | `upstream-contribute` | Procedural |
+
+### § 3.4 — auto-rules: move-to-guideline (7)
+
+Reference / examples / mechanics. Body migrates into
+`docs/guidelines/<id>.md` (P4.2); rule keeps Iron Law + pointer.
+
+| id | chars | target guideline | rationale |
+|---|---:|---|---|
+| artifact-engagement-recording | 3462 | `artifact-engagement-flow` | Mechanics doc lives in `.agent-src.uncompressed/contexts/contracts/` (P4.1) |
+| augment-portability | 2956 | `augment-portability-patterns` | Project-agnostic-patterns reference |
+| command-suggestion-policy | 3954 | `command-suggestion-flow` | Flow doc already exists |
+| php-coding | 3433 | `php-coding-patterns` | Reference table; per-stack |
+| roadmap-progress-sync | 7455 | `roadmap-progress-mechanics` | Mostly mechanics + checkbox grammar |
+| rule-type-governance | 2661 | `rule-type-governance` | Reference: when always vs auto |
+| skill-quality | 5367 | `skill-quality-checklist` | Reference checklist |
+
+## § 4 — Verification
+
+| check | command | acceptance |
+|---|---|---|
+| Coverage | `python3 scripts/measure_rule_budget.py` | 56 rules total → 9 kernel + 22 compress + 18 skill + 7 guideline |
+| Determinism | `python3 scripts/measure_rule_budget.py --json` × 2 | byte-identical output |
+| No-edits | `git diff --stat .agent-src.uncompressed/rules/` | clean (this is plan-only) |
+
+## § 5 — Open questions
+
+1. **Kernel swap ADR (P2.1).** `agent-authority` ↔
+   `autonomous-execution`. See `kernel-membership.md` § 5.2 for the
+   three resolution variants; this file syncs once the ADR lands.
+2. **`reviewer-awareness` + `review-routing-awareness` merge.** Both
+   target the same skill — P4.1 must consolidate, not duplicate.
+3. **`onboarding-gate` migration shape.** The rule fires only on the
+   first turn; the migrated form must keep that trigger latch.
+   Router state-machine primitives (once / every-turn / on-mode-
+   switch) are a P3.1 deliverable dependency before P4 ships
+   (Council R2).
+4. **P4 migration shapes spec.** Per-disposition contract
+   (replace / merge / stub / disappear) for `move-to-skill` and
+   `move-to-guideline` — frontmatter handling, conflict resolution,
+   one-liner + `routes_to:` shape vs body merge. P4 deliverable
+   spec; flagged by Council R2 to prevent inconsistent implementer
+   calls.
+5. **`think-before-action` / `context-hygiene` / `augment-source-of-
+   truth` boundary.** Currently `compress-and-keep` (auto). Council
+   did not flag for promotion; revisit only if the swap ADR (#1)
+   forces a re-projection.

package/docs/contracts/rule-router.md

@@ -0,0 +1,153 @@
+---
+stability: beta
+---
+
+
+# Rule Router — Frontmatter Schema and Compiled Output
+
+Status: locked for Phase 3 of `road-to-kernel-and-router.md`.
+Owners: this contract; `scripts/compile_router.py` (Phase 3.2);
+`scripts/skill_linter.py` extension (Phase 3.3).
+
+## Why a router
+
+The kernel (9 rules, ≤ 26k chars per ADR-002) loads on every session.
+Every other rule must declare **when it activates** and **which
+artifacts (skills / guidelines) carry the body**. The router compiles
+those declarations into a deterministic lookup table that host agents
+read once at session start.
+
+Kernel rules never appear in the router — they are unconditional.
+
+## Frontmatter schema
+
+All keys live in the rule's existing YAML frontmatter. Existing fields
+(`type`, `tier`, `description`, `alwaysApply`, `source`, `load_context`)
+are preserved. New / formalized fields:
+
+| Key | Required | Values | Purpose |
+|---|---|---|---|
+| `type` | yes | `always` \| `auto` | Existing. Kernel = `always`; everything else = `auto`. |
+| `tier` | yes | `kernel` \| `tier-1` \| `tier-2` | New names. Kernel = always-loaded; tier-1 = balanced + full; tier-2 = full only. |
+| `triggers` | yes for non-kernel | list of objects | When the rule activates. **Forbidden** on kernel rules. |
+| `routes_to` | yes for non-kernel | list of strings | Skills / guidelines whose body fulfils the rule. **Forbidden** on kernel rules. |
+| `profile` | no | `minimal` \| `balanced` \| `full` | Override the tier-derived default profile. Rare; used only when a tier-2 rule must ship in `balanced`. |
+| `triggered_by` | back-ref, on routed artifact | list of strings | Skill / guideline frontmatter declares which rule(s) route to it. Bidirectional check (P3.3). |
+
+### `triggers:` shape
+
+Each item is an object with exactly one match key plus an optional
+`reason:` for the linter / docs. Match keys (any of):
+
+```yaml
+triggers:
+  - keyword: "commit"          # case-insensitive substring of user prompt
+  - phrase: "should I commit"  # case-insensitive substring, multi-word
+  - intent: "git-write"        # named intent token (router-defined vocabulary)
+  - file_pattern: "*.tf"       # glob over edited / opened paths
+  - path_prefix: "agents/"     # directory prefix over edited / opened paths
+  - command: "/commit"         # literal slash-command invocation
+```
+
+Multiple `triggers:` entries are OR-combined — any match activates the rule.
+Within one entry, only one match key is allowed. The router-defined
+intent vocabulary lives in `docs/contracts/router-intents.md` (Phase 3.2).
+
+### `routes_to:` shape
+
+Plain string list. Each entry is `<kind>:<id>`:
+
+```yaml
+routes_to:
+  - skill:php-coder
+  - guideline:agent-infra/asking-and-brevity-examples
+  - command:onboard
+  - contract:command-suggestion-flow
+```
+
+`kind` is one of `skill`, `guideline`, `command`, `contract`. `id`
+resolves to the target file under:
+
+| kind | path |
+|---|---|
+| `skill` | `.agent-src.uncompressed/skills/<id>/SKILL.md` |
+| `guideline` | `docs/guidelines/<id>.md` |
+| `command` | `.agent-src.uncompressed/commands/<id>.md` |
+| `contract` | `docs/contracts/<id>.md` |
+
+Linter checks each target exists. `command` is for procedural rules
+that route to a slash-command's source file. `contract` is for rules
+whose body is fully covered by an existing architectural contract.
+
+## Compiled output — `router.json`
+
+`scripts/compile_router.py` reads every rule frontmatter and emits
+`router.json` at the repo root, used by host agents at session start.
+Deterministic key order, sorted lists, stable across runs.
+
+```json
+{
+  "schema_version": 1,
+  "kernel": ["agent-authority", "ask-when-uncertain", "commit-policy",
+             "direct-answers", "language-and-tone", "no-cheap-questions",
+             "non-destructive-by-default", "scope-control",
+             "verify-before-complete"],
+  "tier_1": [{"id": "augment-source-of-truth",
+              "triggers": [{"path_prefix": "agents/"},
+                           {"path_prefix": ".agent-src/"}],
+              "routes_to": ["skill:agent-docs-writing"]}],
+  "tier_2": [/* same shape as tier_1 */],
+  "profiles": {
+    "minimal":  ["__kernel__"],
+    "balanced": ["__kernel__", "__tier_1__"],
+    "full":     ["__kernel__", "__tier_1__", "__tier_2__"]
+  }
+}
+```
+
+Generated alongside `marketplace.json` during `task generate-tools`.
+
+## Activation semantics
+
+The host agent reads `router.json` once per session. Per turn:
+
+1. Always evaluate kernel rules.
+2. If `profile = minimal` → stop after kernel.
+3. Otherwise, walk tier_1 (and tier_2 if `profile = full`); a rule
+   activates when **any** of its `triggers:` matches the current
+   prompt + open files + invoked command.
+4. Active rules are loaded inline; their routed artifacts (`skill:`
+   or `guideline:`) are surfaced to the agent for that turn.
+
+No runtime profile resolution — the profile is fixed at session
+start, the router lookup is keyword/phrase/path/intent matching only.
+
+## Linter contract (Phase 3.3)
+
+`scripts/skill_linter.py` extension enforces:
+
+- Every kernel rule has **no** `triggers:` and **no** `routes_to:`.
+- Every non-kernel rule has ≥ 1 `triggers:` entry and ≥ 1 `routes_to:` entry.
+- Every `routes_to:` target exists on disk.
+- Every routed skill / guideline declares `triggered_by:` listing the rule(s)
+  that route to it (bidirectional check; mirrors the existing back-ref
+  pattern in `scripts/check_references.py`).
+- `tier` and `profile` are in the allowed value sets.
+
+## Backward compatibility
+
+- The legacy `tier: "1" | "2" | "2a" | "3" | "mechanical-already"` values
+  remain readable; the compiler maps them to `kernel` / `tier-1` / `tier-2`
+  as locked in `kernel-membership.md` § 4 (status-quo bucket model).
+- Rules without `triggers:` keep firing under their current `description`-
+  matching behaviour until P4.x migrations land — the linter only enforces
+  presence; activation falls back to `description` for unmigrated rules.
+- The router is **additive** to the existing always/auto split; no
+  existing rule changes behaviour until its frontmatter is migrated.
+
+## Source-of-truth
+
+- This file: schema specification.
+- `kernel-membership.md` § 4: kernel locked count + SHAs.
+- `rule-classification.md`: per-rule tier + disposition pre-Phase-4.
+- `router.json` (generated): runtime artifact, never hand-edited.

package/docs/customization.md

@@ -78,12 +78,23 @@ drift.
 
 ### Cost profiles
 
-| Profile | Description |
-|---|---|
-| `minimal` | Rules, skills, and commands only. **Includes the learning loop.** Default. |
-| `balanced` | `minimal` + Runtime dispatcher for skills that declare a shell command. |
-| `full` | `balanced` + Tool adapters (GitHub / Jira, read-only, opt-in). |
-| `custom` | Ignore profile — every matrix value must be set explicitly. |
+`cost_profile` is the master switch for rule-tier loading. The kernel
+(always-loaded Iron-Law floor, ≤ 26k chars across 9 rules) ships in every
+profile. Tier-1 and tier-2 rules are gated by profile and resolved at
+session start from `router.json` (compiled by `scripts/compile_router.py`).
+
+| Profile | Rule tiers loaded | Token footprint | Best for |
+|---|---|---|---|
+| `minimal` | kernel only (no router, no auto-rules) | lowest | Cost-sensitive sessions; trivial Q&A; CI runs |
+| `balanced` | kernel + tier-1 auto-rules (default) | medium | Day-to-day work — current behaviour superset |
+| `full` | kernel + tier-1 + tier-2 (everything) | highest | Agent-config development; full rule fidelity |
+| `custom` | profile ignored — every matrix value must be set explicitly | varies | Power users with bespoke rule sets |
+
+The kernel-and-router architecture is documented in
+[`docs/contracts/rule-router.md`](contracts/rule-router.md) and
+[`docs/contracts/kernel-membership.md`](contracts/kernel-membership.md).
+Tier flags live in each rule's frontmatter (`tier: kernel | tier-1 | tier-2`);
+the router compiles them into `router.json` deterministically.
 
 All profiles except `custom` ship with `pipelines.skill_improvement: true`,
 so the agent captures learnings after meaningful tasks by default. Set it

package/docs/decisions/ADR-001-kernel-swap-deferred.md

@@ -0,0 +1,109 @@
+---
+adr: 001
+status: accepted
+date: 2026-05-06
+decision: kernel-swap-deferred
+supersedes: —
+superseded_by: —
+phase: road-to-kernel-and-router · P2.1
+---
+
+# ADR-001 — Kernel-Set Swap Deferred (variant a)
+
+## Status
+
+**Accepted** · 2026-05-06.
+
+## Context
+
+Phase 1.4 of `road-to-kernel-and-router` ran an AI Council
+cross-check (Sonnet 4.5 + GPT-4o) against the locked 9-rule kernel
+set in `docs/contracts/kernel-membership.md` § 4. Sonnet flagged that
+`agent-authority` carries **no Iron-Law fence** — it is a routing
+index dispatching to four other kernel rules (`non-destructive-by-default`,
+`scope-control`, `commit-policy`, `autonomous-execution`) by Band.
+Sonnet proposed swapping `agent-authority` out of the kernel and
+promoting `autonomous-execution` in. Three resolution variants
+landed in `kernel-membership.md` § 5.2:
+
+| variant | sum-projected (× 0.712) | bucket budget | Iron-Law-override ADRs |
+|---|---:|---|---|
+| (a) status quo (current § 4) | 23 071 | ✓ ≤ 25k | 2 (`direct-answers`, `language-and-tone`) |
+| (b) swap, raise hard cap to 27k | 26 213 | ✓ ≤ 27k | 3 (+`autonomous-execution`) |
+| (c) swap + demote `verify-before-complete` | 24 545 | ✓ ≤ 25k | 3 (+`autonomous-execution`) |
+
+## Decision
+
+**Variant (a) — status quo through P2.2 + P3.1.**
+
+- Keep `agent-authority` in the kernel.
+- Keep `autonomous-execution` in `compress-and-keep` (auto-tier) per
+  `docs/contracts/rule-classification.md` § 3.2.
+- Re-evaluate the swap as a P3.2 ADR after the router schema and
+  compiler ship.
+
+## Consequences
+
+### Accepted
+
+- 25k hard cap stays intact (no governance erosion via cap-raise).
+- 2 Iron-Law-override ADRs land in P2.2 if post-compression
+  measurement confirms overage (`direct-answers`, `language-and-tone`).
+- The 9-rule set carried into P2.2 is the locked § 4 list.
+
+### Trade-offs
+
+- Sonnet's Iron-Law-purity critique stands: `agent-authority`
+  remains in the kernel without a fence of its own. Mitigation —
+  the rule **mechanically depends** on four other kernel rules
+  (every Band redirects), so its kernel residency is structurally
+  load-bearing even if not syntactically Iron Law. Treated as a
+  routing primitive that dispatches to Iron Laws, not a rule in
+  parallel to them.
+- `autonomous-execution` (5631 chars current, ~4009 projected)
+  remains in auto-tier. Behaviour preserved because the rule
+  already declares `type: auto` and ships under the `balanced` and
+  `full` cost profiles by default.
+
+## Re-evaluation trigger
+
+Phase 3 (`docs/contracts/rule-router.md`) introduces a
+`tier:` / `band:` / `priority:` schema in rule frontmatter. Once
+that schema is locked in P3.1 and the compiler is wired in P3.2,
+`agent-authority` becomes redundant: each kernel rule carries its
+own band as frontmatter, and the compiled `router.json` resolves
+precedence at build time. At that point:
+
+- `agent-authority` migrates to a guideline
+  (`docs/guidelines/agent-authority.md`) as documentation of the
+  band model.
+- `autonomous-execution` can be promoted into the kernel under a
+  new ADR (ADR-N) that replaces this one, *if* its post-compression
+  size fits the cap with no further demotion.
+
+This deferral is **not** indefinite: P3.2 ships the router compiler;
+the swap re-evaluation ADR is mandatory before P4.1 (rule → skill
+migrations) so the migration plan reflects the final kernel set.
+
+## Alternatives considered
+
+- **Variant (b) — swap + raise cap to 27k.** Rejected. Raising the
+  hard cap mid-roadmap weakens the original 25k contract that the
+  whole roadmap is built around. If 27k turns out to be the real
+  ceiling, that is a separate ADR after compression measurement
+  proves the band, not a pre-emptive concession.
+- **Variant (c) — swap + demote `verify-before-complete`.**
+  Rejected. `verify-before-complete` carries criterion #1 (Iron
+  Law) and gates completion-claims across every reply. Demoting it
+  to auto-tier removes the floor that prevents the agent from
+  claiming "done" without fresh evidence — a behavioural regression
+  that the golden-transcript suite would catch but that no other
+  kernel rule replaces.
+
+## References
+
+- `docs/contracts/kernel-membership.md` § 4, § 5.2
+- `agents/council-sessions/20260506T044941Z-phase1-cross-check-r2.json` <!-- council-ref-allowed: ADR decision trace -->
+- `agents/roadmaps/road-to-kernel-and-router.md` § Decisions, § Phase 2
+- `.agent-src.uncompressed/rules/agent-authority.md` (subject)
+- `.agent-src.uncompressed/rules/autonomous-execution.md` (proposed promotion)

package/docs/decisions/ADR-002-kernel-bucket-overrides.md

@@ -0,0 +1,124 @@
+# ADR-002 — Kernel-Bucket Cap Raise (25k → 26k) and Per-Rule Iron-Law Overrides
+
+- **Status:** Accepted (2026-05-06)
+- **Phase:** Road to Rule Kernel and Router · P2.2 (Heavy Compression)
+- **Supersedes:** none — extends the Council R2 amendments locked in
+  `docs/contracts/kernel-membership.md` § 5.1 (median r=0.712, per-rule cap 2.5k,
+  kernel-bucket 25k).
+- **Related:** ADR-001 (kernel-swap deferred); Council R2 cross-check session
+  `agents/council-sessions/20260506T044941Z-phase1-cross-check-r2.json`. <!-- council-ref-allowed: ADR decision trace -->
+
+## Context
+
+P1.3 projected the post-compression kernel bucket at **23 071 chars** using
+the median pilot ratio r=0.712 (3 pilots: agent-authority, direct-answers,
+language-and-tone). Pilot rules were **short to medium** (1.0k–2.5k baseline).
+
+P2.2 applied the same compression discipline to the remaining 6 kernel rules
+(ask-when-uncertain, commit-policy, no-cheap-questions,
+non-destructive-by-default, scope-control, plus the verify-before-complete
+auto-tier rule kept by ADR-001). Iron-Law SHA preservation verified for
+all 8 rules with Iron-Law fences (`scripts/iron_law_sha.py`).
+
+**Empirical post-compression measurements (2026-05-06):**
+
+| metric | projected | actual |
+|---|---:|---:|
+| kernel bucket sum | 23 071 | **25 590** |
+| compression ratio r (kernel-wide) | 0.712 (median pilot) | **0.795** |
+| rules > 2.5k cap | 2 (pilots) | 6 |
+| rules > 4.0k ceiling | 0 | 0 |
+
+The actual ratio (0.795) is worse than the pilot median (0.712) because
+**longer rules compress less efficiently than short ones**: each Iron-Law
+rule has a fixed payload of frontmatter, Iron-Law fence, exception
+enumeration, see-also list — shrinkage is bounded by what cannot leave
+the rule without breaking the rule's contract. The 5 longest source rules
+(non-destructive-by-default, scope-control, no-cheap-questions,
+ask-when-uncertain, language-and-tone) each kept multiple
+non-externalisable structural elements (Iron-Law fence + trigger
+enumeration + pre-send self-check + decline/fence semantics).
+
+## Decision
+
+1. **Raise KERNEL_HARD from 25 000 → 26 000 chars** in
+   `scripts/measure_rule_budget.py`. KERNEL_TARGET stays at 20 000.
+   This accommodates the empirical 25 590 with ~410 chars headroom for
+   future minor edits (typo fixes, link updates, frontmatter tweaks)
+   without re-tripping the gate.
+
+2. **Add the following 6 kernel rules to `docs/contracts/iron-law-overrides.txt`**
+   with this ADR as their justification. All sit between 2.5k and 4.0k
+   (the override ceiling):
+
+   | rule | chars | + over 2.5k | < 4.0k ceiling |
+   |---|---:|---:|---|
+   | `language-and-tone` | 3 602 | +1 102 | ✓ |
+   | `scope-control` | 3 641 | +1 141 | ✓ |
+   | `non-destructive-by-default` | 3 420 | +920 | ✓ |
+   | `no-cheap-questions` | 3 238 | +738 | ✓ |
+   | `ask-when-uncertain` | 3 130 | +630 | ✓ |
+   | `direct-answers` | 2 841 | +341 | ✓ |
+
+3. **Cap stays sticky.** Future kernel additions or rule-body growth must
+   either (a) compress within the 26k bucket, (b) externalise to a
+   `contexts/authority/*` companion, or (c) require a follow-up ADR.
+
+## Rationale
+
+Each over-cap rule defends a **distinct Iron Law fence** that loses meaning
+if split. Externalising the enumeration to a context file would force the
+agent to load the context every time the Iron Law applies (i.e. always),
+defeating the kernel-vs-auto split that motivates the budget in the first
+place.
+
+- `non-destructive-by-default` and `scope-control` carry the **Hard Floor**
+  trigger table (prod-trunk merge, deploy, push, prod data/infra, bulk
+  deletion) and the per-row example column. Splitting the table breaks
+  matching at decision time.
+- `no-cheap-questions` carries the **8-class cheap-question catalog** plus
+  a 6-step Pre-Send Self-Check that must be evaluated before every
+  numbered-options block — this is the gate, not a footnote.
+- `ask-when-uncertain` carries the **vague-request trigger list** (9 user
+  phrasings the agent must recognise without scrolling to a context file).
+- `language-and-tone` carries the **pre-send language gate** for every
+  reply token (prose, headings, table cells, inter-tool commentary,
+  Recommendation: vs Empfehlung: label) — splitting loses the exhaustive
+  catalog the agent matches against.
+- `direct-answers` carries **3 Iron Laws** (no flattery, no invented facts,
+  brevity by default) plus the severity-tiered claim table — already the
+  most condensed form of these obligations.
+
+The `commit-policy` rule was trimmed below 2.5k (2 354 chars) by removing
+a redundant cross-reference line, demonstrating that aggressive trimming
+is possible where the rule does not carry an enumeration. The 6 overrides
+are the rules where further compression would force semantic loss.
+
+## Consequences
+
+- **Pro:** Iron-Law fidelity preserved — every fence still byte-identical
+  to baseline (verified by `iron_law_sha.py --all-kernel`).
+- **Pro:** Empirical compression r=0.795 documented; future kernel work
+  uses this as the realistic ratio (not 0.712, which was a pilot-skewed
+  optimum).
+- **Pro:** Override ceiling (4 000) untouched — no rule grows
+  unboundedly; the 4k cap remains the next checkpoint.
+- **Con:** 25 590 / 26 000 = 98.4 % bucket utilisation. Adding any
+  10th kernel rule would require either compression of an existing rule
+  or a further cap raise.
+- **Con:** ratio 0.795 means future "always" promotions cost more than
+  Phase 1 estimated. Phase 4 token-budget measurements should treat
+  0.795 as the reference compression rate.
+
+## Rollback
+
+If Phase 4 token measurements show that the kernel adds > 10 % to the
+agent's per-turn token cost (`docs/contracts/kernel-membership.md` § 6
+abort criteria), revisit:
+
+1. Demote `verify-before-complete` from kernel to auto (saves 2 344 chars,
+   bucket → 23 246, falls back inside 25k).
+2. Or split `scope-control` into git-ops and decline/fence halves —
+   git-ops stays kernel, decline/fence becomes auto-tier.
+
+Both moves are reversible; this ADR does not lock either out.