devrites 3.0.5 → 3.0.6

package/pack/generated/claude/skills/devrites-ux-shape/reference/visual-direction-probe.md

@@ -1,7 +1,7 @@
-# Visual-direction probe — test the lane before the brief locks
+# Visual-direction probe: test the lane before the brief locks
 
 Before finalizing `design-brief.md`, pressure-test the visual direction with something
-concrete instead of words — *when it will actually clarify the brief*. This is the
+concrete instead of words, *when it will clarify the brief*. This is the
 DevRites-native answer to "build it according to the design (Figma, images)": show a
 direction, get a reaction, then write the brief.
 
@@ -9,7 +9,7 @@ direction, get a reaction, then write the brief.
 - The work is **net-new** or directionally **ambiguous**. An existing surface or an
   approved reference classified **target** already fixes the direction → skip.
 - Fidelity is **mid-fi or higher**. Sketch-only planning → skip.
-- A probe tool is actually available (below). **Capability-gated** — never ask the user to
+- A probe tool is available (below). **Capability-gated**: never ask the user to
   install APIs or tooling. If none is available, **announce the skip in one line** and
   proceed to the brief. The one-line announcement is required; it forces a conscious choice
   instead of letting the step quietly evaporate.
@@ -21,10 +21,10 @@ direction, get a reaction, then write the brief.
    silent choice.
 2. **Native image generation available** (Figma Make, an image-gen MCP, computer-use, or
    similar) → generate **2-4 distinct direction probes** from the discovery answers (color
-   strategy, scene sentence, anchors). They must differ in **primary direction** —
-   hierarchy, density, typographic voice, topology — not just palette tweaks. Treat them as
+   strategy, scene sentence, anchors). They must differ in **primary direction**:
+   hierarchy, density, typographic voice, topology, not just palette tweaks. Treat them as
    *direction tests*, not final UI.
-3. **A code-fidelity question** ("which of these layouts actually works in our stack") →
+3. **A code-fidelity question** ("which of these layouts works in our stack") →
    route to **`/rite-prototype`** (2-4 real UI variations on one throwaway route). Prototype
    is DevRites' existing tool for this; don't rebuild it here.
 4. **Reference sites / links only** → screenshot them (`devrites-browser-proof` tooling)
@@ -35,14 +35,14 @@ direction, get a reaction, then write the brief.
 - Ask which direction feels closest, what's off, what carries forward. Don't treat
   generated imagery as final UX, copy, or accessibility behavior.
 - If the probe reveals a mismatch, revise the **discovery inputs** (scene sentence, color
-  strategy, anchors) *before* writing the brief — that's the whole point of probing.
+  strategy, anchors) *before* writing the brief. That's the whole point of probing.
 - Save probe artifacts (generated images, Figma exports, screenshots) into
   `.devrites/work/<slug>/references/`, index them in `references.md` with what each shows,
   and note the winning direction in the brief's **Visual-direction probe** section.
 
 ## Limits
 - Don't skip discovery because image generation is available.
-- Don't run a probe for a minor refinement of existing work — it's for shaping a new
+- Don't run a probe for a minor refinement of existing work. It's for shaping a new
   surface or a big directional choice.
-- Don't block the brief on a slow or failing tool — try once, then skip with the one-line
+- Don't block the brief on a slow or failing tool: try once, then skip with the one-line
   note.

package/pack/generated/claude/skills/rite/SKILL.md

@@ -6,11 +6,11 @@ user-invocable: true
 disable-model-invocation: true
 ---
 
-# /rite — DevRites menu + router
+# /rite: DevRites menu + router
 
 You are the DevRites entry point. Two modes:
 
-- **No args** → run `devrites-engine first-task`, render one recommended-start line above the menu, then stop. Do not execute a phase or read `state.md` — status is `/rite-status`.
+- **No args** → run `devrites-engine first-task`, render one recommended-start line above the menu, then stop. Do not execute a phase or read `state.md`: status is `/rite-status`.
 - **Verb arg** → pass-through dispatch to the matching `rite-<verb>` skill (`/rite spec foo` ≡ `/rite-spec foo`); the called skill owns the output.
 
 When the user asks which rite fits, load [`devrites-lib/reference/intent-map.md`](../devrites-lib/reference/intent-map.md).
@@ -63,11 +63,11 @@ What each verb does lives once, in the Menu below; this table is the dispatch ma
 | `quick [change]` | `/rite-quick` |
 | `frame [task]` | `/rite-frame` |
 
-Both forms hit the same skill — the menu form for discovery, the `/rite-<verb>` shortcut for muscle memory.
+Both forms hit the same skill: the menu form for discovery, the `/rite-<verb>` shortcut for muscle memory.
 
-`use <slug>` is handled **inline** — there is no `rite-use` skill. Confirm
+`use <slug>` is handled **inline**. There is no `rite-use` skill. Confirm
 `.devrites/work/<slug>/` exists, then re-point `.devrites/ACTIVE` to `<slug>` and report
-the now-active feature. It is cheap context-switching only — no re-spec, no phase run. If
+the now-active feature. It is cheap context-switching only: no re-spec, no phase run. If
 the workspace is missing, list the slugs under `.devrites/work/` and stop.
 
 `guide` is an inline first-feature walkthrough. Agree on one **real, genuinely small**
@@ -92,7 +92,7 @@ Called phase skills own the shared completion reply contract
 1. **Verb in `$ARGUMENTS`** → dispatch per the table above.
 2. **No args** → menu mode, as above.
 3. **Unrecognized first token** → tell the user the known verbs and stop. Don't guess.
-4. **No active feature** and the user asked "where am I" or named no verb → point at `/rite spec <feature>` (or `/rite-spec`). Don't summarize state yourself — `/rite status` (or `/rite-status`) owns that.
+4. **No active feature** and the user asked "where am I" or named no verb → point at `/rite spec <feature>` (or `/rite-spec`). Don't summarize state yourself: `/rite status` (or `/rite-status`) owns that.
 
 ## Menu
 
@@ -132,7 +132,7 @@ UTILITY       /rite frame | prototype | handoff | zoom-out | pressure-test  (or
 > **Small one-off change?** A typo, copy tweak, config bump, or one-function fix → **`/rite-quick`**
 > (express lane: one contract → build → prove → ship, no full workspace). It escalates to
 > `/rite-spec` the instant the change grows past small / reversible / unambiguous. The full
-> lifecycle above is for real features — don't pay its ceremony for a one-off.
+> lifecycle above is for real features: don't pay its ceremony for a one-off.
 
 ## Core operating rules (every DevRites skill enforces)
 

package/pack/generated/claude/skills/rite/reference/menu.md

@@ -8,25 +8,25 @@ what each command does or how phases connect.
 | Phase | Command | Use when |
 |---|---|---|
 | Spec | `/rite-spec <feature>` | **New feature.** Investigate deeply → write spec.md. Asks with options; gathers attached design references (optional). |
-| Adopt | `/rite-adopt` | Onboard an existing codebase instead of starting fresh — reverse-derive spec.md + seed the conventions ledger. |
-| Temper | `/rite-temper` | _Optional, before define._ Strategic review of the spec — scope mode (expand/selective/hold-rigor/reduce) + pre-mortem; hardens the spec. Best on big/risky features; mandatory in `/rite-autocomplete`. |
+| Adopt | `/rite-adopt` | Onboard an existing codebase instead of starting fresh: reverse-derive spec.md + seed the conventions ledger. |
+| Temper | `/rite-temper` | _Optional, before define._ Strategic review of the spec: scope mode (expand/selective/hold-rigor/reduce) + pre-mortem; hardens the spec. Best on big/risky features; mandatory in `/rite-autocomplete`. |
 | Plan | `/rite-define` | Turn the approved spec into plan + vertical task slices + state. |
-| Vet | `/rite-vet` | _Required before build._ Review every plan — scope · architecture · tests · perf; light for simple/reversible, full for high stakes. |
+| Vet | `/rite-vet` | _Required before build._ Review every plan: scope · architecture · tests · perf; light for simple/reversible, full for high stakes. |
 | Re-plan | `/rite-plan` | The active plan is too big, wrong, stale, ambiguous, or blocked. |
 | Build | `/rite-build` | Implement the next single vertical slice. Stops after one slice. |
-| Converge | `/rite-converge` | _Recovery._ Code drifted from / falls short of intent (resumed cold, adopted, stalled build) — assess live code vs spec/plan/tasks and append the remaining work as new slices for `/rite-build`. |
+| Converge | `/rite-converge` | _Recovery._ Code drifted from / falls short of intent (resumed cold, adopted, stalled build): assess live code vs spec/plan/tasks and append the remaining work as new slices for `/rite-build`. |
 | Prove | `/rite-prove` | Prove the current scope: tests, build, runtime, browser evidence. |
 | Polish | `/rite-polish` | Code polish always; UI normalize + ship-quality polish if UI is in scope. Modes: `bolder/quieter/distill/harden/normalize-only`. |
 | Review | `/rite-review` | Feature-scoped review before sealing. |
 | Seal | `/rite-seal` | Final GO / NO-GO decision (no git). |
 | Ship | `/rite-ship` | Type-GO → commit/push/tag, then archive the task + clear ACTIVE. |
 | Status | `/rite-status` | See where the active feature stands. |
-| Doctor | `/rite-doctor` | Health check — install integrity, stale ACTIVE, orphaned gates, hook wiring, merge/rebase state. |
+| Doctor | `/rite-doctor` | Health check: install integrity, stale ACTIVE, orphaned gates, hook wiring, merge/rebase state. |
 | Learn | `/rite-learn` | Review the captured learning ledger → promote recurring lessons to project rules / principles. |
 
 ## Typical orderings
 
-- **Every feature**: `/rite-spec` (spec) → *(big feature? `/rite-temper` — strategic review)* →
+- **Every feature**: `/rite-spec` (spec) → *(big feature? `/rite-temper`: strategic review)* →
   `/rite-define` (plan) → `/rite-vet` (engineering review; light or full) →
   `/rite-build` ×N (all slices) → `/rite-prove` (once all built) →
   `/rite-polish` (always: code + UI if UI) → `/rite-review` → `/rite-seal` → `/rite-ship`.

package/pack/generated/claude/skills/rite-adopt/SKILL.md

@@ -5,7 +5,7 @@ argument-hint: "[path or area to adopt] [+ what you want to build next]"
 user-invocable: true
 ---
 
-# /rite-adopt — brownfield on-ramp
+# /rite-adopt: brownfield on-ramp
 
 The **reverse** of `/rite-spec`. `/rite-spec` goes idea → spec; `/rite-adopt` goes
 **existing code → spec + seeded conventions**, so an already-built project can enter the
@@ -33,14 +33,14 @@ upholds invariants worth proposing as project principles (step 4a).
 ## Workflow
 0. **Read `.claude/skills/devrites-lib/reference/standards/core.md`**, then run
    `devrites-engine preamble` for deterministic workspace orientation.
-1. **Scope the adoption** (`$ARGUMENTS`). Which repo or sub-area is being onboarded, and —
-   if stated — what the user wants to build *next* on top of it. If the next-build objective
+1. **Scope the adoption** (`$ARGUMENTS`). Which repo or sub-area is being onboarded, and:
+   if stated: what the user wants to build *next* on top of it. If the next-build objective
    is missing, ask once (it shapes the spec's acceptance); if the area is ambiguous, confirm
    before investigating the whole tree.
-2. **Reverse-investigate the existing code** — the durable shape of the project. Use a
-   code-intelligence index if available — codebase-memory-mcp first (its `get_architecture`
+2. **Reverse-investigate the existing code:** the durable shape of the project. Use a
+   code-intelligence index if available (codebase-memory-mcp first (its `get_architecture`
    gives a fast overview), cross-checked with codegraph + graphify, else standard methods
-   (LSP / Read/Grep/Glob); see `.claude/skills/devrites-lib/reference/standards/tooling.md` — for
+   (LSP / Read/Grep/Glob); see `.claude/skills/devrites-lib/reference/standards/tooling.md`) for
    structure, callers, and impact. Capture, per [adoption](reference/adoption.md): **current
    behavior**, **architecture + placement** (layers, seams, where each kind of thing lives),
    the **commands** (test / build / typecheck / lint), and the **idioms** (naming, layering,
@@ -55,7 +55,7 @@ upholds invariants worth proposing as project principles (step 4a).
 3a. **Seed the capability ledger** from the baseline. If the reverse-derived `spec.md` carries
    structured `### Requirement:` blocks, fold them into the living
    `.devrites/specs/<capability>/spec.md` ledger so the project's *current* proven behavior is on
-   record before the first new feature — the ledger the next `/rite-spec` writes deltas against
+   record before the first new feature: the ledger the next `/rite-spec` writes deltas against
    ([ledger.md](../rite-ship/reference/ledger.md)). A flat baseline folds as all-ADDED into the
    feature slug's capability; tag capabilities in the spec first if you want finer granularity.
    ```bash
@@ -63,33 +63,33 @@ upholds invariants worth proposing as project principles (step 4a).
    devrites-engine ledger sync .devrites/work/<slug>   # seed
    ```
    Skip when the baseline records no structured requirements (nothing to seed).
-4. **Seed the conventions ledger** from what the investigation *observed* —
+4. **Seed the conventions ledger** from what the investigation *observed*:
    [adoption § seeding](reference/adoption.md). This is the deliberate bootstrap exception to
    evidence-gated promotion: the seeds start at the base band and are provenance-tagged as
    onboarding observations, not sealed-slice proofs, so real slices later corroborate or
    (fresh-wins) contradict them.
    **Completion:** every seed names observed evidence, provenance, and the base band.
 4a. **Propose candidate principles** (human-ratified; optional). Where the investigation found an
-   invariant the code *consistently and deliberately* upholds — money always in integer cents, PII
-   always redacted from logs, every v1 endpoint preserved — surface it as a **candidate
+   invariant the code *consistently and deliberately* upholds (money always in integer cents, PII
+   always redacted from logs, every v1 endpoint preserved) surface it as a **candidate
    principle**, not a seeded convention. Principles are prescriptive and gating, so they are
    **ratified by the human, never auto-seeded** the way conventions are: present the candidates via
    `AskUserQuestion` with the evidence (where the code upholds it), and write the ones the human
    ratifies to `.devrites/principles.md` with a dated Governance entry
-   ([`principles.md`](../devrites-lib/reference/standards/principles.md)). Propose, don't impose — an unratified candidate
-   stays a convention, not a gate. Skip cleanly when nothing rises to an invariant (common — a
+   ([`principles.md`](../devrites-lib/reference/standards/principles.md)). Propose, don't impose: an unratified candidate
+   stays a convention, not a gate. Skip cleanly when nothing rises to an invariant (common: a
    fresh adopt may declare zero principles, and that's valid).
 5. **Hand off.** Spec and ledger are ready. Next: `/rite-temper` if big/risky,
    else `/rite-define`; every plan then runs `/rite-vet` before build. Do not plan/build here.
    **Completion:** one next rite is reported and no plan or application code was written.
 
-> **Mid-flight discipline.** Don't invent conventions the code doesn't actually follow, don't
-> seed an idiom you only assumed, and don't expand scope into a rewrite — adoption documents
+> **Mid-flight discipline.** Don't invent conventions the code doesn't follow, don't
+> seed an idiom you only assumed, and don't expand scope into a rewrite: adoption documents
 > what exists; the *next* feature changes it. See [`anti-patterns`](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:
 ```

package/pack/generated/claude/skills/rite-adopt/reference/adoption.md

@@ -1,22 +1,22 @@
-# Adoption — reverse-investigate + seed (the on-ramp contract)
+# Adoption: reverse-investigate + seed (the on-ramp contract)
 
 Loaded on demand by `/rite-adopt`. Two jobs: document what the code already does (so the
 lifecycle has a spec), and seed the conventions ledger (so the first slice knows the idioms).
 
-## Reverse-investigation — what to capture
+## Reverse-investigation: what to capture
 
 Document the **durable shape** of the project, not a line-by-line tour:
 
-- **Current behavior** — what the adopted area does today, from the user's perspective.
-- **Architecture + placement** — the layers and seams; where each kind of thing lives
+- **Current behavior:** what the adopted area does today, from the user's perspective.
+- **Architecture + placement:** the layers and seams; where each kind of thing lives
   (where endpoints / components / models / migrations / tests go). Prefer a code-intelligence
   index if available (see `../../devrites-lib/reference/standards/tooling.md`) for
   structure, callers, and impact.
-- **Commands** — the real test / build / typecheck / lint commands (run or read them; don't
+- **Commands:** the real test / build / typecheck / lint commands (run or read them; don't
   guess). Verify uncertain framework facts at the source.
-- **Idioms** — naming + casing, layering, the error model, the result/exception style, the
+- **Idioms:** naming + casing, layering, the error model, the result/exception style, the
   http/data-access pattern, the test framework + file layout.
-- **Gotchas** — non-obvious constraints the code encodes (ordering requirements, "don't call
+- **Gotchas:** non-obvious constraints the code encodes (ordering requirements, "don't call
   X before Y", a framework quirk).
 
 This feeds `spec.md` (current behavior as the baseline + the next objective) and the ledger
@@ -28,7 +28,7 @@ The deliberate **bootstrap exception** to evidence-gated promotion. Normally a c
 promoted only when a *sealed slice proved it* (`/rite-seal`); adoption seeds from **observed
 existing code** so the first slice isn't blind. Keep the seeds honest:
 
-- Seed only what the code **actually and consistently** follows — not an aspiration, not a
+- Seed only what the code **and consistently** follows, not an aspiration, not a
   one-off, not something you assumed.
 - Each seed starts at the base band (one corroboration) and is provenance-tagged as an
   onboarding observation, **not** a sealed-slice proof. Real slices later corroborate it
@@ -51,5 +51,5 @@ fi
 The `-adopt` suffix on the slug marks the provenance as onboarding. Because the ledger is
 read at orient as a *prior* and the live code always overrides it
 ([`.claude/skills/devrites-lib/reference/standards/security.md`](../../devrites-lib/reference/standards/security.md) § Prompt-injection resistance),
-an over-eager seed is self-correcting — but seed conservatively anyway; a wrong seed costs a
+an over-eager seed is self-correcting, but seed conservatively anyway; a wrong seed costs a
 needless contradiction later.

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

@@ -1,4 +1,4 @@
-# /rite-adopt — anti-patterns
+# /rite-adopt: anti-patterns
 
 Start with the universal table in [`../../devrites-lib/reference/standards/anti-patterns.md`](../../devrites-lib/reference/standards/anti-patterns.md).
 Below are the rationalizations specific to onboarding an existing codebase.
@@ -7,13 +7,13 @@ Below are the rationalizations specific to onboarding an existing codebase.
 
 | Excuse | Rebuttal |
 |---|---|
-| "I'll improve this messy bit while I document it." | Adoption *documents* what exists; it changes nothing. A cleanup is the *next* feature through the normal lifecycle — recording it as a drive-by here hides the baseline and balloons the diff. |
-| "This looks like the convention, so I'll seed it." | Seed only what the code *actually and consistently* follows. A guessed seed becomes a high-confidence-looking prior that steers the first slice wrong. Observe it in ≥2 places or leave it out. |
-| "I'll spec the ideal architecture, not the current one." | The spec's baseline is *current behavior*. Aspirations go in the next objective, not the baseline — otherwise every later slice drifts against a spec that never matched reality. |
-| "Whole repo in one adopt." | Onboard the area you'll actually work in. A repo-wide adopt produces an unfocused spec and a ledger full of conventions no slice will touch. |
+| "I'll improve this messy bit while I document it." | Adoption *documents* what exists; it changes nothing. A cleanup is the *next* feature through the normal lifecycle: recording it as a drive-by here hides the baseline and balloons the diff. |
+| "This looks like the convention, so I'll seed it." | Seed only what the code *and consistently* follows. A guessed seed becomes a high-confidence-looking prior that steers the first slice wrong. Observe it in ≥2 places or leave it out. |
+| "I'll spec the ideal architecture, not the current one." | The spec's baseline is *current behavior*. Aspirations go in the next objective, not the baseline: otherwise every later slice drifts against a spec that never matched reality. |
+| "Whole repo in one adopt." | Onboard the area you'll work in. A repo-wide adopt produces an unfocused spec and a ledger full of conventions no slice will touch. |
 
 ## Red flags
 
 - A seeded convention with no concrete code location behind it.
 - `spec.md` describing behavior the code does **not** currently have (that's the next feature, not the baseline).
-- Editing source during adoption — adoption writes `.devrites/` + the ledger, never project code.
+- Editing source during adoption: adoption writes `.devrites/` + the ledger, never project code.

package/pack/generated/claude/skills/rite-autocomplete/SKILL.md

@@ -5,11 +5,11 @@ argument-hint: "[idea] [--ship|--yolo] [--max-slices N]"
 user-invocable: true
 ---
 
-# /rite-autocomplete — full lifecycle, unattended
+# /rite-autocomplete: full lifecycle, unattended
 
 Drives every DevRites phase in order without stopping for discretionary input. The
-prompt may be vague — autocomplete asks its clarifying questions **up front**, then
-runs to completion. It does **not** disable the safety gates: hard irreversible-risk,<!-- pack-scan-ignore: negated statement — gates are NOT disabled -->
+prompt may be vague: autocomplete asks its clarifying questions **up front**, then
+runs to completion. It does **not** disable the safety gates: hard irreversible-risk,<!-- pack-scan-ignore: negated statement: gates are NOT disabled -->
 blocking / escalating gates, and any NO-GO still pause.
 
 ## Rules consulted (read on demand from `.claude/skills/devrites-lib/reference/standards/`)
@@ -18,15 +18,15 @@ blocking / escalating gates, and any NO-GO still pause.
 ## Operating rules
 - **One human window.** Clarifying questions are batched up front via
   `devrites-interview`. After that, discretionary decisions are made automatically and
-  recorded in `decisions.md` — not asked. See [reference/decision-policy.md](reference/decision-policy.md).
+  recorded in `decisions.md`, not asked. See [reference/decision-policy.md](reference/decision-policy.md).
 - **Safety gates are not bypassable.** AFK never auto-passes destructive migration /
   auth-authz change / public-API break / external-contract change / red tests; blocking
   and escalating gates and any open `gate: validating` always pause. `--ship` auto-confirms
-  the **final** type-GO only — nothing else. A change that violates a declared project
-  principle (`.devrites/principles.md`) with no recorded exception pauses too — autocomplete
+  the **final** type-GO only: nothing else. A change that violates a declared project
+  principle (`.devrites/principles.md`) with no recorded exception pauses too: autocomplete
   never grants a principle exception on its own (`principles.md`: that's a human decision).
 - **Loop budget = the plan's own slice count, not a fixed number.** After `/rite-vet`
-  (not `/rite-define` — vet may split or add slices, so the count isn't final until then),
+  (not `/rite-define`: vet may split or add slices, so the count isn't final until then),
   set the AFK budget to however many slices the plan has, so the loop builds exactly the
   task's slices and stops when they're done. `--max-slices N` is an OPTIONAL *lower* safety
   cap (partial / babysat run); omit it to run the whole plan. The budget is finite
@@ -34,13 +34,13 @@ blocking / escalating gates, and any NO-GO still pause.
 - **Best option, recorded.** For each discretionary choice, pick the option the relevant
   specialist / reviewer favours and record the rationale. Never silently coin-flip.
 - **Strategic review runs, but never auto-grows scope.** After `/rite-spec`, run `/rite-temper`
-  (significance-gated — it skips low-stakes specs in one line). Unattended it auto-applies only
+  (significance-gated; it skips low-stakes specs in one line). Unattended it auto-applies only
   `hold-rigor` + `reduce-to-MVP` (these never grow acceptance); **any `expand` is a blocking
   pause**, and irreversible-risk findings always pause. Autocomplete hardens and may *prune* the
   spec on its own; it never *expands* the build's scope without the human.
 - **Engineering review runs on every plan, but never auto-grows scope.** After `/rite-define`,
-  run `/rite-vet` on **every** feature (depth scales — a light pass on simple plans, full rigor on
-  big/risky; never skipped). Unattended it auto-applies only *hardening* findings — added test
+  run `/rite-vet` on **every** feature (depth scales: a light pass on simple plans, full rigor on
+  big/risky; never skipped). Unattended it auto-applies only *hardening* findings: added test
   requirements, error-handling / failure-mode coverage, tightened scope, reuse-over-rebuild,
   ordering / parallel-lane fixes (these never grow acceptance); **any finding that grows scope,
   adds a slice, or changes acceptance is a blocking pause**, and irreversible-risk findings always
@@ -52,11 +52,11 @@ blocking / escalating gates, and any NO-GO still pause.
    type-GO), `--max-slices N` (OPTIONAL *lower* safety cap for a partial run; default =
    the plan's slice count, i.e. run all planned slices).
 2. **Clarify up front.** If the idea is underspecified, run `devrites-interview` to
-   ~95% confidence — the only interactive window. If already clear, skip.
+   ~95% confidence: the only interactive window. If already clear, skip.
 3. **Arm AFK.** Write `.devrites/AFK` with `allow_gates: [advisory]`; set the slice budget
    from the plan's count after `/rite-vet` (the slice count is only final post-vet), or from
    an explicit `--max-slices` ([reference/loop.md](reference/loop.md)). validating / blocking / escalating +
-   irreversible-risk still pause. Also `touch .devrites/CHECKPOINT` — an unattended run is the
+   irreversible-risk still pause. Also `touch .devrites/CHECKPOINT`: an unattended run is the
    case checkpoint mode earns its keep, so each proven slice is committed local-only as
    crash-survivable `WIP` ([rite-build/reference/checkpoint.md](../rite-build/reference/checkpoint.md));
    `/rite-ship` collapses them into the one feature commit.
@@ -72,12 +72,12 @@ blocking / escalating gates, and any NO-GO still pause.
    type-GO. Without it, render the type-GO prompt and stop for the human.
 
 > **Mid-flight discipline.** When tempted to auto-pass a blocking gate "to keep moving",
-> answer a material question yourself instead of pausing, or run past red tests — stop.
+> answer a material question yourself instead of pausing, or run past red tests: stop.
 > Autonomy is for the routine path; the gates exist for everything else.
 
 ## Output
 A compact phase-by-phase log, then the final status. **Progress first for the final
-status** — run `devrites-engine progress`, then use the shared typed states from
+status**: run `devrites-engine progress`, then use the shared typed states from
 [`devrites-lib/reference/reply-contract.md`](../devrites-lib/reference/reply-contract.md):
 `Shipped`, `Stopped`, `Awaiting human`, `NO-GO`, or `GO`.
 

package/pack/generated/claude/skills/rite-autocomplete/reference/decision-policy.md

@@ -1,8 +1,8 @@
-# Decision policy — how autocomplete "chooses the best option"
+# Decision policy: how autocomplete "chooses the best option"
 
 Unattended ≠ careless. Every discretionary choice is made the way a senior engineer
 would, then **recorded** so the seal can audit it. The difference from interactive mode
-is only *who answers* a discretionary question — not whether it's reasoned.
+is only *who answers* a discretionary question, not whether it's reasoned.
 
 ## The rule
 
@@ -20,7 +20,7 @@ not pick the option that's merely easiest to implement.
 
 ## Defaults autocomplete may assume (record them)
 
-- Follow the project's existing conventions, components, and test commands — always.
+- Follow the project's existing conventions, components, and test commands: always.
 - Prefer the smallest vertical slice that proves the acceptance criterion.
 - Reuse → extend → build new, in that order (`coding-style.md`).
 - When two options are equivalent on the evidence, choose the lower-risk / more
@@ -29,7 +29,7 @@ not pick the option that's merely easiest to implement.
 ## When a choice is NOT autocomplete's to make
 
 If a discretionary choice would change **product behaviour, scope, data model, security
-posture, or acceptance criteria**, it is no longer discretionary — it is a material
+posture, or acceptance criteria**, it is no longer discretionary. It is a material
 question. Route it through the Spec Drift Guard / a `blocking` question and **stop**
 (see [stop-conditions.md](stop-conditions.md)). Autocomplete answers *how*, never
 *what to build* beyond what the up-front interview settled.

package/pack/generated/claude/skills/rite-autocomplete/reference/loop.md

@@ -1,8 +1,8 @@
-# The autocomplete loop — arm AFK, drive every phase
+# The autocomplete loop: arm AFK, drive every phase
 
 Autocomplete is an orchestrator: it runs the existing `/rite-*` skills in order,
 exactly as a human would, but without stopping between them. It owns no workflow of
-its own — the phases do the work; autocomplete sequences them and enforces stops.
+its own: the phases do the work; autocomplete sequences them and enforces stops.
 
 ## Arm AFK
 
@@ -16,11 +16,11 @@ allow_gates: [advisory]        # only advisory auto-handles; validating+ pause
 # caps how many run unattended (default = all the plan's slices).
 ```
 
-The budget is the plan's own slice count, not a fixed number — so the loop builds exactly
+The budget is the plan's own slice count, not a fixed number, so the loop builds exactly
 the task's slices and stops when they're done; `--max-slices N` only *lowers* it for a
 partial run. Arm the gate policy at step 3; write `max_slices` / `AFK slices remaining`
 **after `/rite-vet`** (it runs before the build loop and may split or add a slice, so the
-count isn't final until then — vet runs on every plan here, so always set the budget after it).
+count isn't final until then: vet runs on every plan here, so always set the budget after it).
 
 `allow_gates: [advisory]` is deliberate: an open `gate: validating` is merge-blocking
 at seal (`afk-hitl.md`), so autocomplete must *pause* on it rather than queue it and
@@ -30,7 +30,7 @@ then hit NO-GO. Widen `allow_gates` only if the caller explicitly asked.
 
 Run each by Reading its `SKILL.md` and executing that workflow. State flows through the
 workspace files (`state.md`, `tasks.md`, `evidence.md`, …), so each phase picks up where
-the last left off — there is nothing to thread through chat.
+the last left off. There is nothing to thread through chat.
 
 | Step | Phase | Loop / gate |
 |---|---|---|
@@ -38,7 +38,7 @@ the last left off — there is nothing to thread through chat.
 | 2 | `/rite-temper` | significance-gated strategic review; harden spec + write `strategy.md`. Skip low-stakes specs in one line. AFK: `hold-rigor` / `reduce-to-MVP` auto-apply; **any `expand` pauses (blocking)**; irreversible-risk pauses |
 | 3 | `/rite-define` | reads `strategy.md`; `plan.md` + `tasks.md`; record `Plan approved` |
 | 4 | `/rite-vet` | engineering plan review on **every** plan (light pass on simple plans, full on big/risky; never skipped); harden `plan.md` / `tasks.md` + write `eng-review.md` + `test-plan.md`. AFK: hardening / coverage findings auto-apply; **any scope-growing / acceptance-changing finding pauses (blocking)**; irreversible-risk pauses. Set the slice budget after this (vet may split a slice) |
-| 5 | `/rite-build` ×N | **loop** while any slice is `pending`; build one (the slice-wright reads `test-plan.md` for coverage), then run `devrites-engine tick-afk state.md` — exit 3 (budget hit) ⇒ STOP |
+| 5 | `/rite-build` ×N | **loop** while any slice is `pending`; build one (the slice-wright reads `test-plan.md` for coverage), then run `devrites-engine tick-afk state.md`: exit 3 (budget hit) ⇒ STOP |
 | 6 | `/rite-prove` | once all slices `built`; walks `test-plan.md`; on failure → `devrites-debug-recovery` within scope |
 | 7 | `/rite-polish` | re-verify after code edits (evidence must stay fresh) |
 | 8 | `/rite-review` | apply in-scope fixes; re-prove if code changed |
@@ -48,7 +48,7 @@ the last left off — there is nothing to thread through chat.
 ## Between phases
 
 - Re-read the active workspace before each phase (don't trust chat memory).
-- After a phase that edits code (build, polish, review), evidence may be stale — let
+- After a phase that edits code (build, polish, review), evidence may be stale: let
   the next gate re-prove rather than carrying a stale pass (see
   `.claude/skills/devrites-lib/reference/standards/development-workflow.md`).
 - Check [stop-conditions.md](stop-conditions.md) at every gate **before** advancing.

package/pack/generated/claude/skills/rite-autocomplete/reference/stop-conditions.md

@@ -1,10 +1,10 @@
-# Stop conditions — when autocomplete must pause for a human
+# Stop conditions: when autocomplete must pause for a human
 
 Autonomy covers the routine path. These are the cases where autocomplete writes
 `state.md` (`Status: awaiting_human` or `blocked`), surfaces *why* + the single resume
 command, fires `notify` if set, and **stops**. None are bypassable by `--ship`.
 
-## Always stop (irreversible-risk list — from `afk-hitl.md`)
+## Always stop (irreversible-risk list: from `afk-hitl.md`)
 
 Regardless of `allow_gates` or `--ship`:
 - Destructive data migration (drop column/table, irreversible backfill).
@@ -23,8 +23,8 @@ Regardless of `allow_gates` or `--ship`:
 
 ## Stop on strategic-review scope expansion (`/rite-temper`)
 
-- `/rite-temper` choosing scope mode `expand` — or otherwise **adding** any acceptance
-  criterion to `spec.md` — → synchronous pause, regardless of `allow_gates` / `--ship`.
+- `/rite-temper` choosing scope mode `expand`, or otherwise **adding** any acceptance
+  criterion to `spec.md`: → synchronous pause, regardless of `allow_gates` / `--ship`.
   Autocomplete may auto-apply only `hold-rigor` and `reduce-to-MVP` (they harden / prune and
   never grow the build's scope); **growing scope unattended is never automatic**. A low-stakes
   spec that temper skips, or a `hold-rigor` / `reduce-to-MVP` run, does **not** pause.
@@ -35,13 +35,13 @@ Regardless of `allow_gates` or `--ship`:
   direction. Do not round NO-GO up to GO.
 - **Spec Drift Guard fires** (`/rite-build` finds the plan is wrong and the change
   alters product behaviour) → stop; route through `/rite-plan repair`.
-- **Budget exhausted with slices still pending** — `devrites-engine tick-afk` exit 3 while `tasks.md`
+- **Budget exhausted with slices still pending:** `devrites-engine tick-afk` exit 3 while `tasks.md`
   still has unbuilt slices (only when an explicit `--max-slices` capped the run below the
   plan's count) → stop; report slices remaining. Exhausting the default budget = all
   planned slices built = normal completion → continue to `/rite-prove`, don't pause.
-- **Still low-confidence after the interview** — the idea can't be pinned to testable
+- **Still low-confidence after the interview:** the idea can't be pinned to testable
   acceptance criteria → stop and ask, rather than guessing the product.
-- **Repeated failure** — a phase fails, `devrites-debug-recovery` can't fix it within
+- **Repeated failure:** a phase fails, `devrites-debug-recovery` can't fix it within
   scope after a bounded number of attempts → stop with the reproduction.
 
 ## The final type-GO

package/pack/generated/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