devrites 3.0.5 → 3.0.7

package/pack/.claude/skills/rite-temper/reference/scope-modes.md

@@ -1,48 +1,48 @@
 # Scope modes + the two passes
 
 The heart of `/rite-temper`: two ordered passes (heat, then quench), converging on exactly
-one scope mode. Ambition is a **generative** move followed by a **required convergence** — the
+one scope mode. Ambition is a **generative** move followed by a **required convergence**: the
 divergence is never the spec; the converged sweet spot is.
 
-## Pass 1 — FORWARD (heat: raise ambition on the outcome)
+## Pass 1: FORWARD (heat: raise ambition on the outcome)
 Diverge on the *real problem*, not the obvious path. Ask:
 - What would an order-of-magnitude-better **outcome** look like (the 10-star version)? Design
-  the extreme, then come back to the feasible sweet spot — don't ship the extreme.
+  the extreme, then come back to the feasible sweet spot: don't ship the extreme.
 - Is a **premise** load-bearing and wrong? Name the assumptions the spec rests on; challenge
   the one that, if false, changes everything.
-- Where is **under-reaching** the real risk — a timid improvement to a path we should reframe?
+- Where is **under-reaching** the real risk: a timid improvement to a path we should reframe?
 
 Ambition aims at the **outcome** (problem definition, success bar, user value) and at
 complexity-**neutral** future-proofing. It never aims at the **solution surface** (that's Pass 2's
-job to prune). Ground every ambitious idea in the codebase's real seams and blast radius (a code-intelligence
-index if available — see `../../devrites-lib/reference/standards/tooling.md`) — don't invent greenfield scope a
+job to prune). Ground every ambitious idea in the codebase's real seams and blast radius. Use a
+code-intelligence index if available (see `../../devrites-lib/reference/standards/tooling.md`). Don't invent greenfield scope a
 constrained codebase can't absorb.
 
-## Pass 2 — INVERSION (quench: pre-mortem + prune)
+## Pass 2: INVERSION (quench: pre-mortem + prune)
 Invert. Two subtractive moves:
 - **Pre-mortem (prospective hindsight).** State it in past tense: *"It's six months out. This
   shipped and failed. What went wrong?"* List the top failure modes; for each: likelihood,
   mitigation, and the slice that will own the mitigation. Unmitigated top risks are **gating**.
 - **YAGNI ledger.** Each candidate scope item gets the "imagine the later refactor" test: if
   adding it *later* isn't materially more expensive, **defer it** (with a revisit note).
-  Bias hard toward defer — most presumed-needed features are never actually used. Reuse the
-  pack's existing standard — `patterns.md` ("no abstraction before two real callers",
-  "speculative generality") — don't invent a new YAGNI rule.
+  Bias hard toward defer: most presumed-needed features are never used. Reuse the
+  pack's existing `patterns.md` standards, including "no abstraction before two real callers"
+  and "speculative generality." Don't invent a new YAGNI rule.
 
-## The four modes — commit exactly one
+## The four modes: commit exactly one
 Mode selection is the first convergence move. Record the chosen mode + rationale + the
 **hinge** (what would change the call) in `strategy.md` and `decisions.md`.
 
 | Mode | When | What it does | YAGNI / Drift Guard |
 |---|---|---|---|
-| **EXPAND** *(opt-in, default OFF)* | Under-reaching on the outcome is the real risk | Raise the success bar / reframe to the deeper problem; thinner-but-more-complete path to a bigger target | Expands the *problem + acceptance*, not machinery. Each added criterion is a Drift-Guard-recorded, human-confirmed (HITL) decision — never auto-grown |
+| **EXPAND** *(opt-in, default OFF)* | Under-reaching on the outcome is the real risk | Raise the success bar / reframe to the deeper problem; thinner-but-more-complete path to a bigger target | Expands the *problem + acceptance*, not machinery. Each added criterion is a Drift-Guard-recorded, human-confirmed (HITL) decision: never auto-grown |
 | **SELECTIVE** | One or two high-leverage dimensions deserve more; the rest is right | Expand only the high-upside dimension; hold the rest at spec scope | Each selected expansion routes through the Guard; everything not selected is parked in Non-goals so it's neither dropped nor re-injected mid-build |
-| **HOLD-RIGOR** | The spec is right-sized (default for irreversible-risk-heavy or already-tight specs) | No scope change — pure hardening: pre-mortem, risk mitigations, acceptance sharpening, cross-cutting coverage | Adds zero surface; trivially Drift-Guard-clean (no acceptance change) |
-| **REDUCE-TO-MVP** | Over-scoped: second-system bloat, ~all must-haves, gold-plating | Hammer scope to the Minimum Usable Subset; move the rest to Non-goals with one-line reasons + revisit notes | Strongest YAGNI alignment. Cutting acceptance is **still a spec change** — record it via the Guard, never a silent trim |
+| **HOLD-RIGOR** | The spec is right-sized (default for irreversible-risk-heavy or already-tight specs) | No scope change: pure hardening: pre-mortem, risk mitigations, acceptance sharpening, cross-cutting coverage | Adds zero surface; trivially Drift-Guard-clean (no acceptance change) |
+| **REDUCE-TO-MVP** | Over-scoped: second-system bloat, ~all must-haves, gold-plating | Hammer scope to the Minimum Usable Subset; move the rest to Non-goals with one-line reasons + revisit notes | Strongest YAGNI alignment. Cutting acceptance is **still a spec change**: record it via the Guard, never a silent trim |
 
 ## Bound ambition by reversibility
 The bigger the bet, the more it must be reversible. Irreversible-risk areas (auth, migrations,
-public API, data model) get the **opposite** of ambition — maximum conservatism, explicit
+public API, data model) get the **opposite** of ambition: maximum conservatism, explicit
 rollback, and they **always pause** regardless of mode (the `afk-hitl.md` irreversible-risk
 list is honored verbatim). Size big bets so that if the whole thing vanished tomorrow, you'd be
 fine.
@@ -50,4 +50,4 @@ fine.
 ## Effort foresight (frame it now, not "later")
 While choosing scope, surface the late-stage questions early: *"What will surprise us at
 integration? What will we wish we'd planned for at polish/test time?"* Turn each into a
-constraint, a risk, or a deferred Non-goal **now** — not a "figure it out later".
+constraint, a risk, or a deferred Non-goal **now**, not a "figure it out later".

package/pack/.claude/skills/rite-temper/reference/significance.md

@@ -1,4 +1,4 @@
-# Significance test — fire the full review, or skip it
+# Significance test: fire the full review, or skip it
 
 `/rite-temper` is **significance-gated**: full strategic rigor only when the work is big
 enough to earn it, a one-line skip otherwise. This is the shared definition used by both the
@@ -9,24 +9,24 @@ A strategic review of a five-line, reversible change is theatre; a strategic rev
 auth rewrite is the cheapest insurance you'll buy. Gate on stakes and shape, not uniformly.
 
 ## Fire the FULL review when ANY trips
-- **Irreversible-risk contact** — the slice/spec touches anything on the `afk-hitl.md`
+- **Irreversible-risk contact:** the slice/spec touches anything on the `afk-hitl.md`
   irreversible-risk list: destructive data migration, auth/authz boundary, public-API break,
   external-service contract, filesystem destruction outside the workspace.
-- **Data model** — new/changed entities, relationships, or persistence shape.
-- **Cross-module blast radius** — the impact (from a code-intelligence index if available — see
-  `../../devrites-lib/reference/standards/tooling.md` — or an honest estimate) crosses
+- **Data model:** new/changed entities, relationships, or persistence shape.
+- **Cross-module blast radius:** the impact (from a code-intelligence index if available (see
+  `../../devrites-lib/reference/standards/tooling.md`) or an honest estimate) crosses
   module/service boundaries or has many dependents.
-- **Greenfield / ambiguous scope** — a new surface with no existing seam to follow, or a spec
+- **Greenfield / ambiguous scope:** a new surface with no existing seam to follow, or a spec
   whose "right size" is genuinely open (multiple defensible scopes).
-- **Multi-slice / multi-day** — the work decomposes into several slices (large enough that a
+- **Multi-slice / multi-day:** the work decomposes into several slices (large enough that a
   wrong scope call is expensive to unwind).
-- **The user asked** — "think bigger", "is this ambitious enough", "scope check", "pre-mortem",
+- **The user asked:** "think bigger", "is this ambitious enough", "scope check", "pre-mortem",
   an explicit `/rite-temper` invocation, or a chosen `--mode`. An explicit ask always fires.
 
 ## Skip (low stakes) when ALL hold
 - Single-module, reversible, behavior-shaped-not-structural change.
 - No irreversible-risk contact; blast radius contained to the touched files.
-- Scope is unambiguous — there's one obvious right size and the spec already has it.
+- Scope is unambiguous: there's one obvious right size and the spec already has it.
 
 On skip, **don't run the passes**. Write only the one-line verdict to `strategy.md`:
 
@@ -36,7 +36,7 @@ Significance: skipped — low stakes (<the trigger that was NOT met, e.g. "singl
 Next: /rite-define
 ```
 
-Then recommend `/rite-define`. A skip is a *recorded* decision, not a silent omission — the
+Then recommend `/rite-define`. A skip is a *recorded* decision, not a silent omission: the
 seal can see the call was made deliberately.
 
 ## In `/rite-autocomplete`

package/pack/.claude/skills/rite-temper/reference/strategy-template.md

@@ -1,10 +1,10 @@
 # `strategy.md` template + fold-back rules
 
 `/rite-temper` produces two kinds of output. The `strategy.md` artifact is the durable
-**record** of the review; the **fold-back edits** are what the build actually follows. The
-record without the fold-back is dead prose — the build reads `spec.md`, not `strategy.md`.
+**record** of the review; the **fold-back edits** are what the build follows. The
+record without the fold-back is dead prose: the build reads `spec.md`, not `strategy.md`.
 
-## `strategy.md` — the record
+## `strategy.md`: the record
 Write to `.devrites/work/<slug>/strategy.md`. If one exists for the slug, **update** it, don't
 clobber.
 
@@ -58,33 +58,33 @@ Floor verdict: <weakest band> on <dimension> → pass | blocked
 - Final: floor = <band>; unresolved → <none | blocking qid>
 ```
 
-## Fold-back — the part the build follows
+## Fold-back: the part the build follows
 Apply through the **Spec Drift Guard** (these are spec changes, not free edits). If a plan
 already exists, record in `drift.md` and route via `/rite-plan repair` instead of editing
 `spec.md` blind.
 
-- **`spec.md`** (these are the spec template's actual section headings — edit each named one,
-  don't collapse pairs):
-  - *Success criteria* **and** *Acceptance criteria* (separate sections) — add to **both** for
+- **`spec.md`:** these are the spec template's actual section headings. Edit each named one;
+  don't collapse pairs.
+  - Add to *Success criteria* **and** *Acceptance criteria* (separate sections) for
     every opt-in **expansion**; remove (via the Guard) from both for every **reduction**. Each
     must stay measurable + technology-agnostic.
-  - *Non-goals* — append every deferred item (from the YAGNI ledger + the Deferred register), so
+  - *Non-goals*: append every deferred item (from the YAGNI ledger + the Deferred register), so
     it is neither silently dropped nor silently re-injected mid-build.
-  - *Constraints* **and** *Risks* (separate sections) — tighten *Constraints* where the pre-mortem
+  - *Constraints* **and** *Risks* (separate sections): tighten *Constraints* where the pre-mortem
     demands; add the top failure modes + mitigations to *Risks*.
-  - *Gaps, issues & decisions* table — one row per scope call (options offered → decision → owner).
+  - *Gaps, issues & decisions* table: one row per scope call (options offered → decision → owner).
   - **Re-run the Readiness gate** at the bottom of the spec after edits; it must still pass, and
     **every folded scope delta must trace to a recorded decision** (a `questions.md` qid or a
-    `decisions.md` ADR) — an untraceable change is the batch-dump failure.
-- **`decisions.md`** — one ADR-style entry per scope call and accepted trade-off:
+    `decisions.md` ADR): an untraceable change is the batch-dump failure.
+- **`decisions.md`:** one ADR-style entry per scope call and accepted trade-off:
   `context · decision · why-not-the-alternative · what-would-change-it`.
-- **`assumptions.md`** — every "we'll probably need X" demoted to an explicit
+- **`assumptions.md`:** every "we'll probably need X" demoted to an explicit
   **assumption-to-verify**, never smuggled into scope as a fact.
 
 ## Write discipline
 - **Single canonical writer.** The skill writes `strategy.md` and edits the canonical files; the
   `devrites-strategy-reviewer` agent is **read-only** and only returns findings + bands.
 - **No silent scope.** An expansion that the human didn't opt into, or a reduction that drops an
-  acceptance criterion without a recorded decision, is a defect — not a convenience.
+  acceptance criterion without a recorded decision, is a defect, not a convenience.
 - Add `strategy.md` to the workspace between `spec.md` and `plan.md`; `/rite-define`,
   `/rite-review`, and `/rite-seal` read it.

package/pack/.claude/skills/rite-vet/SKILL.md

@@ -5,13 +5,13 @@ argument-hint: "[slug] [--cross-model] [--full]"
 user-invocable: true
 ---
 
-# /rite-vet — vet the plan before you build
+# /rite-vet: vet the plan before you build
 
 Take a defined plan and **vet** it the way a senior staff engineer would in a plan review:
 challenge the scope, walk architecture / plan code-quality / test-coverage / performance,
 calibrate every finding by confidence (and refuse to emit one you can't trace to a quoted
 line), design the test coverage the build will target, and map the failure modes and
-parallel lanes — *before* `/rite-build` writes a line. The one DevRites step that hardens
+parallel lanes: *before* `/rite-build` writes a line. The one DevRites step that hardens
 the **implementation plan** at the engineering level and folds the result into the canonical
 contract, so the build follows a reviewed plan. Runs on **every** plan (depth scales to
 stakes; never skipped) and is always part of `/rite-autocomplete`; `--cross-model` adds a
@@ -23,36 +23,36 @@ Temper decides *the right thing*; vet decides *the right way to build it*.
 
 ## Rules consulted (read on demand from `.claude/skills/devrites-lib/reference/standards/`)
 Pull on demand: `principles.md` (the project
-invariants gate — how `.devrites/principles.md` is scored pass/fail), `patterns.md` +
-`coding-style.md` (the over-engineering / reuse-first / YAGNI rubric — reuse the pack's
+invariants gate (how `.devrites/principles.md` is scored pass/fail), `patterns.md` +
+`coding-style.md` (the over-engineering / reuse-first / YAGNI rubric) reuse the pack's
 standard), `testing.md` (the test-coverage axis) + `spec-grammar.md` (when the spec uses
 structured Requirement/Scenario blocks, each scenario is a coverage unit `test-plan.md` must
 map), `performance.md` (the perf axis),
 `error-handling.md` (failure-mode coverage), `development-workflow.md` (parallel lanes,
 definition of done), `afk-hitl.md` (irreversible-risk list + gate ceiling),
-`developer-experience.md` (when the plan ships a developer-facing surface — API / CLI / SDK /
-webhook / config / error messages / getting-started — predict the DX scorecard here),
-`elicitation.md` (the move-set to deepen an axis finding or a risky design choice — selected by
+`developer-experience.md` (when the plan ships a developer-facing surface (API / CLI / SDK /
+webhook / config / error messages / getting-started) predict the DX scorecard here),
+`elicitation.md` (the move-set to deepen an axis finding or a risky design choice: selected by
 the section's risk: Tournament for two viable designs, Delphi for a shaky estimate, Assumption
 Audit for a plan resting on unstated beliefs).
-- `definition-of-done.md` — standing Done bar: acceptance mapped, fresh proof, no open hard gates, scoped edits, rollback/docs where needed.
+- `definition-of-done.md`: standing Done bar: acceptance mapped, fresh proof, no open hard gates, scoped edits, rollback/docs where needed.
 
 
 ## Operating rules
 - **Review the plan, not the spec's ambition.** The spec's scope/ambition is `/rite-temper`'s
   job and is treated as settled here. Vet asks *given this scope, is this the right, simplest,
-  best-tested, lowest-risk way to build it* — and challenges only implementation scope creep.
+  best-tested, lowest-risk way to build it*, and challenges only implementation scope creep.
 - **You harden the plan directly; the reviewer judges.** Vet *is* the plan-hardening phase, so
   behavior-preserving plan refinements (test requirements, tightened scope boundaries, ordering,
   parallel lanes, error-handling + failure-mode coverage) are written straight into
-  `plan.md` / `tasks.md` / `test-plan.md` — you are the single canonical writer. A finding that
+  `plan.md` / `tasks.md` / `test-plan.md`. You are the single canonical writer. A finding that
   changes **acceptance criteria or product behavior** is *not* a plan refinement: it routes
   through the **Spec Drift Guard** (record in `drift.md`, recorded decision, then `/rite-plan
   repair` for any structural reslice). Nothing that grows the build's scope lands without a
   recorded human decision.
 - **Confidence over assertion.** Every finding carries a confidence band; a finding you cannot
   back by quoting the plan/spec line (or the code it references) is forced to low confidence and
-  suppressed from the main report — see the verification gate in [`reference/review-axes.md`](reference/review-axes.md).
+  suppressed from the main report: see the verification gate in [`reference/review-axes.md`](reference/review-axes.md).
 - **Bound rigor by reversibility.** Auth / migration / public-API / data-model touches get
   maximum conservatism and always pause (irreversible-risk list), regardless of run mode.
 - **Honest verdict, gated on the floor.** Never round "thin" up to "ready"; the axis verdict is
@@ -60,7 +60,7 @@ Audit for a plan resting on unstated beliefs).
 
 ## Workflow
 0. **Read `.claude/skills/devrites-lib/reference/standards/core.md`** first.
-   Then **run the shared orientation preamble** — it prints `state.md`, the artifacts present,
+   Then **run the shared orientation preamble**. It prints `state.md`, the artifacts present,
    the run mode (HITL/AFK), and the open-question tally by gate, so you orient deterministically
    instead of re-deriving state from raw Markdown:
    ```bash
@@ -70,53 +70,53 @@ Audit for a plan resting on unstated beliefs).
    Then the workspace: `plan.md`, `tasks.md`, `spec.md`
    (for intent + acceptance), `strategy.md` (if `/rite-temper` ran), `decisions.md`,
    `assumptions.md`, `design-brief.md` (if UI), `state.md`. Require a `plan.md` whose
-   Readiness gate passes (or `Plan approved`) — else STOP → `/rite-define`. Prefer a
+   Readiness gate passes (or `Plan approved`): else STOP → `/rite-define`. Prefer a
    code-intelligence index if available (see
    `.claude/skills/devrites-lib/reference/standards/tooling.md`) for placement / blast-radius / reuse checks.
-1. **Calibrate depth — never skip** — [`reference/depth.md`](reference/depth.md). Every plan is
+1. **Calibrate depth. Never skip this step.** See [`reference/depth.md`](reference/depth.md). Every plan is
    vetted; what scales is the *depth*. A simple, single-module, reversible plan with no
    irreversible-risk / data-model / new-pattern trigger → **light pass** (brief scope check + a
    one-line scan per axis + the acceptance→test map). Any full-pass trigger (or `--full`) → the
    **full pass** below. There is no skip: every feature leaves a recorded engineering verdict and
    a `test-plan.md` coverage map.
-2. **Scope Challenge (blocking gate)** — [`reference/review-axes.md`](reference/review-axes.md)
+2. **Scope Challenge (blocking gate):** [`reference/review-axes.md`](reference/review-axes.md)
    §0. Search prior archived decisions for the plan's main nouns before asking the human to re-decide:
    `devrites-engine decisions search "<2-4 plan nouns>"` (run `decisions index` first if needed).
    What already exists that solves a sub-problem (reuse vs rebuild)? The minimum diff for the
    stated acceptance? Complexity smell (the plan touches **>8 files** or adds **>2 new
    services/modules**) → **STOP and ask** before any axis. Verify each new pattern / infra choice
    against a built-in (dispatch `devrites-source-driven`); completeness check (with AI, full
-   coverage is ~100× cheaper than the human-hours saved by a shortcut — prefer complete); and a
+   coverage is ~100× cheaper than the human-hours saved by a shortcut: prefer complete); and a
    distribution check for any new artifact.
 2a. **Cross-artifact analyze gate + principles / charter / conventions gate.** Before the axes, run
    one read-only consistency+coverage pass over `spec.md` + `plan.md` + `tasks.md` (+ `traceability.md`
-   if present); any **CRITICAL** — an acceptance criterion with no slice, a slice satisfying no
-   criterion, a contradiction across artifacts, a requirement stated twice with conflicting terms —
+   if present); any **CRITICAL**: an acceptance criterion with no slice, a slice satisfying no
+   criterion, a contradiction across artifacts, a requirement stated twice with conflicting terms:
    **blocks `/rite-build`** until resolved. The engine covers the deterministic floor (AC coverage,
    orphan slices, vague adjectives); you add the semantic passes it can't: **terminology drift**
-   (the same concept named differently across artifacts — normalize to the spec's term) and
+   (the same concept named differently across artifacts: normalize to the spec's term) and
    **duplicated or conflicting requirements**. Then score
    the three project gates as explicit **pass/fail** on the planned approach:
-   - **Principles** (`.devrites/principles.md`, rubric in [`principles.md`](../devrites-lib/reference/standards/principles.md))
-     — the authored invariants the project will not break. A plan that bakes in a violation of a
+   - **Principles** (`.devrites/principles.md`, rubric in [`principles.md`](../devrites-lib/reference/standards/principles.md)).
+     The authored invariants the project will not break. A plan that bakes in a violation of a
      declared principle with **no recorded, human-approved exception** is a **top-severity** finding,
      walked **first**, and **blocks `/rite-build`**. Absent or empty file → none declared → passes;
      **never block for the absence of principles**. A genuine need to break one routes to a scoped,
-     dated exception in the principles register — never a silent work-around (adding the exception is
+     dated exception in the principles register: never a silent work-around (adding the exception is
      an irreversible-risk decision: it always pauses for a human, even in AFK).
    - **The anti-slop charter** (`coding-style.md` + `prose-style.md`) and **the conventions ledger**
-     (`.devrites/conventions.md`) — a plan that bakes in a god-module, a speculative abstraction with
+     (`.devrites/conventions.md`): a plan that bakes in a god-module, a speculative abstraction with
      no second caller, or a dependency where an in-repo option exists is a **top-severity** violation.
    **Re-check all three after the axes harden the plan** (post-design). Write the result to `analysis.md`.
    ```bash
    devrites-engine analyze; echo "analyze rc=$?"
    ```
-3. **Four-axis review** — [`reference/review-axes.md`](reference/review-axes.md), through the
+3. **Four-axis review:** [`reference/review-axes.md`](reference/review-axes.md), through the
    senior-engineer lenses in [`reference/eng-lenses.md`](reference/eng-lenses.md): **Architecture
    → Plan code-quality → Test-coverage design → Performance**, ≤8 findings per axis, each
    `[severity] (confidence: N/10) <ref> — finding`. **Walk findings WITH the human, one at a
    time** via `AskUserQuestion` (best-guess + why + options with effort/risk/maintenance, mapped
-   to a rule) — the artifact is the *output* of the review, not a substitute for it.
+   to a rule): the artifact is the *output* of the review, not a substitute for it.
    When an axis finding hinges on a genuinely open design choice or a shaky estimate, deepen that
    one finding with a fitting technique from
    [`elicitation.md`](../devrites-lib/reference/standards/elicitation.md) (Tournament for two viable
@@ -124,7 +124,7 @@ Audit for a plan resting on unstated beliefs).
    single-sourced in [`reference/depth.md`](reference/depth.md): hardening /
    coverage-increasing findings auto-apply; **anything that grows scope or changes acceptance is a
    blocking pause**; irreversible-risk always pauses.)
-4. **Required outputs** — write every shape and fold-back required by
+4. **Required outputs:** write every shape and fold-back required by
    [`reference/artifacts.md`](reference/artifacts.md), using the review rules in
    [`reference/review-axes.md`](reference/review-axes.md). Ground parallelization in:
    ```bash
@@ -135,7 +135,7 @@ Audit for a plan resting on unstated beliefs).
 4a. **Forge gate (only when `Forge: yes`).** Apply the eligibility and scorecard contract in
    [`rite-build/reference/forge.md`](../rite-build/reference/forge.md). Confirm and record
    genuinely distinct strategies, or clear the flag; an ineligible Forge never reaches build.
-5. **Write `eng-review.md` + `test-plan.md`, fold back** — [`reference/artifacts.md`](reference/artifacts.md).
+5. **Write `eng-review.md` + `test-plan.md`, fold back:** [`reference/artifacts.md`](reference/artifacts.md).
    `eng-review.md` is the durable record; `test-plan.md` is the build-readable coverage target
    (`/rite-build` and `/rite-prove` read it). Harden `plan.md` / `tasks.md` directly for
    behavior-preserving refinements; route every acceptance/behavior-changing delta through the
@@ -157,13 +157,13 @@ Audit for a plan resting on unstated beliefs).
    failure-mode criticals; recommend `/rite-build`.
 
 > **Mid-flight discipline.** When tempted to batch-dump findings into `eng-review.md` and skip
-> the walk-through, harden the plan past a finding that actually changes acceptance, score before
-> quoting the source, or wave through a complexity smell "to keep moving" — see
+> the walk-through, harden the plan past a finding that changes acceptance, score before
+> quoting the source, or wave through a complexity smell "to keep moving": see
 > [`reference/anti-patterns.md`](reference/anti-patterns.md).
 
 ## Output
 
-**Progress first** — run `devrites-engine progress`, then use the shared completion reply contract
+**Progress first**: run `devrites-engine progress`, then use the shared completion reply contract
 ([`devrites-lib/reference/reply-contract.md`](../devrites-lib/reference/reply-contract.md)).
 Default success shape:
 ```
@@ -177,4 +177,4 @@ Record: .devrites/work/<slug>/eng-review.md
 ```
 If a blocker or Spec Drift Guard delta remains, use the shared `Stopped / blocked`
 form and route `Fix:` to `/rite-plan`; do not recommend `/rite-build`.
-**DO NOT write code, slice, or run the build here** — that's `/rite-build`. Vet reviews and hardens the plan; it never implements.
+**DO NOT write code, slice, or run the build here**. That's `/rite-build`. Vet reviews and hardens the plan; it never implements.

package/pack/.claude/skills/rite-vet/reference/anti-patterns.md

@@ -1,7 +1,7 @@
-# /rite-vet — anti-patterns
+# /rite-vet: anti-patterns
 
 Universal rationalizations + red flags live in
-[`../../devrites-lib/reference/standards/anti-patterns.md`](../../devrites-lib/reference/standards/anti-patterns.md) — read it when the
+[`../../devrites-lib/reference/standards/anti-patterns.md`](../../devrites-lib/reference/standards/anti-patterns.md): read it when the
 reluctance is broader than this phase. Below are the vet-specific ones.
 
 ## Phase rationalizations
@@ -9,21 +9,21 @@ reluctance is broader than this phase. Below are the vet-specific ones.
 | Excuse | Rebuttal |
 |---|---|
 | "I'll write all the findings into `eng-review.md` and let the user read it." | The artifact is the *output* of an interactive review, not a substitute for it. A material finding's path to "done" goes **through `AskUserQuestion`**, one at a time, with a recommendation + why. Dumping findings into one write and moving on is the exact failure this skill exists to prevent. |
-| "The plan doesn't handle X — flag it." (without checking) | Quote the line first. If you can't quote where the plan handles X, you also can't be sure it doesn't — force confidence ≤4 and suppress. The "field/case doesn't exist" finding is the most common false positive; the verification gate exists to kill it. |
-| "It's an obvious fix — I'll just edit the plan." | An obvious *plan refinement* (a test requirement, an error path, tighter scope) you write directly — that's vet's job. A fix that **changes an acceptance criterion or product behavior** is not obvious enough to skip the human: route it through the Spec Drift Guard with a recorded decision. |
-| "This dimension is thin but the others are strong — net it's fine." | The gate is the **floor**, not the average. A plan `broken` on test-coverage does not pass because it's `strong` on architecture. |
-| "I can see it's adequate — I'll note the band, the evidence is obvious." | Cite the quoted evidence **before** the band. Score-first-justify-later is how a reviewer waves through a plan it already likes. |
-| "8+ files but it all needs to change — proceed." | The complexity smell is a **STOP-and-ask**, not a note. Name the overbuilt part, propose the smaller version that still meets acceptance, and let the human decide before any axis runs. Maybe it's justified — record *why* — but the gate fires first. |
-| "There's no test for this, but the user can add one later." | Coverage is designed **now**, before the code, so the build writes tests alongside it. A deferred test is a test that misses the boundary cases writing-it-now would expose. Regressions are non-negotiable — Critical, no question. |
-| "Performance looks fine." | "Looks fine" is not a measurement. A perf finding is "measure X against budget Y" or it's nothing — don't recommend speculative tuning, and don't wave past an N+1 you can quote. |
+| "The plan doesn't handle X: flag it." (without checking) | Quote the line first. If you can't quote where the plan handles X, you also can't be sure it doesn't: force confidence ≤4 and suppress. The "field/case doesn't exist" finding is the most common false positive; the verification gate exists to kill it. |
+| "It's an obvious fix. I'll just edit the plan." | An obvious *plan refinement* (a test requirement, an error path, tighter scope) you write directly. That's vet's job. A fix that **changes an acceptance criterion or product behavior** is not obvious enough to skip the human: route it through the Spec Drift Guard with a recorded decision. |
+| "This dimension is thin but the others are strong: net it's fine." | The gate is the **floor**, not the average. A plan `broken` on test-coverage does not pass because it's `strong` on architecture. |
+| "I can see it's adequate. I'll note the band, the evidence is obvious." | Cite the quoted evidence **before** the band. Score-first-justify-later is how a reviewer waves through a plan it already likes. |
+| "8+ files but it all needs to change: proceed." | The complexity smell is a **STOP-and-ask**, not a note. Name the overbuilt part, propose the smaller version that still meets acceptance, and let the human decide before any axis runs. Maybe it's justified (record *why*) but the gate fires first. |
+| "There's no test for this, but the user can add one later." | Coverage is designed **now**, before the code, so the build writes tests alongside it. A deferred test is a test that misses the boundary cases writing-it-now would expose. Regressions are non-negotiable. Critical, no question. |
+| "Performance looks fine." | "Looks fine" is not a measurement. A perf finding is "measure X against budget Y" or it's nothing: don't recommend speculative tuning, and don't wave past an N+1 you can quote. |
 | "Cross-model agrees, so apply it." | Cross-model consensus is a strong *signal*, not an approval. Every cross-model finding is informational until the human approves it (or, in AFK, until the gate ceiling clears a hardening-only change). |
 
 ## Red flags
-- `eng-review.md` / `test-plan.md` written but `plan.md` / `tasks.md` **not** hardened — the build
+- `eng-review.md` / `test-plan.md` written but `plan.md` / `tasks.md` **not** hardened: the build
   follows the plan, so the review changed nothing.
-- A finding raised with confidence ≥7 but **no quoted source line** — that defeats the verification gate.
+- A finding raised with confidence ≥7 but **no quoted source line**, that defeats the verification gate.
 - A scope-growing finding auto-applied in AFK (it must pause), or any irreversible-risk touch that didn't pause.
-- A failure-mode table with rows but no verdict column filled — a "no test + no handling + silent" row not marked Critical.
+- A failure-mode table with rows but no verdict column filled: a "no test + no handling + silent" row not marked Critical.
 - The reviewer loop running past 3 iterations, or the reviewer / cross-model being handed the author's reasoning (defeats the fresh-context point).
-- The skill writing code, implementing a slice, or running the build — that's `/rite-build`. Vet reviews and hardens the plan; it never implements.
-- Re-litigating the **spec's** scope/ambition — that was `/rite-temper`. Vet challenges *implementation* scope only.
+- The skill writing code, implementing a slice, or running the build. That's `/rite-build`. Vet reviews and hardens the plan; it never implements.
+- Re-litigating the **spec's** scope/ambition, that was `/rite-temper`. Vet challenges *implementation* scope only.

package/pack/.claude/skills/rite-vet/reference/artifacts.md

@@ -2,10 +2,10 @@
 
 `/rite-vet` produces two artifacts and a set of fold-back edits. `eng-review.md` is the durable
 **record** of the review; `test-plan.md` is the build-readable **coverage target**; the
-fold-back edits to `plan.md` / `tasks.md` are what the build actually follows. The record
-without the fold-back is dead prose — the build reads `plan.md` + `test-plan.md`, not `eng-review.md`.
+fold-back edits to `plan.md` / `tasks.md` are what the build follows. The record
+without the fold-back is dead prose: the build reads `plan.md` + `test-plan.md`, not `eng-review.md`.
 
-## `eng-review.md` — the record
+## `eng-review.md`: the record
 Write to `.devrites/work/<slug>/eng-review.md`. If one exists for the slug, **update** it, don't
 clobber.
 
@@ -52,7 +52,7 @@ Sequential — no opportunity   # OR the dependency table + lanes + order + conf
 - Plan: hardened in place | <n> deltas via Spec Drift Guard
 ```
 
-## `test-plan.md` — the build-readable coverage target
+## `test-plan.md`: the build-readable coverage target
 Write to `.devrites/work/<slug>/test-plan.md`. `/rite-build` (the slice-wright) reads it to write
 tests alongside the code; `/rite-prove` walks it against `evidence.md`. Keep it about *what to
 test and where*, not implementation detail.
@@ -101,11 +101,11 @@ Order:  launch A + B in parallel worktrees → merge → C
 Conflicts: Lanes A and B both touch models/ — sequential or coordinate.
 ```
 
-## Fold-back — the part the build follows
+## Fold-back: the part the build follows
 Vet *is* the plan-hardening phase, so behavior-preserving refinements are written **directly**;
 acceptance/behavior changes route through the **Spec Drift Guard**.
 
-- **Write directly into `plan.md` / `tasks.md`** (single canonical writer — you, not the reviewer):
+- **Write directly into `plan.md` / `tasks.md`** (single canonical writer: you, not the reviewer):
   - `plan.md` §Scope boundaries ← "NOT in scope" items.
   - `plan.md` §Architecture decisions ← reuse-over-rebuild calls + named failure scenarios.
   - `plan.md` §Dependency graph / §Implementation order ← the parallel lanes + any ordering fix
@@ -117,18 +117,18 @@ acceptance/behavior changes route through the **Spec Drift Guard**.
   - Re-run the `plan.md` Readiness gate after edits; it must still pass.
 - **Route through the Spec Drift Guard** (record `drift.md` + a recorded decision, then `/rite-plan
   repair` for any structural reslice) for anything that **changes an acceptance criterion, product
-  behavior, or the spec** — including a scope reduction that drops a criterion. A folded change with
+  behavior, or the spec**, including a scope reduction that drops a criterion. A folded change with
   no recorded decision is the batch-dump failure.
-- **`decisions.md`** — one ADR per material call: `context · decision · why-not-the-alternative ·
+- **`decisions.md`:** one ADR per material call: `context · decision · why-not-the-alternative ·
   what-would-change-it`.
-- **`assumptions.md`** — every "we'll probably need X" demoted to an explicit assumption-to-verify,
+- **`assumptions.md`:** every "we'll probably need X" demoted to an explicit assumption-to-verify,
   never smuggled into scope as a fact.
 
 ## Write discipline
 - **Single canonical writer.** The skill writes `eng-review.md` / `test-plan.md` and edits
   `plan.md` / `tasks.md`; `devrites-plan-reviewer` is **read-only** and only returns findings + bands.
 - **No silent scope.** A plan refinement that grows acceptance without a recorded decision, or a
-  deferral that drops a criterion without the Guard, is a defect — not a convenience.
+  deferral that drops a criterion without the Guard, is a defect, not a convenience.
 - Add `eng-review.md` + `test-plan.md` to the workspace between `tasks.md` and `state.md`.
   `/rite-build` (the slice-wright) and `/rite-prove` **read `test-plan.md`** as the coverage
   target; `/rite-review` and `/rite-seal` may consult `eng-review.md` for the failure-mode +

package/pack/.claude/skills/rite-vet/reference/cross-model.md

@@ -1,20 +1,20 @@
-# `--cross-model` — the outside voice (a genuinely different model)
+# `--cross-model`: the outside voice (a genuinely different model)
 
-`devrites-plan-reviewer` gives an *independent* read (fresh context, no authoring reasoning) —
+`devrites-plan-reviewer` gives an *independent* read (fresh context, no authoring reasoning):
 but it's still the same model family. `--cross-model` adds a second opinion from a **different**
 AI system, because two models agreeing on a plan is stronger signal than one model reviewing it
 thoroughly. It is **opt-in** for `/rite-vet` (the flag) and **off by default in
-`/rite-autocomplete`** unless the flag was armed — it costs latency and a second runtime.
+`/rite-autocomplete`** unless the flag was armed. It costs latency and a second runtime.
 
 ## When it runs
 Only when `$ARGUMENTS` contains `--cross-model` **and** a different-model reviewer is available.
 First run `devrites-engine reviewers list`; configured aliases there are preferred over ad-hoc
-model choices. The default path (no flag) relies on `devrites-plan-reviewer` for independence —
+model choices. The default path (no flag) relies on `devrites-plan-reviewer` for independence:
 that is a complete review on its own; cross-model is an enhancement, not a requirement.
 
 ## Dispatch
 After the in-model reviewer loop converges (or in parallel with its final iteration), hand the
-**same fresh inputs** to a different model — preferentially a configured `codex` reviewer alias,
+**same fresh inputs** to a different model: preferentially a configured `codex` reviewer alias,
 then the `codex:codex-rescue` agent if no alias exists. Give it only the contract, never the
 authoring reasoning:
 
@@ -23,14 +23,14 @@ authoring reasoning:
 > boundaries, scope discipline & reuse, test-coverage design, performance, reversibility, and
 > failure-mode coverage. For every finding, quote the line that motivates it and give a 1-10
 > confidence; suppress anything you can't quote. Return labeled findings (Critical / Important /
-> Suggestion) with a concrete fix. Do not edit anything. Do not approve — find what will cost a redo.
+> Suggestion) with a concrete fix. Do not edit anything. Do not approve: find what will cost a redo.
 
 If the agent / runtime is unavailable, **skip and say so** in `eng-review.md` ("cross-model:
-requested but unavailable — in-model review only"); do not block on it and do not silently treat
+requested but unavailable, in-model review only"); do not block on it and do not silently treat
 the absence as a pass.
 
 ## Integration rule (the important one)
-Cross-model findings are **informational until the human approves each one** — even when you
+Cross-model findings are **informational until the human approves each one**: even when you
 agree with them, even when they overlap the in-model reviewer. Cross-model **consensus** is a
 strong signal: surface it as such ("both reviewers flagged SLICE-003's missing timeout test"), but
 the human still makes the call via `AskUserQuestion`. In AFK, the same gate ceiling applies:
@@ -39,5 +39,5 @@ scope* or changes acceptance is a blocking pause.
 
 ## Recording
 In `eng-review.md` §6, note: which model ran, the overlap with the in-model reviewer (consensus
-findings), and any **unique** findings the outside voice caught that the in-model pass missed —
+findings), and any **unique** findings the outside voice caught that the in-model pass missed:
 those are the highest-value output of running it at all.

package/pack/.claude/skills/rite-vet/reference/depth.md

@@ -1,39 +1,39 @@
-# Depth calibration — always vet, scale the rigor (never skip)
+# Depth calibration: always vet, scale the rigor (never skip)
 
-`/rite-vet` runs on **every** plan — every feature deserves a correct engineering plan, not
+`/rite-vet` runs on **every** plan: every feature deserves a correct engineering plan, not
 just the big ones. What changes with stakes is the *depth*, never *whether* it runs: a simple,
 reversible plan gets a fast **light pass**; a big or risky one gets the **full pass**. There is
 no skip. This shared definition is used by both the standalone `/rite-vet` and the always-run
 `/rite-autocomplete` step, so they agree on how deep to go.
 
 A four-section deep-dive on a one-file reversible plan is wasteful; rubber-stamping a
-migration-touching plan is dangerous. Match the effort to the stakes — but **always** leave a
+migration-touching plan is dangerous. Match the effort to the stakes, but **always** leave a
 recorded engineering verdict and a coverage plan.
 
 ## Full pass when ANY trips
-- **Irreversible-risk contact** — the plan touches anything on the `afk-hitl.md` irreversible-risk
+- **Irreversible-risk contact:** the plan touches anything on the `afk-hitl.md` irreversible-risk
   list: destructive data migration, auth/authz boundary, public-API break, external-service
   contract, filesystem destruction outside the workspace.
-- **Data model** — new/changed entities, relationships, or persistence shape.
-- **Cross-module blast radius** — the impact (from a code-intelligence index if available — see
-  `../../devrites-lib/reference/standards/tooling.md` — or an honest estimate) crosses
+- **Data model:** new/changed entities, relationships, or persistence shape.
+- **Cross-module blast radius:** the impact (from a code-intelligence index if available (see
+  `../../devrites-lib/reference/standards/tooling.md`) or an honest estimate) crosses
   module/service boundaries or has many dependents.
-- **Complexity** — `plan.md` touches **>8 files** or adds **>2 new services/modules/classes**.
+- **Complexity:** `plan.md` touches **>8 files** or adds **>2 new services/modules/classes**.
 - **Multi-slice / multi-day**, or a new dependency / pattern / second design system.
 - **The user asked**, or `--full`.
 
 Full pass = §0 scope challenge + all four axes (each walked finding-by-finding) + the failure-mode
 table + parallelization + the reviewer loop. See [`review-axes.md`](review-axes.md).
 
-## Light pass otherwise (the default for simple plans — still never a skip)
+## Light pass otherwise (the default for simple plans: still never a skip)
 When none of the full-pass triggers fire, run the **light pass**: a fast but real engineering
 check that still leaves a verdict and a coverage plan. In a handful of lines:
-- **§0 scope challenge, in brief** — confirm minimum diff + reuse (one line each); if a complexity
+- **§0 scope challenge, in brief:** confirm minimum diff + reuse (one line each); if a complexity
   smell or missed reuse appears, escalate that to the full treatment.
-- **One-line scan per axis** (architecture / plan code-quality / test-coverage / performance) —
+- **One-line scan per axis** (architecture / plan code-quality / test-coverage / performance):
   "No issues" is a valid result, but you must look and say so per axis, not assume.
 - **Always** produce the acceptance→test map + any regression-Criticals in `test-plan.md`. This is
-  the part that makes "a correct engineering plan for *everything*" real — it never downgrades,
+  the part that makes "a correct engineering plan for *everything*" real. It never downgrades,
   light or full.
 - Write the short `eng-review.md` (`Depth: light`) and harden `tasks.md` with the test requirements.
 
@@ -41,9 +41,9 @@ A light-pass finding that turns out to be real **escalates that axis to full tre
 with the human, confidence-banded). Light means *less ceremony*, never *less honesty*.
 
 ## In `/rite-autocomplete`
-Autocomplete runs `/rite-vet` after `/rite-define` on **every** feature — light or full per the
+Autocomplete runs `/rite-vet` after `/rite-define` on **every** feature: light or full per the
 triggers above, **never skipped**. Under the AFK gate ceiling:
-- **Auto-apply (no pause):** hardening findings — added test requirements, error-handling /
+- **Auto-apply (no pause):** hardening findings: added test requirements, error-handling /
   failure-mode coverage, tightened scope, reuse-over-rebuild, dependency-order / parallel-lane fixes
   (these never grow acceptance). Record the rationale in `decisions.md`.
 - **Blocking pause:** any finding that **grows scope, adds a slice, changes an acceptance