@event4u/agent-config 16.2.0 → 16.3.0

package/dist/agent-src/commands/roadmap/triage-parked.md

@@ -0,0 +1,325 @@
+---
+model_tier: high
+name: roadmap-triage-parked
+pack: product-basic
+visibility: internal
+cluster: roadmap
+sub: triage-parked
+skills: [roadmap-management, roadmap-writing, decision-review, agent-docs-writing]
+description: Drain later/ and skipped/ — verify each parked roadmap against the current tree, run its resume condition, then promote, absorb, archive, or re-park it with a fresh reason.
+argument-hint: "[<file> | later | skipped | all] [--batch <n>] [--triage-only]"
+suggestion:
+  eligible: false
+  rationale: "Cluster sub-command — reached via its cluster head's routing or its explicit /roadmap:triage-parked name; not independently suggested (surface-consolidation)."
+workspaces:
+  - agent-config-maintainer
+packs:
+  - meta
+---
+
+# /roadmap:triage-parked
+
+Drain sub of the [`/roadmap`](../roadmap.md) cluster. `later/` and `skipped/`
+are excluded from the dashboard and from every `/roadmap:process-*` run, so
+nothing ever looks at them again unless asked. A parked roadmap is a **frozen
+claim about a tree that has since moved**: its resume condition may have fired
+weeks ago, its open steps may have shipped under another roadmap, its skip
+reason may no longer hold. This command re-reads them against the current tree
+and gives every file a decision, so the two folders shrink instead of rotting.
+
+It is the [`/analyze:inbox`](../analyze/inbox.md) discipline applied to the
+roadmap estate's own back room: verify every claim, prefer "already shipped" as
+the most valuable finding, and never let a file leave the run without a named
+disposition.
+
+## The Iron Law
+
+```
+A PARKED ROADMAP IS A CLAIM, NOT A FACT. VERIFY ITS OPEN STEPS AND EXECUTE ITS
+RESUME CONDITION AGAINST THE CURRENT TREE BEFORE DECIDING ANYTHING.
+"ALREADY SHIPPED" IS THE MOST VALUABLE FINDING — MARK IT [x] WITH A file:line.
+EVERY FILE IN SCOPE LEAVES THE RUN WITH EXACTLY ONE OF FIVE DISPOSITIONS.
+RE-PARKING WITHOUT A REFRESHED, CHECKABLE REASON IS NOT A DISPOSITION.
+NEVER DELETE A ROADMAP. NEVER DROP AN OPEN OR DEFERRED STEP SILENTLY.
+NEVER WRITE [-] — CANCELLING A STEP IS OWNER-RESERVED. "OBSOLETE" IS A
+FINDING THE OWNER RULES ON, NOT A CANCELLATION THE AGENT APPLIES.
+AN OWNER-RESERVED BLOCKER STAYS OWNER-RESERVED — PROMOTION NEVER LIFTS IT.
+REVIVING A skipped/ ROADMAP REOPENS A RECORDED DECISION — COUNCIL FIRST.
+```
+
+## Argument
+
+| Given | Scope |
+|---|---|
+| a file path | that roadmap only |
+| `later` | every roadmap in `agents/roadmaps/later/` |
+| `skipped` | every roadmap in `agents/roadmaps/skipped/` |
+| `all` or nothing | both folders |
+
+`README.md` is never in scope. `--batch <n>` caps the deep pass (default **15**
+files per run); the cheap inventory in Phase 1 always covers the whole scope.
+`--triage-only` stops after Phase 2 — the table, no edits.
+
+> The batch default of 15 is a **stated default, not a measured optimum**.
+> *Revisit-if:* a run reports files past the cap that the inventory had already
+> classified as trivial (too low), or a run's verification column filling with
+> `unverifiable` towards its end (too high — reading degraded).
+
+## Where the work happens
+
+Runs in the checked-out branch, like `/analyze:inbox`. Its output is roadmap
+edits and `git mv`s — no generated tree, nothing to isolate. A worktree, a
+branch, a commit or a PR only on an explicit ask
+([`scope-control`](../../rules/scope-control.md) § Git operations,
+[`commit-policy`](../../rules/commit-policy.md)).
+
+## Instructions
+
+### 1. Live screen and inventory — cheap, every file in scope
+
+Read live state first, never the dashboard or an earlier screen:
+
+```bash
+agent-config roadmap:context
+```
+
+Then one row per file, from commands, not from reading:
+
+| file | folder | `[x]` | `[ ]` | `[~]` | `[-]` | parked since | resume condition | blockers | skip reason |
+
+- **Checkbox counts** — `grep -cE '^\s*[-*] \[x\]'` and siblings, per marker.
+  A grep also counts boxes inside fenced code blocks; where a count looks off,
+  trust the dashboard parser (`collect()` in the progress generator) over it.
+- **Parked since** — the date the file first appeared in its folder:
+  `git log --diff-filter=A --format=%ad --date=short -- <path> | tail -1`.
+  Age is a finding: a file parked eleven days ago and one parked two hundred
+  days ago are not the same decision.
+- **Resume condition** — the `entry_condition:` mapping (`what` / `when` /
+  `who`) or a `Blocked until` / `Resume when` line, quoted verbatim. Absent on a
+  `later/` file is itself a defect, recorded in the row.
+- **Blockers** — every `### blocker: <slug>` with its `Status:` and
+  `Resolved when`.
+- **Skip reason** — for `skipped/`, the top-of-file reason or
+  `> Superseded by …` pointer, quoted.
+
+A table with fewer rows than the scope has files is the first finding of the run.
+
+### 2. Triage — first-impression disposition, all files
+
+Add a `candidate` column to the inventory. Most files settle here cheaply:
+
+- **Zero open, zero deferred** (`[ ]` = 0, `[~]` = 0) → `archive` candidate. The
+  file is finished or fully cancelled and only its folder is wrong.
+- **Superseded pointer resolves** to a roadmap that exists in `archive/` or the
+  active tree → `archive` candidate, with the pointer as its reason.
+- **Resume condition names a PR, an ADR, a file, or a merged branch** → it is
+  mechanically checkable; Phase 3 runs it first.
+- **Resume condition names only an owner decision or a calendar date** → read
+  the decision record (`agents/roadmaps/` `## Decisions` tables, ADRs) and the
+  date; a past date with no recorded decision is a `re-park` or an escalation,
+  never a silent pass.
+
+Show the table before any edit. `--triage-only` ends the run here.
+
+### 3. Verify — the load-bearing phase, up to `--batch` files
+
+Order the deep pass: mechanically-checkable resume conditions first, then
+`later/` by age (oldest first), then `skipped/`. Delegate when more than ~4 files
+survive — one subagent per file, told to verify against the tree and **write no
+repo files**; their return is a reading, re-checked against the file before any
+edit ([`delegation-policy`](../../rules/delegation-policy.md)).
+
+Per file, three checks:
+
+**3a. Execute the resume condition and every blocker's `Resolved when` as a
+check** — never trust a `Status:` word, which records the past:
+
+```bash
+gh pr view <n> --json state,mergedAt     # "PR X merged"
+ls docs/decisions/ADR-NNN-*.md           # "the ADR exists"
+git log --oneline origin/main -- <path>  # "<file> landed on main"
+grep -n '<key>' <file>                   # "<key> exists"
+```
+
+Verdict per condition: `met` · `unmet` · `unverifiable` (with the one line why).
+
+**3b. Verify every open `[ ]` and deferred `[~]` step against the current tree**,
+with a `file:line` or command output for what was checked:
+
+`already-shipped` · `still-needed` · `obsolete` (the target it acts on no longer
+exists or was superseded) · `unverifiable`
+
+Search wide: an open step in a parked roadmap was frequently shipped by a
+*different* roadmap. `grep` the step's named file, flag, key or command across
+`src/`, `docs/`, and `agents/roadmaps/archive/` before calling it `still-needed`.
+
+**3c. Re-test the parking reason itself.** For `later/`: is the gate the file
+names still the real gate, or has the blocking work moved (a dependency now
+merged, a decision now recorded, a benchmark now runnable)? For `skipped/`: does
+the skip reason still hold — is the superseding roadmap real, is the rejected
+scope still rejected, or has a later inbox round or decision asked for this
+again ([`recurring-criticism`](../../rules/recurring-criticism.md) owns a repeat)?
+
+### 4. Decide — exactly one disposition per file
+
+| Disposition | When | What it writes |
+|---|---|---|
+| **promote** | resume condition `met` or no longer a gate, and ≥ 1 step `still-needed` that an agent can execute now — for a `skipped/` file, only after the council ruled the rejection no longer holds (below) | `git mv` to `agents/roadmaps/`, steps adapted to the current tree (below), the active-tree shape (below), a `> Promoted from <folder>/ on YYYY-MM-DD: <condition met + evidence>` line under the title |
+| **absorb** | the surviving steps belong to an active roadmap already covering the area | the steps copied into that roadmap as a new phase or step block, each tagged `<!-- from: <parked-slug> -->`; the target's Risk Register `reviewed:` re-stamped (a new phase is a substantial change); then the parked file is **archived** with a pointer to where its items went |
+| **archive** | every open/deferred step is `already-shipped` or absorbed, and no blocker is still open — or the file is finished and only misfiled | shipped steps flipped to `[x]` with `<!-- shipped: <file:line or PR> -->`, `status: archived`, `git mv` to `archive/`, a `> Archived from <folder>/ on YYYY-MM-DD by /roadmap:triage-parked: <reason>` line |
+| **re-park** | the gate is real and still `unmet` | stays in place; the resume condition rewritten as a **checkable** `entry_condition:` mapping (`what` / `when` / `who`), a `review_by: YYYY-MM-DD` in the frontmatter, a `> Last triaged: YYYY-MM-DD — <verdict of 3a>` line, shipped steps still flipped to `[x]` |
+| **owner-decision** | the only thing between the file and a disposition is a decision an agent may not take — any step judged `obsolete` (cancelling it is `[-]`, owner-reserved), or a gate in the [`decision-revisit-gate`](../../rules/decision-revisit-gate.md) owner-reserved set | stays in place; the question written onto the file with the candidate dispositions, and the item put to the owner (Output 1) |
+
+**Adapting a promoted or absorbed step to the current tree** is the point of the
+command, not a nicety. Rewrite each `still-needed` step so it would execute
+against today's tree — renamed paths, moved scripts, changed commands, current
+gate names — and tag it `<!-- adapted: <what changed> -->` so a reader can tell
+an update from a transcription. A step that cannot be made executable becomes a
+`[ ]` investigation step stating what is unknown, never the stale wording.
+
+**The active-tree shape a promoted file must have.** `later/` and `skipped/` are
+exempt from the gates that read the active tree; a promoted file is not. Before
+it lands at the top level it carries at least one `## Phase` heading with a
+checkbox step under each (`check_roadmap_trackable`), a `## Risk Register` with a
+current `reviewed:` date (`lint_plan_risk_register`), and it passes
+`lint_roadmap_family_cap`, `lint_roadmap_complexity` and `lint_roadmap_ci_steps`.
+Set `status: ready` only when all of that is written. A file whose plan needs
+more rework than that is promoted as `status: draft` — off the dashboard and the
+risk-register gate until the owner flips it.
+
+**Constraints that come with the folder, not with the decision:**
+
+- **Reviving a `skipped/` file reopens a recorded rejection.** It goes to the
+  council first per [`decision-revisit-gate`](../../rules/decision-revisit-gate.md)
+  (mechanism-match, then the five steps), and to the owner when the transition
+  lands in the owner-reserved set. 3c's evidence is the input; the verdict is
+  recorded on the file before the `git mv`.
+- **`skipped/` → `archive/` is legitimate here** once 3c confirms the file holds
+  nothing to resume. This widens `archive/` from "work happened" to "nothing left
+  to do here", deliberately: the folder that must stay small is the one nobody
+  reads, and the `> Archived from skipped/` line carries the original skip reason
+  forward verbatim, so the rejection stays on record.
+- **Deferred `[~]` steps never follow a file into `archive/` silently** —
+  [`roadmap-progress-sync`](../../rules/roadmap-progress-sync.md) Iron Law 3
+  applies unchanged. Each one is `already-shipped` (flip to `[x]`), or absorbed /
+  carried, and then annotated in the source step as
+  `<!-- deferred-resolution: merged-into=<slug> -->` or
+  `<!-- deferred-resolution: carried-to=<slug> -->` (a carried-to target also
+  carries `parent_roadmap: <source-slug>`). A bare `[~]` in `archive/` reds
+  `lint_deferral_integrity`.
+- **Blockers resolve before their file moves.** A blocker whose `Resolved when`
+  ran `met` in 3a gets `- **Status:** resolved` — the only closing token
+  `lint_roadmap_blockers` and the estate count accept. A file with a blocker
+  still open is not archived; it is promoted with the blocker, re-parked, or put
+  to the owner.
+- **Promotion never lifts a blocker.** A promoted roadmap keeps every blocker
+  whose `Resolved when` is still `unmet`, and a blocker marked owner-reserved
+  stays so; the file is active because *some* step is executable now, not
+  because the gate went away.
+- **Promote only what is executable now.** If every surviving step is gated,
+  the answer is `re-park`, however old the file is — the
+  [Active vs. Later test](../../skills/roadmap-management/references/archival.md)
+  is unchanged.
+
+### 5. Apply — the mechanics that red CI if skipped
+
+In this order, after all decisions of the batch are taken:
+
+1. `git mv` each moved file and fix its own outgoing relative links:
+   `later/` or `skipped/` → top level removes exactly one `../` from each;
+   `later/` or `skipped/` → `archive/` changes none. Migrate inbound references
+   to the new path (`grep -rn '<slug>' agents/ docs/ src/`).
+2. Frontmatter: a file leaving `later/` must not keep `status: later` —
+   `lint_roadmap_later_disposition` reads the word, not the folder. Archived →
+   `status: archived`; promoted → `status: ready` or `draft` (step 4).
+3. **Estate ratchet — a promotion is an addition.** `check_estate_count` reads a
+   `later/x.md` → `x.md` move as a new active roadmap on both halves, and only a
+   move of an *active top-level* roadmap out of the tree offsets it — archiving
+   a parked file lowers `later_roadmaps`, never `active_roadmaps`. So each
+   promoted file needs its own `estate_offset_exempt: <reason>` written in this
+   change; the reason must name the disposition rejected instead (archive, park,
+   merge — `_lib/exemption_shape.ts`), e.g. *"promoted from later/: resume
+   condition met (PR #N); not re-parked because …; not merged because …"*. Many
+   parked files already carry an old `estate_offset_exempt` — **replace** it,
+   never inherit a reason written for a different event. The gate reads
+   `<base>...HEAD`, so it sees only committed changes: run it after the change is
+   committed, and read its `this change +N active / -M disposed, K exempt` line,
+   where `K` must equal `N`.
+
+   ```bash
+   ./scripts-run src/scripts/check_estate_count
+   ```
+4. Regenerate: `./agent-config roadmap:progress --no-archive` (dashboard — the
+   flag keeps it from sweeping unrelated finished roadmaps into this change) and
+   `./scripts-run src/scripts/build_archive_index` (archive index — nothing else
+   in the archival path regenerates it).
+5. Run the lints that read what moved: `lint_roadmap_later_disposition`,
+   `lint_roadmap_blockers`, `lint_deferral_integrity`, `check_no_roadmap_refs`,
+   `check_estate_count`, and — for every promoted or absorbing file —
+   `check_roadmap_trackable`, `lint_plan_risk_register`,
+   `lint_roadmap_family_cap`, `lint_roadmap_complexity`, `lint_roadmap_ci_steps`.
+   Draining `later/` loosens ratchets: when `lint_roadmap_later_disposition`
+   reports a baseline as loose, lower it in the same change. A drop below a
+   `min_scanned` floor in `src/config/gate-coverage.yml` is the corpus shrinking,
+   not a regression — lower the floor with the evidence in its note.
+
+### 6. Close the run
+
+Re-read every edited file once against the decision table (pass 3 of the
+inbox discipline): each `[x]` flip carries its evidence, each promoted step its
+`adapted` tag, each archived file its reason line. A disposition the file does
+not carry is not applied.
+
+## Output
+
+1. **Owner decisions required**, if any — at the top: the list of every pending
+   item (file, question, candidate dispositions), then **one** numbered-options
+   question for the most blocking item; the rest are asked one per turn after
+   it is answered ([`user-interaction`](../../rules/user-interaction.md),
+   [`ask-when-uncertain`](../../rules/ask-when-uncertain.md)). Each question is
+   also written onto its file, so the next run finds it posed.
+2. The inventory table (every file in scope) with the `candidate` column.
+3. Per deep-checked file: resume-condition verdicts, the step verification table,
+   the disposition and what was written.
+4. **The disposition ledger — the run's completeness check:**
+
+   ```
+   scope     N files (later: L, skipped: S) · deep-checked: D · deferred to next batch: R
+   promote   n → <paths>
+   absorb    n → <parked> → <target roadmap>
+   archive   n → <paths>
+   re-park   n → <paths, with the refreshed condition>
+   owner     n → <paths>
+   steps     N verified → already-shipped / still-needed / obsolete / unverifiable
+   folders   later/: before → after · skipped/: before → after
+   ```
+
+   Deep-checked files must sum to their dispositions. Files past the batch cap
+   are named in `deferred to next batch`, never silently absent.
+5. One closing summary: how many files left each folder, how many steps were
+   prevented by `already-shipped`, and which gate the run is waiting on next.
+
+## Honest enforcement — `instruction-only`
+
+No gate checks that a resume condition was executed rather than read, or that an
+`already-shipped` flip was verified. The ledger is the control: it carries
+numbers and `file:line` evidence a reviewer can challenge after the fact. The
+folder-placement and estate gates named in step 5 catch a malformed **move**;
+they cannot see a wrong **decision**.
+
+## Do NOT
+
+- Promote a roadmap because it is old. Age is evidence that the parking reason
+  went unchecked, not evidence that it stopped holding.
+- Archive a file with `still-needed` steps that were neither absorbed nor
+  carried into a follow-up.
+- Write `[-]` to make a file archivable. An obsolete step is a finding put to
+  the owner; the agent never cancels one.
+- Re-park with the same prose condition. If it could not be checked this run, it
+  will not be checked next run either — rewrite it as an `entry_condition:`.
+- Execute a promoted roadmap in the same run — triage authorizes moving and
+  rewriting plans, not doing their work
+  ([`scope-control`](../../rules/scope-control.md) § Authoring vs. implementation).
+  `/roadmap:next` or `/roadmap:process-full` picks it up afterwards.
+- Resolve an owner-reserved gate into an accurate paragraph. Past the decision
+  the agent cannot take, the output is the escalation block.

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

@@ -2,13 +2,13 @@
 model_tier: medium
 name: roadmap
 disable-model-invocation: true
-argument-hint: "[create|ai-council|process-step|process-phase|process-full|next] [args]"
+argument-hint: "[create|ai-council|process-step|process-phase|process-full|next|triage-parked|resolve-blockers] [args]"
 pack: product-basic
-intent: "Roadmap dispatcher — create, process-step, process-phase, process-full, next, ai-council"
-routes_to: [roadmap-create, roadmap-ai-council, roadmap-materialize, roadmap-process-step, roadmap-process-phase, roadmap-process-full, roadmap-next]
+intent: "Roadmap dispatcher — create, process-step, process-phase, process-full, next, triage-parked, resolve-blockers, ai-council"
+routes_to: [roadmap-create, roadmap-ai-council, roadmap-materialize, roadmap-process-step, roadmap-process-phase, roadmap-process-full, roadmap-next, roadmap-triage-parked, roadmap-resolve-blockers]
 replaces: []
 visibility: advanced
-description: Roadmap orchestrator — routes to create (authoring), process-step / process-phase / process-full (autonomous execution), and next (pick a roadmap and ship it).
+description: Roadmap orchestrator — create (authoring), process-step / -phase / -full (execution), next (pick and ship), triage-parked (later/, skipped/), resolve-blockers.
 cluster: roadmap
 type: orchestrator
 suggestion:
@@ -40,6 +40,8 @@ paused for confirmation before every step) was removed —
 | `/roadmap:process-phase` (**default execution scope**) | `commands/roadmap/process-phase.md` | Autonomously process every open step in the current phase |
 | `/roadmap:process-full` | `commands/roadmap/process-full.md` | Autonomously process every open step across every phase; `--all` iterates the whole active estate, `--worktree` isolates the workspace |
 | `/roadmap:next` | `commands/roadmap/next.md` | Screen for the next executable roadmap, then carry it to a reviewable PR (selection + `process-full` + delivery) |
+| `/roadmap:triage-parked` | `commands/roadmap/triage-parked.md` | Re-check every roadmap in `later/` and `skipped/` against the current tree; promote, absorb, archive, or re-park each one |
+| `/roadmap:resolve-blockers` | `commands/roadmap/resolve-blockers.md` | Check every open blocker, close what the tree settled, decide the rest in the AI council, ask the owner one question at a time |
 
 Sub-command names match the locked contract in
 [`docs/contracts/command-clusters.md`](../docs/contracts/command-clusters.md).
@@ -71,6 +73,8 @@ each only binds a scope delta.
    > 4. process-phase — process the current phase (default)
    > 5. process-full — process every open step across every phase
    > 6. next — pick the next executable roadmap and ship it to a PR
+   > 7. triage-parked — drain later/ and skipped/ against the current tree
+   > 8. resolve-blockers — check and resolve open roadmap blockers, council first
 
 ## Rules
 
@@ -91,3 +95,13 @@ each only binds a scope delta.
   [`/roadmap:next`](roadmap/next.md), which is the only sub that
   screens and selects. The three `process-*` subs never choose across
   roadmaps.
+- **Parked-estate intents** (*"go through later/ and skipped/"*, *"geh die
+  geparkten Roadmaps durch"*, *"which parked roadmaps are unblocked now?"*) route
+  to [`/roadmap:triage-parked`](roadmap/triage-parked.md) — the only sub that
+  reads `later/` and `skipped/`. It moves and rewrites plans; it never executes
+  one.
+- **Blocker intents** (*"resolve the blockers"*, *"lös die Blocker auf"*,
+  *"which blockers still need me?"*) route to
+  [`/roadmap:resolve-blockers`](roadmap/resolve-blockers.md) — council first,
+  the owner one question at a time. It decides and records; it never executes
+  the unblocked work.

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

@@ -5,7 +5,7 @@ pack: engineering-base
 visibility: internal
 cluster: tests
 sub: create
-skills: [test-case-discovery, pest-testing, quality-tools]
+skills: [test-case-discovery, quality-tools]
 description: Write meaningful tests for the current branch — stack-adaptive (pest / phpunit / vitest / jest / pytest / …)
 suggestion:
   eligible: false
@@ -27,7 +27,18 @@ tests in the framework the project actually uses, never a hard-coded one:
 
 - **PHP** → Pest (`pestphp/pest`) or PHPUnit.
 - **JS/TS** → Vitest or Jest. **Python** → pytest. **Go** → `testing`.
-  **Rust** → `#[test]`.
+  **Rust** → `#[test]`. **Ruby** → RSpec. **JVM** → JUnit.
+  **.NET** → `dotnet test`.
+
+**The resolver is the only stack authority, and `skills:` deliberately names
+no single-stack skill.** Binding `pest-testing` unconditionally made a
+React-only repository load PHP testing guidance before it reached the sentence
+above telling it not to, and a static list cannot express a per-repository
+answer. So the frontmatter keeps only stack-neutral skills and the load is
+**resolver-conditional**: once step 1 has named the runner, load the skill for
+THAT runner if one exists — `pest-testing` for pest, `laravel` for
+`php artisan test`, `playwright-testing` for playwright. Unconditional became
+conditional; it did not become nothing.
 
 Then read the existing tests under the project's test directory to match
 the style and conventions already in use (assertion shape, naming, fixtures).
@@ -95,7 +106,10 @@ funnel per changed behavior — enumerate first, write second:
 
 ### 7. Verify
 
-- Run the tests locally in the PHP container to make sure they pass.
+- Run the tests locally with the command step 1 resolved — the same runner the
+  tests were written for. Reach for a container only when the resolved stack
+  calls for one, exactly as `/tests execute` branches on the resolved tool
+  before reaching for Docker.
 - If a test fails, fix it — don't just delete it.
 
 ### Rules

package/dist/agent-src/commands/tests/execute.md

@@ -5,7 +5,7 @@ pack: engineering-base
 visibility: internal
 cluster: tests
 sub: execute
-skills: [pest-testing, quality-tools]
+skills: [quality-tools]
 description: Run the project's test suite — stack-adaptive (pest / phpunit / vitest / jest / pytest / …)
 argument-hint: "[file | filter] [--include-e2e] [--include-slow] [--php]"
 suggestion:
@@ -31,6 +31,19 @@ returns the runner(s) to invoke per ecosystem:
   phpunit (`vendor/bin/phpunit`).
 - **JS/TS** → vitest (`npx vitest run`) or jest (`npx jest`).
 - **Python** → pytest. **Go** → `go test ./...`. **Rust** → `cargo test`.
+- **Ruby** → rspec (`bundle exec rspec`). **JVM** → junit (`./gradlew test`,
+  `./mvnw test`). **.NET** → `dotnet test`.
+
+**The resolver is the only stack authority, and `skills:` deliberately names
+no single-stack skill.** The frontmatter used to bind `pest-testing` unconditionally, which
+contradicted the sentence directly above it: a React-only repository was handed
+PHP testing guidance before it read the instruction not to hard-code a stack.
+A static list cannot express a per-repository answer, so the frontmatter keeps
+only the stack-neutral `quality-tools` and the load is
+**resolver-conditional**: once step 1 has named the runner, load the skill for
+THAT runner if one exists — `pest-testing` for pest, `laravel` for
+`php artisan test`, `playwright-testing` for playwright (selected under
+`--include-e2e`). Unconditional became conditional; it did not become nothing.
 
 **Wrappers win.** When a `Makefile`/`Taskfile.yml` `test:` target or a
 `package.json` `test` script exists, the resolver returns the wrapper
@@ -52,11 +65,15 @@ ask interactively, or emit `ambiguous_routing` in CI.
   `vendor/bin/phpunit`) → run **inside the PHP Docker container**
   (`docker compose exec -T <service> ...`); detect the service from
   `docker-compose.yml` / `compose.yaml` (see `rules/docker-commands.md`).
-- **Direct JS/Python/Go/Rust tool** → run on the host (or the relevant
-  container when the project containerises it).
+- **Every other direct tool** — JS, Python, Go, Rust, Ruby
+  (`bundle exec rspec`, or bare `rspec` with no Gemfile), JVM
+  (`./gradlew test` / `./mvnw test`), .NET (`dotnet test`) → run on the host,
+  or in the relevant container when the project containerises it. PHP is the
+  only ecosystem with a standing container rule.
 - If the user named a specific file or filter, pass it through the
-  resolved runner's native flag (`--filter=…` / a path for pest/phpunit,
-  a path/`-t` for vitest/jest, a node-id for pytest).
+  resolved runner's native flag: `--filter=…` or a path for pest/phpunit, a
+  path or `-t` for vitest/jest, a node-id for pytest, `-e`/a path for rspec,
+  `--tests`/`-Dtest=` for gradle/maven, `--filter` for `dotnet test`.
 - No specific test requested → run the resolved fast suite.
 
 ### 3. Analyze results

package/dist/agent-src/contexts/authority/decision-revisit-gate-enforcement.md

@@ -0,0 +1,43 @@
+# Decision Revisit Gate — Enforcement Reach
+
+Loaded by [`decision-revisit-gate`](../../rules/decision-revisit-gate.md).
+The honest-enforcement record moved out of the rule verbatim: why the gate
+ships `instruction-only`, and the two reach limits a consumer install has.
+
+## Honest enforcement — `instruction-only`
+
+`adr_cite_check` is deterministic where it runs, and nothing makes it run. No
+gate can observe an agent citing a decision it never opened, so step 2 above is
+model-carried — the same honesty boundary
+[`security-sensitive-stop`](security-sensitive-stop.md) and
+[`active-remediation`](active-remediation.md) state for their own obligations.
+
+Two reach limits, named rather than implied. The tool lives in this repository's
+`src/scripts/` and is **not** exposed as an `agent-config` verb, so a consumer
+install performs step 2 by hand; wiring the verb touches six further surfaces
+plus the curated `dist/agent-src/scripts/` list and is deliberately out of this
+change. And `docs/decisions/` is projected into no agent-visible tree at all —
+the agent sees ADR *numbers* cited across rules and skills, almost never ADR
+*text*. Until that changes, "evaluate before citing" means opening the file.
+
+`docs/contracts/` is unprojected on the same terms (`dist/agent-src/` carries no
+`docs/`), so the burden table this rule points at is maintainer-reachable only.
+That is why the reserved-set table above stays here rather than becoming a
+pointer: a consumer install receives these lines and not the contract.
+
+## Why the council is the default venue — the measurement
+
+The old "offers the user a
+path" wording made every lock an owner interrupt; measured across 26 days of
+transcripts, the agent reported a lock and waited while the owner voided the
+decision retroactively — twice with the lock report timestamped **before** the
+override demand. The ordering was the defect; the permission was never missing.
+
+## Why the five steps are inlined rather than only routed
+
+The five are stated here, not only behind a route, because the route was
+measurably unreachable: `decision-review` ships `install.default: false` in the
+non-default `analysis-workbench` pack, so a pack-legal install received the
+obligation and not the procedure. `routes_to` now names two always-on skills;
+the backward-audit depth in
+`decision-review` stays optional.

package/dist/agent-src/contexts/communication/rules-auto/design-fidelity-enforcement.md

@@ -0,0 +1,24 @@
+# Design Fidelity — Enforcement Reach
+
+Loaded by [`design-fidelity`](../../../rules/design-fidelity.md). The
+honest-enforcement record moved out of the rule verbatim.
+
+## Honest enforcement — `instruction-only`
+
+Nothing records a fidelity comparison. The estate's two design linters measure
+generic AI-aesthetic tells (`lint_design_slop`) and accessibility
+(`lint_design_quality`); neither opens the handover, so nothing can tell a
+proven 1:1 from an asserted one. The proof clause in the Iron Law is therefore
+model-carried, and the committed matrix
+([`design-review`](../skills/design-review/SKILL.md) § Fidelity proof) is the
+control — a reviewer can open it, which is more than any gate here does.
+
+## Routing — why each trigger class is shaped as it is
+
+Every class carries its own near-miss row in `ROUTING_MATRIX`
+([`design_fidelity_routing.test.ts`](../../tests/scripts/design_fidelity_routing.test.ts)),
+and the row must test the direction the NEW trigger opens, not one that was
+already closed — apply that before writing a trigger, not after. Why each class
+is shaped as it is, why `*.html` and a bare builder host are refused, and the
+worked example behind the direction rule:
+[`design-fidelity-routing`](../../../guidelines/design-fidelity-routing.md).

package/dist/agent-src/contexts/execution/auto-dispatch-classification.md

@@ -224,7 +224,7 @@ NEVER A SILENTLY DEGRADED ANSWER. NO LLM CLASSIFIER FALLBACK (CUT C3).
 
 | Task pattern | Lookup class | Primitive |
 |---|---|---|
-| "where is X defined" / "confirm X's definition location" | `definition` | capped `rg` (definition-shaped patterns, `--max-count`); `code_graph query` only as an opportunistic accelerant when an index is present + fresh + `hooks.code_graph.enabled: true` |
+| "where is X defined" / "confirm X's definition location" | `definition` | capped `rg` (definition-shaped patterns, `--max-count`); `code_graph query` only as an opportunistic accelerant when an index is present + fresh (`hooks.code_graph.enabled` gates nothing — it is inert) |
 | "who calls / imports X" / "confirm call sites" | `references` | capped `rg` (reference-shaped patterns); same optional `code_graph affected` accelerant clause |
 | "does string Y exist" / "probe candidate strings" | `string-existence` | FTS one-shot (`memory_lookup` for the knowledge corpus) or capped `rg -n --max-count` for the codebase |
 | "run report Z" / "run check_*" | `report-run` | direct script run, wrapped per the **measured** rtk allowlist (`internal/bench/rtk-savings/RESULTS.md` — wrap only the ~55%-savings class) |
@@ -232,11 +232,11 @@ NEVER A SILENTLY DEGRADED ANSWER. NO LLM CLASSIFIER FALLBACK (CUT C3).
 **Why rg-first** (council 2026-07-28, 2 rounds): the pre-registered benchmark
 behind the `code-graph-retrieval-null` claim (`docs/CLAIMS.md`) measured
 native-graph recall 0.365 vs grep 0.797 on graph-shaped questions — an
-indexing gap that kept `code_graph.enabled` false BY DEFAULT until that flag
-was retired (2026-09-07) — not permanently: the 2026-08-15 withdrawal retracted
-that, and the figures predate the 2026-08-22 extractor repair. The accelerant
-clause above is that bound's escape hatch, reached only when a caller passes a
-usable graph, which no production caller yet does.
+indexing gap that kept `code_graph.enabled` false BY DEFAULT until the hook it
+gated was replaced (2026-09-07), leaving the key inert and still registered —
+not permanently: the figures predate the 2026-08-22 extractor repair. The
+accelerant clause above is that bound's escape hatch, reached only when a
+caller passes a usable graph, which no production caller yet does.
 
 **Escalation, not degradation:** a primitive that returns nothing (index miss,
 pattern too ambiguous, report script absent) — **or an unusable result**

package/dist/agent-src/contexts/execution/roadmap-process-loop.md

@@ -1056,8 +1056,38 @@ execution either way.
 
 ### 6a. Deferred-resolution gate — Iron Law 3
 
-Before any `git mv` to `archive/`, count `[~]` items in the closing
-roadmap. If `count_deferred > 0`, archival is **blocked** per
+**Default: the sweep resolves it.** `archive_completed_roadmaps --all` carries
+every bare `[~]` step, plus every open blocker such a step names, into a
+`<slug>-carried` follow-up created in the same change (`deferral_carry.ts`),
+annotates the parent `carried-to=<slug>`, and archives — the "carry item +
+blocker" council row below, executed deterministically, so a finished
+`/roadmap:process-full` run ends archived instead of parked at 100 %. The
+manual flow below applies only to what the sweep refuses: an open blocker no
+deferred step names, a hand-written annotation that fails validation, or a run
+with `--no-carry`.
+
+**Owner-dependent blockers stop the carry.** When a carried step names a blocker
+whose `Owner:` is the human (`maintainer` / `user` / `owner`, or any value that is
+not `implementer` / `council` / `agent` / `ai`), the sweep writes nothing and
+prints a `❓` block plus one `OWNER-DECISION {json}` line. Put that decision to
+the owner as ONE numbered-options question, never resolve it yourself:
+
+1. **Archive it** — run the printed `archive_command` (`… --owner-decision later --only <roadmap>`):
+   the parent archives, the steps and their blockers park in
+   `later/<slug>-carried.md`.
+2. **Step by step** — show the FIRST step (`first_step`, verbatim) with its
+   blocker's question, in the same message, so the owner can answer it or push
+   it to later in one reply. An answer → do the step, flip it, show the next
+   one. "Later" → leave that step `[~]` and show the next one. When no step is
+   left to show, run that `archive_command`: what is still
+   deferred parks, the parent archives.
+
+A **subagent** never answers this and never passes `--owner-decision` itself: it
+stops and returns the `OWNER-DECISION` line verbatim, and the orchestrator puts
+it to the owner. A non-interactive run ends on the question, not on a report.
+
+Before any `git mv` to `archive/` the sweep refused, count `[~]` items in the
+closing roadmap. If `count_deferred > 0`, archival is **blocked** per
 [`roadmap-progress-sync § Iron Law 3`](../../rules/roadmap-progress-sync.md).
 The loop MUST: