@event4u/agent-config 1.15.0 → 1.17.0

package/docs/contracts/file-ownership-matrix.md

@@ -0,0 +1,134 @@
+---
+stability: beta
+---
+
+# File-ownership matrix
+
+> **Audience:** roadmap authors, phase reviewers, and CI gate writers
+> who need to know which artefact reads which, and whether two phases
+> can run concurrently without colliding.
+> **Generator:** `scripts/generate_ownership_matrix.py`
+> (run via `task generate-ownership-matrix`).
+> **Validator:** `task check-ownership-matrix` (fails if the JSON drifts
+> from a fresh regeneration).
+> **Companion contracts:** [`load-context-schema.md`](load-context-schema.md),
+> [`context-paths.md`](context-paths.md).
+
+This contract defines the **schema** of the file-ownership matrix: the
+machine-readable JSON at `docs/contracts/file-ownership-matrix.json` and
+the human-readable mirror at
+`agents/contexts/structural/file-ownership-matrix.md`. Both are
+regenerated from `.agent-src.uncompressed/` by the generator and locked
+by CI.
+
+**Status:** internal-locked (`stability: beta`). Schema bumps require a
+contract version increment plus a roadmap revision (per
+`road-to-structural-optimization.md` § 0.1).
+
+## Why the matrix exists
+
+`road-to-structural-optimization` Phase 0.1 (CRITICAL) is the DAG
+successor of Phase 0.6 (path conventions). Subsequent phases (1, 2A,
+2B, 3, 6) extract material into context files, slim rules, and reorder
+command surface. The matrix is the substrate that lets later phases
+ask three questions deterministically:
+
+1. **Which files does my edit reach transitively?** Answered by the
+   `READ_ONLY` edges plus their depth-2 closure.
+2. **Can Phase X and Phase Y land in either order?** Answered by
+   intersecting per-phase `WRITE` sets — empty intersection = safe.
+3. **Has the matrix drifted since the last green CI run?** Answered by
+   the `check-ownership-matrix` consistency gate.
+
+## Schema (v1)
+
+The JSON document is a single object:
+
+```json
+{
+  "version": 1,
+  "generated_by": "scripts/generate_ownership_matrix.py",
+  "source_of_truth": ".agent-src.uncompressed/",
+  "files": {
+    "<repo-root-relative path>": {
+      "kind": "rule | skill | command | context | persona",
+      "rule_type": "always | auto | manual | null",
+      "load_context": ["<path>", ...],
+      "load_context_eager": ["<path>", ...]
+    }
+  },
+  "edges": [
+    {
+      "source": "<path>",
+      "target": "<path>",
+      "type": "READ_ONLY | WRITE | BLOCKS_IF_CONCURRENT",
+      "via": "load_context | load_context_eager | load_context_transitive | body_link",
+      "depth": 1
+    }
+  ]
+}
+```
+
+**Edge types**
+
+| Type | Meaning | Populated in v1 |
+|---|---|:-:|
+| `READ_ONLY` | Source file reads target (frontmatter declaration or body markdown link). | ✅ |
+| `WRITE` | Source file owns target. Self-edge for every file (`source == target`). | ✅ |
+| `BLOCKS_IF_CONCURRENT` | Two phases would write the same file. Derived later from a phase manifest; reserved in v1. | ⏳ |
+
+**Edge `via` values**
+
+- `load_context` — frontmatter `load_context:` entry (lazy).
+- `load_context_eager` — frontmatter `load_context_eager:` entry.
+- `load_context_transitive` — depth-2 hop reached by following a target's own
+  `load_context*` declarations one level deeper.
+- `body_link` — markdown link in body to a path inside one of the
+  scanned roots.
+
+## Depth invariant (G2 — v3.1)
+
+The generator computes the transitive closure of `load_context` /
+`load_context_eager` edges **up to depth 2**. Any chain
+`R → A → B → C` where every hop is a `load_context*` edge **fails the
+build** with exit code 2. This duplicates the same nesting cap that
+Phase 0.2.4 will enforce in `scripts/check_always_budget.py` — two
+enforcement points, one invariant.
+
+## Regeneration policy
+
+| Trigger | What runs | What fails |
+|---|---|---|
+| `task generate-ownership-matrix` | Regenerates JSON + MD in place. | Depth-3 chain → exit 2. |
+| `task check-ownership-matrix` (CI) | Regenerates to memory, diffs against committed JSON. | Diff non-empty → exit 1. Depth-3 → exit 2. |
+| Pre-commit hook (Phase 2A — A1 fix) | Future: regenerate and diff on commits that touch contexts. | Same as `check-ownership-matrix`. |
+
+Any commit that adds, moves, or modifies a context, rule, skill, or
+command MUST regenerate the matrix in the same commit. CI is the
+backstop; the consistency gate fails if regeneration drifts.
+
+## Scope notes (v1)
+
+- **Greppable surface:** `rules/`, `skills/`, `commands/`, `contexts/`,
+  `personas/` under `.agent-src.uncompressed/`. Generated tool
+  projections (`.augment/`, `.claude/`, `.cursor/`, …) are intentionally
+  ignored — they are downstream of the source of truth.
+- **`skill:` frontmatter in rules** (named in roadmap 0.1.2) is reserved.
+  No rules currently declare it; the generator scans for it but emits
+  zero edges of that kind in v1.
+- **Body link parser** is conservative: it only recognises markdown
+  link targets ending in `.md` whose path resolves under one of the
+  scanned roots. Bare backtick-name references (e.g., `` `skill-quality` ``)
+  are **not** edges in v1; they are too ambiguous to attribute.
+- **Cycles** are not the matrix's concern — the existing
+  `lint_load_context.py` rejects them. The matrix generator follows
+  edges with a visited-set so a cycle, if one slipped through, cannot
+  loop forever; it would surface as a depth-3 abort.
+
+## Versioning
+
+`version: 1` is the initial lock. Schema-breaking changes (renaming a
+field, removing an edge type, changing semantics of an existing
+`via`) require a version bump and a roadmap revision. Additive changes
+(new `via` values, new optional file fields) MAY land at the current
+version with a `CHANGELOG.md` entry under `### Beta`.

package/docs/contracts/implement-ticket-flow.md

@@ -4,10 +4,9 @@ stability: beta
 
 # `/implement-ticket` — Flow Contract
 
-> Technical contracts for the delivery orchestrator shipped under
-> [`road-to-implement-ticket.md`](../../agents/roadmaps/road-to-implement-ticket.md).
-> This document is the stable reference; the roadmap tracks phased
-> delivery.
+> Technical contracts for the `/implement-ticket` delivery orchestrator.
+> This document is the stable reference for engine boundaries, state
+> schema, and replay protocol.
 >
 > - **Created:** 2026-04-22
 > - **Status:** Phase 1 shipped 2026-04-23 — `DeliveryState` +
@@ -133,9 +132,9 @@ against actual engine output rather than synthetic fixtures.
 Prompt envelopes (`input.kind="prompt"`) carry a free-form goal
 instead of a refined ticket. The `refine` step routes on shape
 (presence of `raw` key) and on the first pass emits an
-`@agent-directive: refine-prompt` halt — the agent runs the
-matching skill, which reconstructs `acceptance_criteria` +
-`assumptions`. On the rebound, `scoring/confidence.py` produces a
+`@agent-directive: refine-prompt` halt — the host agent is
+instructed to run the matching skill, which reconstructs
+`acceptance_criteria` + `assumptions`. On the rebound, `scoring/confidence.py` produces a
 frozen `ConfidenceScore(band, score, dimensions, reasons,
 ui_intent)` and the dispatcher branches on `band`:
 
@@ -281,7 +280,7 @@ via `resolve_policy()` in
 [`persona_policy.py`](../../.agent-src.uncompressed/templates/scripts/implement_ticket/persona_policy.py).
 Policies live alongside the dispatcher so the flow can consume
 them directly; the shared
-[`role-contracts`](../../.agent-src.uncompressed/guidelines/agent-infra/role-contracts.md)
+[`role-contracts`](../../docs/guidelines/agent-infra/role-contracts.md)
 guideline remains the source of truth for persona behaviour in the
 wider agent surface.
 
@@ -616,13 +615,11 @@ are blocked by `freeze-guard.yml::manifest-integrity` at PR time.
 
 ## See also
 
-- [`agents/roadmaps/road-to-implement-ticket.md`](../../agents/roadmaps/road-to-implement-ticket.md)
-- [`agents/roadmaps/road-to-universal-execution-engine.md`](../../agents/roadmaps/road-to-universal-execution-engine.md)
 - `tests/golden/` — capture sandbox, recipes, and Capture Packs
 - [`../../tests/golden/harness.py`](../../tests/golden/harness.py) — Strict-Verb replay harness
 - [`../../.github/workflows/freeze-guard.yml`](../../.github/workflows/freeze-guard.yml) — manifest-integrity + live-replay gates
 - [`agent-memory-contract.md`](agent-memory-contract.md)
-- [`../../.agent-src.uncompressed/guidelines/agent-infra/role-contracts.md`](../../.agent-src.uncompressed/guidelines/agent-infra/role-contracts.md)
+- [`../../docs/guidelines/agent-infra/role-contracts.md`](../../docs/guidelines/agent-infra/role-contracts.md)
 - [`../../.agent-src.uncompressed/rules/user-interaction.md`](../../.agent-src.uncompressed/rules/user-interaction.md)
 - [`../../.agent-src.uncompressed/rules/scope-control.md`](../../.agent-src.uncompressed/rules/scope-control.md)
 - [`../../.agent-src.uncompressed/rules/minimal-safe-diff.md`](../../.agent-src.uncompressed/rules/minimal-safe-diff.md)

package/docs/contracts/linear-ai-rules-inclusion.md

@@ -4,7 +4,6 @@ stability: beta
 
 # Linear AI — rules inclusion list
 
-> Phase 3 Step 1 deliverable for [`road-to-universal-distribution.md`](../../agents/roadmaps/road-to-universal-distribution.md).
 > Per-rule decision for the Linear AI rules digest. The digest is a
 > Markdown blob the user pastes into Linear's `Settings → Agents →
 > Additional guidance` (workspace / team / personal). The third-party
@@ -101,7 +100,7 @@ These reference Augment-only mechanics — model identity in Augment's
 system prompt, Augment's `/slash` command surface, and the Augment
 onboarding flow gated by `.agent-settings.yml`.
 
-`model-recommendation`, `onboarding-gate`, `slash-commands`.
+`model-recommendation`, `onboarding-gate`, `slash-command-routing-policy`.
 
 ### Skill-routing only (1)
 

package/docs/contracts/linear-ai-three-layers.md

@@ -4,7 +4,6 @@ stability: beta
 
 # Linear AI — three-layer split rationale
 
-> Phase 3 Step 3 deliverable for [`road-to-universal-distribution.md`](../../agents/roadmaps/road-to-universal-distribution.md).
 > Per-rule routing is in [`linear-ai-rules-inclusion.md`](linear-ai-rules-inclusion.md);
 > this file documents *why* the split is workspace / team / personal and
 > what belongs in each.
@@ -128,4 +127,3 @@ does not maintain `event4u/agent-config`.
 - Per-rule decision: [`linear-ai-rules-inclusion.md`](linear-ai-rules-inclusion.md)
 - Builder script: [`scripts/build_linear_digest.py`](../../scripts/build_linear_digest.py)
 - Generated digests: `dist/linear/{workspace,team,personal}.md` (gitignored)
-- Roadmap: [`road-to-universal-distribution.md`](../../agents/roadmaps/road-to-universal-distribution.md) Phase 3

package/docs/contracts/load-context-budget-model.md

@@ -0,0 +1,178 @@
+---
+stability: beta
+---
+
+# `load_context:` Budget Accounting Model
+
+> **Audience:** maintainers of `type: "always"` rules and the budget
+> linter who need a single, deterministic answer to "how many chars
+> does this rule cost the always-budget?".
+> **Linter:** `scripts/check_always_budget.py`
+> (run via `task check-always-budget`).
+> **Companion:** [`load-context-schema.md`](load-context-schema.md) —
+> frontmatter contract for citing a context from a rule.
+> [`STABILITY.md § Budget contracts`](STABILITY.md#budget-contracts) —
+> the numeric caps this model enforces.
+
+This contract locks the **accounting model** by which a `type: "always"`
+rule's `load_context:` declarations contribute to the always-rule
+budget. It resolves the "is the rule its file size or its file size
+plus everything it loads?" ambiguity surfaced by Round-2 council on
+`road-to-structural-optimization` (Finding 7, CRITICAL).
+
+**Status:** internal-locked. Changes require a contract version bump
+and a roadmap revision (per
+`road-to-structural-optimization.md` § Definitions). The 2 % tolerance
+band on the retroactive test (G3 in v3.1) is the only legal way to
+adjust the model parameters without a roadmap revision; an overshoot
+above the band rejects the model and escalates to the council.
+
+## The locked model — Model (b) literal
+
+For any rule with frontmatter `type: "always"`:
+
+```
+EffectiveSize(rule) = RawSize(rule)
+                    + Σ RawSize(c) for every c in transitive_closure(rule.load_context*)
+```
+
+Where:
+
+- `load_context*` is the union of `load_context:` (lazy) **and**
+  `load_context_eager:` entries declared in frontmatter
+  (per [`load-context-schema.md`](load-context-schema.md)).
+- `transitive_closure` walks `load_context:` declarations on
+  context files **up to depth 2** — see § Nesting cap below.
+- `RawSize` is the byte size of the compressed file
+  (`.agent-src/...`), measured by `os.path.getsize()`. The
+  uncompressed source paths in frontmatter are mapped to their
+  compressed counterparts before sizing.
+- A context loaded by N always-rules counts **N times** (once per
+  loading rule). Rationale: the always-budget protects context-window
+  utilization at activation time; if rule A and rule B both fire on
+  the same turn, the agent pays both costs.
+
+### Why model (b) and not (a) or (c)
+
+| Model | Definition | Why rejected |
+|---|---|---|
+| (a) rule chars only | `EffectiveSize = RawSize(rule)` | Ignores the cost of declared contexts. Phase-2A obligation extraction would *appear* free, allowing unbounded context bloat. |
+| (b) literal *(this contract)* | `EffectiveSize = RawSize(rule) + Σ contexts` | Simplest invariant. Aligns with how the agent actually pays the cost when both rule and context fire on a turn. |
+| (c) shared-divisor | `EffectiveSize = RawSize(rule) + Σ (RawSize(c) / N_loaders)` | Tempting for shared `commit-mechanics`-style contexts but breaks the "what does each rule cost in isolation" question. Reserved as the **first refinement step** if the 2 % tolerance band is exceeded. |
+
+Council Round 3 converged A/A/A on the **separate-skills + shared-context**
+extraction pattern (Q1) and the **one-rule + three-contexts** consolidation
+(Q2); model (b) literal is the accounting that makes both patterns
+honest about their cost.
+
+## Nesting cap — depth 2
+
+A rule's `load_context:` may cite a context (depth 1). A context may
+cite further contexts in its own frontmatter (depth 2). A depth-2
+context citing a third context (depth 3) **aborts the build**.
+
+Rationale: bounded recursion makes the linter terminate in O(N) and
+prevents accidental cycles. Council Round-2 finding 9 (HIGH).
+
+The check is enforced by `scripts/check_always_budget.py` as a
+separate exit-code-1 condition (independent of the budget caps), so
+that a depth violation surfaces with the violating chain, not as a
+budget-cap breach.
+
+## Known-breach allowlist (transitional)
+
+Phase 2A targets `non-destructive-by-default` and `scope-control`
+for slimming. Both rules currently exceed the **6,000-char per-rule
+cap** under model (b) literal — this is expected and intentional:
+Phase 0.2 lands the model and its measurement; Phase 2A brings the
+breaches under the cap.
+
+To keep CI green during the transition, the linter and the test
+suite carry an explicit `KNOWN_PER_RULE_BREACHES` allowlist with the
+**measured ceiling** for each entry. Each entry must:
+
+- Be referenced by the Phase 2A roadmap step that will retire it.
+- Have a documented expected-removal date or roadmap milestone.
+- Fail the build the moment the breach **grows** above the recorded
+  ceiling (regression guard).
+
+Phase 2A's success criterion (`budget delta ≥ −5 %`) is the trigger
+to remove entries from the allowlist. The allowlist must be **empty**
+before Phase 2A is marked complete.
+
+## Retroactive test result (Phase 0.2.3)
+
+PR #34's `autonomous-execution` split moved mechanics into three
+contexts under `contexts/execution/`. Re-measuring under model (b)
+literal:
+
+| Metric | Value | Cap | Utilization |
+|---|---:|---:|---:|
+| Total extended budget | 49,311 chars | 49,000 | **100.6 %** |
+| Top-3 extended | 22,248 chars | 24,500 | 90.8 % |
+| Per-rule breaches | 2 of 9 | 0 | `non-destructive-by-default` (7,887), `scope-control` (8,529) |
+
+The total sits **0.6 % over** the cap — within the 2 % tolerance band
+(G3) which permits parameter refinement before model rejection. Per
+the contract, the model is **accepted**; the per-rule breaches are
+recorded in the transitional allowlist for Phase 2A.
+
+`autonomous-execution` itself is `type: "auto"` and does not enter
+the always-budget. Its own extended size (rule 5,196 + three contexts
+8,453) = 13,649 chars is reported by the linter for Phase 2B
+diagnostics but does not gate the always-budget cap.
+
+## Linter contract
+
+`scripts/check_always_budget.py` enforces:
+
+1. `EffectiveSize` per always-rule against the per-rule cap (with
+   the transitional allowlist).
+2. Sum of `EffectiveSize` across all always-rules against the total
+   cap (warn at 80 %, fail at ≥ 90 % — unchanged from PR #34).
+3. Top-3 sum against the top-3 cap.
+4. Depth ≤ 2 on every `load_context:` chain reachable from an
+   always-rule.
+
+### Recovery band (Phase 2A → Phase 5 transitional)
+
+Locked by AI Council session `2026-05-03T12-02-42Z` (verdict A1)
+after Phase 2A was attempted and reverted: the 1:1 rule-to-context
+split was uneconomical under Model (b) literal because the
+frontmatter and citation-line tax on the new context file outweighed
+the chars removed from the rule. Reverting Phase 2A left the budget
+at 96.8 % — strictly better than the `main` baseline at 100.6 % but
+inside the 90–100 % gap zone the linter rejects.
+
+While `RECOVERY_BAND_ENABLED = True`, the linter accepts a branch in
+the gap zone iff:
+
+- `total_ext < baseline` (read from `.github/budget-baseline.txt`,
+  the chars at last-green `main`), AND
+- every per-rule cap holds (allowlisted entries unchanged), AND
+- top-3 cap holds, AND
+- depth-2 cap holds.
+
+A branch passing only the recovery band reports
+`⚠️  WARN (recovery band, baseline N)`. The band is a one-way ratchet:
+once a smaller branch lands on `main`, the baseline file must be
+updated to the new total in the same commit. Phase 5 of
+`road-to-structural-optimization` flips `RECOVERY_BAND_ENABLED` to
+`False` and removes both the band and the G3 tolerance — the gate
+collapses to `total < TOTAL_CAP` strict.
+
+Exit codes: 0 = pass (or warn, including recovery band), 1 = any cap
+breach or depth violation, 3 = internal error.
+
+## What this contract intentionally does **not** promise
+
+- **No claim about runtime cost.** The model treats every context
+  as if it were active when its rule fires. The agent may cache or
+  short-circuit lazy loads at runtime; the budget is the **upper
+  bound**, not the realised cost.
+- **No claim about `type: "auto"` rules.** Auto rules enter the
+  agent's context only when their description matches; they have
+  their own per-rule LOC targets in Phase 2B (not a global budget).
+- **No claim about commands or skills.** Commands and skills load
+  on user invocation. Their token cost is accounted by the
+  command-cluster and skill-family contracts, not here.

package/docs/contracts/load-context-schema.md

@@ -0,0 +1,184 @@
+---
+stability: beta
+---
+
+# `load_context:` Frontmatter Schema
+
+> **Audience:** rule authors and reviewers who want to keep an Always-rule
+> small while making deeper reasoning available on demand.
+> **Linter:** `scripts/lint_load_context.py` (run via `task lint-load-context`).
+> **Companion:** [`rule-priority-hierarchy.md`](rule-priority-hierarchy.md) —
+> hierarchy that decides *which* rule wins when several fire on the same turn.
+
+This contract defines the frontmatter convention by which a rule (or
+another context) declares the deeper reading material it relies on.
+The convention is **lazy by default**: declared entries are *available
+to load* when the situation demands them, never auto-loaded into every
+turn.
+
+## Schema
+
+Two keys, both optional, both top-level frontmatter:
+
+```yaml
+---
+type: "always"
+description: "..."
+load_context:                # lazy — on-demand reference list
+  - .agent-src.uncompressed/contexts/<file>.md
+  - agents/contexts/<file>.md
+load_context_eager:          # opt-in eager — auto-loaded on rule fire
+  - .agent-src.uncompressed/contexts/<file>.md
+---
+```
+
+| Key | Loading | When to use |
+|---|---|---|
+| `load_context:` | **Lazy.** The agent reads the entry only when the rule's reasoning needs it. | Default. Use for everything that is "available knowledge" rather than "on every turn". |
+| `load_context_eager:` | **Eager.** The entry is concatenated into the active context whenever the rule fires. | Only when the deeper material is needed *every single time* the rule fires. Counts against the combined char budget. |
+
+**No default eager-load.** A rule with `load_context:` only does **not**
+auto-load anything; the agent decides per turn. Eager loading is
+opt-in and budget-gated.
+
+## Path rules
+
+- Paths are repo-root relative.
+- Paths MUST end in `.md`.
+- Allowed roots: `.agent-src.uncompressed/contexts/`, `agents/contexts/`,
+  `.agent-src/contexts/` (compressed mirror). Any other root → linter
+  error.
+- A rule MAY reference contexts under either tree, but a
+  `.agent-src.uncompressed/` rule SHOULD NOT eager-load an
+  `agents/contexts/` file (project-local leak into shared package).
+  Linter warns on this combination.
+- A context file may itself declare `load_context:` (chain reasoning).
+  The linter rejects cycles.
+
+## Subdirectory conventions
+
+Subdirectories under `contexts/` are **conventional, not enforced**.
+The linter only validates the root prefix; subdirectory layout is a
+documentation contract for human reviewers.
+
+Two canonical subdirectories are in production:
+
+| Subdir | Holds | First consumer |
+|---|---|---|
+| `contexts/execution/` | runtime decision logic, mechanics, and examples for execution-time rules (autonomy detection, verification mechanics, etc.) | `autonomous-execution` (Phase 2 of `road-to-pr-34-followups`) |
+| `contexts/authority/` | mechanics behind authority gates — what makes commits, scope changes, and git ops legal vs. illegal | `commit-policy` and `scope-control` (Phase 6 of `road-to-pr-34-followups`) |
+
+A third subdirectory, `contexts/communication/`, was proposed by the
+PR #34 round-6 review for user-interaction and language-and-tone
+mechanics. It is **not yet created** — the anti-speculation guard in
+Phase 6 forbids creating a context root before its triggering rule
+exists. Add it the same turn as the first migrating rule, not before.
+
+A new subdirectory is justified when:
+
+- A second rule needs to share contexts with the first one, AND
+- The contexts have a coherent topic (execution, authority, communication, …), AND
+- The triggering rule and its content move at the same time
+  (no empty subdir reservations).
+
+Single-rule contexts that don't fit one of the canonical topics live
+directly under `contexts/` (see `contexts/model-recommendations.md`,
+`contexts/skills-and-commands.md`).
+
+## Combined char-budget guard
+
+`load_context_eager:` triggers a budget check:
+
+```
+chars(rule.md) + sum(chars(eager_target.md) for each entry) ≤ rule_cap
+```
+
+`rule_cap` is the per-rule budget:
+
+- Always rule: 2,500
+- Auto rule: 4,000
+- Safety rule (`type: "always"` AND covers Hard-Floor topics): 5,000
+
+Linter computes the rule's class from frontmatter `type:` and the
+hard-floor allowlist (`non-destructive-by-default`,
+`security-sensitive-stop`). Exceeding the cap → linter error.
+
+Lazy `load_context:` does **not** count against the budget — by
+definition it is not loaded into every turn.
+
+## Public-vs-internal leak
+
+A rule shipped to consumers (`.agent-src.uncompressed/rules/`) may
+declare `load_context:` entries pointing at:
+
+- `.agent-src.uncompressed/contexts/` — public, OK.
+- `agents/contexts/` — package-internal, **lint warning** (the entry
+  will not exist in consumer projects).
+
+Project-local rules may reference either. The linter classifies by
+the rule's tree, not by the target's tree.
+
+## No circular references
+
+A `load_context:` graph that cycles fails the linter. Cycles are
+defined across both `load_context:` and `load_context_eager:` edges.
+
+## Examples
+
+### Real consumer — `autonomous-execution`
+
+`.agent-src.uncompressed/rules/autonomous-execution.md` is the first
+production rule to declare `load_context:`. Its frontmatter:
+
+```yaml
+---
+type: "auto"
+description: "Deciding whether to ask the user or just act on a workflow step — trivial-vs-blocking classification, autonomy opt-in detection, commit default; defers to non-destructive-by-default for the Hard Floor"
+alwaysApply: false
+source: package
+load_context:
+  - .agent-src.uncompressed/contexts/execution/autonomy-detection.md
+  - .agent-src.uncompressed/contexts/execution/autonomy-mechanics.md
+  - .agent-src.uncompressed/contexts/execution/autonomy-examples.md
+---
+```
+
+Three lazy-loaded contexts, no `load_context_eager:`. The agent reads
+each context only when the corresponding section of the slim rule
+points at it (the rule body cites the same paths in prose so the
+load is intent-driven, not blanket).
+
+Pattern proven by this consumer:
+
+- **Slim the rule to obligations only** — the 192-line pre-split
+  source dropped to 119 lines (≤ 120 target met) by extracting LOGIC
+  (detection algorithm), MECHANICS (setting table, cloud behavior),
+  and EXAMPLES (anchor phrases, worked cases, failure modes) into
+  three separate context files.
+- **Cite, don't duplicate** — the slim rule contains zero
+  algorithm/mechanics/example prose; everything moved was physically
+  removed (verified by Phase 2.5 obligation diff:
+  [`agents/reports/pr-34-phase-2-5-autonomous-execution-obligation-check.md`](../../agents/reports/pr-34-phase-2-5-autonomous-execution-obligation-check.md)).
+- **Lazy by default** — no eager-load is declared; the budget guard
+  is therefore a no-op for this rule.
+
+`task lint-load-context` reports **1 declarer**, all paths resolve,
+no cycles.
+
+## Stability
+
+`beta` — schema is settled and serves one production rule
+(`autonomous-execution`). A breaking schema change is a SemVer-minor
+pre-1.0 bump. Adding a new optional key is non-breaking. The first
+consumer surfaced no schema gaps; the next migration batch (roadmap
+`road-to-pr-34-followups` Phase 6 — `commit-policy`, `scope-control`,
+`verify-before-complete`) is the next stress test.
+
+## Cross-references
+
+- [`rule-priority-hierarchy.md`](rule-priority-hierarchy.md) — which
+  rule wins on conflict; this schema is orthogonal (depth, not
+  priority).
+- [`rule-interactions.yml`](rule-interactions.yml) — pairwise rule
+  interaction matrix.
+- [`STABILITY.md`](STABILITY.md) — beta-tag implications.

package/docs/contracts/rule-interactions.md

@@ -104,4 +104,3 @@ junior (yields). For `complements`, ordering is documentary only.
 
 - [`docs/contracts/STABILITY.md`](STABILITY.md) — public-surface stability tiers.
 - [`docs/contracts/adr-chat-history-split.md`](adr-chat-history-split.md) — ADR pattern for major rule structural changes.
-- [`agents/roadmaps/archive/road-to-post-pr29-optimize.md`](../../agents/roadmaps/archive/road-to-post-pr29-optimize.md) § P2.2 — anchor for this matrix.