devrites 3.0.5 → 3.0.7

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

@@ -3,7 +3,7 @@
 DevRites uses **project-local** agents under `.claude/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 — `.claude/agents/`
+## Review subagents: `.claude/agents/`
 Fresh-context, read-only reviewers. Each is given the active feature workspace path
-(`.devrites/work/<slug>/`) + the diff, and returns findings — they do **not** edit code.
+(`.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 — `.claude/agents/devrites-slice-wright.md`
+## The executor subagent: `.claude/agents/devrites-slice-wright.md`
 
 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:
 `.claude/skills/rite-build/reference/wright-dispatch.md`, `.../reference/forge.md`.
 
-## The cross-feature analyst — `.claude/agents/devrites-retrospector.md`
+## The cross-feature analyst: `.claude/agents/devrites-retrospector.md`
 
 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
   (`.claude/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 `.claude/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 `.claude/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 `.claude/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/.claude/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/.claude/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.

package/pack/.claude/skills/devrites-lib/reference/standards/code-review.md

@@ -1,33 +1,33 @@
 # Code review
 
-The reviewer's one question: **does this change make the codebase healthier** — clearer
+The reviewer's one question: **does this change make the codebase healthier**: clearer
 design, cleaner logic, better tests, fewer risks? If not, it doesn't merge yet.
 
 ## Keep changes small
-- One concern per change (a fix, an endpoint, a refactor) — not three at once. Refactoring
+- One concern per change (a fix, an endpoint, a refactor), not three at once. Refactoring
   that rides along with new behavior is two changes: split them.
 - Aim for small diffs: under ~200 lines reviews well and merges fast; treat ~400 as a
   soft ceiling and self-split beyond it. Large diffs hide defects and get rubber-stamped.
 - Watch **file size**, not just diff size: a small diff that grows an already-large file
-  (~1000+ total lines) is an inspection signal — extract the helper or module *first*,
+  (~1000+ total lines) is an inspection signal: extract the helper or module *first*,
   then add.
 - To self-split: **stack** (land the smallest standalone piece, build on top) or cut a
   **thinner vertical slice** (`rite-plan/reference/slicing.md`). Whole-file deletions and
-  mechanical refactors may run large — review intent, not every line.
+  mechanical refactors may run large: review intent, not every line.
 
 ## What to check (tests first)
-1. **Tests** — do they exist and prove the behavior + failure modes (empty, error,
+1. **Tests:** do they exist and prove the behavior + failure modes (empty, error,
    boundary, concurrency)? Would they fail if the code were wrong?
-2. **Correctness** — logic, edge cases, error paths, race conditions, wrong assumptions. For branching or boundary changes, run the mechanical [`edge-case trace`](edge-case-trace.md): explicit paths, fixed-set siblings, and deletion contracts.
-3. **Readability** — names, function size, control flow, intent obvious without the author.
-4. **Architecture** — right seam, coupling/cohesion, fits existing patterns, no premature
+2. **Correctness:** logic, edge cases, error paths, race conditions, wrong assumptions. For branching or boundary changes, run the mechanical [`edge-case trace`](edge-case-trace.md): explicit paths, fixed-set siblings, and deletion contracts.
+3. **Readability:** names, function size, control flow, intent obvious without the author.
+4. **Architecture:** right seam, coupling/cohesion, fits existing patterns, no premature
    abstraction. How does it fit the bigger system, not just what it does?
-5. **Security** — trust boundaries, input validation, authz, secrets.
-6. **Risk** — migrations, destructive changes, rollback.
+5. **Security:** trust boundaries, input validation, authz, secrets.
+6. **Risk:** migrations, destructive changes, rollback.
 
 ## Give actionable feedback
 - Read surrounding source before severity: call sites, existing guards, and the nearest consumer decide impact; a diff hunk alone is not enough.
-- Label severity so the author knows what blocks — each label names the author's action:
+- Label severity so the author knows what blocks: each label names the author's action:
 
   | Label | Author action |
   |---|---|
@@ -35,12 +35,12 @@ design, cleaner logic, better tests, fewer risks? If not, it doesn't merge yet.
   | **Important** | Fix before merge. |
   | **Suggestion** | Weigh it; adopt or answer why not. |
   | **Nit** | May ignore. |
-  | **FYI** | No action — context only. |
+  | **FYI** | No action: context only. |
 - Be specific: point at the line, name the problem, propose the fix. Frame non-blocking
   ideas as questions ("what about a map here for readability?").
 - **Uncertainty lowers the label.** A finding anchored to a quoted line or reproduced
   behavior keeps its severity; one that isn't drops a notch (Important → Suggestion), and a
-  Critical always carries anchored evidence — the diff-review form of quote-or-suppress.
+  Critical always carries anchored evidence: the diff-review form of quote-or-suppress.
 - **Skipped checks are recorded.** A check you couldn't run gets a
   `Skipped: <check> — <why>` line.
 - Let automation (linters, formatters, CI) catch the trivial stuff so review focuses on
@@ -52,60 +52,60 @@ Walk it first and spend the review's weight there; the nits are a footnote, and
 dissolve once the structure moves. A review that opens with whitespace and buries the wrong seam
 on line 200 has optimized for the cheap finding over the load-bearing one.
 
-## Smell lexicon — advisory vocabulary
+## Smell lexicon: advisory vocabulary
 Name these as judgment calls, not automatic violations. They block only when the smell creates a
 concrete risk or breaks a DevRites/project standard.
 
-- **Feature Envy** — code asks another object/module for too much data, so behavior likely lives
+- **Feature Envy:** code asks another object/module for too much data, so behavior likely lives
   on the wrong side of the seam.
-- **Primitive Obsession** — strings/maps/booleans stand in for a real domain concept and scatter
+- **Primitive Obsession:** strings/maps/booleans stand in for a real domain concept and scatter
   validation.
-- **Shotgun Surgery** — one change forces many tiny edits across unrelated files.
-- **Divergent Change** — one module changes for multiple unrelated reasons.
-- **Speculative Generality** — abstraction/config/extension point exists for a future nobody needs
+- **Shotgun Surgery:** one change forces many tiny edits across unrelated files.
+- **Divergent Change:** one module changes for multiple unrelated reasons.
+- **Speculative Generality:** abstraction/config/extension point exists for a future nobody needs
   yet.
-- **Long Method / Large Class** — too many responsibilities for a reviewer to reason about safely.
-- **Data Clumps** — the same fields travel together without a named value object/type.
-- **Message Chains / Middle Man** — callers know too much about navigation, or wrappers only pass
+- **Long Method / Large Class:** too many responsibilities for a reviewer to reason about safely.
+- **Data Clumps:** the same fields travel together without a named value object/type.
+- **Message Chains / Middle Man:** callers know too much about navigation, or wrappers only pass
   calls through.
-- **Duplicate Code** — repeated logic likely hides inconsistent future fixes.
+- **Duplicate Code:** repeated logic likely hides inconsistent future fixes.
 
-## Structural Remedies — propose the move, not just the problem
+## Structural Remedies: propose the move, not just the problem
 "This is hard to follow" names a smell; it doesn't discharge the review. When the problem is
 structural, name the **move** that fixes it so the author has a concrete next step, not a vibe:
 
-- **Replace a conditional chain with a typed dispatcher** — a map/table keyed by the variant,
+- **Replace a conditional chain with a typed dispatcher:** a map/table keyed by the variant,
   each state carrying its own fields, instead of a growing `if/else` on a type tag.
-- **Delete a pass-through wrapper** — a function that only forwards its arguments earns removal;
+- **Delete a pass-through wrapper:** a function that only forwards its arguments earns removal;
   call the inner thing directly.
-- **Collapse duplicate branches** — two arms doing the same work behind different conditions
+- **Collapse duplicate branches:** two arms doing the same work behind different conditions
   become one.
-- **Hoist an invariant out of the loop** — computation that doesn't change per iteration moves
+- **Hoist an invariant out of the loop:** computation that doesn't change per iteration moves
   above it.
 
 A restructuring must *reduce* the concepts a reader holds, not relocate them
-([`patterns.md`](patterns.md)) — prefer the move that makes a whole branch or mode disappear.
+([`patterns.md`](patterns.md)): prefer the move that makes a whole branch or mode disappear.
 
-## Disagreement hierarchy — what wins when you and the author differ
+## Disagreement hierarchy: what wins when you and the author differ
 Resolve a review disagreement by the strongest ground available, in order: **facts** (a
 correctness bug, a failing case, a measured number) > **the project's stated style/convention** >
 **a general design principle** > **personal preference or consistency-for-its-own-sake**. If your
-objection bottoms out at the last tier, it's a Suggestion at most — say so, and don't block on it.
+objection bottoms out at the last tier, it's a Suggestion at most: say so, and don't block on it.
 An author who is factually right wins over a reviewer's taste.
 
 ## Zero findings is suspicious
-An adversarial review that comes back empty is a claim, not a default — and the model's
+An adversarial review that comes back empty is a claim, not a default, and the model's
 strongest pull in review is to agree. So a clean bill of health has to be *earned* the same way a
 finding is: by showing the work. When an axis (spec, code, security, a doubt) genuinely finds
-nothing, it records a **`No-findings:`** justification — the specific adversarial passes it ran
+nothing, it records a **`No-findings:`** justification: the specific adversarial passes it ran
 (edge cases, error paths, the riskiest decision, the consumer whose test might not cover the
 change) and why each came back empty. "Looks good" is not a terminal state; a *justified* empty is.
-Treat a silent axis — no finding and no justification — as a re-run, not a pass.
+Treat a silent axis (no finding and no justification) as a re-run, not a pass.
 
 This is the mirror of confidence-banding: banding suppresses the noisy false positive; the
 no-findings justification catches the silent false negative. `devrites-engine review-integrity`
 checks the account is present (a `No-findings:` line on any axis section that raised nothing), not
-its quality — the same honesty contract as `doubt-coverage` and the footprint roster.
+its quality: the same honesty contract as `doubt-coverage` and the footprint roster.
 
 After `review.md` is written, run `devrites-engine review-fingerprints --write <slug>` to record
 stable IDs for findings. Those IDs make recurring findings and later dismissals correlate cleanly
@@ -119,21 +119,21 @@ drive-by edits that balloon the diff.
 Treat external review as claims to verify, not orders to obey. Clarify unclear feedback before a
 partial fix; check each claim against the live code; push back with evidence when it is wrong;
 then implement blocking → simple → complex items one at a time and test each fix. Technical
-replies state the evidence and next action — no performative agreement, no gratitude theater:
+replies state the evidence and next action: no performative agreement, no gratitude theater:
 "Fixed: <what> in <where>" beats "Great catch, thanks!". About to write "Thanks"? Delete it
 and state the fix.
 
 ## Principles, charter & conventions are pass/fail gates
 Three project layers are evaluated as explicit pass/fail at `/rite-vet`, re-checked after design
-lands, and re-checked against the diff at `/rite-review` / `/rite-seal` — none are advisory:
+lands, and re-checked against the diff at `/rite-review` / `/rite-seal`: none are advisory:
 
-1. **Project principles** (`.devrites/principles.md`) — the authored invariants the project will
+1. **Project principles** (`.devrites/principles.md`): the authored invariants the project will
    not break ([`principles.md`](principles.md)). A change that violates one with **no recorded,
    human-approved exception** is a **Critical** finding and a **NO-GO** at seal, the same standing
    as an unproven acceptance criterion. Check the diff against each principle's scope; an absent
    or empty file means none are declared (gate passes).
-2. **The anti-slop charter** (`coding-style.md` + `prose-style.md`) — the AI-tells do-not list.
-3. **The conventions ledger** (`.devrites/conventions.md`) — proven project idioms (an untrusted
+2. **The anti-slop charter** (`coding-style.md` + `prose-style.md`): the AI-tells do-not list.
+3. **The conventions ledger** (`.devrites/conventions.md`): proven project idioms (an untrusted
    prior; a fresh read of the live code overrides it).
 
 A change that violates a stated convention or trips the charter is a **Critical** finding, not a

package/pack/.claude/skills/devrites-lib/reference/standards/coding-style.md

@@ -27,7 +27,7 @@ if (!user.active) return Forbidden
 ## Comments explain *why*, not *what*
 - Self-explanatory code beats a comment restating it. Rename before you comment.
 - Reserve comments for intent, trade-offs, non-obvious constraints, and "here be
-  dragons" warnings. Delete commented-out code — that's what version control is for.
+  dragons" warnings. Delete commented-out code. That's what version control is for.
 
 ## Simplicity
 - Prefer the simplest thing that works. Don't add abstraction before you have two real
@@ -39,17 +39,17 @@ if (!user.active) return Forbidden
 Before adding a new util, helper, hook, type, component, or formatter, **search** for an
 existing one. **Reuse → extend → build new**, in that order. Don't re-implement what the
 project (or stdlib) already provides. If forcing reuse would distort the existing thing's
-shape, build a sibling and consolidate later — duplication is cheaper than the wrong
+shape, build a sibling and consolidate later: duplication is cheaper than the wrong
 abstraction (AHA).
 
 ## Edit reliably, change only what's asked
 - **No elision.** Never write `// ... rest unchanged` / `# ... existing code` in place of an
-  edit — emit the whole coherent function. Don't anchor an edit on line numbers; match on the
-  surrounding code. If an edit fails to apply, **re-read the file before retrying** — it may
+  edit: emit the whole coherent function. Don't anchor an edit on line numbers; match on the
+  surrounding code. If an edit fails to apply, **re-read the file before retrying**. It may
   have changed under you.
-- **Do what's asked, no more — and no less.** Don't improve, comment, or refactor code unrelated
+- **Do what's asked, no more, and no less.** Don't improve, comment, or refactor code unrelated
   to the task while you're in the file (feature scope). And never leave a comment describing code
-  you didn't write — implement it.
+  you didn't write: implement it.
 - **Never hand-edit a manifest or lockfile.** Add / update / remove dependencies through the
   package manager (`npm install`, `pip install`, `go get`, `cargo add`) so the lockfile stays
-  consistent — don't paste a version into `package.json` / `requirements.txt` by hand.
+  consistent: don't paste a version into `package.json` / `requirements.txt` by hand.