devrites 3.0.4 → 3.0.6

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

@@ -5,7 +5,7 @@ argument-hint: "[slice number or name]"
 user-invocable: true
 ---
 
-# /rite-build — one verified slice
+# /rite-build: one verified slice
 
 Build the next single slice, leave it working and proven, then **stop**. **Read the
 active workspace first**; if none, tell the user to run `/rite-spec <feature>`.
@@ -18,55 +18,55 @@ run the post-return gates (doubt, fail-on-red, record, stop). See
 
 ## Rules consulted (read on demand from `.claude/skills/devrites-lib/reference/standards/`)
 Read `.claude/skills/devrites-lib/reference/standards/core.md` first (workflow step 0). The
-following load on demand — **the wright reads them** (they are named in its contract) while it
+following load on demand: **the wright reads them** (they are named in its contract) while it
 writes; read them yourself for the doubt/record gates or in the inline fallback:
-- `coding-style.md` — naming, function shape, guard clauses, comments, reuse-first.
-- `error-handling.md` — fail fast, no silent catches, fail closed.
-- `testing.md` — pyramid, behaviour over implementation, see-it-fail-first.
-- `patterns.md` — composition over inheritance, avoid premature abstraction.
-- `principles.md` — the project invariants (`.devrites/principles.md`) the slice must honor; the wright reads them as **binding**, not priors.
-- `security.md` — when the slice touches user input, auth, data, or external integrations.
-- `definition-of-done.md` — standing Done bar: acceptance mapped, fresh proof, no open hard gates, scoped edits, rollback/docs where needed.
+- `coding-style.md`: naming, function shape, guard clauses, comments, reuse-first.
+- `error-handling.md`: fail fast, no silent catches, fail closed.
+- `testing.md`: pyramid, behaviour over implementation, see-it-fail-first.
+- `patterns.md`: composition over inheritance, avoid premature abstraction.
+- `principles.md`: the project invariants (`.devrites/principles.md`) the slice must honor; the wright reads them as **binding**, not priors.
+- `security.md`: when the slice touches user input, auth, data, or external integrations.
+- `definition-of-done.md`: standing Done bar: acceptance mapped, fresh proof, no open hard gates, scoped edits, rollback/docs where needed.
 
 
 ## Operating rules
 - **One slice at a time. DO NOT** start the next slice without the user asking.
-- Evidence over confidence. Prefer existing conventions. Feature scope only — no
+- Evidence over confidence. Prefer existing conventions. Feature scope only: no
   drive-by refactors.
 - **Noticed, not touched.** An adjacent smell the wright sees outside `touched-files.md` is
-  recorded as an FYI follow-up in `decisions.md`, never fixed inline — the slice's change summary
+  recorded as an FYI follow-up in `decisions.md`, never fixed inline: the slice's change summary
   states what it *deliberately left alone* ([`git-workflow.md`](../devrites-lib/reference/standards/git-workflow.md) "Things
   I didn't touch"), so the reviewer reads a feature-scoped diff, not a renovation. The `devrites-engine reconcile`
   gate (step 6) enforces this by exit code.
 - **Don't re-run an unchanged check.** Re-running the same build/test command on code that hasn't
-  changed since proves nothing new — it's motion, not evidence. Re-verify after an edit, not before.
+  changed since proves nothing new. It's motion, not evidence. Re-verify after an edit, not before.
 - Surface material assumptions; ask before adding dependencies or a second design
   system. The [Spec Drift Guard](reference/spec-drift-guard.md) is active throughout.
 - **Avoid AI slop while writing.** `devrites-slice-wright` enforces the anti-slop charter **at
-  the source** — the canonical do-not list is `rite-polish/reference/anti-ai-slop.md` (the
+  the source**: the canonical do-not list is `rite-polish/reference/anti-ai-slop.md` (the
   wright reads it; don't restate it here). It writes the code the *project* would write, in its
-  idiom, reusing before building; **you verify the charter held on return** — you do not re-list
+  idiom, reusing before building; **you verify the charter held on return**. You do not re-list
   it and you do not fix slop by editing source. Polish catches what slips; build prevents.
-  The **prose you write yourself** — `evidence.md`, `decisions.md`, the slice report — follows
+  The **prose you write yourself** (`evidence.md`, `decisions.md`, the slice report) follows
   the human-voice charter (`.claude/skills/devrites-lib/reference/standards/prose-style.md`; depth in `devrites-prose-craft`): no
   filler openers, no marketing adjectives, exact commands and identifiers kept verbatim.
 - **Honor declared project principles.** The wright reads `.devrites/principles.md` and treats
-  each invariant as **binding** (not a prior to weigh like a convention) — a slice it cannot build
+  each invariant as **binding** (not a prior to weigh like a convention): a slice it cannot build
   without breaking one is an **Escalation**, not a silent violation. On return **you verify no
-  principle was broken**; a fresh violation is handled like any irreversible-risk item — a
+  principle was broken**; a fresh violation is handled like any irreversible-risk item: a
   human-approved, scoped exception in the register or a stop, never folded into the slice. No
   `.devrites/principles.md` → none declared → nothing to honor.
-- **You never edit source — the wright is the only writer of code + tests.** You write only
+- **You never edit source: the wright is the only writer of code + tests.** You write only
   `.devrites/` bookkeeping. On any red gate, doubt finding, or coverage gap your only remedies
-  are **continue the same wright once** (it fixes in its own context) or **stop + escalate** —
+  are **continue the same wright once** (it fixes in its own context) or **stop + escalate**:
   never patch the code yourself. The `devrites-engine reconcile` gate (step 6) enforces this by exit code:
   any source file changed outside the wright's claimed set is a hard STOP.
-- **A `Forge: yes` slice competes candidates — one author still lands.** When `/rite-vet`
-  flagged the slice a genuine architecture fork, step 3 runs K=2–3 candidate wrights in
+- **A `Forge: yes` slice competes candidates: one author still lands.** When `/rite-vet`
+  flagged the slice a genuine architecture fork, step 3 runs K=2-3 candidate wrights in
   **isolated worktrees** and lands exactly one winner's diff; the single-writer invariant holds
   because no tree ever has two authors and only the winner reaches the working tree. You still
   never edit source, and reconcile runs against the winner's claimed set. The default slice is
-  single-path — forge is the rare exception ([`reference/forge.md`](reference/forge.md)).
+  single-path: forge is the rare exception ([`reference/forge.md`](reference/forge.md)).
 
 ## Workflow
 

package/pack/.claude/skills/rite-build/reference/afk-discipline.md

@@ -1,4 +1,4 @@
-# AFK discipline — running `/rite-build` unattended without burning the trunk
+# AFK discipline: running `/rite-build` unattended without burning the trunk
 
 AFK mode is `.devrites/AFK` present. It lets `/rite-build` chain slices without per-slice
 user input. The discipline below is what keeps an AFK loop from drifting into damage.
@@ -25,13 +25,13 @@ notify: "ntfy.sh/my-topic"           # shell command run on awaiting_human trans
 allow_gates: [advisory, validating]  # gate severities AFK may auto-handle
 ```
 
-`.devrites/AFK` is **read-only config** — never rewritten in place. `max_slices` is the
+`.devrites/AFK` is **read-only config**: never rewritten in place. `max_slices` is the
 initial budget; the mutable remaining count lives in `state.md` as `AFK slices remaining:
 <n>`, seeded from `max_slices` on the first AFK build and decremented by `devrites-engine tick-afk`
 (see "Iteration cap").
 
 Defaults when keys are omitted:
-- `max_slices`: unlimited (a missing cap is risky — see "Always cap iterations").
+- `max_slices`: unlimited (a missing cap is risky: see "Always cap iterations").
 - `notify`: none.
 - `allow_gates`: `[advisory]`.
 
@@ -44,13 +44,13 @@ into HITL.
 remaining` by 1 each time a slice is marked `built`, by running
 `devrites-engine tick-afk <state.md path>`. The script reads the
 field, decrements, writes it back, prints the new value, and **exits `3` when it hits 0**.
-The cap is enforced by `devrites-engine tick-afk`, not by prose — when it exits 3:
+The cap is enforced by `devrites-engine tick-afk`, not by prose, when it exits 3:
 
 - `/rite-build` treats exit 3 as a forced HITL stop:
   ```
   AFK cap reached. Raise `state.md` `AFK slices remaining` or remove the sentinel to continue.
   ```
-- The workspace stays consistent — no half-built slice, no pending question.
+- The workspace stays consistent: no half-built slice, no pending question.
 
 Step 0 re-derives the remaining budget from `state.md` (seeding it from `.devrites/AFK`
 `max_slices` on the first AFK build); `max_slices` itself is read-only and never rewritten.
@@ -66,7 +66,7 @@ types / lint are red. The reasoning:
 
 - A red signal means either the slice's contract is wrong or the failing code is. Neither
   is something AFK can resolve.
-- Marking it `built` and letting the AFK loop chain to the next slice burns the trunk —
+- Marking it `built` and letting the AFK loop chain to the next slice burns the trunk:
   the next slice builds on broken state.
 
 The fail-on-red path:
@@ -92,7 +92,7 @@ any of:
   rewriting `.gitignore`-listed paths, deleting fixtures).
 - Anything the slice's `Gate: blocking` plus `tasks.md` `Why HITL:` flags as irreversible.
 
-The list is the same one Claude Code auto-mode's transcript classifier protects — adapted
+The list is the same one Claude Code auto-mode's transcript classifier protects: adapted
 to DevRites's workspace shape.
 
 ## The `notify:` hook contract
@@ -117,13 +117,13 @@ Example targets:
 - `osascript -e "display notification \"$DEVRITES_QUESTION\" with title \"DevRites: $DEVRITES_GATE\""`
 - `pb push "$DEVRITES_SLUG: $DEVRITES_QUESTION"` (via pushbullet CLI)
 
-DevRites owns no notification logic — the hook is a seam, not a feature.
+DevRites owns no notification logic: the hook is a seam, not a feature.
 
 ## When to leave AFK
 
 Drop the sentinel before:
 
-- A novel feature where you have not yet seen `/rite-build` work on this codebase HITL —
+- A novel feature where you have not yet seen `/rite-build` work on this codebase HITL:
   Ralph's progression: HITL first → refine prompt → AFK once trusted.
 - A risky slice you marked `Mode: HITL` and want to walk through interactively even if
   the gate is technically `validating`.

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

@@ -1,4 +1,4 @@
-# rite-build — anti-patterns
+# rite-build: anti-patterns
 
 Load this when standing a non-trivial implementation decision, or when the
 agent feels reluctance toward stopping after one slice, applying TDD, or
@@ -19,18 +19,18 @@ generic AI naming, drive-by refactors): see
 
 | Excuse | Rebuttal |
 |---|---|
-| "This slice is hard — I'll forge it." | Hard ≠ forkable. Forge competes ≥2 *genuinely-different* approaches with no clear winner. One hard approach is single-path; building it K times wastes K× for one answer. |
+| "This slice is hard. I'll forge it." | Hard ≠ forkable. Forge competes ≥2 *genuinely-different* approaches with no clear winner. One hard approach is single-path; building it K times wastes K× for one answer. |
 | "I'm not sure which approach is right, so let me compete them and decide." | Forge is for a real fork the plan couldn't settle, not for dodging a decision you can make now. Decide from the code/docs first; forge only when the alternatives are genuinely undecidable on paper. |
-| "Candidate A's data layer plus B's UI would be the best of both." | Don't hand-merge candidates — two authors in one tree is the incoherence the single-writer rule exists to prevent. Land one winner whole; graft a *specific* runner-up idea only by continuing the winning wright once. |
-| "The judge already scored these, so I can skip the post-return doubt." | The judge picks *between* candidates; it doesn't replace doubting the winner's standing decisions. Steps 4–7 run on the winner unchanged. |
-| "A fourth candidate might be even better." | K is capped at 3. A fourth rarely moves the winner and multiplies cost; if none of three is right, the plan is wrong — `/rite-plan repair`, don't add candidates. |
+| "Candidate A's data layer plus B's UI would be the best of both." | Don't hand-merge candidates: two authors in one tree is the incoherence the single-writer rule exists to prevent. Land one winner whole; graft a *specific* runner-up idea only by continuing the winning wright once. |
+| "The judge already scored these, so I can skip the post-return doubt." | The judge picks *between* candidates; it doesn't replace doubting the winner's standing decisions. Steps 4-7 run on the winner unchanged. |
+| "A fourth candidate might be even better." | K is capped at 3. A fourth rarely moves the winner and multiplies cost; if none of three is right, the plan is wrong: `/rite-plan repair`, don't add candidates. |
 
 ## Red Flags
 
 - About to start slice N+1 without the user asking.
 - Skipping `devrites-doubt` on a branching, boundary, data-model, auth, public-API, or migration decision.
 - Adding a dependency or a second design system without recording rationale in `decisions.md`.
-- Writing a `try/catch` block wider than what you actually handle.
+- Writing a `try/catch` block wider than what you handle.
 - A comment that restates what the next line does.
 - Touching files that aren't in `touched-files.md` for "tidiness".
 - Forging a slice with no acceptance / `test-plan.md` coverage for the judge to score against.

package/pack/.claude/skills/rite-build/reference/checkpoint-protocol.md

@@ -1,12 +1,12 @@
-# Checkpoint protocol — what `/rite-build` does when a slice is HITL
+# Checkpoint protocol: what `/rite-build` does when a slice is HITL
 
 When `/rite-build` reaches a slice with `Mode: HITL`, it does **not** start writing code. It
 surfaces the checkpoint as a ranked **option set** and resolves it **before** any code lands:
 
-- **Human present (interactive)** — ask inline via `AskUserQuestion` (the option set below).
+- **Human present (interactive):** ask inline via `AskUserQuestion` (the option set below).
   The human picks; record the pick to `questions.md` (`answered`) + `decisions.md`, clear the
-  gate, and **continue building in place** — no STOP, no `/rite-resolve` round-trip.
-- **Human absent / AFK-pausing / notify-only** — persist the checkpoint (`questions.md` open +
+  gate, and **continue building in place**: no STOP, no `/rite-resolve` round-trip.
+- **Human absent / AFK-pausing / notify-only:** persist the checkpoint (`questions.md` open +
   `state.md` `Awaiting human`), fire the `notify:` hook, and **stop**. Resume later via
   `/rite-resolve` (or `--batch`).
 
@@ -15,13 +15,13 @@ Either way the pause is **pre-action**, not post-action: code never lands before
 ## Render contract
 
 The checkpoint must be rendered in user-facing output **and** persisted to the workspace.
-Both are required — the output is for the human in the room (or the notification target),
+Both are required: the output is for the human in the room (or the notification target),
 the persisted form is for the next session or the AFK observer.
 
-### User-facing render — the option set
+### User-facing render: the option set
 
 Present the checkpoint as an `AskUserQuestion` with a ranked **option set**
-(`afk-hitl.md` → "Option set"): 2–4 options, **recommended first** + labelled `(Recommended)`,
+(`afk-hitl.md` → "Option set"): 2-4 options, **recommended first** + labelled `(Recommended)`,
 each option's description carrying the dimension-tagged rationale + the trade-off it accepts,
 plus the escape hatch. The header names the slice + gate:
 
@@ -35,7 +35,7 @@ Slice <N — name> — HITL (<gate>, SLA <SLA>). <Checkpoint text from tasks.md>
   4. Something else — I'll describe it
 ```
 
-The recommended option (#1) is **required** — a checkpoint without a recommendation is a worse
+The recommended option (#1) is **required**: a checkpoint without a recommendation is a worse
 interrupt than one with shape; the human reacts to a ranked draft faster than to a blank prompt
 (the "give the human something to approve" rule). The recommendation reflects *this* project
 (its conventions, stack, scale), not a generic default. On an interactive pick, resolve in
@@ -93,14 +93,14 @@ In one atomic write (one `state.md` rewrite + one `questions.md` append):
    ```
 
    The hook fires after the workspace write so the notification target sees a workspace
-   that already records the pause. Failures in the hook **do not** roll back the pause —
+   that already records the pause. Failures in the hook **do not** roll back the pause:
    the gate is authoritative; the notification is best-effort.
 
 ## qid generation
 
 Format: `q-YYYY-MM-DD-NNN`, where `NNN` is the next sequential integer for that date in
 `questions.md`. For the write side, call
-`devrites-engine resolve next-qid <questions.md path>` — it
+`devrites-engine resolve next-qid <questions.md path>`. It
 counts existing `## q-YYYY-MM-DD-` headers for today, prints the next zero-padded id, and
 refuses to print an id whose header already exists. Use that id verbatim so each qid is
 unique within the date.
@@ -114,7 +114,7 @@ If `.devrites/AFK` exists and the slice's `Gate` is in `allow_gates`, `/rite-bui
   `decisions.md`, and **dispatch the wright** to build the slice (workflow step 3).
 - For `validating` (only when `allow_gates` includes it): **dispatch the wright** (step 3); on
   return, write a `gate: validating` entry to `questions.md`, mark the slice
-  `built (pending review)` in `state.md`, and continue. A slice's only states are `pending` and `built` —
+  `built (pending review)` in `state.md`, and continue. A slice's only states are `pending` and `built`:
   acceptance is proven at the **feature** level by `/rite-prove` (recorded in
   `evidence.md`), not per slice. The `built (pending review)` slice is not done until the
   open `validating` gate resolves via `/rite-resolve`; an open `validating` gate is a
@@ -122,8 +122,8 @@ If `.devrites/AFK` exists and the slice's `Gate` is in `allow_gates`, `/rite-bui
 
 For gates in `allow_gates`, AFK **auto-picks the recommended option** (option 1 of the set)
 instead of pausing, recording it as above. For `blocking` and `escalating` (and every
-irreversible-risk item), AFK **always** invokes the checkpoint protocol — the sentinel does
-not unlock these gates — **unless `allow_irreversible: true`** is set, which makes AFK
+irreversible-risk item), AFK **always** invokes the checkpoint protocol: the sentinel does
+not unlock these gates: **unless `allow_irreversible: true`** is set, which makes AFK
 auto-pick the recommendation on *every* gate, irreversible included (maximal autonomy, opt-in;
 see `afk-hitl.md`). See `afk-discipline.md` for the irreversible-risk list.
 
@@ -141,7 +141,7 @@ written as a single block.
   updates means the workspace lies on `/clear`.
 - **Don't self-answer a question that *paused* for a human.** When a gate stopped the session
   (an AFK queue, or a HITL pause the human walked away from), `/rite-resolve` requires an
-  explicit answer — the agent doesn't confirm its own `proposed:` on resume. This is distinct
+  explicit answer: the agent doesn't confirm its own `proposed:` on resume. This is distinct
   from the two legitimate auto-resolutions: an interactive `AskUserQuestion` pick the human
   just made, and an AFK auto-pick of the recommended option on a gate `allow_gates` permits.
 - **Don't bundle the `notify:` hook output into chat.** Fire-and-forget; the chat already

package/pack/.claude/skills/rite-build/reference/checkpoint.md

@@ -1,18 +1,18 @@
-# Checkpoint — crash-survivable WIP commits (opt-in)
+# Checkpoint: crash-survivable WIP commits (opt-in)
 
 `.devrites/` markdown survives compaction, but a slice's *source* stays uncommitted until
-`/rite-ship`. A crash or killed session mid-build — the AFK / `/rite-autocomplete` case —
+`/rite-ship`. A crash or killed session mid-build: the AFK / `/rite-autocomplete` case:
 loses that source **and** the reasoning behind it. Checkpoint mode commits each proven
 slice as a local `WIP`, so the work and its context outlive the session.
 
 ## When it's on
-Opt-in via the `.devrites/CHECKPOINT` sentinel — the mirror of `.devrites/AFK`. Absent →
+Opt-in via the `.devrites/CHECKPOINT` sentinel: the mirror of `.devrites/AFK`. Absent →
 no checkpoints; `/rite-build` behaves exactly as before. A long unattended run
 (`/rite-autocomplete`) is the case it earns its keep, so that path sets the sentinel for
-the run. **Local-only by rule:** a checkpoint is never pushed — scratch work must not
+the run. **Local-only by rule:** a checkpoint is never pushed: scratch work must not
 trigger CI.
 
-## The checkpoint commit — orchestrator, at RECORD, after gates are green
+## The checkpoint commit: orchestrator, at RECORD, after gates are green
 A checkpoint records a **proven** slice; it fires only after PROVE is green, never on a red
 gate. Stage only the slice's `touched-files.md`, then commit locally with a
 `[devrites-context]` body a cold reader can restore from:
@@ -29,14 +29,14 @@ BODY
 ```
 
 ## Restore
-The commit body is a durable record, not just a marker. After a crash, a fresh session —
-or `/rite-status` — reads the last `WIP(<slug>)` body to reconstruct the decisions,
+The commit body is a durable record, not just a marker. After a crash, a fresh session:
+or `/rite-status`: reads the last `WIP(<slug>)` body to reconstruct the decisions,
 remaining slices, and dead-ends that in-session `.devrites/` state would have held. No
 special tooling: it's a git log entry any agent can read.
 
 ## Collapse at ship
 WIP commits are scratch and never reach shared history. `/rite-ship` folds them into the
-one atomic feature commit before the Conventional-Commit ladder — see the collapse step in
+one atomic feature commit before the Conventional-Commit ladder: see the collapse step in
 [git-ship.md](../../rite-ship/reference/git-ship.md). Result: one clean commit, bisect
 stays green.
 

package/pack/.claude/skills/rite-build/reference/evidence-standard.md

@@ -26,7 +26,7 @@ Evidence beats confidence. A slice isn't built until there's a record that prove
 ```
 
 ## Honesty rules
-- If a test fails, record the failure and the output — don't hide it.
+- If a test fails, record the failure and the output: don't hide it.
 - If a step was skipped (no browser available, command not found), say so and record
   the manual verification steps instead.
 - Unproven acceptance criteria stay unchecked. The seal will catch them.

package/pack/.claude/skills/rite-build/reference/forge.md

@@ -1,20 +1,19 @@
-# Forge — competing candidate builds for one slice
+# Forge: competing candidate builds for one slice
 
 How `/rite-build` builds a slice that `/rite-vet` flagged `Forge: yes`: instead of one wright,
-**K = 2–3 candidate wrights** each build the slice a genuinely different way in **isolation**, a
+**K = 2-3 candidate wrights** each build the slice a genuinely different way in **isolation**, a
 read-only judge scores them, and exactly **one** winner's diff lands in the working tree. Loaded
 on demand by `/rite-build` step 3; the sibling of single-path
 [`wright-dispatch.md`](wright-dispatch.md).
 
 Forge is the **rare** path. Most slices are single-path (cheaper, and the default). A slice
-forges only when the work is a genuine architecture fork — two or three approaches that actually
-differ, no clear winner on paper, at high enough stakes that building the wrong one costs more
+forges only when the work is a genuine architecture fork: two or three approaches that differ, no clear winner on paper, at high enough stakes that building the wrong one costs more
 than building all of them. That judgment is made at `/rite-vet` and recorded as the slice's
 `Forge:` field; build acts on the flag, it does not invent it.
 
 ## Why this doesn't break the single-writer invariant
 
-DevRites forbids a parallel fan-out of writers **sharing one tree** — concurrent writers on one
+DevRites forbids a parallel fan-out of writers **sharing one tree**: concurrent writers on one
 working tree make conflicting implicit decisions and produce incoherent code
 ([`wright-dispatch.md`](wright-dispatch.md)). Forge keeps that invariant intact by **isolation**:
 every candidate writes in its own worktree (or its own throwaway branch), never touching another
@@ -24,13 +23,13 @@ one slice."
 
 ## Trust the flag, but clear a stale one
 
-Before competing anything, confirm the flag still earns its cost — `/rite-vet` set it, but the
+Before competing anything, confirm the flag still earns its cost: `/rite-vet` set it, but the
 plan may have moved:
 
-- **No objective scorecard** — the slice has no acceptance criteria and no `test-plan.md`
+- **No objective scorecard:** the slice has no acceptance criteria and no `test-plan.md`
   coverage the judge can score against → clear `Forge` to `no`, build single-path. A competition
   with no rubric is a coin toss with K× the cost.
-- **Can't name two genuinely different strategies** — if the candidates would be variations of
+- **Can't name two genuinely different strategies:** if the candidates would be variations of
   one approach, there is nothing to compete → single-path.
 - **Slice shrank below the bar** (now Complexity ≤3, or a dependency landed that picks the
   approach) → single-path.
@@ -40,21 +39,21 @@ slice you can't score, and never forge to avoid making a decision the plan alrea
 
 ## Mechanics
 
-The orchestrator runs F1–F7. Steps 4–7 of the [one-slice-cycle](one-slice-cycle.md) (doubt,
+The orchestrator runs F1-F7. Steps 4-7 of the [one-slice-cycle](one-slice-cycle.md) (doubt,
 fail-on-red, reconcile, record, stop) then run **unchanged** on the winner.
 
-### F1 — Confirm the K strategies
-Take the 2–3 candidate strategies `/rite-vet` named (in the slice brief). Each must be a
-**distinct, complete approach** to the same slice contract — a different seam, data shape,
-reuse-vs-build call, or algorithm — not a tweak of one. Name them `A`, `B`, (`C`) with a
+### F1: Confirm the K strategies
+Take the 2-3 candidate strategies `/rite-vet` named (in the slice brief). Each must be a
+**distinct, complete approach** to the same slice contract (a different seam, data shape,
+reuse-vs-build call, or algorithm) not a tweak of one. Name them `A`, `B`, (`C`) with a
 one-line description each. K is capped at 3: a fourth candidate rarely changes the winner and
 multiplies cost.
 
-### F2 — Snapshot, then isolate each candidate
+### F2: Snapshot, then isolate each candidate
 Snapshot the working tree first (the winner's landing is reconciled against it later), then give
 each candidate its own isolated tree. **Prefer parallel isolated worktrees** when the harness can
 dispatch a sub-agent with worktree isolation; the **always-available** path is one throwaway git
-branch per candidate, built sequentially (slower, universally works — the
+branch per candidate, built sequentially (slower, universally works: the
 [`tooling.md`](../../devrites-lib/reference/standards/tooling.md) "fallback is first-class" discipline):
 
 ```bash
@@ -68,7 +67,7 @@ for C in A B; do
 done
 ```
 
-### F3 — Dispatch K candidate wrights
+### F3: Dispatch K candidate wrights
 Send **each** candidate the identical single-path slice contract from
 [`wright-dispatch.md`](wright-dispatch.md), with **one** line added naming its assigned strategy
 and its isolated tree:
@@ -81,32 +80,32 @@ candidate's work. Same discipline as always — orient → RED → implement sma
 verify → return your structured artifact. Code + tests only.
 ```
 
-Each is still **one wright, one tree** — the invariant holds per candidate. Parallel where the
+Each is still **one wright, one tree**: the invariant holds per candidate. Parallel where the
 harness isolates them; otherwise build candidate A to green, capture its diff, reset to `BASE`,
 then candidate B. A candidate that hits an irreversible-risk item escalates exactly as a
-single-path wright does — **forge never bypasses a gate** (see AFK below).
+single-path wright does: **forge never bypasses a gate** (see AFK below).
 
-### F4 — Judge (read-only, fresh context)
+### F4: Judge (read-only, fresh context)
 Dispatch [`devrites-forge-judge`](../../../agents/devrites-forge-judge.md) with the K finished
 candidate diffs and the scorecard inputs (slice acceptance, `test-plan.md`, `.devrites/principles.md`,
 the anti-slop charter). It scores each candidate, ranks them, names the **winner** and the
 specific runner-up ideas worth grafting, and returns the structured verdict. The judge **never
-writes code** — it reads the diffs and returns findings, like every reviewer agent. If sub-agent
+writes code**. It reads the diffs and returns findings, like every reviewer agent. If sub-agent
 dispatch is unavailable, do the judge's rubric pass yourself in a fresh read, discarding your
 authoring reasoning (a flagged fallback, not an independent judgment).
 
-### F5 — Land the winner, graft sparingly
+### F5: Land the winner, graft sparingly
 Apply **only** the winner's diff to the working tree (merge its worktree / cherry-pick its
 branch). If the judge named a cheap, specific improvement in a runner-up, graft it by
-**continuing the winning wright once** with that instruction — never hand-merge two candidates'
+**continuing the winning wright once** with that instruction: never hand-merge two candidates'
 code (that re-creates the incoherent-tree failure the invariant exists to prevent). The landed
 tree has exactly one author: the winner (plus its own grafted follow-up).
 
-### F6 — Write `forge-report.md`
+### F6: Write `forge-report.md`
 The durable record of the competition (template below). One per forged slice; archived with the
 feature.
 
-### F7 — Clean up, then return to the cycle
+### F7: Clean up, then return to the cycle
 Remove only clean losing worktrees / delete their candidate branches. If a losing worktree is dirty,
 preserve it and record the path in `forge-report.md`; never `--force` away unlanded work.
 
@@ -152,18 +151,18 @@ slice that might be tempted to retry one>.
 ```
 
 The **Discarded** section matters: it is a dead-end record at the slice level, the same role
-`decisions.md` "Dead ends" plays for the feature — a later slice shouldn't re-litigate an
+`decisions.md` "Dead ends" plays for the feature: a later slice shouldn't re-litigate an
 approach forge already rejected.
 
 ## AFK & budget
 
 - **Cost.** Forge multiplies the build by K. Under `.devrites/AFK`, each candidate counts against
   the slice budget (`devrites-engine tick-afk` once per candidate dispatched), so a forge slice can exhaust the
-  cap faster — that is intended back-pressure, not a bug.
+  cap faster, that is intended back-pressure, not a bug.
 - **Gates are unchanged.** Forge changes *how many candidates build*, never *what pauses*. An
   irreversible-risk item, a blocking/escalating gate, or a red-on-completion in **any** candidate
   pauses per [`afk-hitl.md`](../../devrites-lib/reference/standards/afk-hitl.md) exactly as single-path. AFK widens what is
-  automatic, never what is irreversible — forge included.
+  automatic, never what is irreversible: forge included.
 - **Stuck loop still applies.** Re-dispatching the same candidate without progress trips
   `devrites-engine stuck` the same as a single wright.
 
@@ -171,11 +170,11 @@ approach forge already rejected.
 
 No git, or neither worktrees nor throwaway branches are usable → **degrade to single-path** and
 say so. Forge is an accelerator for choosing between real alternatives; it is never a requirement
-for building the slice. A slice always has a single-path build available — the competition is the
+for building the slice. A slice always has a single-path build available: the competition is the
 optional part.
 
 ## Anti-patterns
 
-See [`anti-patterns.md`](anti-patterns.md) § Forge — the short version: don't forge a decided or
+See [`anti-patterns.md`](anti-patterns.md) § Forge: the short version: don't forge a decided or
 trivial slice, don't forge to dodge a decision, don't hand-merge candidates, don't exceed K=3,
 and don't let a forged slice skip the post-return doubt because "the judge already looked."

package/pack/.claude/skills/rite-build/reference/frontend-trigger.md

@@ -12,7 +12,7 @@ A slice is **frontend/UI** if it touches or plans to touch any of:
 
 ## When triggered
 - `/rite-spec` applies **`devrites-ux-shape`** (spec step 3a) to write the feature-level
-  **`design-brief.md`** before any code — design direction, key states, interaction model,
+  **`design-brief.md`** before any code: design direction, key states, interaction model,
   optional Figma/image visual-direction probe.
 - `/rite-build` applies **`devrites-frontend-craft`**, building **to** that `design-brief.md`
   (register detection, refine the brief per slice, existing design system, all states,
@@ -31,7 +31,7 @@ If the slice spans both layers, it's both a frontend **and** a backend slice. De
 `devrites-frontend-craft/reference/fullstack.md`.
 
 ## When NOT triggered
-Pure backend/data/CLI/infra slices skip craft and browser proof — but still get tests
+Pure backend/data/CLI/infra slices skip craft and browser proof, but still get tests
 and evidence. If unsure whether a slice is "UI enough", treat copy/empty/error states
 and any rendered output as UI.
 

package/pack/.claude/skills/rite-build/reference/one-slice-cycle.md

@@ -27,12 +27,12 @@ STOP      → report + recommend next; do not start slice N+1
 ## Why stop after one slice
 - Keeps the diff reviewable (~one capability, roughly ≤100 lines of meaningful change).
 - Surfaces integration/drift problems while they're cheap.
-- Gives the user a decision point — they may reprioritize, reslice, or polish now.
-- Prevents the "90% done" pile-up where nothing is actually proven.
+- Gives the user a decision point. They may reprioritize, reslice, or polish now.
+- Prevents the "90% done" pile-up where nothing is proven.
 
 ## Restate the scope boundary
 Before coding, write what this slice will and will **not** touch. This is the contract
-you check yourself against — anything outside it is scope creep or a drift event.
+you check yourself against: anything outside it is scope creep or a drift event.
 
 ## When the slice can't be completed cleanly
 - Discovered the plan is wrong → **Spec Drift Guard** (stop, record, classify, maybe

package/pack/.claude/skills/rite-build/reference/output.md

@@ -38,4 +38,4 @@ For a **forged slice**, the `Built` line names the competition and points at the
 `Done: built slice 3 — csv-streaming (forged: 3 candidates, winner B).` and
 `Record: .devrites/work/<slug>/forge-report.md`.
 
-**DO NOT continue to the next slice automatically** — even at `✅ ALL BUILT`, `/rite-prove` is the user's call.
+**DO NOT continue to the next slice automatically**: even at `✅ ALL BUILT`, `/rite-prove` is the user's call.