devrites 3.0.4 → 3.0.6

package/pack/generated/codex/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 @@ $rite-resolve --drop <qid> ["<reason>"]
 $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` (`.agents/skills/rite-resolve/SKILL.md`).
 - Workflow integration: `$rite-build` (`.agents/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: `.agents/skills/rite-build/reference/checkpoint-protocol.md`.
 - Loop discipline: `.agents/skills/rite-build/reference/afk-discipline.md`.

package/pack/generated/codex/skills/devrites-lib/reference/standards/agents.md

@@ -3,7 +3,7 @@
 DevRites uses **project-local** agents under `.codex/agents/` (never a global location).
 It separates three roles: **specialist skills** (model-invoked disciplines that run inline),
 **review subagents** (fresh-context, **read-only** reviewers spawned for independent judgment),
-and the **executor subagent** (`devrites-slice-wright` — fresh-context but **write-capable**,
+and the **executor subagent** (`devrites-slice-wright`: fresh-context but **write-capable**,
 the one agent that produces code).
 
 ## Model tier policy
@@ -13,76 +13,76 @@ standard/inherited, with the strongest available model for high-risk architectur
 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 — `.codex/agents/`
+## Review subagents: `.codex/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.
+(`.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
+[`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.
+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` |
 | `devrites-code-reviewer` | Correctness / readability / architecture / maintainability | `$rite-seal`; after a slice |
-| `devrites-test-analyst` | Do the tests actually prove the acceptance criteria? | `$rite-seal` |
+| `devrites-test-analyst` | Do the tests prove the acceptance criteria? | `$rite-seal` |
 | `devrites-frontend-reviewer` | UX flow, a11y, responsive, design-system, anti-AI-slop | `$rite-seal` on UI features |
 | `devrites-security-auditor` | Untrusted input, trust boundaries, secrets, deps | `$rite-seal` when input/auth/data in scope |
 | `devrites-performance-reviewer` | Measure-first perf (N+1, hot paths, payload size) | `$rite-seal` when perf relevant |
 | `devrites-devex-reviewer` | Developer-experience scorecard + the predict-vs-measure boomerang (TTHW, getting-started, error-message quality, ergonomics, docs) | `$rite-vet` (predict) + `$rite-seal` when a developer-facing surface (API / CLI / SDK / webhook / config / errors / getting-started) is in scope |
-| `devrites-simplifier-reviewer` | Behavior-preserving simplification (Chesterton's Fence, deletion test) — Suggestion-only by design | `$rite-polish` Phase 1; `devrites-audit simplify` |
+| `devrites-simplifier-reviewer` | Behavior-preserving simplification (Chesterton's Fence, deletion test). Suggestion-only by design | `$rite-polish` Phase 1; `devrites-audit simplify` |
 | `devrites-doubt-reviewer` | Adversarial check of a single claim/decision | `devrites-doubt` loop; risky decisions |
-| `devrites-strategy-reviewer` | Spec-vs-rubric strategic review (ambition / scope / premise / pre-mortem / YAGNI / testability / irreversibility / cross-cutting / convention) — **before** any plan or code | `$rite-temper` loop (pre-plan) |
-| `devrites-plan-reviewer` | Plan-vs-rubric engineering review (architecture / scope-reuse / plan code-quality / test-coverage design / performance / reversibility / failure-mode coverage), confidence-banded with a quote-the-source verification gate — **after define, before build** | `$rite-vet` loop (pre-build) |
-| `devrites-forge-judge` | Comparative judge of K=2–3 competing candidate implementations of one slice (acceptance / test strength / principle fit / simplicity / reuse / anti-slop) — picks the single winner to land, names grafts | `$rite-build` forge step, on a `Forge: yes` slice |
+| `devrites-strategy-reviewer` | Spec-vs-rubric strategic review (ambition / scope / premise / pre-mortem / YAGNI / testability / irreversibility / cross-cutting / convention): **before** any plan or code | `$rite-temper` loop (pre-plan) |
+| `devrites-plan-reviewer` | Plan-vs-rubric engineering review (architecture / scope-reuse / plan code-quality / test-coverage design / performance / reversibility / failure-mode coverage), confidence-banded with a quote-the-source verification gate (**after define, before build**) | `$rite-vet` loop (pre-build) |
+| `devrites-forge-judge` | Comparative judge of K=2-3 competing candidate implementations of one slice (acceptance / test strength / principle fit / simplicity / reuse / anti-slop); picks the single winner to land and names grafts | `$rite-build` forge step, on a `Forge: yes` slice |
 
-## The executor subagent — `.codex/agents/devrites-slice-wright.toml`
+## The executor subagent: `.codex/agents/devrites-slice-wright.toml`
 
 The system's one **write-capable** agent, and the mirror of the reviewers: where a reviewer
 reads a finished diff in a fresh context, the wright **writes** one slice in a fresh context.
 
 | Agent | Purpose | When |
 |-------|---------|------|
-| `devrites-slice-wright` | Turn ONE fully-specified slice contract into the smallest complete, idiomatic, proven implementation — orient → TDD → verify, anti-AI-slop, feature scope only | `$rite-build` — the build-core dispatch step |
+| `devrites-slice-wright` | Turn ONE fully specified slice contract into the smallest complete, idiomatic, proven implementation (orient → TDD → verify, anti-AI-slop, feature scope only) | `$rite-build`, the build-core dispatch step |
 
 `$rite-build` is the orchestrator: it owns the gates and the workspace, dispatches the wright
 for the implementation, then doubts, gates, and records the return. Tools:
 `Read, Edit, Write, Bash, Glob, Grep` (+ a code-intelligence index when present). It writes
-**code and tests only** — never the `.devrites/` bookkeeping files; it returns that data and
+**code and tests only**: never the `.devrites/` bookkeeping files; it returns that data and
 the orchestrator persists it, so there is exactly one canonical writer of workspace state and
 the HITL/AFK contract stays intact. **Single-threaded: one wright per slice, never a parallel
 fan-out of writers *sharing a tree*** (concurrent writers on one tree make conflicting implicit
 decisions). The one sanctioned exception is a **forge** slice (`Forge: yes`, flagged by
-`$rite-vet`): K=2–3 candidate wrights build the slice on distinct strategies in **isolated**
-worktrees, `devrites-forge-judge` scores them, and exactly **one** winner's diff lands — no tree
+`$rite-vet`): K=2-3 candidate wrights build the slice on distinct strategies in **isolated**
+worktrees, `devrites-forge-judge` scores them, and exactly **one** winner's diff lands: no tree
 ever has two authors, so the invariant holds. Contract + return shape + fallback + forge:
 `.agents/skills/rite-build/reference/wright-dispatch.md`, `.../reference/forge.md`.
 
-## The cross-feature analyst — `.codex/agents/devrites-retrospector.toml`
+## The cross-feature analyst: `.codex/agents/devrites-retrospector.toml`
 
 A read-only agent like the reviewers, but its scope is the **archive, not a diff**: it reads the
-shipped `.devrites/archive/<slug>/` workspaces and reports the patterns one feature can't show —
+shipped `.devrites/archive/<slug>/` workspaces and reports the patterns one feature can't show:
 a finding class reviewers keep raising, recurring drift, dead-ends, the GO/NO-GO and rework trend.
 
 | 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 `devrites-engine learnings 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
+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
 confirms. This makes the cross-feature learning that otherwise waits for someone to run `$rite-learn`
 fire automatically at close, while keeping rule/principle promotion a deliberate human amendment
 (`principles.md` governance). The capture half is already automatic (`$rite-seal` step 9a); this is
 the synthesis half.
 
-## Namespaces — `rite-*` is the user surface; `devrites-*` is internal
+## Namespaces: `rite-*` is the user surface; `devrites-*` is internal
 
 The prefix mirrors visibility:
 
 - **`rite-*`** = user-invocable (`user-invocable: true`). The public slash-command
-  surface — lifecycle phases plus utilities. `rite`, `rite-spec`, `rite-temper`,
+  surface: lifecycle phases plus utilities. `rite`, `rite-spec`, `rite-temper`,
   `rite-define`, `rite-vet`,
   `rite-plan`, `rite-build`, `rite-prove`, `rite-polish`, `rite-review`, `rite-seal`,
   `rite-ship`, `rite-autocomplete`, `rite-status`, `rite-resolve`, `rite-prototype`,
@@ -94,16 +94,16 @@ The prefix mirrors visibility:
   Internal specialists that fire on trigger from the `rite-*` skills or auto-select.
   `devrites-interview`, `devrites-source-driven`, `devrites-doubt`,
   `devrites-ux-shape` (plans UX/UI into `design-brief.md` at `$rite-spec` when UI is
-  detected — the build target), `devrites-frontend-craft`, `devrites-prose-craft`
+  detected: the build target), `devrites-frontend-craft`, `devrites-prose-craft`
   (human-voice prose for artifacts + replies; the catch pass in `$rite-polish`),
   `devrites-browser-proof`,
   `devrites-debug-recovery`, `devrites-api-interface`, `devrites-audit` (dispatches the
   security / perf / simplify reviewer subagent on an axis argument).
   The `devrites-` prefix avoids collisions with bundled Claude Code skill
-  names (`prototype`, `handoff`, `diagnose`, etc.) — peer skill packs may
+  names (`prototype`, `handoff`, `diagnose`, etc.): peer skill packs may
   collide on the bare names internally even though these never appear in the
   user's slash menu. Parallel reviewer fan-out at `$rite-seal` is no longer
-  a skill — it lives as a shared reference file
+  a skill. It lives as a shared reference file
   (`.agents/skills/devrites-lib/reference/parallel-dispatch.md`), pointed at by both
   `$rite-review` and `$rite-seal`.
 
@@ -113,14 +113,14 @@ The `$rite` menu carries user-facing routing. `user-invocable:` in each
 ## 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
+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. 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`).
+   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.
 
@@ -128,18 +128,18 @@ fire **outside** that fan-out:
 
 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
+reference, not a load: the agent must **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
+  (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.
+  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
@@ -147,7 +147,7 @@ The durable, cross-harness lever is the **agent body**: name the skill and instr
 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 `.agents/skills/devrites-lib/reference/standards/`
-framework either — so a reviewer whose whole job is a rule (`security.md`, `performance.md`,
+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:
@@ -168,10 +168,10 @@ The rule paths are written as `.agents/skills/devrites-lib/reference/standards/<
 - Run independent reviewers **in parallel** at the seal, then reconcile; surface
   disagreements explicitly rather than averaging them away.
 - 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
+  deny-mutating-Bash hook (`devrites-engine hook reviewer-readonly`) through 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
+  `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**.
@@ -180,13 +180,13 @@ The rule paths are written as `.agents/skills/devrites-lib/reference/standards/<
   `.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.
-- **Orchestration depth ≤ 1 — agents don't invoke agents.** The `rite-*` skill (driven by the
+  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 —
+  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 —
+  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/generated/codex/skills/devrites-lib/reference/standards/anti-patterns.md

@@ -1,4 +1,4 @@
-# DevRites — universal anti-patterns
+# DevRites: universal anti-patterns
 
 The pack-wide rationalizations the agent reaches for when discipline gets in
 the way. Apply at every phase. Each `rite-*/reference/anti-patterns.md`
@@ -12,17 +12,17 @@ This file is the **single source** of the universal anti-rationalization table.
 | Excuse | Rebuttal |
 |---|---|
 | "I'll add the tests later." | Tests written after the fact don't drive design and miss the boundary cases the act of writing exposes. Test now or the tests you eventually write are worse. |
-| "Lint and build pass — that proves quality." | Automation proves syntax and style, not design or correctness. Never cite clean automation as evidence of good design. |
-| "It's only a small refactor while I'm in here." | Feature scope only — drive-by cleanup balloons the diff, hides intent, and gets rejected at seal. Record as an FYI follow-up. |
+| "Lint and build pass, that proves quality." | Automation proves syntax and style, not design or correctness. Never cite clean automation as evidence of good design. |
+| "It's only a small refactor while I'm in here." | Feature scope only: drive-by cleanup balloons the diff, hides intent, and gets rejected at seal. Record as an FYI follow-up. |
 | "This is a special case, the pattern doesn't apply." | Special cases multiply silently. Either they really are special (record *why* in `decisions.md`) or they're not (and the pattern wins). |
 | "The user will tell me if something is wrong." | Drift detection is the workflow's job, not the user's QA. Surface assumptions; route material questions through the Spec Drift Guard. |
-| "Generic name (`processData`, `handleItem`) is fine — the code is self-evident." | Generic AI naming is slop. Match the project's idiom; one concept gets one word across the codebase. |
-| "Better safe than sorry — add the defensive null/length check." | Over-defensive guarding is slop. Validate at boundaries; trust the core. A check inside trusted code hides bugs in the boundary. |
+| "Generic name (`processData`, `handleItem`) is fine: the code is self-evident." | Generic AI naming is slop. Match the project's idiom; one concept gets one word across the codebase. |
+| "Better safe than sorry: add the defensive null/length check." | Over-defensive guarding is slop. Validate at boundaries; trust the core. A check inside trusted code hides bugs in the boundary. |
 | "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 (`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`). |
+| "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
 
@@ -37,7 +37,7 @@ These show up at any phase and are equally damning regardless:
 - A `// TODO` left in shipped code.
 - Adding a dependency or a second design system without rationale in `decisions.md`.
 - A change that violates a declared project principle (`.devrites/principles.md`) with no recorded, human-approved exception.
-- "I'll fix it in a follow-up PR" with no follow-up actually opened.
+- "I'll fix it in a follow-up PR" with no follow-up opened.
 
 ## Where this gets loaded
 
@@ -51,7 +51,7 @@ is broader than the phase.
 ## These rows are graded, not just asserted
 
 A row here is a prediction: *the agent will reach for this excuse, so resist it.* For a
-gating rite, that prediction is turned into a graded scenario — a behavioral eval under
+gating rite, that prediction is turned into a graded scenario: a behavioral eval under
 `evals/behavioral/<skill>.json` pairs the excuse with a pressure prompt and checks the
 skill holds the line instead of rationalizing past it. When you add or sharpen a row for a
 gating skill, add or update the matching behavioral eval so the discipline is tested, not

package/pack/generated/codex/skills/devrites-lib/reference/standards/ci-cd.md

@@ -1,6 +1,6 @@
 # CI/CD & automation
 
-CI is the enforcement mechanism for every other rule — the place a discipline that's optional on
+CI is the enforcement mechanism for every other rule: the place a discipline that's optional on
 one engineer's machine becomes mandatory for the trunk. This file is the pipeline-and-release
 layer; it doesn't restate what its neighbours own: local hook staging by cost is
 [`hooks.md`](hooks.md), trunk-always-green + definition-of-done is
@@ -9,17 +9,17 @@ layer; it doesn't restate what its neighbours own: local hook staging by cost is
 
 ## Two forces that set the shape
 
-- **Shift left.** A defect gets cheaper the earlier it's caught — a lint error costs seconds, the
+- **Shift left.** A defect gets cheaper the earlier it's caught: a lint error costs seconds, the
   same bug in production costs an incident. Push each check to the earliest stage that can catch it
   (editor → pre-commit → pre-push → CI), so CI confirms rather than discovers.
-- **Faster is safer.** Small, frequent deploys are *lower* risk, not higher — a release with three
+- **Faster is safer.** Small, frequent deploys are *lower* risk, not higher: a release with three
   changes is debuggable; one with thirty is an investigation. Batch size is a safety lever, so
   optimize for a pipeline fast enough that shipping often is painless.
 
-## The gate pipeline — no gate is skippable
-CI runs an ordered set of gates — lint → type-check → unit → build → integration → audit → e2e —
+## The gate pipeline: no gate is skippable
+CI runs an ordered set of gates: lint → type-check → unit → build → integration → audit → e2e:
 and a red gate stops the line. The discipline is the same as a red test ([`testing.md`](testing.md)):
-**if lint fails, fix the code — don't disable the rule; if a test fails, fix the code — don't skip
+**if lint fails, fix the code (don't disable the rule; if a test fails, fix the code) don't skip
 the test.** A gate silenced to get green is a defect shipped with a clean check on top of it. CI,
 not a local run, is the source of truth for "green".
 
@@ -30,15 +30,15 @@ root, verify locally, push again. Map the failure to its fix: lint → the repor
 (reproduce before fixing); build → config/dependency drift. A blind re-run of a flaky pipeline is the
 CI version of papering over a failing test.
 
-## Build Cop — one owner keeps the trunk green
+## Build Cop: one owner keeps the trunk green
 When the pipeline breaks, the job of getting it green belongs to a designated **Build Cop**, not
-diffused across everyone until no one acts — and the fix is **fix or revert**, whichever is faster,
+diffused across everyone until no one acts, and the fix is **fix or revert**, whichever is faster,
 by whoever holds the role, not necessarily the author of the breaking change. A broken trunk blocks
 everyone, so restoring it outranks feature work until it's green.
 
 ## Feature flags decouple deploy from release
 Deploying code and releasing behaviour are separate events. Ship incomplete or risky work **disabled**
-behind a flag so the trunk keeps moving; turn it on to release, off to roll back — no redeploy on the
+behind a flag so the trunk keeps moving; turn it on to release, off to roll back: no redeploy on the
 critical path. Every flag is born with an **owner and a removal trigger**; a flag that outlives its
 rollout becomes dead branches and combinatorial test cost (staged-rollout mechanics:
 [`git-workflow.md`](git-workflow.md), [`deprecation.md`](deprecation.md) expand→contract).
@@ -46,17 +46,17 @@ rollout becomes dead branches and combinatorial test cost (staged-rollout mechan
 ## Secrets never live where they don't have to
 Tier secret exposure by environment: `.env.example` committed (no values); real `.env` never
 committed; CI secrets injected from the platform's secret store, scoped to the job. **CI must not
-hold production secrets** — a build runner is a broad attack surface, and least privilege
+hold production secrets**: a build runner is a broad attack surface, and least privilege
 ([`security.md`](security.md)) says a compromised pipeline shouldn't reach prod credentials.
 
 ## When the pipeline is too slow (>~10 min), climb the ladder
 Slowness makes engineers skip or batch, which defeats "faster is safer". Fix it in impact order,
 cheapest first: cache dependencies → parallelize independent jobs → path-filter to only what changed
 → shard/matrix the slow suite → prune or re-tier genuinely slow tests → larger runners last. Measure
-before and after ([`performance.md`](performance.md) measure-first) — a "faster" pipeline that didn't
+before and after ([`performance.md`](performance.md) measure-first): a "faster" pipeline that didn't
 move the wall-clock number is just more config.
 
 ## Scope
 Most projects own their own CI; DevRites installs *into* them. Treat this as guidance for the
 pipeline the change touches, not licence to re-architect a project's whole CI in an unrelated
-change — the same feature-scope discipline as the rest of the rules.
+change: the same feature-scope discipline as the rest of the rules.