devrites 3.0.5 → 3.0.7

package/pack/generated/codex/skills/devrites-interview/SKILL.md

@@ -10,20 +10,20 @@ This is the Codex mirror of a DevRites skill. In Codex:
 
 - Load DevRites engineering standards from `.agents/skills/devrites-lib/reference/standards/`. Read `.agents/skills/devrites-lib/reference/standards/core.md` before workflow work, then load the other `.agents/skills/devrites-lib/reference/standards/*.md` files exactly when this skill asks for them.
 - Use the installed `devrites-engine` binary as the canonical runtime helper surface for orientation, gates, and state mutation.
-- When this skill asks for a DevRites specialist or writer agent, **explicitly** spawn the matching Codex custom agent from `.codex/agents/devrites-*.toml` through Codex subagents (`spawn_agent`), then wait for its result and reconcile it as the skill instructs. Do not do the review inline just because the instruction to spawn is embedded here — Codex under-fires embedded spawn/skill instructions (openai/codex #23496), so treat the spawn as required, not optional.
-- The independence of a fresh-context subagent is the point. If Codex genuinely cannot spawn subagents in the current surface, run the documented inline fallback and **label the result an inline fallback, not an independent review** — an inline pass shares the calling context and is weaker evidence.
+- When this skill asks for a DevRites specialist or writer agent, **explicitly** spawn the matching Codex custom agent from `.codex/agents/devrites-*.toml` through Codex subagents (`spawn_agent`), then wait for its result and reconcile it as the skill instructs. Do not do the review inline just because the instruction to spawn is embedded here: Codex under-fires embedded spawn/skill instructions (openai/codex #23496), so treat the spawn as required, not optional.
+- The independence of a fresh-context subagent is the point. If Codex genuinely cannot spawn subagents in the current surface, run the documented inline fallback and **label the result an inline fallback, not an independent review**: an inline pass shares the calling context and is weaker evidence.
 - Codex project hooks are installed in `.codex/hooks.json`. Review and trust them with `/hooks` before relying on hook enforcement.
-- When this skill asks a HITL question via `AskUserQuestion`: Codex's equivalent (`request_user_input`) exists only in Plan mode. Outside Plan mode, render the option set as a plain numbered list in chat and **end the turn** so the human answers — NEVER silently pick an option yourself; auto-picking is AFK's contract, gated by the `.devrites/AFK` sentinel.
+- When this skill asks a HITL question via `AskUserQuestion`: Codex's equivalent (`request_user_input`) exists only in Plan mode. Outside Plan mode, render the option set as a plain numbered list in chat and **end the turn** so the human answers: NEVER silently pick an option yourself; auto-picking is AFK's contract, gated by the `.devrites/AFK` sentinel.
 
 
-# devrites-interview — extract intent
+# devrites-interview: extract intent
 
-Close the gap between what the user said and what they want, at the cheapest moment —
+Close the gap between what the user said and what they want, at the cheapest moment:
 before a plan, spec, or code exists.
 
 ## Protocol
 - **State a confidence number.** Open with your one-line hypothesis of what the user wants and an
-  explicit **0–100%** confidence in it. The number forces honesty — if you wrote 85% but can't
+  explicit **0-100%** confidence in it. The number forces honesty, if you wrote 85% but can't
   predict how the user reacts to your next three questions, the number is wrong. Below **~70%**,
   append the single thing still unresolved so the user can close the gap directly.
 - **One question per turn.** Multiple questions get one answered and the rest ignored.
@@ -31,13 +31,13 @@ before a plan, spec, or code exists.
   > "I'm assuming export is CSV only (covers the stated use case). Right, or also XLSX?"
   This turns an open question into a cheap correction and exposes your model so the user
   can fix the premise.
-- **Highest-value question first** — order by how much the answer changes the build. A
+- **Highest-value question first:** order by how much the answer changes the build. A
   question that moves the data model or acceptance criteria beats a cosmetic one.
 - **Impact-priority + bounded blocking.** Order unknowns **scope > security/privacy > UX >
-  technical**, and cap **blocking** questions at **≤3** per pass — ask the few that actually gate
+  technical**, and cap **blocking** questions at **≤3** per pass: ask the few that gate
   the spec; **default-and-record** the rest in `assumptions.md` (best-guess + why). A reversible
   detail never earns a blocking question.
-- **Structured options** when the space is enumerable — present them as the standard ranked
+- **Structured options** when the space is enumerable: present them as the standard ranked
   **option set** (`standards/afk-hitl.md` → "Option set"): recommended **first**, labelled
   `(Recommended)`, each with a dimension-tagged rationale (`logic · infra · business ·
   architecture`, + `security`/`UX`/`risk` when in scope), plus the escape hatch. Render via
@@ -49,37 +49,37 @@ before a plan, spec, or code exists.
   ```
 
 ## Stop condition
-Stop **opening new questions** when **any** holds — don't interrogate past the point of value.
+Stop **opening new questions** when **any** holds: don't interrogate past the point of value.
 (Stopping the interview ≠ deciding for the user: a material call still goes back as a ranked
-option set — confidence lowers the question's *cost* to a one-pick confirm, not its *owner*.)
-- **Confidence — the predict-three test.** The 95% bar is checkable, not a feeling: *can you
+option set: confidence lowers the question's *cost* to a one-pick confirm, not its *owner*.)
+- **Confidence: the predict-three test.** The 95% bar is checkable, not a feeling: *can you
   predict the user's reaction to the next three questions you would ask?* If yes, you're done
   extracting. If several rounds pass and you still can't predict, something foundational is
-  missing — step back and name it, don't grind out more questions.
-- **Convergence** — the last 2–3 answers only rubber-stamped your guesses and didn't
+  missing: step back and name it, don't grind out more questions.
+- **Convergence:** the last 2-3 answers only rubber-stamped your guesses and didn't
   move the spec.
-- **Soft cap** — after ~8 material questions, proceed with your best-guess answers logged
+- **Soft cap:** after ~8 material questions, proceed with your best-guess answers logged
   in `assumptions.md` rather than asking more (hard-stop sooner if the ask is small).
 
-Depth on the few that matter, not breadth for its own sake. If answers stop converging —
-you keep circling one area without progress — **reframe once** (below) instead of asking
+Depth on the few that matter, not breadth for its own sake. If answers stop converging:
+you keep circling one area without progress: **reframe once** (below) instead of asking
 another question.
 
 ## Want vs. should-want
-People answer with what they think they *should* want — the buzzword, the best practice, the
-convention — not what they actually want. Watch for tells: abstract virtues ("scalable", "clean",
+People answer with what they think they *should* want (the buzzword, the best practice, the
+convention) not what they want. Watch for tells: abstract virtues ("scalable", "clean",
 "modern"), deferral to what's conventional, an answer that could be pasted into any project. When
-you hear one, ask the unlock question — *"if you didn't have to justify this to anyone, what would
-you actually want?"* — it often does more than the previous five questions. Extract the real want,
+you hear one, ask the unlock question, *"if you didn't have to justify this to anyone, what would
+you want?"*. It often does more than the previous five questions. Extract the real want,
 then record it; don't design to the performed one.
 
 ## What counts as a yes
 Approval is an **explicit** yes, and several common replies aren't one:
-- *"Whatever you think is best"* / *"you decide"* — **delegation, not approval.** Re-ask with two
+- *"Whatever you think is best"* / *"you decide"*: **delegation, not approval.** Re-ask with two
   concrete options so the user chooses on the substance, not the deferral.
-- *"Sounds good"* / *"sure, let's go"* — a polite exit; probe once that it's real agreement, not
+- *"Sounds good"* / *"sure, let's go"*: a polite exit; probe once that it's real agreement, not
   fatigue, on anything material.
-- **Silence** — not consent. Half of misalignment is silent disagreement about what *won't* be
+- **Silence:** not consent. Half of misalignment is silent disagreement about what *won't* be
   built. Make the "out of scope" line explicit and get a yes on it too.
 
 ## Don't ask
@@ -87,24 +87,24 @@ Approval is an **explicit** yes, and several common replies aren't one:
 - Reversible implementation details (decide, log as an assumption).
 - Everything at once "to be thorough."
 
-## When the ask is vague — map the decision tree first
+## When the ask is vague: map the decision tree first
 For a one-line or fuzzy ask (`"design a contact page"`), don't fire isolated questions.
-First sketch the **decision tree** — the branches the answer splits into — and resolve
+First sketch the **decision tree** (the branches the answer splits into) and resolve
 each branch **depth-first** with the protocol above. Domain branches per area:
 `rite-spec/reference/interview-patterns.md`.
 
 ## Reframe (once, when stuck)
 If the interview isn't converging, spend **one** turn challenging the premise rather than
-refining it — *"is a form even the right answer here, or a mailto / booking link?"* A good
+refining it: *"is a form even the right answer here, or a mailto / booking link?"* A good
 reframe collapses several open branches. Use it sparingly, then resume the protocol.
 
-## /clarify mode — coverage scan of an existing spec
+## /clarify mode: coverage scan of an existing spec
 When invoked to clarify a written spec (not extract intent from scratch), scan it against the fixed
 taxonomy and mark each **Clear / Partial / Missing**: Functional scope · Data model · Interaction
 (API / UI states) · Non-functional (auth / latency / scale / compliance) · Edge cases (empty /
 boundary / invalid / concurrent / failure). Then ask **≤5 prioritized questions** (impact order
 above), targeting Missing before Partial, one per turn with a best-guess attached. **Integrate each
-answer into the right spec section** as it lands — not just a Q&A log — and append a dated
+answer into the right spec section** as it lands (not just a Q&A log) and append a dated
 **`## Clarifications`** block to `spec.md` (Q + resolution) for durable provenance. Re-run the scan
 after answers; stop when every area is Clear or explicitly deferred, then re-score the affected
 `checklists/<domain>.md`.
@@ -113,4 +113,4 @@ after answers; stop when every area is Clear or explicitly deferred, then re-sco
 A short summary the caller can use: objective in one sentence, confirmed decisions,
 still-open (non-blocking) items, recommended next step. If a workspace is active, write
 Q&A to `questions.md`, confirmed calls to `decisions.md`, standing guesses to
-`assumptions.md`. If not, just return the summary — don't create a workspace.
+`assumptions.md`. If not, just return the summary: don't create a workspace.

package/pack/generated/codex/skills/devrites-lib/SKILL.md

@@ -11,13 +11,13 @@ This is the Codex mirror of a DevRites skill. In Codex:
 
 - Load DevRites engineering standards from `.agents/skills/devrites-lib/reference/standards/`. Read `.agents/skills/devrites-lib/reference/standards/core.md` before workflow work, then load the other `.agents/skills/devrites-lib/reference/standards/*.md` files exactly when this skill asks for them.
 - Use the installed `devrites-engine` binary as the canonical runtime helper surface for orientation, gates, and state mutation.
-- When this skill asks for a DevRites specialist or writer agent, **explicitly** spawn the matching Codex custom agent from `.codex/agents/devrites-*.toml` through Codex subagents (`spawn_agent`), then wait for its result and reconcile it as the skill instructs. Do not do the review inline just because the instruction to spawn is embedded here — Codex under-fires embedded spawn/skill instructions (openai/codex #23496), so treat the spawn as required, not optional.
-- The independence of a fresh-context subagent is the point. If Codex genuinely cannot spawn subagents in the current surface, run the documented inline fallback and **label the result an inline fallback, not an independent review** — an inline pass shares the calling context and is weaker evidence.
+- When this skill asks for a DevRites specialist or writer agent, **explicitly** spawn the matching Codex custom agent from `.codex/agents/devrites-*.toml` through Codex subagents (`spawn_agent`), then wait for its result and reconcile it as the skill instructs. Do not do the review inline just because the instruction to spawn is embedded here: Codex under-fires embedded spawn/skill instructions (openai/codex #23496), so treat the spawn as required, not optional.
+- The independence of a fresh-context subagent is the point. If Codex genuinely cannot spawn subagents in the current surface, run the documented inline fallback and **label the result an inline fallback, not an independent review**: an inline pass shares the calling context and is weaker evidence.
 - Codex project hooks are installed in `.codex/hooks.json`. Review and trust them with `/hooks` before relying on hook enforcement.
-- When this skill asks a HITL question via `AskUserQuestion`: Codex's equivalent (`request_user_input`) exists only in Plan mode. Outside Plan mode, render the option set as a plain numbered list in chat and **end the turn** so the human answers — NEVER silently pick an option yourself; auto-picking is AFK's contract, gated by the `.devrites/AFK` sentinel.
+- When this skill asks a HITL question via `AskUserQuestion`: Codex's equivalent (`request_user_input`) exists only in Plan mode. Outside Plan mode, render the option set as a plain numbered list in chat and **end the turn** so the human answers: NEVER silently pick an option yourself; auto-picking is AFK's contract, gated by the `.devrites/AFK` sentinel.
 
 
-# devrites-lib — internal shared helpers (not a command)
+# devrites-lib: internal shared helpers (not a command)
 
 This is **not** a skill you run. It is DevRites' manifest for shared references
 and control-plane operations. Skills call `devrites-engine <command>` from any
@@ -27,54 +27,54 @@ workspace; no pack script path is required.
 
 These are selected `devrites-engine` contracts; `devrites-engine help` is exhaustive.
 
-**Read-only — orient / gate (never mutate the workspace):**
+**Read-only: orient / gate (never mutate the workspace):**
 
-- `devrites-engine preamble` — orientation digest for the active `.devrites/` feature:
+- `devrites-engine preamble`: orientation digest for the active `.devrites/` feature:
   prints `state.md`, the artifacts present, the run mode (HITL/AFK), and the
   open-question tally by gate. Run first (step 0) by every workspace-operating
   `rite-*` skill so the model orients deterministically instead of re-deriving
   state from raw Markdown.
-- `devrites-engine progress` — progress footer; the mirror of `devrites-engine preamble` (which runs
-  first). Run **last** (output step) by every lifecycle `rite-*` skill to render — from
-  `state.md`, with zero model drift — the `── rite-<phase> ──` header rule, the **slice
+- `devrites-engine progress`: progress footer; the mirror of `devrites-engine preamble` (which runs
+  first). Run **last** (output step) by every lifecycle `rite-*` skill to render (from
+  `state.md`, with zero model drift) the `── rite-<phase> ──` header rule, the **slice
   meter** (`Slice 3/5  ██████░░░░  <last-built> ✓`, or `Slices 5/5  ██████████  ✅ ALL
   BUILT` at completion), and the **flow ribbon** (`spec ✓ define ✓ build ◉ … ship ○`).
   The meter answers "how many slices left"; the `✅ ALL BUILT` marker answers "is the
   build done". The skill prints its own what-was-done / next-step / hygiene lines beneath
   it. Read-only; silent (exit 0) when there is no active workspace. Not for the workspace-less
   utilities (`$rite-prototype`, `$rite-zoom-out`, `$rite-pressure-test`, `$rite-handoff`,
-  the `$rite` menu) — they have no phase/slice state to render.
-- `reference/reply-contract.md` — the shared user-facing completion reply contract. It
+  the `$rite` menu). They have no phase/slice state to render.
+- `reference/reply-contract.md`: the shared user-facing completion reply contract. It
   standardizes the compact chat lines printed below `devrites-engine progress` for success,
   awaiting-human, stopped/blocked, GO, NO-GO, and shipped states. The chat reply is a
   status summary; durable detail stays in the workspace artifacts.
-- `reference/model-tiers.md` — the dispatch-by-task-shape contract (extraction / generation /
+- `reference/model-tiers.md`: the dispatch-by-task-shape contract (extraction / generation /
   ceiling). A skill names a **tier** by the shape of the work and never hardcodes a model name;
   reviewers are ceiling on purpose. Carries the degradation rule for harnesses that cannot pick
   models per agent. Loaded on demand by any skill that dispatches subagents.
-- `devrites-engine build-readiness` — build-readiness gate. Exits non-zero on `$rite-build`'s
+- `devrites-engine build-readiness`: build-readiness gate. Exits non-zero on `$rite-build`'s
   step-0 stop conditions so they hold by exit code, not by prose the model must
   remember: `2` no `Plan approved` (→ `$rite-define`), `3` `awaiting_human`
   (→ `$rite-resolve`), `4` `blocked` (→ `$rite-plan`), `5` no workspace, `0` ready.
-- `devrites-engine evidence-fresh` — evidence-freshness gate for `$rite-seal`. Exits `3`
+- `devrites-engine evidence-fresh`: evidence-freshness gate for `$rite-seal`. Exits `3`
   when any file in `touched-files.md` is newer than `evidence.md` /
   `browser-evidence.md` (stale proof = NO-GO until re-proven), `0` when fresh.
-- `devrites-engine check-acceptance` — executable acceptance gate. Compiles `spec.md`'s
+- `devrites-engine check-acceptance`: executable acceptance gate. Compiles `spec.md`'s
   acceptance IDs and exits `1` unless every one is checked (proven) in `seal.md`;
   new workspaces use `AC-###`, while legacy archives may still carry old `[ACn]`
   ids. Used by `$rite-seal` and by the outcome grader.
-- `devrites-engine spec-validate` — spec-grammar gate (the spec-side mirror of
+- `devrites-engine spec-validate`: spec-grammar gate (the spec-side mirror of
   `devrites-engine check-acceptance`). Lints `spec.md`'s structured `### Requirement:` / `#### Scenario:`
   blocks (SHALL/MUST present, ≥1 scenario each, every scenario has WHEN + THEN, headers
   unique). Exits `1` on a grammar violation, `0` when valid **or** when the spec uses the flat
-  `AC-###` flat-bullet form (no structured blocks — nothing to lint, never a failure). Used by
+  `AC-###` flat-bullet form (no structured blocks: nothing to lint, never a failure). Used by
   `$rite-spec`'s readiness gate; see [`standards/spec-grammar.md`](reference/standards/spec-grammar.md).
 
-**State mutators — write `state.md` / `questions.md` under one contract:**
+**State mutators: write `state.md` / `questions.md` under one contract:**
 
-- `devrites-engine tick-afk` — decrement the AFK slice budget; exits `3` at 0 (forced HITL stop).
-- `devrites-engine resolve` — backs the `$rite-resolve` contract (answer / drop / batch).
-- `devrites-engine close-out` — archive the workspace + clear `ACTIVE` on `$rite-ship`.
+- `devrites-engine tick-afk`: decrement the AFK slice budget; exits `3` at 0 (forced HITL stop).
+- `devrites-engine resolve`: backs the `$rite-resolve` contract (answer / drop / batch).
+- `devrites-engine close-out`: archive the workspace + clear `ACTIVE` on `$rite-ship`.
 
 ### Canonical footer snippet
 

package/pack/generated/codex/skills/devrites-lib/reference/model-tiers.md

@@ -1,4 +1,4 @@
-# Model tiers — dispatch by task shape, never by model name
+# Model tiers: dispatch by task shape, never by model name
 
 The single source for how DevRites skills choose a model for a dispatched subagent. A skill
 names a **tier** by the *shape of the work*; it never hardcodes provider SKUs (Claude,
@@ -9,11 +9,11 @@ any skill that dispatches subagents (review fan-out, scouts, judges); not a skil
 
 | Tier | For work that is… | Examples in DevRites | Model policy |
 |---|---|---|---|
-| **extraction** | search-and-quote: retrieval, grep, verbatim quoting, mechanical scanning — no judgement | archive-search scouts, footprint scanning, repo-profile gathering, an evidence-dossier scout | cheapest capable model **when the harness exposes a per-agent override**; otherwise inherit |
+| **extraction** | search-and-quote: retrieval, grep, verbatim quoting, mechanical scanning: no judgement | archive-search scouts, footprint scanning, repo-profile gathering, an evidence-dossier scout | cheapest capable model **when the harness exposes a per-agent override**; otherwise inherit |
 | **generation** | evidence-driven or mechanical verification: apply a rule to text, draft to a contract, check a claim against a source | drafting to a `design-brief`, mechanical convention checks, first-pass claim verification | mid-tier when the harness allows; otherwise inherit |
-| **ceiling** | adversarial judgement and composition: the calls that decide GO/NO-GO or write the artifact a human reads | every reviewer in the seal/review fan-out, `devrites-forge-judge`, `devrites-plan-reviewer`, `$rite-explain` composition | the orchestrator's own model — inherited by declaring **no** model, never dispatched down |
+| **ceiling** | adversarial judgement and composition: the calls that decide GO/NO-GO or write the artifact a human reads | every reviewer in the seal/review fan-out, `devrites-forge-judge`, `devrites-plan-reviewer`, `$rite-explain` composition | the orchestrator's own model: inherited by declaring **no** model, never dispatched down |
 
-**Reviewers are ceiling on purpose.** Adversarial review is where a cheap model costs the most —
+**Reviewers are ceiling on purpose.** Adversarial review is where a cheap model costs the most:
 a missed vulnerability or a rubber-stamp is far more expensive than the tokens saved. DevRites
 agent definitions therefore declare **no** `model:` field: they inherit the ceiling. Do not add
 one to a reviewer to save cost. The tier a scout runs on is where savings are safe.
@@ -25,7 +25,7 @@ correctly on a harness that cannot select models per agent, or has no subagent p
 
 1. **Per-agent model override unavailable** → dispatch the scout on the **inherited** model and
    keep its **read budget and output cap**. The cost control falls back to structure, not model
-   choice — this is why every scout dispatch also carries an explicit read budget.
+   choice. This is why every scout dispatch also carries an explicit read budget.
 2. **No subagent primitive at all** → run the scout work **inline** in the orchestrator, with the
    same budgets. The tier still tells you how much to spend, even with nothing to dispatch to.
 

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

@@ -1,79 +1,79 @@
 # Parallel review dispatch
 
 How `$rite-review` and `$rite-seal` fan out the fresh-context review subagents under
-`.codex/agents/`. The **single source** for the dispatch + reconciliation contract — loaded on
+`.codex/agents/`. The **single source** for the dispatch + reconciliation contract: loaded on
 demand by the calling skill (each points here); not a skill itself.
 
-The seal/review fan-out **roster** is the seven post-build reviewers in the table below — this
+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 `.codex/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.
+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.
 
-## The roster — every reviewer the fan-out accounts for
+## The roster: every reviewer the fan-out accounts for
 
-These seven are the **roster**. `$rite-seal` accounts for **all** of them — the always-on three
+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.
+either fired or consciously skipped: never silently dropped.
 
-| Reviewer | Fires | Trigger — the checkable signal |
+| Reviewer | Fires | Trigger: the checkable signal |
 |---|---|---|
 | `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-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 |
+| `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
+### 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+
+- `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
+  `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
+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
+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
+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
+`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.
+(`$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.
+(at both `$rite-review` and `$rite-seal`): don't rename it per caller.
 
 ## Dispatch shape
 
-For each chosen subagent, the caller uses the harness's subagent primitive — the `Task` tool on
+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:
+Codex) with this prompt shape:
 
 ```
 Audit the active DevRites feature.
@@ -102,10 +102,10 @@ reconciles.
 Rules:
 
 - **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 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.
+  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
@@ -113,21 +113,21 @@ Rules:
   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
+## Account for every reviewer: the roster gate
 
-The fan-out is done only when **every roster reviewer is accounted for** — dispatched, or
+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
+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 `.codex/agents/` stem, e.g. `devrites-frontend-reviewer`; the `roster`
+**exact agent name**: the `.codex/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
+- 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:
 
@@ -136,23 +136,23 @@ devrites-engine footprint roster <slug>   # rc=0 complete · rc=3 a reviewer was
 ```
 
 `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
+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.
+of `$rite-review`'s verdict on an **unchanged** diff: confirm that, don't wave it through.
 
 ## Reconciliation
 
 When the subagents return:
 
-1. **Quote verbatim.** Place each subagent's findings under its own `## <axis>` heading in `review.md` / `seal.md`. Do not merge, re-rank, or summarize. `devrites-code-reviewer` runs its **full** documented discipline (tests-first, correctness, readability, architecture, maintainability, standards); the inline lead **reconciles** the returned reports — it does not re-run those same axes itself.
+1. **Quote verbatim.** Place each subagent's findings under its own `## <axis>` heading in `review.md` / `seal.md`. Do not merge, re-rank, or summarize. `devrites-code-reviewer` runs its **full** documented discipline (tests-first, correctness, readability, architecture, maintainability, standards); the inline lead **reconciles** the returned reports. It does not re-run those same axes itself.
 2. **Surface contradictions explicitly.** "Spec axis says complete, Code-review axis says untestable" is a finding, not noise. The caller decides at the gate.
 3. **Severity is the gate, not a score.** Sum the labels (`Critical / Important / Suggestion / Nit / FYI`) and apply the caller's gate (`$rite-seal` blocks on `Critical == 0`; `$rite-review` reports counts).
-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.
+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
+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
@@ -161,5 +161,5 @@ save cost. Extraction-tier savings belong to scouts (archive-search, footprint),
 ## Fallback
 
 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.
+`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/generated/codex/skills/devrites-lib/reference/standards/README.md

@@ -1,14 +1,14 @@
 # DevRites rules
 
 Stack-agnostic engineering rules that DevRites installs to `.agents/skills/devrites-lib/reference/standards/`. They encode
-the standards the DevRites workflow holds code to — quality, safety, testing, and review
+the standards the DevRites workflow holds code to: quality, safety, testing, and review
 discipline that apply in any language.
 
 These are **common** by design: nothing here assumes a specific framework or language.
 Project-specific conventions always win where they exist (DevRites reads the codebase and
 prefers what's already there).
 
-## Loading model — progressive disclosure
+## Loading model: progressive disclosure
 
 To keep context lean, the rules follow progressive disclosure: each DevRites `rite-*`
 skill Reads `.agents/skills/devrites-lib/reference/standards/core.md` as its first step;
@@ -25,20 +25,20 @@ the remaining rule files load on demand by the phase that needs them.
 | Rule | Covers | Typical phase |
 |---|---|---|
 | `coding-style.md` | Naming, function shape, guard clauses, comments, simplicity, reuse-first. | `$rite-build`, `$rite-polish` Phase 1. |
-| `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. |
+| `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 `devrites-engine spec-validate`. Progressive rigor; flat `AC-###` 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`. |
-| `developer-experience.md` | DX as a measured axis — the predict-at-vet / measure-at-prove / reconcile-at-seal boomerang; scorecard (TTHW, getting-started, error-message quality, ergonomics, docs); severity by who-pays. Conditional + greenfield no-op. | When a developer-facing surface is in scope (public API, CLI, SDK/library, webhook, config, error messages, getting-started); `$rite-vet`, `$rite-prove`, `$rite-seal`. |
+| `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`. |
+| `developer-experience.md` | DX as a measured axis: the predict-at-vet / measure-at-prove / reconcile-at-seal boomerang; scorecard (TTHW, getting-started, error-message quality, ergonomics, docs); severity by who-pays. Conditional + greenfield no-op. | When a developer-facing surface is in scope (public API, CLI, SDK/library, webhook, config, error messages, getting-started); `$rite-vet`, `$rite-prove`, `$rite-seal`. |
 | `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. |
+| `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`. |
@@ -48,7 +48,7 @@ the remaining rule files load on demand by the phase that needs them.
 | `context-hygiene.md` | `/clear` vs `/compact`, lost-in-the-middle, phase-aware hygiene footer. | Phase-end hygiene footer; choosing `/clear` vs `/compact`. |
 | `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. |
+| `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`. |
@@ -57,5 +57,5 @@ the remaining rule files load on demand by the phase that needs them.
 | `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
+directly. They are guidance, not enforced gates: the enforced gates live in the
 workflow skills (Spec Drift Guard, readiness gates, the seal).