@event4u/agent-config 1.16.0 → 1.18.0

package/.agent-src/rules/missing-tool-handling.md

@@ -6,34 +6,38 @@ description: "When a CLI tool needed for the task is not installed — ask befor
 
 # Missing Tool Handling
 
-When a CLI tool is needed and **not installed** (`command not found`,
-`which X` empty), **STOP and ask** before working around it or installing it.
+When a CLI tool is needed to solve the task cleanly and is **not installed**
+(`command not found`, `which X` empty, missing from `$PATH`), **STOP and ask**
+before working around it or installing it.
 
 ## The rule
 
-- **Never install silently.** Installing changes the user's system —
-  requires explicit permission (`scope-control`).
+- **Never install silently.** Installing is an action that changes the user's
+  system — it requires explicit permission (see `scope-control`).
 - **Never silently work around** a missing tool with a brittle substitute
-  (awk for YAML, `grep` for JSON, string splicing) when a proper tool is
-  the standard answer. The workaround hides the dependency.
-- **Ask with numbered options** (`user-interaction`). State the tool, why
-  it fits, the install command, and the workaround cost.
+  (awk-regex for YAML, `grep` for JSON, string splicing) when a proper tool
+  is the standard answer for the job. The workaround hides the real
+  dependency and makes the decision invisible to the user.
+- **Ask with numbered options** (see `user-interaction`). State which tool,
+  why it's the best fit, the install command, and the workaround cost.
 
 ## When it applies
 
-- Shell returns `command not found` for a tool the task genuinely needs
-  (yq, jq, rtk, gh, docker, mkcert, terraform, …).
-- A skill or spike needs the idiomatic tool but it's absent locally.
-- You're about to substitute a verbose script for a single tool call
+- Any shell command fails with `command not found` for a tool the task
+  genuinely needs (yq, jq, rtk, gh, docker, mkcert, terraform, …).
+- A skill or spike requires a tool that is the idiomatic answer but is
+  absent locally.
+- You are about to substitute a verbose script for a single tool invocation
   because the tool isn't there.
 
 ## When it does NOT apply
 
-- Nice-to-have — clean substitute already present (e.g. `jq` available →
-  no `yq` needed just for JSON).
-- Tool is forbidden by project policy (check `scope-control` and
-  tool-allowlists first).
-- Missing library dependency → use `composer`, `npm`, `pip` per package
+- The tool is a nice-to-have and a clean substitute already exists in the
+  repo (e.g. `jq` present → no need for `yq` just for JSON).
+- The tool is explicitly forbidden by project policy (check
+  `scope-control` and tool-allowlists first).
+- The missing artefact is a library dependency — those go through
+  `composer require`, `npm install`, `pip install` per the package-manager
   rules, still with explicit permission.
 
 ## How to ask
@@ -49,14 +53,16 @@ When a CLI tool is needed and **not installed** (`command not found`,
 > 4. Skip this path — I propose a different approach
 ```
 
-After the user picks: if **install**, wait for confirmation or run the
-documented command only if explicitly authorised this turn. If
-**workaround**, record the decision in the artefact (comment or ADR).
+After the user picks: if **install**, wait for confirmation that it is
+done (or run the documented install command only if the user explicitly
+authorises it in this turn). If **workaround**, record the decision in
+the artefact (comment or ADR) so the cost is visible.
 
 ## Capture the learning
 
-If the same tool keeps missing across tasks, flag it in the project's
-setup docs or `.agent-settings.yml` prerequisites.
+If the same tool keeps coming up as missing across multiple tasks, flag
+it in the project's setup docs or `.agent-settings.yml` prerequisites.
+Don't make every session re-discover the gap.
 
 See also: `scope-control` · `ask-when-uncertain` · `user-interaction` ·
 `tool-safety`.

package/.agent-src/rules/no-cheap-questions.md

@@ -8,14 +8,11 @@ source: package
 # No Cheap Questions
 
 A question is **cheap** when the answer follows from stated context,
-when an option would breach an Iron Law, when choices differ only in
-sequencing or format, or when one option is obviously dominant. Cheap
-questions are noise, regardless of `personal.autonomy`.
-
-Mode-independent. The "trivial" failure modes in
-[`autonomous-execution`](autonomous-execution.md) are scoped to
-`personal.autonomy: on` (or `auto`-after-opt-in); this rule lifts the
-**no-trade-off** subset to apply in `off` and pre-opt-in `auto` too.
+an option breaches an Iron Law, choices differ only in sequencing /
+format, or one option is obviously dominant. Mode-independent — holds
+in `off`, `auto`, and `on`; autonomy never lifts the no-trade-off
+floor (cf. [`autonomous-execution`](autonomous-execution.md), whose
+"trivial" failure modes only scope to `on` / opted-in `auto`).
 
 ## The Iron Laws
 
@@ -29,61 +26,50 @@ Hold in `off`, `auto`, and `on`. Autonomy never lifts them.
 
 ## What counts as cheap
 
-| Class | Pattern · why cheap |
-|---|---|
-| **Sequencing** | "Step 2 or 3 next?" when roadmap orders them — answer is in the roadmap |
-| **Format-only** | "Table or paragraph?" — no semantic trade-off |
-| **Commit asks** | "Commit now?" — [`commit-policy`](commit-policy.md): never ask |
-| **CI / test asks** | "Run tests now?" — [`verify-before-complete`](verify-before-complete.md) decides |
-| **Fenced-step re-asks** | "Start Phase 1?" after "plan only" — [`scope-control § fenced step`](scope-control.md#fenced-step--user-set-review-gates) |
-| **Iron-Law option** | Option breaches `commit-policy`, `scope-control § git-ops`, or `non-destructive-by-default` — does not exist |
-| **Context-derived** | Answer follows from prior turn / standing instruction / roadmap — act, state assumption inline |
-| **Dominant option** | One choice obviously correct; alternatives carry no upside — pick it |
-| **Re-ask after decline** | Same path after user said no — [`scope-control § decline = silence`](scope-control.md#decline--silence--no-re-asking-on-the-same-task) |
+- **Sequencing** — "Step 2 or 3 next?" when the roadmap orders them.
+- **Format-only** — "Table or paragraph?"; no semantic trade-off.
+- **Commit asks** — forbidden by [`commit-policy`](commit-policy.md).
+- **CI / test asks** — [`verify-before-complete`](verify-before-complete.md) decides, not the user.
+- **Fenced-step re-asks** — "Start Phase 1?" after *"plan only"*; see
+  [`scope-control § fenced step`](scope-control.md#fenced-step--user-set-review-gates).
+- **Iron-Law option** — breaches `commit-policy`, `scope-control` § git-ops, or `non-destructive-by-default`.
+- **Context-derived** — answer follows from prior turn / standing instruction / roadmap; act, state the assumption inline.
+- **Dominant option** — one choice obviously correct; alternatives carry no upside.
+- **Re-ask after decline** — forbidden per [`scope-control § decline = silence`](scope-control.md#decline--silence--no-re-asking-on-the-same-task).
+
+Examples per class:
+[`asking-and-brevity-examples`](../../docs/guidelines/agent-infra/asking-and-brevity-examples.md#cheap-question-class-catalog--extended-examples).
 
 ## Pre-Send Self-Check — MANDATORY before every question
 
-Before drafting any numbered-options block, run silently:
-
-1. Does the answer follow from already-stated context?
-2. Does any option violate [`commit-policy`](commit-policy.md),
-   [`scope-control § git-ops`](scope-control.md), or
-   [`non-destructive-by-default`](non-destructive-by-default.md)?
-3. Are options pure sequencing / format with no trade-off?
-4. Is one option obviously dominant?
-5. Did the user fence the next step (*"plan only"*, *"review first"*)?
-   → deliver + handback per [`scope-control § fenced step`](scope-control.md#fenced-step--user-set-review-gates).
-6. Did the user already decline? Re-asking is forbidden per
-   [`scope-control § decline = silence`](scope-control.md#decline--silence--no-re-asking-on-the-same-task).
-
-Any "yes" → **do not ask**. Pick the dominant path, state the
-assumption inline (*"assuming X — adjust if wrong"*), hand back. The
-one-question-per-turn Iron Law from
-[`ask-when-uncertain`](ask-when-uncertain.md) still applies when the
-question is genuine.
+Run silently before any numbered-options block:
+
+1. Answer already in stated context?
+2. Any option violates `commit-policy`, `scope-control` § git-ops, or `non-destructive-by-default`?
+3. Options pure sequencing / format, no trade-off?
+4. One option obviously dominant?
+5. User fenced next step (*"plan only"*, *"review first"*) → deliver + handback per `scope-control` § fenced step.
+6. User already declined? Re-ask forbidden per `scope-control` § decline = silence.
+
+Any "yes" → **do not ask**. Pick the dominant path, state assumption
+inline (*"assuming X — adjust if wrong"*), hand back. One-question-per-turn
+from [`ask-when-uncertain`](ask-when-uncertain.md) still applies when
+the question is genuine.
 
 ## When asking IS allowed
 
 - Real architectural / scope decision with non-obvious trade-offs.
-- Vague-request trigger per
-  [`ask-when-uncertain`](ask-when-uncertain.md#vague-request-triggers--must-ask).
-- Security-sensitive path per
-  [`security-sensitive-stop`](security-sensitive-stop.md).
-- Hard Floor in [`non-destructive-by-default`](non-destructive-by-default.md)
-  fires — confirmation is mandatory, never cheap.
+- Vague-request trigger per [`ask-when-uncertain`](ask-when-uncertain.md#vague-request-triggers--must-ask).
+- Security-sensitive path per [`security-sensitive-stop`](security-sensitive-stop.md).
+- Hard Floor per `non-destructive-by-default` — confirmation mandatory.
 - Two genuinely-equivalent paths; user preference is the tiebreaker.
 
-In doubt → genuine. Ask. This rule narrows asking, never widens silence.
+In doubt → ask. This rule narrows asking, never widens silence.
 
 ## Interactions
 
-- [`ask-when-uncertain`](ask-when-uncertain.md) — vague triggers +
-  one-question-per-turn; this rule narrows the cheap subset.
-- [`autonomous-execution`](autonomous-execution.md) — mode-scoped
-  triviality there; mode-independent floor here.
-- [`commit-policy`](commit-policy.md) · [`scope-control`](scope-control.md) ·
-  [`non-destructive-by-default`](non-destructive-by-default.md) —
-  the Iron Laws this rule defends.
-- [`user-interaction`](user-interaction.md) — numbered-options shape;
-  this rule decides whether the block is sent at all.
+- [`ask-when-uncertain`](ask-when-uncertain.md) — vague triggers + one-question-per-turn; narrows the cheap subset.
+- [`autonomous-execution`](autonomous-execution.md) — mode-scoped triviality there; mode-independent floor here.
+- [`commit-policy`](commit-policy.md) · [`scope-control`](scope-control.md) · [`non-destructive-by-default`](non-destructive-by-default.md) — Iron Laws this rule defends.
+- [`user-interaction`](user-interaction.md) — numbered-options shape; this rule decides whether to send.
 - [`direct-answers`](direct-answers.md) — brevity, no flattery.

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

@@ -0,0 +1,73 @@
+---
+type: "auto"
+description: "Adding a link to a specific file in agents/roadmaps/ from any stable artifact (rule, skill, command, context, guideline) — roadmaps are transient; promote durable findings to agents/contexts/ instead"
+alwaysApply: false
+source: package
+---
+
+# No Roadmap References from Stable Artifacts
+
+Roadmaps in `agents/roadmaps/` are **transient** — archived, skipped,
+or deleted as work completes. Stable artifacts (rules, skills,
+commands, contexts, guidelines, AGENTS.md, README) outlive them. A
+stable artifact citing a specific roadmap file becomes a broken
+reference the moment that roadmap is deleted.
+
+## The Iron Law
+
+```
+NEVER LINK TO A SPECIFIC FILE IN agents/roadmaps/ FROM A STABLE ARTIFACT.
+PROMOTE DURABLE CONCLUSIONS TO agents/contexts/ AND CITE THAT INSTEAD.
+```
+
+Stable artifact = anything that is **not** a roadmap, council
+session, chat-history archive, commit message, or PR description.
+
+## Forbidden patterns
+
+These paths must not appear inside a stable artifact:
+
+- `agents/roadmaps/<file>.md`, `agents/roadmaps/archive/<file>.md`,
+  `agents/roadmaps/skipped/<file>.md`
+
+Stable artifact = any file under `.agent-src.uncompressed/{rules,
+skills,commands,contexts,templates,personas}/`, `agents/contexts/`,
+`docs/guidelines/`, `docs/contracts/`, `docs/architecture.md`,
+`docs/customization.md`, `docs/getting-started.md`, `docs/catalog.md`,
+`AGENTS.md`, `README.md`, `copilot-instructions.md`.
+
+CI enforcement: `scripts/check_no_roadmap_refs.py` (companion linter
+— fails the build on any new violation).
+
+## Allowed patterns
+
+- `agents/roadmaps/` and its subdirectories as directory mentions
+  (talking about the layer, not a specific file)
+- Roadmap → roadmap references (siblings within the transient layer)
+- Council sessions, `.agent-chat-history`, commit messages, PR
+  descriptions — transient by construction, not part of the package
+  surface
+
+## What to do instead
+
+When a stable artifact needs to cite a roadmap finding:
+
+1. Identify the durable conclusion — decision, contract, lesson,
+   mechanic.
+2. Promote it to a context file under `agents/contexts/` (ADR,
+   mechanics doc, locked decision). The roadmap can then point at
+   the context, not the other way around.
+3. Reference the context from the stable artifact.
+
+Failure mode: *"I'll just link to the roadmap, it's evidence."* The
+roadmap gets archived, then deleted, then the link rots. **Promote
+first, link second.**
+
+## See also
+
+- [`docs-sync`](docs-sync.md) — cross-reference sync after rename / delete
+- [`agent-docs`](agent-docs.md) — roadmap layer conventions
+- [`roadmap-progress-sync`](roadmap-progress-sync.md) — sync dashboard on
+  roadmap touch
+- [`augment-source-of-truth`](augment-source-of-truth.md) — edit
+  `.agent-src.uncompressed/`

package/.agent-src/rules/onboarding-gate.md

@@ -7,6 +7,12 @@ source: package
 
 # Onboarding Gate
 
+> **Enforced by:** [`scripts/onboarding_gate_hook.py`](../../scripts/onboarding_gate_hook.py)
+> on Augment + Claude Code (`SessionStart`). The hook refreshes
+> `agents/state/onboarding-gate.json` from `.agent-settings.yml`; the
+> prose below is the spec the hook implements and the fallback for
+> platforms without a hook surface.
+
 Forces a one-time `/onboard` run for each developer on each project. This
 replaces the previously scattered "ask once" patterns across `user_name`,
 `personal.ide`, `personal.rtk_installed`, and cost profile confirmation.
@@ -92,3 +98,4 @@ gate. This protects projects that were set up before this rule shipped.
 - [`layered-settings`](../../docs/guidelines/agent-infra/layered-settings.md) — merge rules for mid-life edits
 - [`agent-settings` template](../templates/agent-settings.md) — `onboarding.onboarded` reference
 - [`rule-type-governance`](rule-type-governance.md) — why this is `always`
+- [`hardening-pattern`](../../agents/contexts/hardening-pattern.md) — Tier 1 mechanical-rule contract

package/.agent-src/rules/package-ci-checks.md

@@ -3,11 +3,16 @@ type: "auto"
 alwaysApply: false
 description: "Before pushing to remote or creating a PR in the agent-config package — run all CI checks locally first"
 source: package
+load_context:
+  - .agent-src.uncompressed/contexts/communication/rules-auto/package-ci-checks-mechanics.md
 ---
 
 # Package CI Checks
 
-Before **any** push/PR in agent-config: run ALL CI checks locally.
+## When this applies
+
+Before **any** push to remote or PR creation in the **agent-config** package.
+This rule is specific to this package — it does NOT apply to consumer projects.
 
 ## The Iron Law
 
@@ -17,69 +22,24 @@ NEVER push without running ALL CI checks locally first.
 
 Every CI pipeline failure is preventable by running these checks before pushing.
 
-## Required checks
-
-### 1. Sync
-
-```bash
-bash scripts/compress.sh --check          # .agent-src/ matches .agent-src.uncompressed/
-bash scripts/compress.sh --check-hashes   # compression hashes are clean
-```
-
-### 2. Consistency
-
-```bash
-python3 scripts/check_compression.py   # compressed variants are valid
-python3 scripts/check_references.py     # no broken cross-references
-python3 scripts/check_portability.py    # no project-specific references in shared files
-```
-
-### 3. Linter (0 FAIL required)
-
-```bash
-python3 scripts/skill_linter.py --all   # 0 FAIL required
-```
-
-### 4. Tests
-
-```bash
-python3 -m pytest tests/ --tb=short     # all tests must pass
-```
-
-### 5. README
-
-```bash
-python3 scripts/readme_linter.py README.md --root .
-```
-
-## Quick one-liner
-
-```bash
-bash scripts/compress.sh --check && \
-bash scripts/compress.sh --check-hashes && \
-python3 scripts/check_compression.py && \
-python3 scripts/check_references.py && \
-python3 scripts/check_portability.py && \
-python3 scripts/skill_linter.py --all && \
-python3 -m pytest tests/ --tb=short && \
-python3 scripts/readme_linter.py README.md --root .
-```
-
-## After editing skills/rules in .agent-src.uncompressed/
-
-1. Edit uncompressed file
-2. Edit compressed file in `.agent-src/` to match
-3. `bash scripts/compress.sh --mark-done {relative-path}` — update hash
-4. `bash scripts/compress.sh --check-hashes` — verify
+## Required checks — see mechanics
 
-**Skip step 3 → CI WILL fail.**
+Five checks must pass locally before push, in this order:
 
-## After editing scripts/compress.py
+1. **Sync** — `compress.sh --check` and `--check-hashes`.
+2. **Consistency** — `check_compression.py`, `check_references.py`, `check_portability.py`.
+3. **Linter** — `skill_linter.py --all`, 0 FAIL required.
+4. **Tests** — `pytest tests/`.
+5. **README** — `readme_linter.py`.
 
-Run `python3 -m pytest tests/test_compress.py -v` **immediately** — don't wait.
+The full command snippets, common-failure notes per step, the quick
+chained one-liner, and the post-edit workflow ("after editing
+skills/rules", "after editing `scripts/compress.py`") all live in
+[`contexts/communication/rules-auto/package-ci-checks-mechanics.md`](../contexts/communication/rules-auto/package-ci-checks-mechanics.md).
+Pull it whenever pre-push verification is needed.
 
 ## Do NOT
 
-- Push "to see if CI passes" — wastes pipeline minutes
-- Skip hash checks for "small changes"
-- Assume tests pass because linter passes
+- Do NOT push "to see if CI passes" — that wastes pipeline minutes
+- Do NOT skip hash checks because "I only changed one file"
+- Do NOT assume tests pass because linter passes — they check different things

package/.agent-src/rules/preservation-guard.md

@@ -7,43 +7,78 @@ source: package
 
 # Preservation Guard
 
-Transformations (merge, refactor, compress, split) must produce output **at least as strong** as input.
+When transforming any agent artifact (merge, refactor, compress, split, restructure),
+the result must be **at least as strong** as the original.
 
 ## Iron Laws — every passage stays, caveman is fine
 
-Sections marked **Iron Law** (heading matches `# Iron Law`, `# Iron Laws`,
-`# The Iron Law`, any level, numbered like `Iron Law 1`, `Iron Law 2`)
-are **non-negotiable**, strictest preservation:
+Sections marked **Iron Law** (any heading matching `# Iron Law`, `# Iron Laws`,
+`# The Iron Law`, at any heading level, including numbered variants like
+`Iron Law 1`, `Iron Law 2`) are **non-negotiable** and require the strictest
+preservation:
 
-- [ ] **Heading verbatim** — exact text, exact level. Drop heading → law gone, even if code block survives.
-- [ ] **Fenced code blocks byte-for-byte** — the law itself.
-- [ ] **Negation clauses kept** — `NO X`, `NEVER Y`, `NOT Z` stay. Load-bearing exception denials, not filler.
-- [ ] **Every passage stays** — every paragraph, every list item, every fenced code block from source survives in compressed output, in order. One paragraph → one paragraph; one bullet → one bullet. Dropping whole sentences, merging two paragraphs, skipping a list item is forbidden, even if surviving prose still "makes the point".
-- [ ] **No Iron Law downgrades** — `## Iron Law` MUST NOT become `### Iron Law`, `**Iron Law:**`, or inline prose. Heading level is part of prominence.
+- [ ] **Heading preserved verbatim** — exact text and exact heading level. Drop the
+  heading → the law is gone, even if the code block underneath survives.
+- [ ] **Fenced code blocks preserved byte-for-byte** — the law itself.
+- [ ] **Negation clauses preserved** — `NO X`, `NEVER Y`, `NOT Z` stay in. These
+  are the load-bearing exception denials, not filler.
+- [ ] **Every passage stays** — every paragraph, every list item, and every
+  fenced code block from the source survives in the compressed output, in
+  order. One paragraph → one paragraph; one bullet → one bullet. Dropping
+  whole sentences, merging two paragraphs into one, or skipping a list item
+  is forbidden, even if the surviving prose still "makes the point".
+- [ ] **No Iron Law downgrades** — `## Iron Law` MUST NOT become `### Iron Law`,
+  `**Iron Law:**`, or inline prose. Heading level is part of the prominence.
 
-**Caveman style encouraged for Iron Law bodies** — drop articles ("the", "a"), shorten phrasing, primitive grammar, terse cave-speak. Word count not a budget; structural unit count is. Every paragraph, bullet, code block from source present → compress as hard as you want. Forbidden is **deletion**: rationale paragraph stays, canonical-failure example stays, every "NEVER X" bullet stays.
+**Caveman style is encouraged for Iron Law bodies** — drop articles ("the",
+"a"), shorten phrasing, primitive grammar, terse cave-speak. Word count is
+not a budget; the structural unit count is. As long as every paragraph,
+bullet, and code block from the source is present, compress as hard as you
+want. What's forbidden is **deletion**: the rationale paragraph stays, the
+canonical-failure example stays, every "NEVER X" bullet stays.
 
-`scripts/check_compression.py` enforces mechanically — any violation is `error`, not warning.
+`scripts/check_compression.py` enforces these mechanically — any violation is
+an `error`, not a warning.
 
-## Checklist — verify before completing
+## Mandatory preservation checklist
 
-- [ ] **Iron Law sections** preserved per rules above — heading, body, fenced blocks, rationale
-- [ ] Strongest validation step preserved
-- [ ] Strongest example preserved
-- [ ] Strongest anti-pattern / "Do NOT" preserved
-- [ ] Essential decision hints (if/when/unless) preserved
-- [ ] Required sections preserved
-- [ ] Single clear responsibility preserved
-- [ ] Strong language ("MUST"/"NEVER") not weakened
+Before completing any transformation, verify:
 
-## Reject if
+- [ ] **Iron Law sections** preserved per the rules above — heading, body, fenced blocks, rationale
+- [ ] **Strongest validation step** preserved — concrete verify/confirm actions survive
+- [ ] **Strongest example** preserved — the most illustrative code block or scenario stays
+- [ ] **Strongest anti-pattern** preserved — the most important "Do NOT" or failure mode stays
+- [ ] **Essential decision hints** preserved — if/when/unless logic that prevents mistakes
+- [ ] **Required sections** preserved — When to use, Procedure, Output, Gotchas, Do NOT
+- [ ] **Single clear responsibility** preserved — no scope creep from merging unrelated concerns
+- [ ] **Strong language** preserved — "MUST", "NEVER", "Do NOT" not weakened to "should", "avoid"
 
-- Iron Law heading removed or downgraded
-- Paragraph, list item, or fenced code block dropped from Iron Law section
-- Negation clauses or canonical-failure prose stripped from Iron Law
-- Validation, example, or anti-pattern removed without replacement
-- Decision logic weakened
-- Scope broadened by merging unrelated concerns
-- Strong language downgraded
+## Reject criteria
 
-→ Skills: `skill-management`, `skill-reviewer` · Command: `/compress` · Linter: `check_compression_quality()`
+**REJECT** the transformation if it:
+
+- Removes or downgrades an Iron Law heading
+- Drops a paragraph, list item, or fenced code block from an Iron Law section
+- Strips negation clauses or canonical-failure prose from an Iron Law
+- Removes a concrete validation step without equivalent replacement
+- Removes the strongest example without equivalent replacement
+- Removes the strongest anti-pattern without equivalent replacement
+- Weakens routing or decision logic
+- Broadens scope by merging unrelated workflows
+- Weakens strong enforcement language
+
+## Applies to
+
+- Skill merges (combining two skills into one)
+- Skill splits (extracting part of a skill)
+- Refactoring (restructuring without behavior change)
+- Compression (`.agent-src.uncompressed/` → `.agent-src/`)
+- Rule consolidation
+- Guideline restructuring
+
+## References
+
+- Skill: `skill-management` — compression/refactoring modes
+- Skill: `skill-reviewer` — compression safety checks
+- Command: `/compress` — compression quality checklist
+- Linter: `scripts/skill_linter.py` — `check_compression_quality()`

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

@@ -2,6 +2,8 @@
 type: "auto"
 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
+load_context:
+  - .agent-src.uncompressed/contexts/communication/rules-auto/review-routing-awareness-mechanics.md
 ---
 
 # Review Routing Awareness
@@ -37,24 +39,13 @@ Look, in order, for:
 - `.github/historical-bug-patterns.yml` (or
   `agents/historical-bug-patterns.yml`)
 
-If neither file exists, fall back to the engineering-memory layer via
-[`memory-access`](../../docs/guidelines/agent-infra/memory-access.md):
-
-```python
-from scripts.memory_lookup import retrieve
-extra = retrieve(
-    types=["ownership", "historical-patterns"],
-    keys=<changed file paths>,
-    limit=5,
-)
-```
-
-Curated memory (`agents/memory/ownership.yml`,
-`agents/memory/historical-patterns.yml`) carries the same schema as the
-project-local YAMLs and is merged into the routing output alongside
-them. If both memory and project YAMLs are absent, skip this rule and
-rely on [`reviewer-awareness`](reviewer-awareness.md) defaults. **Do
-not invent owners or patterns** from context.
+If neither file exists, fall back to the engineering-memory layer.
+Memory-lookup snippet and merge semantics live in
+[`contexts/communication/rules-auto/review-routing-awareness-mechanics.md`](../contexts/communication/rules-auto/review-routing-awareness-mechanics.md)
+§ Memory-lookup fallback. If both memory and project YAMLs are absent,
+skip this rule and rely on
+[`reviewer-awareness`](reviewer-awareness.md) defaults. **Do not
+invent owners or patterns** from context.
 
 ### 2. Match the diff
 
@@ -71,25 +62,19 @@ for the schema).
 
 ### 3. Surface findings
 
-When producing a review plan, include:
-
-- **Owner-mapped roles** — explicitly preferred over generic roles. If
-  the ownership map says `app/Billing/**` is owned by `finance-engineering
-  + security`, use those, not "backend + security".
-- **Historical-pattern warnings** — list every matched pattern with a
-  short label and the required control, e.g. _"Pattern: N+1 on tenant
-  listings → add an eager-load regression test"_.
-- **Confidence note** — if the ownership map is stale (last updated > 6
-  months ago per the `updated` field), say so. Ownership maps rot.
+When producing a review plan, include owner-mapped roles (preferred
+over generic), historical-pattern warnings (with required control),
+and a staleness note if the ownership map's `updated` field is older
+than 6 months. Worked examples for each in
+[`contexts/communication/rules-auto/review-routing-awareness-mechanics.md`](../contexts/communication/rules-auto/review-routing-awareness-mechanics.md)
+§ Surface findings.
 
 ### 4. Do NOT overreach
 
-- **Never rename paths** or add ownership entries as a side effect of a
-  code change. Ownership map edits are a separate, explicit task.
-- **Never mark a change safe** only because no pattern matched. Pattern
-  absence means "no known hit", not "no risk".
-- **Never copy historical-pattern names into the diff** as code comments
-  or commit messages — they are routing metadata, not commentary.
+The "do NOT overreach" guardrails (no path renames as side effects, no
+"safe because no match", no pattern names in diffs/commits) live in
+[`contexts/communication/rules-auto/review-routing-awareness-mechanics.md`](../contexts/communication/rules-auto/review-routing-awareness-mechanics.md)
+§ Do NOT overreach.
 
 ## Interaction with other rules
 
@@ -102,16 +87,12 @@ When producing a review plan, include:
   matched pattern is a reason to **add a test**, never a reason to
   expand scope into unrelated refactors.
 
-## Anti-patterns — reject them
+## Anti-patterns
 
-- Suggesting owners "because this looks like billing code" without
-  consulting the ownership map when one exists.
-- Inventing historical patterns from general knowledge — patterns must
-  come from the project's own registry.
-- Downgrading a matched high-severity pattern because "the author said
-  it's fine" — the pattern was registered because it bit before.
-- Treating an out-of-date map as absent. Flag staleness; do not silently
-  skip.
+The four anti-pattern rejections (invented owners, invented patterns,
+downgrading high-severity hits, treating stale maps as absent) live in
+[`contexts/communication/rules-auto/review-routing-awareness-mechanics.md`](../contexts/communication/rules-auto/review-routing-awareness-mechanics.md)
+§ Anti-patterns.
 
 ## See also