devrites 2.6.1 → 3.0.0

package/pack/.claude/skills/devrites-lib/reference/parallel-dispatch.md

@@ -4,36 +4,76 @@ How `/rite-review` and `/rite-seal` fan out the fresh-context review subagents u
 `.claude/agents/`. The **single source** for the dispatch + reconciliation contract — loaded on
 demand by the calling skill (each points here); not a skill itself.
 
-DevRites ships ten fresh-context review subagents under `.claude/agents/` (plus the
-write-capable `devrites-slice-wright`, which is not a reviewer). Eight are post-build reviewers
-used at the seal / multi-axis review; the other two are gate-specific and *not* part of this
-fan-out — `devrites-strategy-reviewer` is **pre-plan** (it judges the spec for `/rite-temper`)
-and `devrites-plan-reviewer` is **pre-build** (it judges the plan for `/rite-vet`). The seal and
-the multi-axis review need most of the post-build reviewers running **at the same time**, on the
-same workspace + diff, so the verdicts don't contaminate each other.
+The seal/review fan-out **roster** is the seven post-build reviewers in the table below — this
+file is the single source of which reviewer fires when. The seal and the multi-axis review need
+them running **at the same time**, on the same workspace + diff, so the verdicts don't
+contaminate each other. Every other agent under `.claude/agents/` fires from its own phase, not
+here — the roster table below names them under **Not in this fan-out** so the set is unambiguous.
 
 Pattern: delegate to specialized agents with isolated context, brief each one precisely, run
 them concurrently, reconcile on return.
 
-## When to use which subagent
+## The roster — every reviewer the fan-out accounts for
 
-| Subagent | Always | Conditional |
+These seven are the **roster**. `/rite-seal` accounts for **all** of them — the always-on three
+plus each conditional, either dispatched or skip-recorded; `/rite-review` runs the two always-on
+axes. Each trigger is a *checkable signal*, not a judgement call, so a conditional reviewer is
+either fired or consciously skipped — never silently dropped.
+
+| Reviewer | Fires | Trigger — the checkable signal |
 |---|---|---|
-| `devrites-spec-reviewer` | `/rite-review` Spec axis; `/rite-seal` | — |
-| `devrites-code-reviewer` | `/rite-review` Code-review axis; `/rite-seal` | — |
-| `devrites-test-analyst` | `/rite-seal` | — |
-| `devrites-frontend-reviewer` | — | UI files in the diff |
-| `devrites-security-auditor` | — | input / auth / data / external integrations / secrets in scope |
-| `devrites-performance-reviewer` | — | perf budget in `spec.md` or visible regression risk |
-| `devrites-doubt-reviewer` | — | a non-trivial decision is being stood up (called from `devrites-doubt`) |
-| `devrites-simplifier-reviewer` | — | `/rite-polish` Phase 1 audit (called from `devrites-audit simplify`) |
+| `devrites-spec-reviewer` | always | `/rite-review` Spec axis; `/rite-seal` (carry review's verdict forward only if the diff is unchanged) |
+| `devrites-code-reviewer` | always | `/rite-review` Code-review axis; `/rite-seal` (carry forward only if the diff is unchanged) |
+| `devrites-test-analyst` | always | at `/rite-seal` |
+| `devrites-frontend-reviewer` | conditional | the diff touches a UI file — component / template / stylesheet, per the project's UI paths |
+| `devrites-security-auditor` | conditional | the diff touches input handling, auth / authz, data storage or access, an external integration, or a secret |
+| `devrites-performance-reviewer` | conditional | `spec.md` states a perf budget, **OR** the diff adds a query / a loop over a growing set / hot-path or render work |
+| `devrites-devex-reviewer` | conditional | the diff changes a developer-facing surface — public API, CLI, SDK/library export, webhook, config/env contract, error message, or getting-started path |
+
+### Hit-rate gating — consult before dispatching conditionals
+
+Before dispatching, run `devrites-engine reviewer-stats report`. It grades each reviewer from the
+cross-feature dispatch ledger (`.devrites/reviewer-stats.jsonl`):
+
+- `run` / `run (always-on)` / `run (insurance — never gated)` — dispatch per the trigger table above.
+- `gate-candidate` — this **conditional** reviewer produced zero surviving findings in its last 10+
+  dispatches on this project. Skip it as a *recorded* skip:
+  `devrites-engine footprint log <slug> skip devrites-<x>-reviewer` with the reason
+  `gated: zero surviving findings in <N> dispatches`. The roster gate stays satisfied — a gated
+  skip is a conscious skip.
+
+The verdict is engine-owned and deterministic; never gate by your own judgement of a reviewer's
+past usefulness. Two hard bounds: the always-on axes (`spec`, `code-review`, `test-analyst`) and
+the insurance reviewers (`security-auditor`, `doubt-reviewer`) are **never** gated — the engine
+never grades them `gate-candidate`, and a caller must not skip them on hit-rate grounds. The user
+can override gating for one run by asking for a full panel (`--full`): then dispatch every
+triggered reviewer regardless of verdict.
+
+After reconciliation, close the loop — record each **dispatched** reviewer's outcome so the
+ledger stays live:
+
+```bash
+devrites-engine reviewer-stats record devrites-<x>-reviewer <surviving Critical+Important count> <slug>
+```
+
+Surviving means it stood after reconciliation and dismissals — a finding the caller dismissed as a
+false positive does not count. Record `0` honestly; dry streaks are the signal.
+
+**Not in this fan-out** (named so the roster is unambiguous): `devrites-simplifier-reviewer` fires
+at `/rite-polish` Phase 1 (via `devrites-audit simplify`) and `devrites-doubt-reviewer` fires from
+`devrites-doubt` when a decision is stood up — neither is a seal reviewer, so neither is part of
+the seal accounting. `devrites-strategy-reviewer` (pre-plan, `/rite-temper`), `devrites-plan-reviewer`
+(pre-build, `/rite-vet`), `devrites-forge-judge` (`/rite-build` forge), and `devrites-retrospector`
+(`/rite-ship` close) are single-agent, phase-locked gates — they fire iff their phase runs, not here.
 
 One entity, one name: the `devrites-code-reviewer`'s axis is the **Code-review axis** everywhere
 (at both `/rite-review` and `/rite-seal`) — don't rename it per caller.
 
 ## Dispatch shape
 
-For each chosen subagent, the caller uses the `Task` tool with this prompt shape:
+For each chosen subagent, the caller uses the harness's subagent primitive — the `Task` tool on
+Claude Code, `spawn_agent` (with the matching `.codex/agents/devrites-*.toml` custom agent) on
+Codex — with this prompt shape:
 
 ```
 Audit the active DevRites feature.
@@ -61,10 +101,44 @@ reconciles.
 
 Rules:
 
-- **One Task call per subagent.** Send them in a single message with multiple `Task` invocations so the runtime dispatches concurrently.
+- **One Task call per subagent, awaited in the same turn.** Send them in a single message with multiple `Task` invocations so the runtime dispatches concurrently. Never background/detach reviewers in `/rite-autocomplete` or AFK; there is no event loop that guarantees a later result is reconciled.
 - **No cross-pollination.** Each subagent gets only its narrow brief and the workspace path. Do not pass another subagent's findings into a sibling's prompt — that recreates the masking problem.
 - **No author context.** Do not include the caller's analysis or the user's framing of the change; the point is a fresh, adversarial read.
+- **Never coach a reviewer.** No "do not flag X", "treat Y as at most Minor", or "the plan
+  chose this" in a dispatch prompt — pre-judging findings is how a known defect sails through.
+  A plan-mandated quirk still gets reported; the caller (or the human) grades it, not the prompt.
 - **Feature scope only.** Each subagent must stay inside `touched-files.md` + the diff.
+- **Can't-verify is a verdict, not a pass.** A reviewer that cannot verify a spec requirement
+  from the diff + its allowed reads returns it as a `CANNOT-VERIFY: <requirement> — <why>` line.
+  The caller resolves each one itself before the gate; an unresolved CANNOT-VERIFY on an
+  acceptance-mapped requirement stands as a gap, not a pass.
+
+## Account for every reviewer — the roster gate
+
+The fan-out is done only when **every roster reviewer is accounted for** — dispatched, or
+consciously skipped with a one-line reason. A conditional reviewer that genuinely does not apply
+(no UI in the diff → `frontend-reviewer`) is a *recorded* skip, not a silent no-op. That record
+is the difference between "reviewed" and "declared done after firing three of seven" — the silent
+skip is exactly how a needed reviewer never runs.
+
+Record each decision to the footprint as you make it (via `devrites-engine footprint`, as in `/rite-build`). Log the reviewer's
+**exact agent name** — the `.claude/agents/` stem, e.g. `devrites-frontend-reviewer`; the `roster`
+gate matches on it (stripping the `devrites-` prefix), so a freehand label like `frontend` or
+`Spec axis` will not match and the gate reads that reviewer as unaccounted:
+
+- dispatched → `devrites-engine footprint log <slug> reviewer devrites-<x>-reviewer`  (the dispatch record itself)
+- skipped → `devrites-engine footprint log <slug> skip devrites-<x>-reviewer`  # e.g. `skip devrites-frontend-reviewer` — no UI in the diff
+
+Then, **before the verdict**, prove the roster is complete:
+
+```bash
+devrites-engine footprint roster <slug>   # rc=0 complete · rc=3 a reviewer was neither dispatched nor skipped · rc=1 an always-on reviewer was skipped
+```
+
+`rc=3` is the silent omission the gate exists to catch: resolve it by dispatching the reviewer or
+recording why it does not apply — never by proceeding with it unaccounted. `rc=1` means an
+always-on axis (Spec / Code-review) was skip-recorded; that is legitimate only as a carry-forward
+of `/rite-review`'s verdict on an **unchanged** diff — confirm that, don't wave it through.
 
 ## Reconciliation
 
@@ -76,6 +150,16 @@ When the subagents return:
 4. **One scale.** All subagents use the same five-label scale (Critical / Important / Suggestion / Nit / FYI). Reject any subagent output that invents its own. **Exception:** `devrites-simplifier-reviewer` deliberately emits only Suggestion / Nit / FYI (it is non-blocking by design) — that is a valid subset of the scale, not an invented one; do not reject it during reconciliation.
 5. **Consensus roll-up (after the verbatim per-axis record).** Keep every axis's findings verbatim under its `## <axis>` heading (above), then add one deduped roll-up the gate reads: where **≥2 axes flag the same `file:line`**, raise it to the top and mark it *consensus* — independent corroboration raises confidence. A lone low-confidence finding with no `file:line` or evidence anchor drops out of the roll-up (it stays in its per-axis section). The roll-up reduces noise without hiding any axis — the verbatim sections are the audit trail; the roll-up is the actionable summary the gate acts on.
 
+## Model tier
+
+Every reviewer in this fan-out runs at **ceiling tier** — the orchestrator's own model, inherited
+by declaring no `model:` in the agent definition (see
+[`model-tiers.md`](model-tiers.md)). Adversarial review is exactly where a cheaper model costs the
+most: a missed Critical is far more expensive than the tokens saved. Do not downgrade a reviewer to
+save cost. Extraction-tier savings belong to scouts (archive-search, footprint), not to the panel.
+
 ## Fallback
 
-If the `Task` tool is unavailable in the current environment, the caller runs the relevant subagent discipline **inline** in its own context and flags the result as a fallback (not an independent review). The seal weighs the fallback differently — see [`../../rite-seal/reference/risk-and-rollback.md`](../../rite-seal/reference/risk-and-rollback.md).
+If the harness has **no subagent primitive at all** (neither Claude's `Task` nor Codex's
+`spawn_agent` — an absent tool on one harness while the other's equivalent exists does NOT
+qualify), the caller runs the relevant subagent discipline **inline** in its own context and flags the result as a fallback (not an independent review). The seal weighs the fallback differently — see [`../../rite-seal/reference/risk-and-rollback.md`](../../rite-seal/reference/risk-and-rollback.md). This is the [`model-tiers.md`](model-tiers.md) degradation rule applied to the review panel: no subagent primitive → run inline under the same discipline and budget.

package/pack/.claude/skills/devrites-lib/reference/reply-contract.md

@@ -0,0 +1,111 @@
+# DevRites completion reply contract
+
+Use this for every user-facing, workspace-operating `rite-*` skill. The chat reply is
+a compact status summary; durable detail belongs in the phase artifact
+(`spec.md`, `plan.md`, `eng-review.md`, `evidence.md`, `polish-report.md`,
+`review.md`, `seal.md`, `ship.md`, and related records).
+
+Before the final reply, persist the phase event, then render the deterministic
+progress chrome:
+
+```bash
+devrites-engine timeline log completed --skill <skill> --slug "$(cat .devrites/ACTIVE 2>/dev/null)" --outcome "<ok|blocked|no-go|go>" --decision "<one-line result>"
+devrites-engine budget
+devrites-engine progress
+```
+
+If the phase produced a quality verdict (review, prove, polish, seal, ship), also
+record the evidence-backed health signal before `progress`:
+
+```bash
+devrites-engine health record <0..10> "<evidence-backed label>" --note "<primary check or blocker>"
+```
+
+Skip `timeline` / `health` only when the skill is explicitly workspace-less or
+read-only and has no active `.devrites` workspace.
+
+Do not restate the slice meter or flow ribbon in prose. Keep the default reply to
+roughly 8-10 lines after the progress footer.
+
+## Default completion
+
+```text
+Done: <phase result in one sentence>
+Changed: <artifact(s) written/updated, or "workspace only">
+Evidence: <checks/proof/artifact pointer, or "not applicable">
+Open: <none | non-blocking questions or follow-ups>
+Next: <exactly one recommended command>
+Record: <primary durable artifact path>
+↻ Hygiene: <clear/compact/handoff advice, one line>
+```
+
+Rules:
+- Use this default form only for a green, non-blocking result. If proof, a verdict,
+  or a required decision is missing, use `Awaiting human`, `Stopped / blocked`, or
+  `NO-GO`; do not label the phase `Done` or advance it.
+- `Next:` contains exactly one recommended command. Put alternates in `Open:` or an
+  `Alternative:` line only when the phase needs one.
+- Use `Evidence: not applicable` only when the phase truly does not verify runtime
+  behavior, such as spec or plan creation.
+- Claims such as "proved", "reviewed", "sealed", "shipped", and "all slices built"
+  must point to evidence or an artifact.
+- Use stable labels: `Done`, `Changed`, `Evidence`, `Open`, `Next`, `Record`,
+  `↻ Hygiene`.
+- Status symbols are optional; never rely on color or emoji alone. Pair them with
+  explicit text labels such as `Done`, `Stopped`, `Awaiting human`, `NO-GO`, `GO`,
+  or `Shipped`.
+
+## Awaiting human
+
+```text
+Awaiting human: <qid> · <gate> · <slice/phase>
+Question: <one-line question>
+Recommended: <option 1 + short reason>
+Options: <2-4 compact choices, if already generated>
+Resume: /rite-resolve <qid> "<answer>"
+Record: .devrites/work/<slug>/questions.md
+↻ Hygiene: no /clear until the answer is persisted
+```
+
+## Stopped / blocked
+
+```text
+Stopped: <reason>
+Blocking: <specific blocker>
+Why: <one-line impact>
+Fix: <single command or action>
+Record: <artifact path>
+↻ Hygiene: /compact (<topic>) if fixing now; /clear if stopping
+```
+
+## NO-GO
+
+```text
+NO-GO: <short verdict>
+Blockers: <count + top 1-3 blockers>
+Fix: <single next command>
+Record: .devrites/work/<slug>/seal.md
+↻ Hygiene: /compact (seal blockers) if fixing now; /clear if stopping
+```
+
+## GO
+
+```text
+GO: feature cleared to ship
+Follow-ups: <none | non-blocking count>
+Next: /rite-ship
+Record: .devrites/work/<slug>/seal.md
+↻ Hygiene: /clear before /rite-ship
+```
+
+## Shipped
+
+```text
+Shipped: <feature>
+Commit: <sha> on <branch>
+Tag/PR: <value | none>
+Acceptance: <n>/<total> proven
+Archived: .devrites/archive/<slug>/ · ACTIVE cleared
+Record: .devrites/archive/<slug>/ship.md
+↻ Hygiene: /clear
+```

package/pack/.claude/{rules → skills/devrites-lib/reference/standards}/README.md

@@ -1,6 +1,6 @@
 # DevRites rules
 
-Stack-agnostic engineering rules that DevRites installs to `.claude/rules/`. They encode
+Stack-agnostic engineering rules that DevRites installs to `.claude/skills/devrites-lib/reference/standards/`. They encode
 the standards the DevRites workflow holds code to — quality, safety, testing, and review
 discipline that apply in any language.
 
@@ -10,10 +10,9 @@ prefers what's already there).
 
 ## Loading model — progressive disclosure
 
-To keep context lean, the rules follow Claude's progressive-disclosure pattern. There
-are 23 rule files (plus this README index): each DevRites `rite-*` skill Reads
-`.claude/rules/core.md` as its first step; the other 22 rule files load on demand by the
-phase that needs them.
+To keep context lean, the rules follow progressive disclosure: each DevRites `rite-*`
+skill Reads `.claude/skills/devrites-lib/reference/standards/core.md` as its first step;
+the remaining rule files load on demand by the phase that needs them.
 
 ### Always-on (read by each `rite-*` skill as step 0)
 
@@ -29,8 +28,9 @@ phase that needs them.
 | `prose-style.md` | Human-voice writing for artifacts + replies; two registers (prose vs technical); the LLM-tell cut-list. Depth in the `devrites-prose-craft` skill. | Any phase that writes prose — `/rite-spec`, `/rite-define`, `/rite-review`, `/rite-seal`, `/rite-ship`; `/rite-polish` Phase 1 as the catch. |
 | `error-handling.md` | Fail fast, no silent catches, meaningful messages, fail closed. | `/rite-build`, `/rite-polish` (backend), `/rite-review`. |
 | `testing.md` | Pyramid, behavior over implementation, determinism. | `/rite-build`, `/rite-prove`, `/rite-review`. |
-| `spec-grammar.md` | Optional, recommended structure for behavioral acceptance — `### Requirement:` (SHALL/MUST) + `#### Scenario:` (WHEN/THEN), validated deterministically by `spec-validate.sh`. Progressive rigor; flat `[ACn]` bullets stay valid. | `/rite-spec` readiness gate; `/rite-prove`, `/rite-review` consume the scenario hooks. |
+| `spec-grammar.md` | Optional, recommended structure for behavioral acceptance — `### Requirement:` (SHALL/MUST) + `#### Scenario:` (WHEN/THEN), validated deterministically by `devrites-engine spec-validate`. Progressive rigor; flat `AC-###` bullets stay valid. | `/rite-spec` readiness gate; `/rite-prove`, `/rite-review` consume the scenario hooks. |
 | `code-review.md` | Small PRs, severity labels, what to check, actionable feedback. | `/rite-review`, `/rite-seal`. |
+| `edge-case-trace.md` | Mechanical branch/boundary sweep, fixed-set siblings, and deletion-contract checks. | `/rite-review`, `/rite-seal`, `devrites-doubt`. |
 | `security.md` | Untrusted input, least privilege, secrets, three-tier trust boundary, fail closed. | When input / auth / data / integrations are in scope. |
 | `performance.md` | Measure first, common pitfalls, prove the win. | When perf is in scope. |
 | `observability.md` | Structured logs, metrics/SLIs, traces, symptom-based alerts, verify-the-telemetry-fires — proof a feature works in prod. | When the change has a runtime surface (endpoint, job, integration, user flow); `/rite-prove`, `/rite-seal`. |
@@ -38,7 +38,9 @@ phase that needs them.
 | `patterns.md` | SOLID, composition, loose coupling, avoid over-engineering. | `/rite-build`, simplification audit. |
 | `git-workflow.md` | Conventional Commits, atomic commits, small PRs. | `/rite-ship` commit / push / tag steps. |
 | `hooks.md` | Stage checks by cost, fast local hooks, secret scanning. | Reference-only — read when setting up the project's git hooks; not auto-loaded by any phase. |
+| `ci-cd.md` | Shift-left + faster-is-safer, the no-skip gate pipeline, the CI-failure loop, Build Cop, feature-flags decouple deploy from release, secret tiers, the pipeline-speed ladder. | Reference — read when setting up or changing a build/deploy pipeline; `/rite-ship` when CI/CD is in scope. |
 | `documentation.md` | Explain why, keep current, record decisions. | `/rite-spec`, `/rite-define`, `/rite-seal`. |
+| `elicitation.md` | A move-set of named reasoning techniques (Steelman, Delphi, Red-Team/Blue-Team, Assumption Audit, Pre-Mortem…) selected per section by risk, to deepen a spec or plan on demand. | `/rite-temper`, `/rite-vet`; any section that needs sharper thinking. |
 | `development-workflow.md` | Small batches, trunk-always-green, definition of done. | `/rite-define`, `/rite-plan`. |
 | `principles.md` | The four knowledge layers; project invariants (`.devrites/principles.md`) as a *trusted, gating* pass/fail (vs conventions' untrusted prior); justified-exception register; dated-amendment governance. | `/rite-define`, `/rite-vet`, `/rite-build`, `/rite-review`, `/rite-seal`; seeded by `/rite-adopt`, grown by `/rite-learn`. |
 | `deprecation.md` | Code-as-liability, Hyrum's law, prove-unused-before-remove, expand→contract, deprecate-before-delete. The safe path behind the irreversible-migration gate. | When removing / replacing / migrating code, a feature, an API, or data. |
@@ -47,6 +49,12 @@ phase that needs them.
 | `anti-patterns.md` | Pack-wide rationalizations + red flags the agent reaches for. | Loaded by each `rite-*/reference/anti-patterns.md`; loaded directly when reluctance is broader than the active phase. |
 | `afk-hitl.md` | AFK vs HITL contract: `.devrites/AFK` sentinel format, `questions.md` schema, four-gate taxonomy (advisory / validating / blocking / escalating), AFK-never-silently-accepts boundaries. | `/rite-build`, `/rite-status`, `/rite-resolve`, `devrites-doubt`; anywhere a pause-or-proceed decision happens. |
 | `tooling.md` | Optional external tools — code intelligence (codebase-memory-mcp first → cross-verify with codegraph + graphify → standard methods LSP / `Read`/`Grep`/`Glob`), up-to-date library docs (context7), architecture/ADR memory. Recommended, not required. | Any phase doing structural lookups (callers / impact / placement) or relying on external library/framework facts. |
+| `skill-authoring.md` | Skill descriptions, progressive disclosure, completion criteria, and pruning rules for keeping DevRites skills predictable and cheap. | When creating or editing DevRites skills or reviewing skill pack quality. |
+| `definition-of-done.md` | Done means acceptance proven, evidence recorded, drift resolved, and handoff/ship state clean. | `/rite-prove`, `/rite-seal`, `/rite-ship`. |
+| `review-checklist.md` | Compact reviewer pass/fail checklist. | `/rite-review`, `/rite-seal`. |
+| `test-proof-checklist.md` | Proof-quality checklist for tests and evidence. | `/rite-prove`, `/rite-seal`. |
+| `browser-proof-checklist.md` | Browser/UI proof checklist. | UI features in `/rite-prove`, `/rite-polish`, `/rite-seal`. |
+| `security-checklist.md` | Security review checklist. | Auth/input/data/integration changes. |
 
 How they're used: DevRites skills follow these rules; you and Claude can reference them
 directly. They are guidance, not enforced gates — the enforced gates live in the

package/pack/.claude/{rules → skills/devrites-lib/reference/standards}/afk-hitl.md

@@ -14,12 +14,16 @@ The contract is intentionally small: one sentinel, one queue, one verb.
   human picks; the skill records the pick to `questions.md` (`answered`) + `decisions.md` and
   **continues in place — no `/rite-resolve` round-trip**. `/rite-resolve` is only for answering
   **async** (a pause that already stopped the session) or in **batch**.
+  **No interactive question tool in the current surface?** (Codex outside Plan mode —
+  `request_user_input` is Plan-mode-only.) Render the same option set as a plain numbered
+  list in chat and **end the turn**; the human's reply is the pick. Auto-picking an option
+  is **AFK's contract, gated by the `.devrites/AFK` sentinel** — a missing tool never
+  converts a HITL gap into a self-answered one.
 - **AFK** — `.devrites/AFK` is present. For any gate AFK may auto-handle (severity in
   `allow_gates`), the skill **auto-picks the recommended option** (option 1 of the set), records
   it (`gate: advisory` + a `decisions.md` ADR), and continues unattended. Gates above the
   ceiling — and every irreversible-risk item — pause and queue a `questions.md` entry for
-  `/rite-resolve`, **unless `allow_irreversible: true`** is set (see [Maximal
-  autonomy](#irreversible-risk-list-always-pause)).
+  `/rite-resolve`.
 
 `.devrites/AFK` presence is authoritative for run mode; gate-deciding skills re-read the
 sentinel at decision time (the shared preamble derives the mode from it). There is no
@@ -33,14 +37,11 @@ Presence = AFK active. The file body is optional YAML:
 max_slices: 10                       # read-only INITIAL budget; seeds state.md `AFK slices remaining`
 notify: "ntfy.sh/my-topic"           # shell command run on awaiting_human transition
 allow_gates: [advisory, validating]  # gate severities AFK auto-handles (auto-picks the recommended option)
-allow_irreversible: false            # DANGER, opt-in. true → auto-pick the recommended option even on
-                                     # irreversible gates (drop-table, auth, public-API break, data-loss).
-                                     # Lifts the safety floor; destructive changes ship unattended. Default false.
 ```
 
 The file is **read-only config** — never rewritten in place. `max_slices` is the initial
 budget; the mutable remaining count lives in `state.md` as `AFK slices remaining: <n>`,
-seeded from `max_slices` on the first AFK build and decremented by `tick-afk.sh` (which
+seeded from `max_slices` on the first AFK build and decremented by `devrites-engine tick-afk` (which
 exits non-zero at 0, forcing a HITL stop). The cap is enforced by the script, not prose.
 
 Missing keys fall back to defaults:
@@ -50,14 +51,13 @@ Missing keys fall back to defaults:
 | `max_slices` | unlimited | a missing cap is unsafe; recommend setting one explicitly |
 | `notify` | none | no notification fires |
 | `allow_gates` | `[advisory]` | AFK auto-handles advisory only by default (auto-picks the recommended option) |
-| `allow_irreversible` | `false` | when `true`, AFK auto-picks even irreversible-risk gates — the safety floor is lifted (see [Maximal autonomy](#irreversible-risk-list-always-pause)) |
 
 To leave AFK, delete the file. The next skill invocation reverts to HITL.
 
 ## The four gates
 
 Every `Mode: HITL` slice declares a `Gate:` and an `SLA:`. See
-[`.claude/skills/rite-define/reference/gates.md`](../skills/rite-define/reference/gates.md)
+[`.claude/skills/rite-define/reference/gates.md`](../../../rite-define/reference/gates.md)
 for the full taxonomy. Summary:
 
 | Gate | Stakes | Pause? | SLA | AFK auto-handle when in `allow_gates`? |
@@ -115,14 +115,6 @@ abandon the work.
 
 By default, AFK widens what's *automatic*; it never widens what's *irreversible*.
 
-**Maximal autonomy (`allow_irreversible: true` — opt-in, dangerous).** Setting this key in
-`.devrites/AFK` lifts the floor: AFK then **auto-picks the recommended option on irreversible
-gates too, with no pause**. This ships destructive migrations / auth changes / public-API
-breaks / data-loss paths **unattended, with zero human review** — recommended *only* on a
-throwaway or sandboxed target you can roll back wholesale. Default is `false`; a missing key
-keeps the floor. The floor is the deliberate safety default — `allow_irreversible` is the user
-pulling the trigger themselves, not something a stray sentinel can do silently.
-
 ## `questions.md` schema
 
 Append-only. One entry per qid. Format:
@@ -184,7 +176,7 @@ stopped the session (an AFK blocking/escalating/irreversible queue, or a HITL pa
 walked away from), plus `--batch`. In an **interactive HITL** session the skill resolves the
 `AskUserQuestion` pick **in place** (the same `questions.md` `answered` write + `state.md`
 clear), so you don't type `/rite-resolve` for gaps you answer live. Both paths flip
-`status: open → answered` and clear `Awaiting human` through the **same `resolve.sh` writer** —
+`status: open → answered` and clear `Awaiting human` through the **same `devrites-engine resolve` writer** —
 one source of truth, two entry points (live pick vs typed verb). Manual edits work but the
 script is the contract — use it.
 
@@ -215,7 +207,7 @@ doubt becomes a blocking question regardless of AFK config.
   On the third failure, stop guessing and convert it to a `gate: blocking` question — a fourth
   identical attempt is thrash, not progress.
 - **Stuck loops pause even in AFK.** A detected loop — the same action repeating, or an
-  action↔error ping-pong — pauses regardless of `allow_gates` (`stuck.sh`), the same standing as
+  action↔error ping-pong — pauses regardless of `allow_gates` (`devrites-engine stuck`), the same standing as
   the irreversible-risk list. AFK widens what's automatic, never what's looping.
 - **Bias to self-resolve.** Before raising a question, try to answer it from the code, the docs,
   or `decisions.md`. Communicate only for a blocked environment, a deliverable to hand over,

package/pack/.claude/{rules → skills/devrites-lib/reference/standards}/agents.md

@@ -6,10 +6,23 @@ It separates three roles: **specialist skills** (model-invoked disciplines that
 and the **executor subagent** (`devrites-slice-wright` — fresh-context but **write-capable**,
 the one agent that produces code).
 
+## Model tier policy
+
+Use [`model-tiers.md`](../model-tiers.md) when a harness supports model choice. Wright defaults to
+standard/inherited, with the strongest available model for high-risk architecture, migration, auth,
+or public API slices; cheap tiers are only for mechanical read-only scouts. Seal/spec/security
+reviewers stay strongest/inherited. If the harness cannot select models, record "host default".
+
 ## Review subagents — `.claude/agents/`
 Fresh-context, read-only reviewers. Each is given the active feature workspace path
 (`.devrites/work/<slug>/`) + the diff, and returns findings — they do **not** edit code.
 
+**Which reviewer fires when is defined once** in
+[`parallel-dispatch.md`](../../../devrites-lib/reference/parallel-dispatch.md) — the seal/review
+fan-out **roster** and its checkable triggers, plus the accounting gate that proves no reviewer is
+silently skipped. The table below is the full catalog (it also covers the phase-locked agents the
+roster excludes); its **When** column is a summary — on any discrepancy, the roster wins.
+
 | Agent | Purpose | When |
 |-------|---------|------|
 | `devrites-spec-reviewer` | Does the diff implement the spec? Missing / partial / wrong criteria; scope creep | `/rite-review` (Spec axis); `/rite-seal` |
@@ -55,7 +68,7 @@ a finding class reviewers keep raising, recurring drift, dead-ends, the GO/NO-GO
 
 | Agent | Purpose | When |
 |-------|---------|------|
-| `devrites-retrospector` | Cross-feature retrospective synthesis — mine recurring patterns + trends across shipped features, **draft** graduation candidates (rule / principle / convention / dismiss) | `/rite-ship` close, cadence-gated by `learnings.sh nudge` (fires only with enough cross-feature signal) |
+| `devrites-retrospector` | Cross-feature retrospective synthesis — mine recurring patterns + trends across shipped features, **draft** graduation candidates (rule / principle / convention / dismiss) | `/rite-ship` close, cadence-gated by `devrites-engine learnings nudge` (fires only with enough cross-feature signal) |
 
 It **proposes, never imposes**: it writes nothing itself — the caller (`/rite-ship`) persists the
 digest to `.devrites/retro.md` and routes any promotion through `/rite-learn`, where the human
@@ -94,29 +107,72 @@ The prefix mirrors visibility:
   (`.claude/skills/devrites-lib/reference/parallel-dispatch.md`), pointed at by both
   `/rite-review` and `/rite-seal`.
 
-The `/rite` menu carries the routing previously held by `devrites-selector`, which
-has been removed. `user-invocable:` in each `SKILL.md` is the source of truth; the
-prefix is a naming convention that matches it.
+The `/rite` menu carries user-facing routing. `user-invocable:` in each
+`SKILL.md` is the source of truth; the prefix is a naming convention that matches it.
 
 ## When to bring in a reviewer (no prompt needed)
+The seal/review fan-out is **roster-driven**: sealing a feature dispatches every roster reviewer
+whose trigger the diff meets (frontend on UI, security on input/auth/data, performance on a perf
+budget or hot-path, devex on a developer-facing surface) and accounts for the rest — the triggers
+and the no-silent-skip gate are the single source in
+[`parallel-dispatch.md`](../../../devrites-lib/reference/parallel-dispatch.md). Three reviewers
+fire **outside** that fan-out:
 1. Standing a non-trivial decision (boundary, data model, auth, public API, migration) →
    `devrites-doubt` → `devrites-doubt-reviewer`.
-2. Sealing a feature → fan out to the relevant reviewers above.
-3. A UI feature at seal → include `devrites-frontend-reviewer`.
-4. Input/auth/data/integration in scope → include `devrites-security-auditor`.
-5. A developer-facing surface in scope (public API / CLI / SDK / webhook / config / error messages /
-   getting-started path) → `devrites-devex-reviewer`, at `/rite-vet` to **predict** and at `/rite-seal`
-   to **measure + reconcile the boomerang** (`developer-experience.md`).
-6. Closing a feature at `/rite-ship`, cadence-gated → `devrites-retrospector` (below). Not a per-diff
+2. A developer-facing surface also gets `devrites-devex-reviewer` **at `/rite-vet` to predict** the
+   DX scorecard — the seal side then measures and reconciles the boomerang (`developer-experience.md`).
+3. Closing a feature at `/rite-ship`, cadence-gated → `devrites-retrospector` (below). Not a per-diff
    reviewer: it fires only when there's enough cross-feature signal to mine.
 
+## How skills reach an agent (both harnesses)
+
+A spawned agent runs in a **fresh context** and does **not** auto-discover skills the way the main
+thread does. Naming a skill in an agent's body ("apply `devrites-frontend-craft`") is a prompt
+reference, not a load — the agent must actually **invoke** the skill, and how it can differs by
+harness:
+
+- **Claude Code** gates skills behind the agent's `tools:` allowlist. An agent that lists `tools:`
+  without `Skill` **cannot invoke any skill**. Two ways to grant access: add **`Skill`** to `tools:`
+  (on-demand invocation — right for the stack-agnostic wright, so a backend slice pays no cost), or a
+  **`skills:`** frontmatter field (preloads the full skill content at startup — right for a focused
+  reviewer that *always* needs it, e.g. `devrites-frontend-reviewer` preloads `devrites-frontend-craft`).
+- **Codex** does not gate skills per-agent: skills are auto-discovered from `.agents/skills/` and
+  subagents inherit that access. So the same agent body that names the skill lets a Codex agent invoke
+  it (`$devrites-frontend-craft`, or implicitly). The Claude-only `skills:`/`Skill` metadata is dropped
+  in translation — do **not** map it to Codex `skills.config`, which *disables* skills, not preloads them.
+
+The durable, cross-harness lever is the **agent body**: name the skill and instruct the agent to
+*invoke* it (carried to Codex via the installer's `developer_instructions`). The `SubagentStart` hook
+(`devrites-engine hook subagent-orient`, Claude) and `AGENTS.md` (Codex) inject the operating-rule discipline
+into every DevRites subagent, since a fresh subagent doesn't run the rite-\* skills that load the rules.
+
+**Reaching every agent, not just one skill.** A fresh subagent doesn't load the `.claude/skills/devrites-lib/reference/standards/`
+framework either — so a reviewer whose whole job is a rule (`security.md`, `performance.md`,
+`testing.md`, `code-review.md`, …) must **Read that rule file at the start of its review**, the
+rule-analog of invoking a skill. Without it the reviewer judges from a remembered summary and misses
+every sharpening the rule has grown. So the discipline is uniform across the fan-out:
+
+- **wright** → reads its in-scope rules (`coding-style`, `testing`, `error-handling`, `patterns`,
+  `security`/`performance` when relevant) **and** invokes its craft skills on demand
+  (`devrites-frontend-craft` / `-source-driven` / `-api-interface`).
+- **frontend reviewer** → preloads the `devrites-frontend-craft` **skill** (its axis has one).
+- **every other reviewer** → Reads its governing **rule** first (code-reviewer→`code-review`+`coding-style`
+  +`patterns`; security→`security`; performance→`performance`; test→`testing`; spec→`spec-grammar`;
+  simplifier→`coding-style`+`patterns`; devex→`developer-experience`; forge-judge→`coding-style`+`testing`
+  +`principles`). Promote a reviewer to a preloaded skill only when a canonical one appears for its axis.
+
+The rule paths are written as `.claude/skills/devrites-lib/reference/standards/<x>.md`; the installer rewrites them to
+`.agents/skills/devrites-lib/reference/standards/<x>.md` for Codex, so one body line serves both harnesses.
+
 ## Rules
 - Run independent reviewers **in parallel** at the seal, then reconcile; surface
   disagreements explicitly rather than averaging them away.
-- Reviewer read-only is **enforced at the tool layer**, not just promised: each reviewer
-  carries a shared deny-mutating-Bash frontmatter hook (`devrites-reviewer-readonly.sh`). A
-  fresh-context reviewer reads untrusted source — a silent write path would be a prompt-injection
-  surface.
+- Reviewer read-only is **wired at the tool layer**: each reviewer carries a shared
+  deny-mutating-Bash hook (`devrites-engine hook reviewer-readonly`) — via subagent frontmatter on Claude
+  Code (project-local install), and globally with agent-type gating in `.codex/hooks.json` on
+  Codex. It runs **observe-by-default** (logs a would-block) and **denies** under
+  `DEVRITES_REVIEWER_RO=enforce`. A fresh-context reviewer reads untrusted source — a silent write
+  path would be a prompt-injection surface, so enable enforce once the log shows no false positives.
 - **Reviewer** agents are **read-only** and return labeled findings (Critical / Important /
   Suggestion / Nit / FYI). Keep review **feature-scoped**.
 - The **executor** agent (`devrites-slice-wright`) is the one **write-capable** agent: it writes
@@ -124,4 +180,13 @@ prefix is a naming convention that matches it.
   `.devrites/` workspace files (the orchestrator does) and never runs in parallel with another
   writer.
 - Give each agent the contract (workspace + diff for a reviewer; the slice contract for the
-  wright) without the author's reasoning — fresh, undirected context is the point.
+  wright) without the author's reasoning — fresh, undirected context is the point.
+- **Orchestration depth ≤ 1 — agents don't invoke agents.** The `rite-*` skill (driven by the
+  user) is the orchestrator; it dispatches reviewers and the wright, collects their findings, and
+  reconciles. A reviewer never spawns another reviewer, and the wright never spawns a sub-writer —
+  the fan-out is one level, always from the orchestrator. Four shapes this rules out: a
+  "meta-orchestrator" agent whose only job is routing (that's the skill's job), an agent that calls
+  a second agent, a sequential chain where each agent paraphrases the last one's hand-off (lossy —
+  the orchestrator passes the real artifact, not a summary), and deep agent trees. Parallel fan-out
+  is many dispatches in **one** orchestrator turn, not nested ones; on Claude Code the platform
+  also enforces this (a subagent can't spawn subagents), so the invariant and the runtime agree.

package/pack/.claude/{rules → skills/devrites-lib/reference/standards}/anti-patterns.md

@@ -5,8 +5,7 @@ the way. Apply at every phase. Each `rite-*/reference/anti-patterns.md`
 extends this with phase-specific items.
 
 This file is the **single source** of the universal anti-rationalization table.
-`core.md` carries only a minimal 5-row subset (its first five rows are
-byte-identical to the matching rows below); read this file for the full set.
+`core.md` points here when an excuse appears.
 
 ## Universal rationalizations
 
@@ -22,7 +21,7 @@ byte-identical to the matching rows below); read this file for the full set.
 | "It's faster to skip the small step." | Process shortcuts pay back later as drift, missed criteria, or unrecorded decisions. The step is the point. |
 | "I observed it pass; recording is bureaucracy." | Un-recorded pass = unproven. The next phase reads `evidence.md`, not your memory. |
 | "User clearly wants this, so I'll bypass the gate." | Gates exist for the failure modes asks miss. Honor the gate; the gate exists *because* of the ask. |
-| "The test is failing — I'll just skip it / loosen the assertion to get green." | Faking green is reward-hacking, not progress. Never delete / skip / `xfail` / `.only` / loosen a failing test — a red test means fix the code or agree the change. A weakened test is a Critical finding (`test-integrity.sh`). |
+| "The test is failing — I'll just skip it / loosen the assertion to get green." | Faking green is reward-hacking, not progress. Never delete / skip / `xfail` / `.only` / loosen a failing test — a red test means fix the code or agree the change. A weakened test is a Critical finding (`devrites-engine test-integrity`). |
 | "This project principle doesn't really apply to my case." | A declared invariant (`.devrites/principles.md`) is not advisory. Either it genuinely needs relaxing — record a scoped, dated exception a human approves — or it applies and the change is wrong. Silently routing around a principle is the defect the gate exists to catch (`principles.md`). |
 
 ## Pack-wide red flags
@@ -43,7 +42,7 @@ These show up at any phase and are equally damning regardless:
 ## Where this gets loaded
 
 Each `rite-*/reference/anti-patterns.md` opens with a pointer back here
-(written as a relative link in the form `../../../rules/anti-patterns.md`
+(written as a relative link in the form `./anti-patterns.md`
 from the per-phase reference file), then lists only the **phase-specific**
 rationalizations + red flags that don't fit here. When the agent is
 reluctant, it reads the phase file first, then this file if the reluctance

package/pack/.claude/skills/devrites-lib/reference/standards/browser-proof-checklist.md

@@ -0,0 +1,9 @@
+# Browser proof checklist
+
+- Open the real UI, not only a screenshot path.
+- Check console and network for errors.
+- Exercise default, loading, empty, error, success, disabled, and responsive states when relevant.
+- Compare to `design-brief.md` and record a Visual Verdict.
+- If MCP/browser tooling is unavailable, record the lower-rung fallback and limitation.
+
+Detailed skill: `devrites-browser-proof`.