devrites 3.0.4 → 3.0.6

package/pack/.claude/skills/rite-spec/reference/investigation.md

@@ -1,8 +1,8 @@
-# Investigation — understand deeply before specifying
+# Investigation: understand deeply before specifying
 
 The spec is only as good as the investigation behind it. Goal: understand the
 requirement **completely**, decide **where it correctly belongs**, name what it
-**resolves**, and surface every **issue and gap** — then drive the gaps to closure with
+**resolves**, and surface every **issue and gap**, then drive the gaps to closure with
 the user so the spec ships fully-covered and correctly-placed. A gap found here is cheap;
 a gap found in `/rite-build` is a drift event.
 
@@ -10,47 +10,47 @@ Use a code-intelligence index if available (see
 `../../devrites-lib/reference/standards/tooling.md`) for the structural parts below; it answers "where does this
 live / what calls it / what would it break" far more cheaply and accurately than reading files.
 With none present, fall back to Read/Grep/Glob. When a gap turns on a fact the codebase can't
-answer — a standard, a prevailing UX pattern, how comparable products solve it — **search the
+answer: a standard, a prevailing UX pattern, how comparable products solve it: **search the
 web if available** (brave MCP preferred; `../../devrites-lib/reference/standards/tooling.md`) and cite the finding in
 the option you present, so the human's pick is informed rather than guessed.
 
-## Prior art — check our own archive first (cheap, silent when empty)
+## Prior art: check our own archive first (cheap, silent when empty)
 Before investigating outward, check whether we already shipped this. Grep the shipped
-archive for the feature's key nouns — a hit means an extension, a conflict, or a re-spec of
+archive for the feature's key nouns: a hit means an extension, a conflict, or a re-spec of
 solved work, and you inherit its decisions instead of re-deriving them:
 ```bash
 devrites-engine archive-search "<key nouns>" 2>/dev/null \
   || grep -rliE '<noun1>|<noun2>' .devrites/archive/*/spec.md 2>/dev/null
 ```
 - **Overlap found** → read the overlapping `spec.md` + its `decisions.md`, then put it to
-  the human as a ranked option — *extend the shipped feature* · *this supersedes it* ·
-  *genuinely distinct* — same option-set contract as a gap.
+  the human as a ranked option (*extend the shipped feature* · *this supersedes it* ·
+  *genuinely distinct*) same option-set contract as a gap.
 - **No archive / no hit** → skip silently; never block a spec on absent history (the
   brownfield / principles no-op discipline).
 
 ## Produce these findings (write into spec.md)
-1. **The real ask** — restate the goal and the *problem behind the request* (people ask
+1. **The real ask:** restate the goal and the *problem behind the request* (people ask
    for "a dashboard" when they want an answer to a question). Who hits it, how often,
    what they do today instead.
-2. **Current behavior** — how it works today, or what's absent. Read the actual code and
+2. **Current behavior:** how it works today, or what's absent. Read the actual code and
    flows; don't assume.
-3. **Placement — where it should live** *(so it's correctly placed to be used)*
+3. **Placement, where it should live** *(so it's correctly placed to be used)*
    - Which module / layer / file / component should own this; the right seam.
    - Existing patterns/components/utilities to **extend or reuse** instead of duplicating.
    - **Integration points**: callers and dependents, the data it reads/writes, the
-     APIs/events/contracts it touches (interface analysis — how it interacts with the
+     APIs/events/contracts it touches (interface analysis: how it interacts with the
      rest of the system).
-4. **What it resolves** — the outcome/value and how we'll *observe* it's resolved (feeds
+4. **What it resolves:** the outcome/value and how we'll *observe* it's resolved (feeds
    success + acceptance criteria).
-5. **Issues** — conflicts with existing code/UX/data/permissions, constraints, and
+5. **Issues:** conflicts with existing code/UX/data/permissions, constraints, and
    anything that makes the obvious approach wrong. Each issue gets a disposition.
-6. **Gaps** — unknowns, ambiguities, undecided behavior, missing inputs. **Every gap
+6. **Gaps:** unknowns, ambiguities, undecided behavior, missing inputs. **Every gap
    becomes a question** (next section).
-7. **Blast radius** — what this change could break (use the code graph's impact/callers).
+7. **Blast radius:** what this change could break (use the code graph's impact/callers).
    Informs risks, test strategy, and rollback.
 
 Also gather any **design/reference materials** the human supplies (screenshots, Figma,
-links, video) — see [references-intake](references-intake.md). They're part of
+links, video): see [references-intake](references-intake.md). They're part of
 understanding the requirement and become the target later phases verify against.
 
 ## Gap analysis (present → desired)
@@ -58,9 +58,9 @@ State the **present state** and the **desired state**; the delta is the work, an
 **unknowns in the delta are the gaps**. Drive the count of open gaps toward zero before
 handing off to `/rite-define`. Mark each gap inline with `[NEEDS CLARIFICATION: question]`.
 
-## Turn gaps & issues into questions WITH options — you recommend, the human decides
+## Turn gaps & issues into questions WITH options: you recommend, the human decides
 For each material gap/issue (one that changes scope, placement, data model, UX, security,
-migration risk, or acceptance), **put it to the human** — one gap at a time, as a ranked
+migration risk, or acceptance), **put it to the human**: one gap at a time, as a ranked
 option set with the recommended option **first and marked `(Recommended)`** plus an escape
 hatch (via `AskUserQuestion` in HITL):
 ```
@@ -71,7 +71,7 @@ hatch (via `AskUserQuestion` in HITL):
 4. Something else — I'll describe it
 ```
 Investigate and recommend; don't settle a material decision yourself. Confidence in the answer
-lowers the *cost* of the question (a one-pick confirm), not its owner — present the set anyway.
+lowers the *cost* of the question (a one-pick confirm), not its owner: present the set anyway.
 Only a **genuinely reversible, low-impact** gap is decided and recorded in `assumptions.md`
 without asking. Full render contract + AFK behaviour: [`afk-hitl.md`](../../devrites-lib/reference/standards/afk-hitl.md).
 
@@ -79,6 +79,6 @@ without asking. Full render contract + AFK behaviour: [`afk-hitl.md`](../../devr
 - The shipped archive was checked for prior art; any overlap was surfaced to the human.
 - The real problem, current behavior, placement, and what-it-resolves are written down.
 - Every issue has a disposition; every material gap is resolved **by a human pick** from its
-  option set (or explicitly deferred as non-blocking) — not settled silently on your confidence.
-- No blocking `[NEEDS CLARIFICATION]` remains — the spec is **fully covered and correctly
+  option set (or explicitly deferred as non-blocking), not settled silently on your confidence.
+- No blocking `[NEEDS CLARIFICATION]` remains: the spec is **fully covered and correctly
   placed**. This is the `/rite-spec` readiness gate before `/rite-define` plans it.

package/pack/.claude/skills/rite-spec/reference/question-protocol.md

@@ -7,16 +7,16 @@ and completion. The shared HITL/AFK rendering contract lives in
 
 This reference owns only the spec-specific coverage and recording rules below.
 
-## Coverage gate — am I done asking?
+## Coverage gate: am I done asking?
 Before declaring the interview complete, each dimension is **resolved** or **explicitly
-deferred** (logged, non-blocking) — never silently skipped:
-- [ ] **Objective** — one-sentence success + the real problem behind it.
-- [ ] **Scope** — what's in vs explicitly out for v1.
-- [ ] **Data model** — core entities + relationships (or "none").
-- [ ] **UX / flow** — happy path + empty / loading / error / permission states (or "no UI").
-- [ ] **Integration** — external systems / APIs / contracts (or "none").
-- [ ] **Non-functional** — auth, sensitive data, latency / scale (or "n/a").
-- [ ] **Acceptance** — how each requirement is *proven* (test / observation).
+deferred** (logged and non-blocking), never silently skipped:
+- [ ] **Objective:** one-sentence success + the real problem behind it.
+- [ ] **Scope**: what's in vs explicitly out for v1.
+- [ ] **Data model**: core entities + relationships (or "none").
+- [ ] **UX / flow**: happy path + empty / loading / error / permission states (or "no UI").
+- [ ] **Integration**: external systems / APIs / contracts (or "none").
+- [ ] **Non-functional**: auth, sensitive data, latency / scale (or "n/a").
+- [ ] **Acceptance**: how each requirement is *proven* (test / observation).
 
 A blocking gap in any dimension keeps the interview open; a deferred one goes to
 `questions.md` and doesn't block. This feeds the `/rite-spec` readiness gate.

package/pack/.claude/skills/rite-spec/reference/references-intake.md

@@ -1,4 +1,4 @@
-# Reference intake — design/style materials from the human
+# Reference intake: design/style materials from the human
 
 During spec, the human may supply screenshots, Figma, video, sites, or docs showing how the
 feature should look or behave. When present, inspect them, save local copies, and classify
@@ -6,14 +6,14 @@ each as a fidelity **target**, hard **constraint**, or **inspiration** so a mood
 cannot become a pixel-match contract. No references is valid; skip this intake.
 
 ## Gather + understand each reference
-- **Images / screenshots / mockups** — open and **view** them (the Read tool renders
+- **Images / screenshots / mockups:** open and **view** them (the Read tool renders
   images). Describe what they show: layout, components, spacing, states, the target look.
-- **Figma link** — if a Figma integration is available, pull its design context (frames,
+- **Figma link:** if a Figma integration is available, pull its design context (frames,
   tokens, components); otherwise record the link and ask the human for an export/screenshot
   so there's something concrete to match offline.
-- **Links / reference sites / docs** — fetch and read for the relevant intent (tone,
+- **Links / reference sites / docs:** fetch and read for the relevant intent (tone,
   layout, interaction, quality bar). Capture *why* it's a reference, not just the URL.
-- **Video** — note what it demonstrates (the expected interaction/flow). Save it; later
+- **Video:** note what it demonstrates (the expected interaction/flow). Save it; later
   phases can step through it as tooling allows.
 
 ## Save local assets into the workspace
@@ -45,14 +45,14 @@ composition, copy, or distinctive assets. Usage is normative too: only **may shi
 enter product code.
 
 ## Feed them into the spec + the design brief
-- Use references to sharpen `spec.md` (UI impact, success/acceptance — e.g. "matches R1").
+- Use references to sharpen `spec.md` (UI impact, success/acceptance: e.g. "matches R1").
 - When the feature touches UI, these references are the primary input to **`devrites-ux-shape`**
   (spec step 3a): they anchor the design direction and can seed the visual-direction probe
   (a Figma link → pulled design context; reference sites → screenshots). The resulting
   `design-brief.md` cites them by R-id **and role**.
-- A reference can *resolve a gap* ("which layout?") — record that in the gaps table.
+- A reference can *resolve a gap* ("which layout?"): record that in the gaps table.
 - If a reference **conflicts** with the existing design system, that's an issue to raise
-  with the human (match the system, or adopt the reference — their call).
+  with the human (match the system, or adopt the reference: their call).
 
 ## Later phases use them (wire-through)
 `devrites-frontend-craft` builds to the approved brief and its **target** references,

package/pack/.claude/skills/rite-spec/reference/spec-checklists.md

@@ -1,30 +1,30 @@
-# Spec-quality checklists — "unit tests for the English"
+# Spec-quality checklists: "unit tests for the English"
 
 Before the spec hands off to `/rite-define`, test the **requirement prose itself** the way you'd
 unit-test code: is each requirement complete, unambiguous, and measurable? These checklists
-interrogate the *writing*, not the implementation — there is no code to run yet. A criterion like
+interrogate the *writing*, not the implementation. There is no code to run yet. A criterion like
 "the banner is prominent" passes a human skim and fails here ("prominent" is unquantified).
 Catching it now is a one-line spec edit; catching it at `/rite-prove` is a reslice.
 
-**Not implementation tests.** A checklist item asks "is *export* defined for an empty dataset?" —
+**Not implementation tests.** A checklist item asks "is *export* defined for an empty dataset?":
 it does **not** ask "does `exportCsv()` handle `[]`?". The first tests the spec; the second is
 `/rite-vet`'s test-plan and `/rite-prove`'s job. These files never name a function, file, or library.
 
-## Output — one file per requirement domain
+## Output: one file per requirement domain
 
-Emit `.devrites/work/<slug>/checklists/<domain>.md`, one per domain the spec actually covers (skip
+Emit `.devrites/work/<slug>/checklists/<domain>.md`, one per domain the spec covers (skip
 a domain the spec marks "none"). The domains mirror the interview taxonomy, so a gap here maps to a
 `devrites-interview` dimension:
 
 | Domain file | Tests the prose of |
 |---|---|
-| `functional.md` | Functional requirements + scenarios — is each capability stated, bounded, testable? |
-| `data-model.md` | Key entities / data model — shapes, fields, lifecycle, relationships (skip if "none"). |
-| `interaction.md` | API / UI impact + UX states — every screen state and contract named (skip if no UI/API). |
+| `functional.md` | Functional requirements + scenarios: is each capability stated, bounded, testable? |
+| `data-model.md` | Key entities / data model: shapes, fields, lifecycle, relationships (skip if "none"). |
+| `interaction.md` | API / UI impact + UX states: every screen state and contract named (skip if no UI/API). |
 | `non-functional.md` | Constraints, auth / data sensitivity, latency / scale / compatibility budgets. |
 | `edge-cases.md` | Empty / boundary / invalid / concurrent / failure paths the requirements imply. |
 
-## Each item — a question, a verdict, the line it interrogates
+## Each item: a question, a verdict, the line it interrogates
 
 ```markdown
 # Spec checklist: <domain> — <slug>
@@ -38,24 +38,24 @@ Scored: <iso>   Verdict: pass | gaps (<n CRITICAL / n minor>)
 ```
 
 Verdict is `pass` / `fail` / `n/a`. A `fail` carries a severity:
-- **CRITICAL** — the ambiguity would change the build or its acceptance: an unquantified
+- **CRITICAL:** the ambiguity would change the build or its acceptance: an unquantified
   acceptance/success criterion, an incomplete enumeration in a requirement, an ambiguous data
   shape, an undefined edge case on a stated flow, a contradictory pair of requirements.
-- **minor** — vague but non-load-bearing prose. Record it; it does not block.
+- **minor:** vague but non-load-bearing prose. Record it; it does not block.
 
-## The question bank (seed — extend per domain)
+## The question bank (seed: extend per domain)
 
 Each question tests one of the failure modes of requirement prose:
-- **Measurability** — every "good / fast / prominent / simple / secure" carries a number, a budget,
+- **Measurability:** every "good / fast / prominent / simple / secure" carries a number, a budget,
   or a named reference. No adjective stands in for a threshold.
-- **Completeness** — every enumeration is closed (no "etc."); every requirement with a precondition
+- **Completeness:** every enumeration is closed (no "etc."); every requirement with a precondition
   states the failure branch; every entity names its required fields + lifecycle; every stated flow
   names its empty / error / boundary behaviour.
-- **Clarity** — one entity, one name (no `user`/`customer`/`account` drift); no requirement two
+- **Clarity:** one entity, one name (no `user`/`customer`/`account` drift); no requirement two
   readers would implement differently; no "should" where "MUST" is meant.
-- **Testability** — each acceptance criterion is binary and names (or clearly implies) its evidence.
+- **Testability:** each acceptance criterion is binary and names (or clearly implies) its evidence.
   A criterion only provable by reading code is a fail.
-- **Consistency** — no requirement contradicts another, the data model, or a non-goal.
+- **Consistency:** no requirement contradicts another, the data model, or a non-goal.
 
 ## How it feeds the readiness gate
 
@@ -63,11 +63,11 @@ The spec **Readiness gate** (bottom of [`spec-template.md`](spec-template.md)) f
 emitted `checklists/<domain>.md` must reach `Verdict: pass` (zero CRITICAL fails) before the gate
 passes. Minor fails are logged, not blocking. A single open CRITICAL keeps the spec `Status: Draft`.
 `/rite-define` reads the checklists at its step 0 and **hard-blocks while any CRITICAL is unchecked**;
-a spec that skips the checklists is treated as not-yet-scored — define stops and routes back here.
+a spec that skips the checklists is treated as not-yet-scored: define stops and routes back here.
 
 ## Discipline
 - Score honestly. A checklist you pass by softening the *question* instead of the *spec* is the
-  spec-quality version of weakening a test to go green — it defeats the gate.
+  spec-quality version of weakening a test to go green. It defeats the gate.
 - Don't pad. Five real questions that find one CRITICAL beat thirty rubber-stamped rows.
 - These are *English* tests. The moment a question needs a function name to answer, it belongs in
   `/rite-vet`'s `test-plan.md`, not here.

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

@@ -6,7 +6,7 @@ user-invocable: true
 disable-model-invocation: true
 ---
 
-# /rite-status — active feature status
+# /rite-status: active feature status
 
 Read-only. Report where the active feature stands. **Do not run any phase.**
 
@@ -37,22 +37,22 @@ Otherwise summarize from the loaded state, concisely:
 1. **Feature** + one-line objective (from `brief.md`).
 2. **Phase**, **active slice** + its slice mode (from `state.md`). **Run mode**
    (`afk` / `hitl`) is derived from `.devrites/AFK` presence (the preamble
-   already does this), not from a `state.md` field — present = `afk`, absent = `hitl`.
-3. **Status** — `running` / `awaiting_human` / `blocked` / `done`. If
+   already does this), not from a `state.md` field: present = `afk`, absent = `hitl`.
+3. **Status:** `running` / `awaiting_human` / `blocked` / `done`. If
    `awaiting_human`, render the `Awaiting human` block from `state.md` (qid, gate,
    question, proposed, raised_at, blocking_slices) and instruct
    `/rite-resolve <qid> "<answer>"`.
-4. **Next action** — the single recommended next command from `snapshot.nextCommands`
+4. **Next action:** the single recommended next command from `snapshot.nextCommands`
    for the current host.
-5. **Evidence** — what's proven vs unproven (from `evidence.md` /
+5. **Evidence:** what's proven vs unproven (from `evidence.md` /
    `browser-evidence.md`).
-6. **Open questions** — count by gate (from `questions.md`:
+6. **Open questions:** count by gate (from `questions.md`:
    `n open: x blocking · y validating · z advisory`) + the blocking qids by id and one-line question.
 7. **Unresolved drift** (`drift.md`).
 8. **Risks** (from `state.md` / `spec.md`); if `.devrites/principles.md` exists, note the count
    of declared invariants and flag any exception in its register that is past its review/removal
    trigger (a stale exception is a standing risk). Omit if there's no principles file.
-9. **Ready for handoff?** — see section below.
+9. **Ready for handoff?:** see section below.
 
 Flag anything blocking: unresolved drift, failing evidence, `Status: awaiting_human`,
 or open questions that change product behavior. End with the recommended next command
@@ -60,8 +60,8 @@ and nothing else.
 
 ## Ready for handoff?
 
-After the summary items (1–8), render the handoff readiness section (item 9 above) last —
-the canonical output order is: progress footer → summary items 1–8 → handoff readiness.
+After the summary items (1-8), render the handoff readiness section (item 9 above) last:
+the canonical output order is: progress footer → summary items 1-8 → handoff readiness.
 A fresh agent
 or a future session should be able to pick the work up from the workspace
 **alone**, with zero chat context. Check:
@@ -82,13 +82,13 @@ If any item above fails, suggest `/rite-handoff` to compact chat-only
 context into the workspace before the session ends.
 
 ## Gotchas
-- Read-only — never advance a phase or write to the workspace; that's the phase skills' job.
+- Read-only: never advance a phase or write to the workspace; that's the phase skills' job.
 - Report from the `.devrites/` files, not chat memory (it's gone after `/clear`).
-- Give the single next command, not a menu of options — an ambiguous next-action fails the handoff check.
+- Give the single next command, not a menu of options: an ambiguous next-action fails the handoff check.
 
 ## Output format
 
-**Progress first** — `/rite-status` *is* the status meter: render it by running
+**Progress first**: `/rite-status` *is* the status meter: render it by running
 `devrites-engine progress`. Then use the shared completion reply contract
 ([`devrites-lib/reference/reply-contract.md`](../devrites-lib/reference/reply-contract.md))
 as a read-only status variant:
@@ -103,5 +103,5 @@ Record: .devrites/work/<slug>/state.md
 ```
 
 If gaps exist, the recommended next command is to **persist them first** (see
-`.claude/skills/devrites-lib/reference/standards/core.md` — "Persistence before stopping"). Only then
+`.claude/skills/devrites-lib/reference/standards/core.md`. "Persistence before stopping"). Only then
 move to the phase's next action.

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

@@ -5,37 +5,37 @@ argument-hint: "[feature-slug] [--mode expand|selective|hold|reduce]"
 user-invocable: true
 ---
 
-# /rite-temper — temper the spec before you plan
+# /rite-temper: temper the spec before you plan
 
 Take a readied spec and **temper** it: heat it (raise ambition on the *outcome*), then
-quench it (pre-mortem + prune the *solution surface*) — stronger and less brittle. The one
+quench it (pre-mortem + prune the *solution surface*): stronger and less brittle. The one
 DevRites step that decides scope/ambition on a written spec and folds the result into the
 canonical contract, so `/rite-define` plans the **hardened** spec. Optional for small work
-(significance-gated — auto-skips low-stakes specs), but always invoked inside
+(significance-gated: auto-skips low-stakes specs), but always invoked inside
 `/rite-autocomplete`. **Read the active workspace first**; if there's no readied
 `spec.md`, tell the user to run `/rite-spec`.
 
 ## Rules consulted (read on demand from `.claude/skills/devrites-lib/reference/standards/`)
 Pull on demand: `patterns.md` +
-`coding-style.md` (the over-engineering / YAGNI rubric — reuse the pack's standard, don't
+`coding-style.md` (the over-engineering / YAGNI rubric (reuse the pack's standard, don't
 invent one), `documentation.md` (ADR-style `decisions.md` entries), `afk-hitl.md`
 (irreversible-risk list + gate ceiling), `elicitation.md` (the move-set to deepen a section
-that needs more than the default pre-mortem — selected by the section's risk).
+that needs more than the default pre-mortem) selected by the section's risk).
 
 ## Operating rules
 - **Ambition on outcomes, minimalism on the surface.** Raise the success bar and solve the
-  *real* problem; never add speculative capability/abstraction. The reconciliation hinge —
+  *real* problem; never add speculative capability/abstraction. The reconciliation hinge:
   bigger ambition, smaller surface.
-- **Every scope change routes through the Spec Drift Guard** — it only becomes real by being
+- **Every scope change routes through the Spec Drift Guard:** it only becomes real by being
   written into `spec.md` as a recorded, confirmable decision. Expansion is **opt-in** (HITL
-  confirm; AFK pauses — see autocomplete policy). Nothing auto-grows into the build.
+  confirm; AFK pauses: see autocomplete policy). Nothing auto-grows into the build.
 - **Bound ambition by reversibility.** Auth / migration / public-API / data-model touches get
-  the *opposite* of ambition — maximum conservatism; they always pause (irreversible-risk list).
+  the *opposite* of ambition: maximum conservatism; they always pause (irreversible-risk list).
 - **Honest verdict.** Never round "needs work" up to "ready"; record every scope call's *why*.
 - **You write; the reviewer judges.** You are the single canonical writer (`strategy.md` +
   the spec edits); the reviewer agent is read-only.
 - **Demand the spec-quality checklists for big features.** `/rite-temper` only fires on
-  significant specs — exactly where vague requirement prose is most expensive. Before hardening,
+  significant specs: exactly where vague requirement prose is most expensive. Before hardening,
   confirm `checklists/<domain>.md` exist and pass (`rite-spec/reference/spec-checklists.md`); a
   scope expansion you fold in **adds its own** rows (new Success/Acceptance criteria get
   "unit-tested for English" too). A folded expansion with an unquantified criterion is a CRITICAL
@@ -45,57 +45,57 @@ that needs more than the default pre-mortem — selected by the section's risk).
 0. **Read `.claude/skills/devrites-lib/reference/standards/core.md`**, then run
    `devrites-engine preamble` for deterministic workspace orientation.
    Then read the workspace: `spec.md` (+ `decisions.md`,
-   `assumptions.md`, `design-brief.md` if UI), `state.md`. Require `Spec gate: passed` — else
+   `assumptions.md`, `design-brief.md` if UI), `state.md`. Require `Spec gate: passed`: else
    STOP → `/rite-spec`. If a plan already exists, scope changes route through `/rite-plan
    repair` (record in `drift.md`), not a blind spec edit.
-1. **Significance test** — [`reference/significance.md`](reference/significance.md). Low-stakes
+1. **Significance test:** [`reference/significance.md`](reference/significance.md). Low-stakes
    / shape-not-meaning work → write the one-line `skipped — low stakes (<trigger>)` verdict to `strategy.md`,
    set `state.md` `Next step: /rite-define`, and recommend it. Otherwise fire the full pass below.
-2. **FORWARD pass + mode selection** — [`reference/scope-modes.md`](reference/scope-modes.md).
+2. **FORWARD pass + mode selection:** [`reference/scope-modes.md`](reference/scope-modes.md).
    First, the **one-sentence-intent test**: state the whole change's intent in a single sentence.
-   If you can't without an "and" that joins two unrelated outcomes, it is **two features** — the
+   If you can't without an "and" that joins two unrelated outcomes, it is **two features**: the
    sharpest scope-creep signal there is; recommend splitting the spec (or narrowing this one) before
    tempering further. Then diverge on the *outcome* (the 10-star version of the real problem), and
    commit **exactly one** scope mode (`expand` opt-in · `selective` · `hold-rigor` · `reduce-to-MVP`)
    with its rationale and the **hinge** (what would change the call). `$ARGUMENTS` `--mode` is a
    hint, not a command.
-3. **INVERSION pass** — pre-mortem in past tense ("it shipped and failed — what went wrong"),
+3. **INVERSION pass:** pre-mortem in past tense ("it shipped and failed: what went wrong"),
    each top risk carrying likelihood + mitigation + the slice it will bind to; then the **YAGNI
    ledger** (each candidate scope item gets the "imagine the later refactor" test; defer unless
    now-cost is trivial AND deferred-cost is large).
    - **Deepen on demand.** When a specific scope call, requirement, or risk needs sharper thinking
-     than the default pre-mortem gives, pull the 3–5 techniques from
+     than the default pre-mortem gives, pull the 3-5 techniques from
      [`elicitation.md`](../devrites-lib/reference/standards/elicitation.md) whose *when-to-reach-for-it* matches that
      section's risk (irreversible decision → Red-Team/Blue-Team + Assumption Audit; sizing → Delphi;
      vague requirement → Steelman-then-Attack), offer them, and run the chosen one **on that one
-     section**. Record what it changed, not that you ran it. Optional — the default passes stand on
+     section**. Record what it changed, not that you ran it. Optional: the default passes stand on
      their own.
-4. **Score the 9 dimensions** — [`reference/review-dimensions.md`](reference/review-dimensions.md).
+4. **Score the 9 dimensions:** [`reference/review-dimensions.md`](reference/review-dimensions.md).
    Cite evidence *before* the band; **gate on the floor** (the weakest dimension, not an average).
    **Completion:** all nine dimensions have cited evidence, a band, and one explicit floor verdict.
-5. **Walk the findings WITH the human — do not batch-dump.** The artifact is the *output* of an
+5. **Walk the findings WITH the human: do not batch-dump.** The artifact is the *output* of an
    interactive review, not a substitute for it: surface each material scope call / finding via
    `AskUserQuestion`, one at a time, best-guess + **why**. Each material scope call ends as a
-   **recorded decision** — a resolved `questions.md` qid (HITL) or a `decisions.md` ADR (AFK) —
+   **recorded decision**: a resolved `questions.md` qid (HITL) or a `decisions.md` ADR (AFK):
    so the walk leaves an auditable trail, not just chat. (AFK gate policy is single-sourced in
    [`reference/significance.md`](reference/significance.md): `hold-rigor` + `reduce-to-MVP`
    auto-apply, **any `expand` is a blocking pause**, irreversible-risk always pauses.)
-6. **Write `strategy.md` + fold back** — [`reference/strategy-template.md`](reference/strategy-template.md).
+6. **Write `strategy.md` + fold back:** [`reference/strategy-template.md`](reference/strategy-template.md).
    **One drift rule (decide by whether a plan exists):** *no `plan.md` yet* (the normal pre-define
-   case) → update `spec.md` **through the Spec Drift Guard** — *Success criteria* **and**
+   case) → update `spec.md` **through the Spec Drift Guard**. *Success criteria* **and**
    *Acceptance criteria* for each opt-in expansion / cut, **Non-goals** for every deferred item,
    *Constraints* **and** *Risks* the pre-mortem demands, and the gaps/decisions table; *`plan.md`
-   already exists* → do **not** edit `spec.md` here — write the deltas to `drift.md` and hand off
+   already exists* → do **not** edit `spec.md` here: write the deltas to `drift.md` and hand off
    to `/rite-plan repair`. Either way, append `decisions.md` (one ADR per scope call: context ·
    decision · why-not · what-would-change-it) and `assumptions.md` (every "we'll probably need X" →
-   assumption-to-verify). **Every scope delta must carry a recorded human decision** — a resolved
+   assumption-to-verify). **Every scope delta must carry a recorded human decision**: a resolved
    `questions.md` qid (HITL) or a `decisions.md` ADR (AFK within the ceiling); a folded change with
    no recorded decision is the batch-dump failure. **Re-check the spec Readiness gate** (it fails if
    any folded scope delta lacks its decision). Update `state.md`: `Phase: temper`,
    `Next step: /rite-define`; on a blocking pause (expand / irreversible / a dimension still below
    bar) write the `Awaiting human` block + `Status: awaiting_human` before stopping.
-7. **Adversarial verification loop** — dispatch [`devrites-strategy-reviewer`](../../agents/devrites-strategy-reviewer.md)
-   (fresh context, **only** the hardened spec + the rubric — no authoring reasoning). Resolve
+7. **Adversarial verification loop:** dispatch [`devrites-strategy-reviewer`](../../agents/devrites-strategy-reviewer.md)
+   (fresh context, **only** the hardened spec + the rubric: no authoring reasoning). Resolve
    actionable findings by editing `spec.md`/`strategy.md`, re-dispatch; **cap ≤3 iterations**. A
    dimension still below bar after 3 → blocking question (HITL) or AFK gate-ceiling entry;
    irreversible-risk findings always pause. If sub-agents are unavailable, do the independent
@@ -105,11 +105,11 @@ that needs more than the default pre-mortem — selected by the section's risk).
 
 > **Mid-flight discipline.** When tempted to dump findings into `strategy.md` and skip the
 > walk-through, expand the surface (not the outcome), grow scope without the Drift Guard, or
-> score before citing evidence — see [`reference/anti-patterns.md`](reference/anti-patterns.md).
+> score before citing evidence: 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:
 ```
@@ -123,4 +123,4 @@ Record: .devrites/work/<slug>/strategy.md
 ```
 If readiness is blocked, use the shared `Stopped / blocked` form and route `Fix:`
 to `/rite-spec`; do not recommend `/rite-define`.
-**DO NOT plan, slice, or write code here** — that's `/rite-define` and `/rite-build`.
+**DO NOT plan, slice, or write code here**. That's `/rite-define` and `/rite-build`.

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

@@ -1,7 +1,7 @@
-# /rite-temper — anti-patterns
+# /rite-temper: 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 temper-specific ones.
 
 ## Phase rationalizations
@@ -9,21 +9,21 @@ reluctance is broader than this phase. Below are the temper-specific ones.
 | Excuse | Rebuttal |
 |---|---|
 | "I'll write all the findings into `strategy.md` and let the user read it." | The artifact is the *output* of an interactive review, not a substitute for it. A 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 mode this skill exists to prevent. |
-| "Bigger is better — let's add the extra capability while we're thinking big." | Ambition belongs on the **outcome**, not the **solution surface**. A speculative capability/abstraction is gold plating. Expand the problem + acceptance; never the machinery. |
-| "The user obviously wants the ambitious version — I'll add it to the spec." | Expansion is **opt-in**, recorded, and confirmed (HITL) or paused (AFK). Adding acceptance the human didn't approve is silent scope growth — route it through the Spec Drift Guard or don't add it. |
-| "It's over-scoped, I'll just trim those criteria." | Reducing scope is **still a spec change**. Cut acceptance only as a recorded Spec-Drift-Guard decision, and park the rest in Non-goals with a revisit note — never a silent trim. |
-| "This dimension is weak but the others are strong — net it's fine." | The gate is the **floor**, not the average. A spec `broken` on risk does not pass because it's `strong` on clarity. |
-| "I can see it's adequate — I'll note the band, evidence is obvious." | Cite the evidence (the spec line or its absence) **before** the band. Score-first-justify-later is how a reviewer rationalizes a spec it already likes. |
-| "It's a strategy doc, the implementation concerns don't apply yet." | Cross-cutting concerns (security/data/observability/modifiability) are where strategy breaks down. Address each or mark it explicitly N/A — silent omission is a gap. |
+| "Bigger is better: let's add the extra capability while we're thinking big." | Ambition belongs on the **outcome**, not the **solution surface**. A speculative capability/abstraction is gold plating. Expand the problem + acceptance; never the machinery. |
+| "The user obviously wants the ambitious version. I'll add it to the spec." | Expansion is **opt-in**, recorded, and confirmed (HITL) or paused (AFK). Adding acceptance the human didn't approve is silent scope growth: route it through the Spec Drift Guard or don't add it. |
+| "It's over-scoped, I'll just trim those criteria." | Reducing scope is **still a spec change**. Cut acceptance only as a recorded Spec-Drift-Guard decision, and park the rest in Non-goals with a revisit note: never a silent trim. |
+| "This dimension is weak but the others are strong: net it's fine." | The gate is the **floor**, not the average. A spec `broken` on risk does not pass because it's `strong` on clarity. |
+| "I can see it's adequate. I'll note the band, evidence is obvious." | Cite the evidence (the spec line or its absence) **before** the band. Score-first-justify-later is how a reviewer rationalizes a spec it already likes. |
+| "It's a strategy doc, the implementation concerns don't apply yet." | Cross-cutting concerns (security/data/observability/modifiability) are where strategy breaks down. Address each or mark it explicitly N/A: silent omission is a gap. |
 | "This greenfield design is elegant." | Elegant for a codebase that doesn't exist. Ground ambition in the real seams + blast radius; flag a new dependency / second design system for an explicit decision. |
 
 ## Red flags
-- `strategy.md` written but `spec.md` acceptance/Non-goals **not** updated — the build follows
+- `strategy.md` written but `spec.md` acceptance/Non-goals **not** updated: the build follows
   the spec, so the review changed nothing.
 - An `expand` decision auto-applied in AFK (it must pause), or any irreversible-risk touch that
   didn't pause.
-- A pre-mortem with risks listed but no mitigation + owning slice — a risk without an owner is a
+- A pre-mortem with risks listed but no mitigation + owning slice: a risk without an owner is a
   wish.
 - The reviewer loop running past 3 iterations, or the reviewer being handed the author's
   reasoning (defeats the fresh-context point).
-- The skill writing a `plan.md`, slicing, or touching code — that's `/rite-define` / `/rite-build`.
+- The skill writing a `plan.md`, slicing, or touching code. That's `/rite-define` / `/rite-build`.

package/pack/.claude/skills/rite-temper/reference/review-dimensions.md

@@ -1,42 +1,42 @@
 # Review dimensions + the floor-gate rubric
 
-The spec is scored on nine dimensions. Each catches a *different* failure mode — strength in
+The spec is scored on nine dimensions. Each catches a *different* failure mode: strength in
 one never compensates for collapse in another, so the gate is the **floor**, not an average.
 
 ## The nine dimensions
-1. **Problem altitude & ambition** — is this solving the *right* problem at the right altitude,
+1. **Problem altitude & ambition:** is this solving the *right* problem at the right altitude,
    or timidly improving the obvious path / over-reaching past the real need? Here, *under-
    reaching* on the outcome is a failure, not just over-building.
-2. **Scope honesty & boundary** — are Non-goals explicit? Is there a Minimum Usable Subset and a
+2. **Scope honesty & boundary:** are Non-goals explicit? Is there a Minimum Usable Subset and a
    clear IN/OUT line? Flags grab-bags and a missing "Won't-have-this-time".
-3. **Premise & alternatives** — are the load-bearing premises stated and challenged, and is at
+3. **Premise & alternatives:** are the load-bearing premises stated and challenged, and is at
    least one genuinely different approach (different data model / flow / boundary) considered
-   with its trade-off? ("Alternatives considered" is one of the most valuable parts of a spec.)
-4. **Pre-mortem risk coverage** — run in prospective hindsight; each top risk carries likelihood
+   with its trade-off? ("Alternatives considered" is one of the most useful parts of a spec.)
+4. **Pre-mortem risk coverage:** run in prospective hindsight; each top risk carries likelihood
    + mitigation + the slice that owns it. **Unmitigated top risks are gating.**
-5. **Over-engineering / YAGNI** — speculative capability, unused extension points, premature
+5. **Over-engineering / YAGNI:** speculative capability, unused extension points, premature
    abstraction, second-system bloat. Apply the pack's standard (`patterns.md`) + the "imagine
    the later refactor" test. Defer unless now-cost is trivial AND deferred-cost is large.
-6. **Acceptance testability & done-ness** — every acceptance criterion measurable, technology-
+6. **Acceptance testability & done-ness:** every acceptance criterion measurable, technology-
    agnostic, and comparable **down to a baseline** ("better than the current workaround"), not
    up to an unbounded ideal. Vague adjectives ("fast/robust/intuitive") and "handles X
    gracefully" are flagged.
-7. **Irreversibility & blast radius** — are auth / migration / public-API / data-model touches
+7. **Irreversibility & blast radius:** are auth / migration / public-API / data-model touches
    treated with conservatism + rollback, and is the blast radius understood (from a
    code-intelligence index if available)?
-8. **Cross-cutting coverage** — security/trust-boundary, data & migration, observability, and
-   modifiability each explicitly addressed **or explicitly N/A** — no silent omission.
-9. **Convention fit & placement realism** — does the ambition fit the codebase's existing seams
+8. **Cross-cutting coverage:** security/trust-boundary, data & migration, observability, and
+   modifiability each explicitly addressed **or explicitly N/A**: no silent omission.
+9. **Convention fit & placement realism:** does the ambition fit the codebase's existing seams
    and patterns, or assume greenfield freedom a constrained space doesn't have? Prefer existing
    conventions; flag a new dependency / second design system for explicit decision.
 
-UI specs additionally inherit `rite-polish/reference/anti-ai-slop.md` at the cross-cutting
-dimension (design-system fit, anti-AI-slop) — but `/rite-temper` reviews the *spec/design-brief*,
+UI specs also inherit `rite-polish/reference/anti-ai-slop.md` at the cross-cutting
+dimension (design-system fit, anti-AI-slop), but `/rite-temper` reviews the *spec/design-brief*,
 not pixels; the built UI is judged later by `devrites-frontend-reviewer`.
 
-## The rubric — coarse bands, evidence first
+## The rubric: coarse bands, evidence first
 Score each dimension on a **labeled band**, never a 1-10 float or a composite number (labels do
-the work — matches the pack's severity-vocabulary stance):
+the work: matches the pack's severity-vocabulary stance):
 
 | Band | Meaning |
 |---|---|
@@ -45,21 +45,21 @@ the work — matches the pack's severity-vocabulary stance):
 | **thin** | Under-addressed; a real gap to close before planning (Important). |
 | **broken** | Missing or wrong in a way that will cost a redo (Critical). |
 
-**Cite evidence before the band** — name the spec line / absence that justifies it; never score
+**Cite evidence before the band**: name the spec line / absence that justifies it; never score
 first and rationalize after. Borderline dimensions may be sampled twice; take the **lower** band
 (don't average up).
 
 ## The floor-gate
 - **Pass** only when every dimension is `adequate` or `strong` **and** no unmitigated top
-  pre-mortem risk remains. The verdict is the **weakest** dimension — a spec strong on clarity
+  pre-mortem risk remains. The verdict is the **weakest** dimension: a spec strong on clarity
   but `broken` on risk does **not** pass.
 - Individual findings carry the pack's standard severity labels (**Critical / Important /
   Suggestion / Nit / FYI**) so they compose with `/rite-review` and `/rite-seal`. `broken` →
-  Critical, `thin` → Important; **FYI is band-independent** — an observation on a `strong` /
+  Critical, `thin` → Important; **FYI is band-independent**: an observation on a `strong` /
   `adequate` dimension, not a failing band.
 - **Don't double-count overlap.** Some dimensions key on the same evidence (e.g. #7
   irreversibility & #9 convention-fit both touch codebase realism; #1 ambition & #2 scope both
-  touch over/under-reach). Don't fail two dimensions for the *same* root cause — cite the
+  touch over/under-reach). Don't fail two dimensions for the *same* root cause: cite the
   evidence once, band it once, so one problem isn't laundered into two floor failures.
 - Below-bar dimension after the ≤3-iteration reviewer loop → blocking question (HITL) or AFK
   gate-ceiling entry. Irreversible-risk findings always pause regardless of band.