@event4u/agent-config 9.16.0 → 9.18.0

package/dist/agent-src/commands/condense.md

@@ -20,8 +20,8 @@ packs:
 
 # condense
 
-Condense agent config `.md` files from `src/` into token-efficient telegraph format
-and write the condensed output to `dist/agent-src/`.
+Project agent config `.md` files from `src/` into `dist/agent-src/` — verbatim
+copy with the path rewriter applied (ADR-201; the LLM prose rewrite is removed).
 
 The projection is deterministic: `dist == rewrite(src)` byte-for-byte. A file is
 out of date only when its projection does not match that rewrite.
@@ -96,76 +96,31 @@ Read `verbosity.post_action_reports` from `.agent-settings.yml` (default
 `minimal`).
 
 - `off` → emit nothing on success; surface errors only.
-- `minimal` (default) → one line: `→ N files condensed (avg X% savings)`.
-- `full` → multi-line table with per-category stats (files condensed,
-  avg savings).
+- `minimal` (default) → one line: `→ N files synced`.
+- `full` → multi-line table with per-category stats (files synced,
+  stale files reaped).
 
-## Iron Laws — do not touch
+## Iron Laws — preserved by construction
 
 Sections under headings matching `Iron Law`, `Iron Laws`, or `The Iron Law` (any
 heading level, numbered variants like `Iron Law 1` included) are **load-bearing
-behavioral rules**. Condensation rules above do **not** apply to them.
-
-For every Iron Law section in a source file:
-
-- **Copy the heading verbatim**, exact text, exact `#` level. NEVER downgrade
-  `## Iron Law` to `### Iron Law` or to inline `**Iron Law:**`.
-- **Copy the fenced code block byte-for-byte**, including capitalization, line
-  breaks, and trailing punctuation.
-- **Copy the negation clauses verbatim** — `NO X`, `NEVER Y`, `NOT Z`. These
-  are the law's exception denials; stripping them weakens the rule.
-- **Telegraph the prose, keep every passage** — every paragraph, every list
-  item, and every fenced code block from the source must appear in the
-  condensed output, in order. Drop articles, shorten phrasing, primitive
-  grammar, terse cave-speak — all encouraged. What's forbidden is dropping
-  whole sentences, merging two paragraphs into one, or skipping a bullet.
-  One paragraph → one paragraph; one bullet → one bullet.
-- **No word-count budget** — condense the prose as hard as telegraph style
-  allows. The check is structural (passage count), not quantitative.
-
-`scripts/check_condensation.ts` enforces these mechanically — `iron_law_missing`,
-`iron_law_passage_dropped`, and `iron_law_heading_downgrade` are `error`-level
-and block CI.
+behavioral rules**. Post-ADR-201 the projection is a verbatim copy, so headings,
+fenced blocks, and negation clauses survive by construction — there is no manual
+preservation step for the agent to perform.
 
-If an Iron Law section genuinely contains filler (rare): edit the SOURCE in
-`src/`, not the condensed copy. Source is the truth.
-
-## Condensation quality checklist
-
-**Also apply the [preservation-guard](../rules/preservation-guard.md) rule** — strongest validation, example, anti-pattern, and decision hints must survive condensation. Iron Laws are non-negotiable.
-
-See also: [markdown-safe-codeblocks](../rules/markdown-safe-codeblocks.md) for fenced-block hygiene.
-
-After condensing each file, verify:
+`scripts/check_condensation.ts` enforces this mechanically — since ADR-201 it
+asserts `dist == rewrite(src)` byte-for-byte; `iron_law_missing`,
+`iron_law_passage_dropped`, and `iron_law_heading_downgrade` remain `error`-level
+diagnostics that name what differs when the bytes do.
 
-- [ ] All code blocks preserved exactly (no content changes)
-- [ ] All inline code, URLs, file paths unchanged
-- [ ] YAML frontmatter identical to source
-- [ ] Headings match source exactly
-- [ ] Tables structure preserved (cell text may be shortened)
-- [ ] "NEVER", "MUST", "Do NOT" and other strong language preserved
-- [ ] Technical terms, library names, API names unchanged
-- [ ] No meaning lost — condensed version says the same thing, shorter
-- [ ] No sections accidentally removed
-- [ ] Word count reduction is 20-50% (typical range for prose-heavy files)
-
-### Safe vs unsafe condensation
-
-Safe:
-- "You should always make sure to run the tests before committing" → "Run tests before commit"
-- "In order to ensure that the configuration is correct" → "To verify config"
-- "It is important to note that this feature requires" → "Requires"
-
-Unsafe (DO NOT do this):
-- Removing a bullet point that contains unique information
-- Changing `php artisan test --filter=MyTest` to `php artisan test`
-- Shortening "Do NOT use float for money" to "Avoid float"
-- Removing "NEVER" from "NEVER add to phpstan-baseline.neon"
+If an Iron Law section genuinely contains filler (rare): edit the SOURCE in
+`src/`, not the projected copy. Source is the truth. Authoring-time transforms
+(merges, splits, refactors) remain governed by
+[preservation-guard](../rules/preservation-guard.md).
 
 ## Rules
 
 - **Do NOT commit or push.** Only write files.
 - **Do NOT modify `src/`** — it is the source of truth.
-- **Only write to `.augment/`** — the condensed output directory.
-- **Preserve ALL technical content** — only condense natural language prose.
-- **YAML frontmatter** in command/skill files must be preserved exactly.
+- **Only write to `dist/agent-src/`** (via `condense.sh` / the script) — never
+  hand-edit any projection.

package/dist/agent-src/commands/evals/agent-handoff.json

@@ -1,6 +1,6 @@
 {
   "command": "agent-handoff",
-  "intent": "Generate a session-handoff summary to continue work in a fresh chat",
+  "intent": "Resume a previous session in a fresh chat: pick a session, generate a handoff, auto-seed the next session",
   "cases": [
     {
       "prompt": "summarize where we are so I can paste it into a new chat",
@@ -29,6 +29,18 @@
     {
       "prompt": "show me the current message count and token cost",
       "expected": "agent-status"
+    },
+    {
+      "prompt": "let me continue an old session in a fresh chat",
+      "expected": "agent-handoff"
+    },
+    {
+      "prompt": "starte eine neue session mit dem stand von gestern",
+      "expected": "agent-handoff"
+    },
+    {
+      "prompt": "resume my previous session where we left off, but in a clean chat",
+      "expected": "agent-handoff"
     }
   ]
 }

package/dist/agent-src/commands/evals/rule-compliance-audit.json

@@ -0,0 +1,46 @@
+{
+  "command": "rule-compliance-audit",
+  "intent": "Audit rule trigger quality and replay the router matcher over recent prompts (routing audit)",
+  "cases": [
+    {
+      "prompt": "audit my rules for weak triggers",
+      "expected": "rule-compliance-audit"
+    },
+    {
+      "prompt": "run a routing audit — which rules fired on my last prompts",
+      "expected": "rule-compliance-audit"
+    },
+    {
+      "prompt": "check whether the rule routing actually matches what I type",
+      "expected": "rule-compliance-audit"
+    },
+    {
+      "prompt": "why did no rule activate on my last message — audit the triggers",
+      "expected": "rule-compliance-audit"
+    },
+    {
+      "prompt": "find rules whose descriptions overlap or never activate",
+      "expected": "rule-compliance-audit"
+    },
+    {
+      "prompt": "fix the failing CI on this branch",
+      "expected": "fix"
+    },
+    {
+      "prompt": "review the changes on this branch before I push",
+      "expected": "review-changes"
+    },
+    {
+      "prompt": "run a full project health check",
+      "expected": "project-health"
+    },
+    {
+      "prompt": "estimate this ticket for me",
+      "expected": "estimate-ticket"
+    },
+    {
+      "prompt": "commit these changes in logical chunks",
+      "expected": "commit"
+    }
+  ]
+}

package/dist/agent-src/commands/feature/plan.md

@@ -21,6 +21,19 @@ packs:
 # /feature plan
 ## Instructions
 
+### 0. Confidence gate (Gate C)
+
+Before gathering, run the plan-confidence gate per
+[`plan-confidence-gate`](../../contexts/execution/plan-confidence-gate.md):
+read `planning.challenge_on_create` (missing = `true`), do the codebase
+lookup, and assess the four 95%-conditions — **seed = the provided
+description** (when none was provided, step 1's ask supplies it first).
+Confident → single marker line, continue with step 1. Uncertain → route
+into `/challenge-me vision` (inline degrade protocol without the command);
+the pitch feeds steps 5c–6, and the C→R1 handoff state is written so the
+risk-review step re-asks nothing. Explicit user bypass wins for the turn
+and is counted.
+
 ### 1. Gather the idea
 
 If the user provided a description, use it. Otherwise ask:
@@ -259,6 +272,13 @@ If picked **2** → continue.
 - Set the `Module` field in the feature doc accordingly.
 - Set status to `📋 Planned`.
 - If Jira tickets were provided, add them to the `Jira` field and reference them in the feature doc.
+- **Risk review (Gate R1)** — before saving, add a `## Risk Register`
+  section per [`plan-review-gates § 1`](../../../docs/contracts/plan-review-gates.md):
+  read the C→R1 handoff state from step 0 if present (resolved branches
+  seed the risks — never re-ask them), rank the highest product and
+  implementation risks descending, one mitigation per row, each row
+  anchored to a section of this document. No material risks → the exact
+  honest-null grammar. Self-review suffices.
 
 **Ask for the filename:**
 ```

package/dist/agent-src/commands/feature/roadmap.md

@@ -55,6 +55,15 @@ Stop.
 - Read the roadmap template at `.augment/templates/roadmaps.md` for the structure.
 - Research the codebase for affected areas mentioned in the feature.
 
+**Confidence gate (Gate C)** — after reading the feature plan, run
+[`plan-confidence-gate`](../../contexts/execution/plan-confidence-gate.md)
+with the **feature document as seed** (`planning.challenge_on_create`,
+missing = `true`). All four 95%-conditions hold → single marker line,
+continue. A gap that would change the phases or acceptance criteria →
+`/challenge-me vision` interview (or inline degrade protocol) **before**
+proposing roadmaps; the C→R1 handoff state is written so the risk-review
+step re-asks nothing. Explicit user bypass wins for the turn and is counted.
+
 Determine how many roadmaps are needed:
 
 - **Single roadmap:** Small/medium features that fit in one document.
@@ -143,6 +152,16 @@ If any planned name already exists anywhere under the namespace,
 Re-run the check after a rename. Never silently overwrite, never
 auto-suffix without the user's pick.
 
+**Risk review (Gate R1)** — every generated roadmap that is saved ready
+(non-draft) carries a `## Risk Register` per
+[`plan-review-gates § 1`](../../../docs/contracts/plan-review-gates.md):
+read the C→R1 handoff state from step 2 if present (resolved branches
+seed the risks — never re-ask them), rank the highest product and
+implementation risks descending, one mitigation per row, each row
+anchored to a phase/step of that roadmap. No material risks → the exact
+honest-null grammar. `lint_plan_risk_register` enforces this at
+pre-push + CI; drafts are exempt until flipped to ready.
+
 ### 5. Link roadmaps in the feature plan
 
 Update the feature file's `## Roadmaps` section:

package/dist/agent-src/commands/memory/promote.md

@@ -184,7 +184,20 @@ echo '{"type":"supersede","supersedes":"<sig-id>","promoted_to":"<curated id>"}'
 This keeps the intake stream truthful — lookups will ignore the
 superseded signal.
 
-### 6. Open a promotion PR
+### 6. Open a promotion PR — git ops are permission-gated
+
+Branch, commit, and push are NOT authorized by invoking this command
+(per `scope-control` § git-ops and the `non-destructive-by-default`
+push floor — invoking `/memory:promote` names the promotion, not a git
+destination). Surface the exact operations and wait for explicit
+confirmation this turn:
+
+> Promotion is written. Ship it as a PR?
+>
+> 1. Yes — branch `memory/promote-<curated-id>`, commit, push, then `/create-pr`
+> 2. No — keep the promotion local, I'll ship it myself
+
+Only on option 1:
 
 ```bash
 git checkout -b memory/promote-<curated-id>

package/dist/agent-src/commands/mode.md

@@ -63,7 +63,9 @@ Extract `roles.default_role` and `roles.active_role`.
 
 Echo the full contract body for the target mode from `role-contracts.md`:
 
-- Goal / Constraints / Output fields
+- The mode's contract-skeleton fields (each mode's skeleton differs —
+  e.g. developer: Goal / Plan / Changes / Tests / Open questions;
+  planner: Goal / Constraints / Option set / …)
 - Default skills the mode loads first
 - Structured mode marker the agent will emit when closing
 
@@ -85,7 +87,7 @@ Do NOT write anything for `/mode` without an argument (status only).
 Announce the switch as:
 
 ```
-> entering {mode} mode — contract: {goal-field} / {constraints-field} / {output-field}
+> entering {mode} mode — contract fields: {first-3-field-names-from-skeleton}
 ```
 
 From this point in the session: the rule
@@ -105,7 +107,7 @@ numbered prompt:
 ## Output format
 
 ```
-> entering {mode} mode — contract: …
+> entering {mode} mode — contract fields: …
 >
 > Default skills: {skill-a}, {skill-b}, {skill-c}
 > Closing marker: <!-- role-mode: {mode} | contract: … -->
@@ -121,8 +123,10 @@ For `/mode` (status only):
 ## Gotchas
 
 - `.agent-settings.yml` is git-ignored. `/mode` never commits the file.
-- If the file is missing the `roles:` section, add it in the correct
-  place (between `subagents:` and EOF) using the template layout.
+- If the file is missing the `roles:` section, add it — note
+  `agent-settings.template.yml` ships no `roles:` block; the reference
+  `roles:` layout lives in
+  `src/agent-src/templates/agents/agent-project-settings.example.yml`.
 - Mode names are case-sensitive in the file; case-insensitive on input.
 - The contract is the source of truth, not this command — if the
   guideline changes, this command reflects the new contract on next run.

package/dist/agent-src/commands/optimize/deep.md

@@ -8,7 +8,13 @@ sub: deep
 cluster: optimize
 skills: [ai-council, roadmap-writing, subagent-orchestration, decision-review]
 description: "Autonomous deep-refactoring loop — subagent analysis, verified findings, council, central + sub-roadmaps, PR, then N refinement loops (default 3). E.g. 'run a deep optimization pass'."
-argument-hint: "[--loops=N] [--scope=<path>] [--no-external]"
+argument-hint: "[--mode=plan|execute] [--loops=N] [--scope=<path>] [--no-external]"
+limits:
+  mode_default: plan
+  max_iterations: 3
+  hard_ceiling: 5
+  no_gain_stop: 2
+  target_metric: required
 suggestion:
   eligible: false
   rationale: "Cluster sub-command — reached via its cluster head's routing or its explicit /cluster:sub name; not independently suggested (surface-consolidation)."
@@ -44,22 +50,71 @@ Do NOT invoke for: a single named bug, an interview-style sweep with the
 user in the loop (route to `/optimize project`), a code-only analysis
 (`/project-analyze`), or agent-layer file tooling (`/optimize` siblings).
 
-## Loop budget
+## Enforced limits (release-truth Phase 4)
+
+The frontmatter `limits:` block is the machine-readable pin
+(`tests/scripts/optimize_deep_limits.test.ts` fails when flow and pin
+drift); the flow steps below are the enforcement — each limit is a step
+the run MUST execute, not advice. The reviews' P0 this closes: an
+autonomous deep-refactoring loop shipped without technically enforced
+limits.
+
+### Execution mode — plan-only default
+
+`--mode=plan` is the **default**: run Steps 0–4 only — analyze, verify,
+council, author the roadmap set in the worktree — then present the plan
+plus the predicted delta on the target metric and STOP. No push, no PR, no
+refinement loop, no edit outside the worktree's roadmap drafts.
+`--mode=execute` must be **explicitly present in the invocation** to enter
+Steps 5–6; treat its absence as plan mode even when conversation momentum
+suggests otherwise. An execute-mode run still respects every gate below.
+
+### Pre-registered target metric — required before loop 1
+
+Before Step 5 may run (and therefore before any refinement loop), the
+central roadmap MUST carry a `Target metric` block naming ONE measurable
+metric (e.g. always-loaded token budget, gate wall-clock, red-test count),
+its **measured baseline at the branch SHA** (command output pasted, not
+asserted), and the predicted direction. No block → REFUSE to enter Step 5
+with: `target metric not pre-registered — record it in the central roadmap
+first`. Loops never move the goalposts: the metric named before loop 1 is
+the metric every loop is scored against.
+
+### Loop budget
 
 `--loops=N` caps the refinement loops. **Default: 3** (council-locked
 2026-08-02: autonomous loops without a fast, trustworthy CI oracle are
 compounding-error machines; 3 with a tripwire beats 5 on cost/benefit).
-Hard ceiling: 5 — above that, re-invoke deliberately with fresh context.
+Hard ceiling: 5 — a larger `--loops` value is clamped to 5 with a warning;
+above that, re-invoke deliberately with fresh context.
 
 **Halt-on-spin tripwire (checked after every loop, overrides the budget):**
 
 - A loop ends with no material roadmap delta (no step added, removed,
   re-scoped, or re-ordered) → STOP, the set has converged.
+- **Two consecutive loops deliver no measurable gain on the pre-registered
+  target metric (re-measured per loop, Step 6e) → STOP** — spinning without
+  gain is the failure the metric exists to catch.
 - The council splits on the same question twice → STOP, escalate that
   question to the user instead of burning a third loop on it.
 - Any validation target fails 3 consecutive refinement attempts → STOP
   (N=3 budget, `autonomous-execution`).
 
+### Hard exclusions — never inside this command
+
+- **Kernel rules:** the run NEVER edits a kernel rule (`is_kernel_rule` in
+  `src/scripts/_lib/kernel_rules.ts`; the `block-kernel-rule-writes`
+  PreToolUse guard denies the write anyway). A finding that wants a
+  kernel-rule change is recorded in the roadmap as a **proposal routed to
+  the kernel slow-rollout process** (`contexts/authority/kernel-rule-edits.md`:
+  own PR, ≥ 24 h soak) — the refusal names that process, never edits.
+- **Public contracts:** no change to a `docs/contracts/` surface marked
+  `stability: stable` without explicit user approval this run — record as a
+  proposal otherwise.
+- **Commit / push / PR floors:** unchanged — the invocation authorizes the
+  worktree branch and (execute mode) pushes to the run's own PR; merge,
+  deploy, and every Hard-Floor action stay this-turn gated.
+
 ## Steps
 
 ### Step 0 — Preflight (read-only)
@@ -115,22 +170,28 @@ work (whatever must be true for the rest to be verifiable — typically the
 CI oracle) gates the leverage-class work explicitly. Regenerate the
 dashboard (`roadmap:progress`) in the same response as any roadmap write.
 
-### Step 5 — Pull request
+### Step 5 — Pull request (execute mode only)
 
-Push the branch and open the PR per [`/create-pr`](../pr/create.md) — its
-mechanics and the always-active PR-surface rules govern the body and reply
-shape; do not restate them here.
+**Gate first:** `--mode=execute` present in the invocation AND the
+`Target metric` block recorded (§ Enforced limits) — otherwise STOP here
+and present the plan (plan mode's defined end state). Then push the branch
+and open the PR per [`/create-pr`](../pr/create.md) — its mechanics and the
+always-active PR-surface rules govern the body and reply shape; do not
+restate them here.
 
-### Step 6 — Refinement loops (×N, autonomous)
+### Step 6 — Refinement loops (×N, execute mode only)
 
 Each loop: (a) re-read the roadmap set with fresh subagent reviewers
 (adversarial: hunt over-building, missing evidence, lock violations,
 sequencing errors); (b) resolve contested deltas in the council; (c) any
 delta resting on a NEW factual claim re-enters the Step-2 verification gate
 before application — reviewer assertions are findings, not facts; (d) apply
-the surviving deltas to the roadmaps; (e) push to the same PR; (f) evaluate
-the tripwire. Loop output is a delta summary in the PR description's
-changelog section, not a comment (`no-pr-progress-comments`).
+the surviving deltas to the roadmaps; (e) **re-measure the pre-registered
+target metric at the new SHA and record the value in the loop verdict** —
+this is the per-loop verification the no-gain tripwire consumes; (f) push
+to the same PR; (g) evaluate the tripwire (§ Enforced limits — including
+the two-consecutive-no-gain stop). Loop output is a delta summary in the PR
+description's changelog section, not a comment (`no-pr-progress-comments`).
 
 ## Output
 

package/dist/agent-src/commands/pr/create.md

@@ -139,6 +139,35 @@ completion is read from the checkbox counts.
   in the working tree.
 - **It reported nothing → proceed.** No completed roadmap in this branch.
 
+### 1d. Completion review (Gate R2) — after the sweep, before the PR
+
+Fixed sequence: (1) the § 1c archival sweep runs first, (2) the R2 review
+runs on the post-archival state (the findings artifact references
+post-archival paths), (3) the PR is created only with a valid findings
+artifact, honest-null, or skip declaration **for the current review-scope
+hash** per
+[`plan-review-gates § 2`](../../../docs/contracts/plan-review-gates.md).
+
+- A completion-review artifact from the roadmap-completion event
+  (`agents/evidence/reviews/<slug>.findings.md`) is re-used when its
+  `scope:` equals the current review-scope hash — one artifact covers
+  both triggers. **Never compare the `diff:` sha**: it is provenance only
+  (§ 2.1), and § 2.0 proves that comparison unsatisfiable — committing the
+  artifact moves HEAD, and CI checks out a synthetic merge commit.
+  Otherwise dispatch a fresh review via `dispatch_r2_reviewer` (fresh
+  subagent, no implementation context, findings BEFORE fixes; every
+  finding ends `fixed` / `accepted-risk` / `deferred`).
+- **Review last.** Any content commit after the review changes the scope
+  hash and invalidates the artifact — freeze the content, then review.
+  Artifacts from earlier rounds stay as audit trail under a name outside
+  the `*.findings.md` glob; the final round is the binding one.
+- Docs-only / plan-only diffs take the explicit skip declaration, never
+  a silent skip.
+- The agent-side check here is advisory; `check_completion_review` at
+  pre-push + CI is the enforcing layer (CI authoritative; advisory mode
+  during the Stage-A baseline window). `planning.completion_review:
+  false` is the settings escape hatch.
+
 ### 2. Generate PR content
 
 Run `/create-pr:description-only` Steps 1–4 to generate the PR title and body.

package/dist/agent-src/commands/roadmap/create.md

@@ -20,6 +20,22 @@ packs:
 # /roadmap create
 ## Instructions
 
+### 0. Confidence gate (Gate C)
+
+Before anything else, run the plan-confidence gate per
+[`plan-confidence-gate`](../../contexts/execution/plan-confidence-gate.md):
+read `planning.challenge_on_create` (missing = `true`), do the codebase
+lookup, and assess the four 95%-conditions against the seed.
+
+- **Confident** (all four hold) → emit the single marker line and continue
+  with step 1.
+- **Uncertain** → route into `/challenge-me vision` with the ask as seed
+  (inline degrade protocol when the command is unavailable); the resulting
+  pitch pre-fills steps 3–4, and the C→R1 handoff state is written per the
+  context doc so the risk-review step re-asks nothing.
+- **Explicit user bypass** ("just write it") → skip the gate for this turn;
+  count the bypass.
+
 ### 1. Determine location
 
 Ask the user (in their language) where the roadmap should be created:
@@ -99,6 +115,19 @@ Show the complete roadmap to the user and ask (in their language) if anything sh
 - If yes → apply changes, show again.
 - Repeat until the user says it's done.
 
+### 5b. Risk review (Gate R1) — after draft, before save
+
+Unless the roadmap will be saved as `status: draft`, add a
+`## Risk Register` per
+[`plan-review-gates § 1`](../../../docs/contracts/plan-review-gates.md):
+read the C→R1 handoff state from step 0 if present (resolved branches
+seed the risk list — never re-ask them), identify the highest product and
+implementation risks, rank descending, write a mitigation per row, and
+anchor every row to a phase/step of this roadmap. No material risks → the
+exact honest-null grammar from the contract. Self-review suffices.
+`lint_plan_risk_register` enforces this at pre-push + CI; drafts are
+exempt until flipped to ready.
+
 ### 6. Save the file
 
 - Generate a filename from the title: kebab-case, e.g. `optimize-webhook-jobs.md`.

package/dist/agent-src/commands/rule-compliance-audit.md

@@ -5,11 +5,11 @@ pack: meta
 tier: 2
 visibility: internal
 skills: [rule-compliance-audit]
-description: Audit rule trigger quality, simulate activation, detect overlaps, and find never-activating rules
+description: Audit rule trigger quality, simulate activation, detect overlaps, find never-activating rules, and replay the router matcher over recent prompts (route:audit)
 suggestion:
   eligible: true
-  trigger_description: "audit my rules, check rule trigger quality"
-  trigger_context: "maintainer working on .augment/rules/ files"
+  trigger_description: "audit my rules, check rule trigger quality, routing audit — which rules fired"
+  trigger_context: "maintainer working on .augment/rules/ files or questioning whether rules route"
 workspaces:
   - agent-config-maintainer
 packs:
@@ -121,7 +121,27 @@ ALWAYS-RULE HEALTH
   {name}: {line_count} lines — {✅ healthy | ⚠️ large (>100 lines) | ⚠️ could be auto}
 ```
 
-### 6. Summary and recommendations
+### 6. Session routing audit (deterministic; the `/routing-audit` surface)
+
+Replay the router's ONE shared matcher over the recent session — read-only,
+no LLM call, deterministic:
+
+```bash
+agent-config route:audit --last 10        # matched rules per recent user prompt
+agent-config route:explain "<prompt>"     # deep trace for one prompt
+agent-config route:audit --weekly         # rolling 7-day recorder render
+```
+
+Render the matched-vs-should-have-matched review: for each audited prompt,
+the tool prints the matched rules + triggers; flag prompts where a rule you
+would expect is absent (should-have-matched is YOUR judgment as reviewer —
+the tool never computes it). Every output opens with the measurement-level
+header: **trigger matching only — what the host actually invoked is NOT
+measured** (ADR-126). Recording (`--record`) is opt-in via
+`telemetry.routing_recorder.enabled` (default off) and stores prompt digests,
+never prompt text.
+
+### 7. Summary and recommendations
 
 ```
 ═══════════════════════════════════════════════
@@ -152,7 +172,10 @@ Wait for user to pick which recommendations to apply.
 ## Rules
 
 - **Do NOT modify any files** until the user approves recommendations.
-- **Do NOT run any scripts** — this is a pure analysis command.
+- **Do NOT run any scripts** — this is a pure analysis command. Sole
+  carve-out: the read-only routing CLI in step 6 (`route:explain` /
+  `route:audit`), which is deterministic and writes nothing (the opt-in
+  `--record` flag is the one gated exception).
 - **Be honest about uncertainty** — if a trigger might or might not match, say "might miss".
 - **Always-rules are expensive** — flag any that could safely be auto.
 - **Auto-rules that never activate are dead weight** — flag them clearly.

package/dist/agent-src/contexts/authority/commit-mechanics.md

@@ -16,8 +16,9 @@ Outside the four below, no commit is allowed and no commit ask is allowed.
    ahead and commit". Single commit, not standing.
 2. **Standing instruction not yet revoked** — earlier "commit after
    every phase"; cache the instruction and commit per its terms.
-3. **Commit command invoked** — `/commit` (split + confirm per commit)
-   or `/commit:in-chunks` (auto-split, Hard Floor still applies).
+3. **Commit command invoked** — `/commit` (split; ONE plan confirm;
+   terse: invoking confirms) or `/commit:in-chunks` (auto-split, Hard
+   Floor still applies).
 4. **Roadmap authorization** — roadmap lists explicit commit steps and
    the user invoked roadmap execution; each commit matches a step.
 
@@ -57,9 +58,8 @@ four exceptions cover *whether* commits happen; the Hard Floor covers
 When **executing** a roadmap that contains commit steps:
 
 - **Non-autonomous mode** (`personal.autonomy: off`, or `auto`
-  before opt-in) — agent may ask before each commit step. The user
-  authorized commits by writing them into the roadmap, but retains
-  step-level control.
+  before opt-in) — the one-shot pre-scan ask below, never per-step
+  (`commit-policy` NEVER-ask holds at every autonomy level).
 - **Autonomous mode** (`personal.autonomy: on`, or `auto` after
   opt-in) — agent does a quick pre-scan of the roadmap **before
   starting execution**. If commit steps are found, ask **once** at

package/dist/agent-src/contexts/communication/rules-auto/guidelines-mechanics.md

@@ -9,6 +9,7 @@ before writing or reviewing code); this file is the catalog.
 
 | File | Topic |
 |---|---|
+| `abstraction-thresholds.md` | Per-class extraction-threshold canon (code 2 · UI shell 3+ · stateful component ~4+state · utility-class string ≥3) — the single source every numeric threshold cites (ADR-213) |
 | `code-clarity.md` | Cross-language clarity rules — inline single-use values, carve-outs (side effects, loops, type narrowing, debugger) |
 | `component-oriented-and-oop-development.md` | Reuse-first components (FE) + OOP-where-it-reduces-complexity (backend); carve-out index; bounded by the anti-over-engineering anchors |
 

package/dist/agent-src/contexts/communication/rules-auto/skill-quality-mechanics.md

@@ -20,7 +20,7 @@ Make descriptions "pushy" — explicit about when to fire:
 - Name 2+ concrete triggers — domains, symptoms, file types, user phrasing.
 - End with: `... even if they don't explicitly ask for \`<skill-name>\`.`
 - Avoid hedges: `may help with`, `can be useful for`, `covers various`.
-- **Keep it ≤ 200 characters.** `scripts/skill_linter.ts` warns at
+- **Keep it ≤ 200 characters.** `scripts/skill_linter.ts` errors at
   `description_too_long` above this. If the pushy tail pushes you over, cut
   adjectives, drop the second example phrasing, or collapse a list — do
   **not** drop the trigger vocabulary or the `even if ...` tail.

package/dist/agent-src/contexts/communication/rules-auto/think-before-action-mechanics.md

@@ -81,7 +81,12 @@ Never load full datasets into context. Extract what you need:
 - Do NOT retry the same approach hoping for a different result.
 - Do NOT loop through trial-and-error when one targeted inspection
   would reveal the cause.
-- Max 2 retries for the same approach — then stop and rethink.
+- Max 2 retries for the same approach — then stop and rethink. The 2
+  retries plus the initial attempt ARE the three attempts of
+  `autonomous-execution`'s N=3 stop: the 3rd consecutive failure on the
+  same target escalates to stop-and-ask, then to `context-hygiene`'s
+  fresh-session recommendation — one ladder, not competing budgets
+  ([`autonomy-mechanics § Retry-budget escalation ladder`](../../execution/autonomy-mechanics.md)).
 
 ## Open files are context, not intent
 

package/dist/agent-src/contexts/communication/rules-auto/token-efficiency-mechanics.md

@@ -53,7 +53,10 @@ command says "ask the user", you ask.
   or ask the user.
 - Max 3 diagnostic commands per error. Read the error, think, act.
 - One hypothesis at a time. Pick the most likely, try it. Fails →
-  ask.
+  next hypothesis; failures on the same target accrue to the ONE
+  retry ladder (2 retries per approach → N=3 stop-and-ask, per
+  [`autonomy-mechanics § Retry-budget escalation ladder`](../../execution/autonomy-mechanics.md))
+  — never a separate one-strike cap.
 
 ### Keep intermediate output minimal