devrites 3.0.5 → 3.0.7

package/pack/.claude/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
-`.claude/agents/`. The **single source** for the dispatch + reconciliation contract — loaded on
+`.claude/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 `.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.
+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 `.claude/agents/` stem, e.g. `devrites-frontend-reviewer`; the `roster`
+**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
+- 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/.claude/skills/devrites-lib/reference/standards/README.md

@@ -1,14 +1,14 @@
 # DevRites rules
 
 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
+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 `.claude/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).

package/pack/.claude/skills/devrites-lib/reference/standards/afk-hitl.md

@@ -1,4 +1,4 @@
-# AFK & HITL — the pause/resume contract
+# AFK & HITL: the pause/resume contract
 
 The rule layer for DevRites's two run modes. Every `rite-*` and `devrites-*` skill that
 might pause for a human reads from this contract; `/rite-build`, `/rite-status`,
@@ -8,28 +8,28 @@ The contract is intentionally small: one sentinel, one queue, one verb.
 
 ## Run modes
 
-- **HITL (default)** — human is present. At a gap/checkpoint the skill **asks inline** via
-  the harness `AskUserQuestion` tool — a ranked **option set** (recommended first, each with
+- **HITL (default):** human is present. At a gap/checkpoint the skill **asks inline** via
+  the harness `AskUserQuestion` tool: a ranked **option set** (recommended first, each with
   dimension-tagged rationale; see [Option set](#option-set--how-every-gap-is-presented)). The
   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
+  **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 —
+  **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
+  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
+- **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
+  ceiling (and every irreversible-risk item) pause and queue a `questions.md` entry for
   `/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
 `state.md` run-mode field to drift out of sync.
 
-## The sentinel — `.devrites/AFK`
+## The sentinel: `.devrites/AFK`
 
 Presence = AFK active. The file body is optional YAML:
 
@@ -39,7 +39,7 @@ notify: "ntfy.sh/my-topic"           # shell command run on awaiting_human trans
 allow_gates: [advisory, validating]  # gate severities AFK auto-handles (auto-picks the recommended option)
 ```
 
-The file is **read-only config** — never rewritten in place. `max_slices` is the initial
+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 `devrites-engine tick-afk` (which
 exits non-zero at 0, forcing a HITL stop). The cap is enforced by the script, not prose.
@@ -64,8 +64,8 @@ for the full taxonomy. Summary:
 |---|---|---|---|---|
 | advisory | low | no | none | yes (log + proceed) |
 | validating | medium | async | 4h | yes (build + queue, no merge until resolved) |
-| blocking | high | sync | 15m | **no** — always pauses |
-| escalating | novel pattern | sync to specialist | 24h | **no** — always pauses |
+| blocking | high | sync | 15m | **no** (always pauses) |
+| escalating | novel pattern | sync to specialist | 24h | **no** (always pauses) |
 
 `blocking` and `escalating` always pause regardless of `allow_gates`. They are the
 "AFK never silently accepts" guarantees in protocol form.
@@ -75,25 +75,25 @@ An open `gate: validating` entry is **merge-blocking by definition**: at `/rite-
 its behavior impact. A slice marked `built (pending review)` is **not done** until that
 validating gate resolves.
 
-## Option set — how every gap is presented
+## Option set: how every gap is presented
 
 Wherever a gap, checkpoint, or non-trivial decision surfaces (`/rite-spec`, `/rite-define`,
 `/rite-build`, `/rite-temper`, `/rite-vet`, `devrites-doubt`, `devrites-interview`), present a
 **ranked option set**, never a single bare guess:
 
-- **2–4 concrete options**, the **recommended one first**, labelled `(Recommended)`.
-- Each option carries a **one-line rationale tagged by the dimensions that matter** —
+- **2-4 concrete options**, the **recommended one first**, labelled `(Recommended)`.
+- Each option carries a **one-line rationale tagged by the dimensions that matter**:
   `logic · infra · business · architecture` (add `security` / `UX` / `risk` when in scope).
   Name the trade-off, not just the choice.
 - Always include an escape hatch (`Something else — I'll describe it`).
 - The recommendation reflects what's best for *this* project (its conventions, stack, scale,
-  domain) — not a generic default.
+  domain), not a generic default.
 
 **HITL** renders the set via `AskUserQuestion` (recommended option first; rationale in each
 option's description); the human's pick resolves the gate **in place**. **AFK** auto-picks
 option 1 (the recommendation) for gates it may auto-handle. Either way the chosen option is
 recorded verbatim and the **rejected options stay in `questions.md`** as the considered-alternatives
-trail — the audit shows what was weighed, not just what was decided.
+trail: the audit shows what was weighed, not just what was decided.
 
 ## Irreversible-risk list (always pause)
 
@@ -136,10 +136,10 @@ answer: <chosen option (or human's verbatim reply / drop reason)>
 ```
 
 Rules:
-- `NNN` is sequential per date — the next-available 3-digit integer.
+- `NNN` is sequential per date: the next-available 3-digit integer.
 - `status: open` is the only state `/rite-resolve` can mutate; `answered` and `dropped`
   are terminal.
-- The file is the audit trail. Don't edit answered/dropped entries — open a new qid that
+- The file is the audit trail. Don't edit answered/dropped entries: open a new qid that
   references the old one (`supersedes: q-...-OLD`) and resolve it.
 
 ## `state.md` `Awaiting human` block
@@ -161,7 +161,7 @@ When a HITL gate fires, `/rite-build` writes:
 
 `/rite-resolve` removes the block on success and flips `Status: running`.
 
-## The resume verb — `/rite-resolve`
+## The resume verb: `/rite-resolve`
 
 Three shapes:
 
@@ -171,14 +171,14 @@ Three shapes:
 /rite-resolve --batch <path-to-yaml>
 ```
 
-`/rite-resolve` is the canonical writer for **async** resume — a gate that already paused and
+`/rite-resolve` is the canonical writer for **async** resume: a gate that already paused and
 stopped the session (an AFK blocking/escalating/irreversible queue, or a HITL pause the human
 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 `devrites-engine resolve` 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.
+script is the contract: use it.
 
 When `/rite-resolve` does resume a stopped session, the skill does **not** auto-run the next
 `/rite-build`. The user types the next command explicitly so:
@@ -198,35 +198,35 @@ When `/rite-resolve` does resume a stopped session, the skill does **not** auto-
   log to `questions.md` as `gate: blocking`, set `state.md` `Status: awaiting_human`,
   fire `notify:`, STOP.
 
-The loop limits of the calling skill still apply — after the limit, the unresolved
+The loop limits of the calling skill still apply: after the limit, the unresolved
 doubt becomes a blocking question regardless of AFK config.
 
 ## Retry cap, stuck loops, and self-resolve
 
 - **Cap retries.** At most **3 attempts** on the same failing check (test, lint, type, build).
-  On the third failure, stop guessing and convert it to a `gate: blocking` question — a fourth
+  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` (`devrites-engine stuck`), the same standing as
+- **Stuck loops pause even in AFK.** A detected loop (the same action repeating, or an
+  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,
   critical info you genuinely can't access, or a credential / permission you lack. This narrows
   needless pauses and never weakens the blocking / escalating / irreversible gates.
 - **Human time is for human-only work.** A `human_intervention` pause is for what the agent
-  literally cannot do (create a cloud account, click a console button) — never for writing code,
+  literally cannot do (create a cloud account, click a console button): never for writing code,
   writing tests, or reviewing. Punting the agent's own job to the human is not a valid gate.
 
 ## What the rule does NOT cover
 
 This contract is about **human pauses**. It does not weaken or replace:
 
-- `/rite-prove`, `/rite-review`, `/rite-seal` — feature-scoped gates that always run.
-- Spec Drift Guard — answer that changes acceptance criteria routes through
+- `/rite-prove`, `/rite-review`, `/rite-seal`: feature-scoped gates that always run.
+- Spec Drift Guard: answer that changes acceptance criteria routes through
   `/rite-plan repair`, not silently into the slice.
-- `evidence.md` writes — every AFK iteration still records evidence; un-recorded passes
+- `evidence.md` writes: every AFK iteration still records evidence; un-recorded passes
   are unproven at `/rite-prove`.
-- `/clear` / `/compact` advice — context-hygiene rules are unchanged.
+- `/clear` / `/compact` advice: context-hygiene rules are unchanged.
 
 AFK shifts the boundary between automatic and "ask"; nothing else.
 
@@ -234,7 +234,7 @@ AFK shifts the boundary between automatic and "ask"; nothing else.
 
 - Skill: `/rite-resolve` (`.claude/skills/rite-resolve/SKILL.md`).
 - Workflow integration: `/rite-build` (`.claude/skills/rite-build/SKILL.md`),
-  workflow steps 0 + 2a (readiness / HITL pre-flight) and steps 4–6 (doubt / fail-on-red /
+  workflow steps 0 + 2a (readiness / HITL pre-flight) and steps 4-6 (doubt / fail-on-red /
   record) on the wright's return.
 - Render contract: `.claude/skills/rite-build/reference/checkpoint-protocol.md`.
 - Loop discipline: `.claude/skills/rite-build/reference/afk-discipline.md`.