devrites 3.0.5 → 3.0.6

package/pack/generated/claude/skills/rite-pressure-test/SKILL.md

@@ -5,37 +5,37 @@ argument-hint: "[rough idea or plan to stress-test]"
 user-invocable: true
 ---
 
-# /rite-pressure-test — diverge then converge
+# /rite-pressure-test: diverge then converge
 
 Use when the *idea* (not just the requirements) is rough. Generate options, then commit
-to one — so `/rite-spec` has a real direction to specify.
+to one, so `/rite-spec` has a real direction to specify.
 
-A thinking stance, not a build phase — capturing thinking is not implementing. Write
+A thinking stance, not a build phase: capturing thinking is not implementing. Write
 workspace/ticket artifacts freely; source edits wait for `/rite-build`, via `/rite-spec`.
 
-Read `.claude/skills/devrites-lib/reference/standards/core.md` first — its operating rules (no silent assumptions, prefer
+Read `.claude/skills/devrites-lib/reference/standards/core.md` first: its operating rules (no silent assumptions, prefer
 existing conventions) shape the divergence. The other rule files load on demand.
 
 ## Diverge (widen)
 - Load the `rejected-direction` entries from `.devrites/learnings.md` first. A recorded
-  rejection re-enters the option set only with new evidence against its recorded *why* —
+  rejection re-enters the option set only with new evidence against its recorded *why*:
   name that evidence when you bring one back.
-- Generate 3–5 genuinely different approaches to the underlying goal, not variations of
+- Generate 3-5 genuinely different approaches to the underlying goal, not variations of
   one. Cover at least: the obvious approach, a simpler/smaller approach, and a
   different-shape approach (different data model, flow, or boundary).
 - Generate from **named lenses** so each option exists for a reason, not to pad the count:
   *inversion* (do the opposite), *constraint-removal* (what if the hard limit vanished),
   *audience-shift* (build it for a different user), *10×* (what if it had to handle ten times
   the scale or scope), *expert-lens* (how a specialist in the domain would do it). Borrow the
-  *structure* of an analogous product, not its surface — "Uber for X" copies the veneer, not
+  *structure* of an analogous product, not its surface. "Uber for X" copies the veneer, not
   the mechanism that made it work.
 - For each: one-line description, what it optimizes for, rough cost, main risk.
-- Stay concrete — name real entities, flows, and surfaces, not abstractions.
+- Stay concrete: name real entities, flows, and surfaces, not abstractions.
 
 ## Converge (commit)
 - Weigh options against the goal, constraints, and existing codebase conventions.
 - **Painkiller or vitamin?** Score each on whether it removes a real, felt pain (a painkiller
-  users seek out) or is merely nice-to-have (a vitamin they forget). Prefer the painkiller — a
+  users seek out) or is merely nice-to-have (a vitamin they forget). Prefer the painkiller: a
   vitamin dressed as a painkiller is the most common ideation trap.
 - **Rank the differentiation**, strongest to weakest: a new capability > a 10× improvement > a
   new audience > a new context > better UX > cheaper. The higher an option sits, the more
@@ -44,18 +44,18 @@ existing conventions) shape the divergence. The other rule files load on demand.
 - Note what would change the recommendation (the decision's hinge).
 
 ## Boundaries
-- This is exploration, not specification. Output a **direction**, not a finished spec —
+- This is exploration, not specification. Output a **direction**, not a finished spec:
   `/rite-spec` writes the spec.
-- Don't over-explore: 3–5 options, one pass of convergence. If the user already knows
+- Don't over-explore: 3-5 options, one pass of convergence. If the user already knows
   the direction, skip this and go straight to `/rite-spec`. If the effort is too foggy for
   one pass, start an investigation map at `.devrites/work/<slug>/investigation-map.md`
   with `Destination`, `Decisions so far`, `Not yet specified`, `Out of scope`, plus one
   frontier question per session.
 - Ask the user to pick when two options are close and the choice changes the product.
-- Name a **"Not doing" list** — the good options you deliberately cut. It's the highest-value
+- Name a **"Not doing" list**: the good options you deliberately cut. It's the highest-value
   output of convergence: it hands `/rite-spec` its scope boundary and stops the rejected ideas
-  from creeping back in later. When a cut is durable — rejected for a reason that outlives this
-  feature — offer to record it: `devrites-engine learnings add <slug> "<direction> — <why>"
+  from creeping back in later. When a cut is durable (rejected for a reason that outlives this
+  feature) offer to record it: `devrites-engine learnings add <slug> "<direction>: <why>"
   rejected-direction`.
 
 ## Output

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

@@ -6,14 +6,14 @@ disable-model-invocation: true
 argument-hint: "[the question the prototype is answering]"
 ---
 
-# /rite-prototype — throwaway code that answers ONE question
+# /rite-prototype: throwaway code that answers ONE question
 
 A prototype is **throwaway code that answers exactly one question**. The question
-chooses the shape — get the shape wrong and the whole prototype wastes the user's time.
+chooses the shape: get the shape wrong and the whole prototype wastes the user's time.
 
 ## 0. Read core rules
 
-Read `.claude/skills/devrites-lib/reference/standards/core.md` first — the operating rules and the "capture the answer"
+Read `.claude/skills/devrites-lib/reference/standards/core.md` first: the operating rules and the "capture the answer"
 persistence discipline apply even to throwaway code. The other rule files load on demand.
 
 ## 1. Name the question
@@ -25,7 +25,7 @@ down. Examples that count as "the question":
 - "Which of these three settings layouts feels right?"
 - "Will the proposed state machine deadlock when X overlaps Y?"
 
-A vague question ("explore this feature") is not enough — push back once to sharpen it.
+A vague question ("explore this feature") is not enough: push back once to sharpen it.
 
 ## 2. Pick the branch
 
@@ -33,23 +33,23 @@ Read the user's prompt + the surrounding code. Two branches:
 
 | Question shape | Branch | Artifact |
 |---|---|---|
-| "Does this **logic / state / data model** behave right?" | **Logic** | Smallest runnable harness — terminal script / REPL / mini node or python file — that pushes the model through the hard cases. |
-| "What should this **look like / which UX wins**?" | **UI** | 2–4 **radically different** UI variations on a single route, switchable via a query param + a small floating selector bar. |
+| "Does this **logic / state / data model** behave right?" | **Logic** | Smallest runnable harness (terminal script / REPL / mini node or python file) that pushes the model through the hard cases. |
+| "What should this **look like / which UX wins**?" | **UI** | 2-4 **radically different** UI variations on a single route, switchable via a query param + a small floating selector bar. |
 
 If genuinely ambiguous and the user is AFK: pick by the surrounding code (backend module
 → Logic; page / component → UI) and state the assumption in a comment at the top.
 
 **Variations must differ in shape.** UI prototypes where the variations are just colour
-or padding tweaks teach nothing — push each variation to a different *information
+or padding tweaks teach nothing: push each variation to a different *information
 architecture* / *interaction model* so the user can pick a direction, not a polish.
 
 ## 3. Rules that apply to both branches
 
-1. **Throwaway from day one — and visibly so.** Place the prototype next to where it
+1. **Throwaway from day one, and visibly so.** Place the prototype next to where it
    will eventually be used (so context is obvious) but name it so a casual reader sees
    it's a prototype: `prototype/`, `__prototype__`, `.scratch/`, etc. Obey the project's
    existing routing / module convention; don't invent a new top-level structure.
-2. **One command to run.** Use whatever task runner the project already has — `pnpm
+2. **One command to run.** Use whatever task runner the project already has: `pnpm
    <name>`, `python <path>`, `bun <path>`. The user must start it without thinking.
 3. **No persistence by default.** State lives in memory. Persistence is usually the
    thing the prototype is *checking*, not a dependency. If the question explicitly
@@ -60,7 +60,7 @@ architecture* / *interaction model* so the user can pick a direction, not a poli
 5. **Surface state.** After every action (Logic) or on every variant switch (UI), print
    or render the full relevant state so the user can see what changed.
 6. **Delete or absorb when done.** When the question has an answer, either delete the
-   prototype or fold the validated decision into the real code — don't leave it
+   prototype or fold the validated decision into the real code: don't leave it
    rotting in the repo.
 
 ## 4. Capture the answer
@@ -73,7 +73,7 @@ one of:
 - A `NOTES.md` next to the prototype if no active feature exists.
 
 If the user is around, this is a quick conversation. If they're AFK, the prototype is
-complete only once the verdict is actually filled in — a blank `VERDICT: ___` is not an
+complete only once the verdict is filled in: a blank `VERDICT: ___` is not an
 answer. Leave it marked **not yet complete** and queue the open question so a later pass
 fills the verdict before the prototype is deleted.
 
@@ -81,9 +81,9 @@ fills the verdict before the prototype is deleted.
 
 `/rite-prototype` is a **scoped detour**, not a phase of its own. Typical placements:
 
-- **Between `/rite-spec` and `/rite-define`** — a design question is undecidable on
+- **Between `/rite-spec` and `/rite-define`:** a design question is undecidable on
   paper; prototype it, capture the answer, return to `/rite-define`.
-- **Mid-build** — `/rite-build` hit a state-model ambiguity that the spec doesn't
+- **Mid-build:** `/rite-build` hit a state-model ambiguity that the spec doesn't
   resolve. Drop into a Logic prototype, capture the answer, return.
 
 After the prototype answers the question and the answer is recorded, return to the

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

@@ -5,13 +5,13 @@ argument-hint: "[feature-slug]"
 user-invocable: true
 ---
 
-# /rite-prove — prove the completed feature
+# /rite-prove: prove the completed feature
 
 Turn "I think it works" into recorded evidence for the **whole feature**. Read the active
 workspace first; if none, run `/rite-spec <feature>`.
 
 > **Differs from built-in `/verify` and `/run`:** those prove a single change /
-> launch the app. `/rite-prove` is feature-scoped — it walks `spec.md` acceptance
+> launch the app. `/rite-prove` is feature-scoped. It walks `spec.md` acceptance
 > criteria one-by-one, runs the full relevant test suite + build/typecheck/lint,
 > ascends the browser-proof ladder (step 4),
 > and writes `evidence.md` + `browser-evidence.md` keyed to the active
@@ -19,7 +19,7 @@ workspace first; if none, run `/rite-spec <feature>`.
 
 ## Gate: all slices must be built first
 Read `tasks.md` + `state.md`. **If ANY slice is still pending/unbuilt, STOP** and tell the
-user to finish it with `/rite-build` — `/rite-prove` runs once, when the full task is
+user to finish it with `/rite-build`: `/rite-prove` runs once, when the full task is
 complete, not after each slice. (Each slice already got its own targeted tests during
 `/rite-build`; this phase is the comprehensive proof of the assembled feature.)
 
@@ -32,22 +32,22 @@ the affected criteria/routes to refresh proof before `/rite-seal`.
 
 ## Rules consulted (read on demand from `.claude/skills/devrites-lib/reference/standards/`)
 Pull these via `Read` when relevant:
-- `testing.md` — pyramid, determinism, no-flake discipline.
-- `test-proof-checklist.md` — compact proof-quality gate for tests and recorded evidence.
-- `browser-proof-checklist.md` — for UI scope, the required browser states and Visual Verdict evidence.
-- `spec-grammar.md` — when the spec uses structured `### Requirement:` / `#### Scenario:`
+- `testing.md`: pyramid, determinism, no-flake discipline.
+- `test-proof-checklist.md`: compact proof-quality gate for tests and recorded evidence.
+- `browser-proof-checklist.md`: for UI scope, the required browser states and Visual Verdict evidence.
+- `spec-grammar.md`: when the spec uses structured `### Requirement:` / `#### Scenario:`
   blocks, each scenario (WHEN/THEN) is one observable behavior to walk and prove.
-- `performance.md` — measure first when perf is in scope.
-- `observability.md` — when the change has a runtime surface (endpoint, job, integration,
+- `performance.md`: measure first when perf is in scope.
+- `observability.md`: when the change has a runtime surface (endpoint, job, integration,
   user flow): telemetry must be present **and observed to emit**, not assumed.
-- `developer-experience.md` — when the change ships a developer-facing surface (API / CLI / SDK /
+- `developer-experience.md`: when the change ships a developer-facing surface (API / CLI / SDK /
   webhook / config / error messages / getting-started): **measure** the DX scorecard (run the flow,
   time time-to-hello-world, capture the verbatim error text), don't assert it.
-- `definition-of-done.md` — standing Done bar: acceptance mapped, fresh proof, no open hard gates, scoped edits, rollback/docs where needed.
+- `definition-of-done.md`: standing Done bar: acceptance mapped, fresh proof, no open hard gates, scoped edits, rollback/docs where needed.
 
 
 ## Operating rules
-- Evidence over confidence. Feature scope only — fix within the feature or record a
+- Evidence over confidence. Feature scope only: fix within the feature or record a
   blocker; don't refactor unrelated code.
 - Spec Drift Guard applies: if tests/evidence reveal the spec is wrong, stop and handle
   drift (`rite-build/reference/spec-drift-guard.md`).
@@ -59,13 +59,13 @@ Pull these via `Read` when relevant:
 1. **Confirm the gate** (all slices built). Read `spec.md` (acceptance criteria +
    "Commands discovered"), `tasks.md`, `state.md`, `test-plan.md` if present (the vetted
    coverage target from `/rite-vet`), and the full `git diff`.
-2. **Discover commands** if not recorded —
+2. **Discover commands** if not recorded:
    [test-command-discovery](reference/test-command-discovery.md): README, package
    scripts, Makefile, CI configs, Gemfile/Rakefile, pyproject, go.mod, Cargo.toml.
    **Completion:** exact runnable test/build/typecheck/lint commands are recorded or explicitly unavailable.
 3. **Run the full relevant test suite** for the feature (not a single slice), then the
    relevant **build / typecheck / lint**.
-4. **UI feature?** Read `design-brief.md` + `references.md`, then run the browser proof ladder over the feature's routes —
+4. **UI feature?** Read `design-brief.md` + `references.md`, then run the browser proof ladder over the feature's routes:
    [proof-ladder](reference/proof-ladder.md) + [browser-proof](reference/browser-proof.md)
    (`devrites-browser-proof`): routes, viewports, screenshots (opened + described),
    console, network, interaction paths, and the brief's proof targets. Compare screenshots
@@ -80,14 +80,14 @@ Pull these via `Read` when relevant:
    `devrites-debug-recovery`. Reproduce → isolate → fix within scope → re-run; if a fix
    would exceed scope, record a blocker.
 7. Update `evidence.md`, `browser-evidence.md` (if UI), `traceability.md`, and
-   `state.md`. New proof goes to `evidence.md` (`proof.md` is a read-only alias —
+   `state.md`. New proof goes to `evidence.md` (`proof.md` is a read-only alias:
    see `devrites-lib/reference/workspace-artifact-schema.md`).
 
-> **Mid-flight discipline.** When tempted to claim an un-observed pass, skip a rung of the browser-proof ladder, or proceed with slices pending — see [`anti-patterns`](reference/anti-patterns.md). Load it the moment you reach for the excuse.
+> **Mid-flight discipline.** When tempted to claim an un-observed pass, skip a rung of the browser-proof ladder, or proceed with slices pending: see [`anti-patterns`](reference/anti-patterns.md). Load it the moment you reach for the excuse.
 
 ## 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-prove/reference/anti-patterns.md

@@ -1,4 +1,4 @@
-# rite-prove — anti-patterns
+# rite-prove: anti-patterns
 
 Load this when standing a non-trivial proof decision, or when tempted to
 report a pass you didn't observe, skip a rung of the browser-proof ladder,
@@ -14,12 +14,12 @@ see [standards/anti-patterns.md](../../devrites-lib/reference/standards/anti-pat
 | "Tests passed during build; that's enough." | Build = per-slice sanity check. Prove = whole-feature suite + build/typecheck/lint + browser. |
 | "Browser proof is overkill for this UI change." | If it's UI and a browser can run, the ladder applies. If you can't, document which rung and why. |
 | "Failure is in pre-existing code, not in this feature." | Still surfaces as a blocker. Feature scope = fix in scope or record + halt. |
-| "Some slices are still pending but the rest can be proved." | No — `/rite-prove` runs once, when every slice is built. Otherwise you're proving a partial system. |
+| "Some slices are still pending but the rest can be proved." | No: `/rite-prove` runs once, when every slice is built. Otherwise you're proving a partial system. |
 
 ## Red Flags
 
-- Reporting "pass" for a command you didn't actually run.
-- Skipping browser-proof rungs 1–3 because rung 4 (project E2E) was easier.
+- Reporting "pass" for a command you didn't run.
+- Skipping browser-proof rungs 1-3 because rung 4 (project E2E) was easier.
 - An acceptance criterion left "unproven" without a corresponding blocker note.
 - Tests recorded green but the diff shows the test file wasn't touched (stale run).
 - About to write `evidence.md` without command + output.

package/pack/generated/claude/skills/rite-prove/reference/browser-proof.md

@@ -1,4 +1,4 @@
-# Browser proof — evidence schema
+# Browser proof: evidence schema
 
 What `browser-evidence.md` must capture for a UI slice. Delegates to
 `devrites-browser-proof`; this is the record contract.
@@ -33,7 +33,7 @@ What `browser-evidence.md` must capture for a UI slice. Delegates to
 ```
 
 ## Rules
-- Open every screenshot path and describe it — never assert from the filename.
+- Open every screenshot path and describe it: never assert from the filename.
 - Read `design-brief.md` + `references.md` first. Compare fidelity only with references
   classified **target**; check constraints as rules and never pixel-match inspiration.
 - Render every proof target named by the brief/slice. At minimum check a small (375) and a

package/pack/generated/claude/skills/rite-prove/reference/failure-triage.md

@@ -4,21 +4,21 @@ When a test/build/runtime/browser check fails, triage before fixing. Delegates t
 loop to `devrites-debug-recovery`.
 
 ## Triage ladder
-1. **Reproduce** — run the failing command again; capture the exact error (quote it).
+1. **Reproduce:** run the failing command again; capture the exact error (quote it).
 2. **Classify** the failure:
    - test is right, code is wrong → fix the code (in scope).
    - test is wrong/outdated → that may be **spec drift** (acceptance criteria wrong).
    - environment/setup (missing dep, wrong node/ruby) → fix setup or record blocker.
    - flaky (passes on re-run, timing/order) → note it; don't paper over with retries.
    - external dependency down → record blocker; don't fake the result.
-3. **Isolate** — minimize to the smallest failing case; bisect the diff if needed.
-4. **Fix within scope** — the current slice/feature only. If the fix reaches outside
+3. **Isolate:** minimize to the smallest failing case; bisect the diff if needed.
+4. **Fix within scope:** the current slice/feature only. If the fix reaches outside
    scope, stop and record a blocker in `state.md` (then `/rite-plan unblock`).
 5. **Re-run** the same command; confirm green; record both attempts in `evidence.md`.
 
 ## Rules
 - Quote the real error text; don't paraphrase it away.
-- Don't loosen/delete a failing assertion to get green — investigate whether it's drift.
+- Don't loosen/delete a failing assertion to get green: investigate whether it's drift.
 - Don't add blanket retries/sleeps to hide flakiness.
 - Three failed fix attempts on the same root cause → escalate: `devrites-debug-recovery`
   for a hypothesis-driven pass, or ask the user.

package/pack/generated/claude/skills/rite-prove/reference/proof-ladder.md

@@ -1,21 +1,21 @@
 # Proof ladder
 
 Prefer real runtime evidence. For UI/browser work, try tools top-down and record which
-rung you used. Detect, don't install — browser tooling setup is the user's call.
+rung you used. Detect, don't install: browser tooling setup is the user's call.
 
 1. **Playwright MCP** (preferred when configured)
    - Detect: the Playwright MCP `browser_*` tools are available (e.g. `browser_navigate`).
      Capabilities: navigation, accessibility-tree snapshots, screenshots, ref-based
      clicks/typing, console messages, network requests, `browser_evaluate`. Drives a
      Playwright-managed browser; detect, don't install.
-2. **Chrome DevTools MCP** (when configured — pairs with Playwright MCP for Lighthouse, the
-   perf trace, and deeper DOM) — screenshots, DOM, console, network, performance,
+2. **Chrome DevTools MCP** (when configured). Pair it with Playwright MCP for Lighthouse, the
+   perf trace, deeper DOM inspection, screenshots, console, network, performance, and the
    accessibility tree.
-3. **Claude Code `/run` and `/verify`** (if available) — launch and observe the app;
+3. **Claude Code `/run` and `/verify`** (if available): launch and observe the app;
    prefer a project-specific run/verify skill if one exists.
-4. **Project-native E2E** (only if already present) — Playwright, Cypress, Capybara,
+4. **Project-native E2E** (only if already present). Playwright, Cypress, Capybara,
    Selenium. Use the project's existing commands; don't add a new framework.
-5. **Manual fallback** — no tooling available: record the limitation and write exact
+5. **Manual fallback:** no tooling available: record the limitation and write exact
    manual steps (route, action, expected result).
 
 ## Non-UI scope

package/pack/generated/claude/skills/rite-prove/reference/test-command-discovery.md

@@ -12,7 +12,7 @@ these sources, in roughly this order of authority:
 | `pyproject.toml` / `tox.ini` / `noxfile.py` | `pytest`, `tox`, `nox` |
 | `go.mod` | `go test ./...`, `go build ./...`, `go vet` |
 | `Cargo.toml` | `cargo test`, `cargo build`, `cargo clippy` |
-| CI configs (`.github/workflows`, `.gitlab-ci.yml`, `circleci`) | the exact commands CI runs — the source of truth for "green" |
+| CI configs (`.github/workflows`, `.gitlab-ci.yml`, `circleci`) | the exact commands CI runs: the source of truth for "green" |
 | README / CONTRIBUTING | documented dev/test workflow |
 | framework conventions | Rails/Django/Next/etc. defaults when nothing else is set |
 

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

@@ -5,7 +5,7 @@ argument-hint: "<what to change>"
 user-invocable: true
 ---
 
-# /rite-quick — express lane for small changes
+# /rite-quick: express lane for small changes
 
 The full DevRites lifecycle is right for real features; it is **ceremony** for a typo, a
 copy tweak, a one-function fix, or a small config change. `/rite-quick` keeps the
@@ -15,39 +15,39 @@ executable, not advisory.
 
 ## The significance gate (the whole safety story)
 
-**Run this first. If ANY of these holds, STOP and route to `/rite-spec` — do NOT use the
+**Run this first. If ANY of these holds, STOP and route to `/rite-spec`. Do NOT use the
 express lane:**
 - Touches **auth / authz**, a **data migration**, a **public API contract**, or any
-  **destructive / data-loss** path (the irreversible-risk list — `standards/afk-hitl.md`).
+  **destructive / data-loss** path in the irreversible-risk list. See `standards/afk-hitl.md`.
 - Spans **more than one vertical slice**, or more than a couple of files of real logic.
-- **Ambiguous scope** — you'd have to guess what "done" means, or the ask hides a design
+- **Ambiguous scope:** you'd have to guess what "done" means, or the ask hides a design
   decision (data model, new dependency, second design system).
 - Security-sensitive input handling, or a measurable performance-critical path.
 - Would **break a declared project principle** (`.devrites/principles.md`) with no recorded,
-  human-approved exception — the express lane never relaxes a project gate; a needed exception is
+  human-approved exception: the express lane never relaxes a project gate; a needed exception is
   a deliberate human decision, so route it to `/rite-spec`.
 
 If none hold, the change is small + reversible + unambiguous → proceed. **When in doubt,
-escalate** — the cost of the full lifecycle on a small change is minutes; the cost of the
+escalate**: the cost of the full lifecycle on a small change is minutes; the cost of the
 express lane on a risky one is the failure mode the lifecycle exists to prevent.
 
 ## Rules consulted
 Load this lane's conditional standards when needed:
-- `coding-style.md` — naming, guard clauses, reuse-first.
-- `testing.md` — TDD, **completeness** (every touched behavior/element asserted) +
+- `coding-style.md`: naming, guard clauses, reuse-first.
+- `testing.md`: TDD, **completeness** (every touched behavior/element asserted) +
   **assertion strength** (no tautological tests; see it fail first), scaled to the change.
-- `error-handling.md` / `security.md` — only if the change touches input/errors.
-- `principles.md` — when `.devrites/principles.md` exists; a change that breaks an invariant is a gate, not a quick fix.
-- `definition-of-done.md` — standing Done bar: acceptance mapped, fresh proof, no open hard gates, scoped edits, rollback/docs where needed.
+- `error-handling.md` / `security.md`: only if the change touches input/errors.
+- `principles.md`: when `.devrites/principles.md` exists; a change that breaks an invariant is a gate, not a quick fix.
+- `definition-of-done.md`: standing Done bar: acceptance mapped, fresh proof, no open hard gates, scoped edits, rollback/docs where needed.
 
 
 ## Workflow
 0. **Orient.** Read `core.md`. If a `.devrites/` workspace is active, run the preamble to
    see it; `/rite-quick` does **not** require one and does **not** create the full tree.
 1. **Significance gate** (above). Fail → STOP, tell the user to run `/rite-spec <feature>`.
-2. **One-line contract.** Restate in 1–3 lines: the change, its **acceptance** (how you'll
+2. **One-line contract.** Restate in 1-3 lines: the change, its **acceptance** (how you'll
    know it works), and the **scope boundary** (what you will NOT touch). This is the entire
-   "spec + plan" for a quick change — keep it in the chat; optionally drop a `brief.md` +
+   "spec + plan" for a quick change: keep it in the chat; optionally drop a `brief.md` +
    `evidence.md` under `.devrites/work/<slug>/` if the user wants a record. This is the
    `/rite-frame` FRAME move: if the acceptance won't reduce to a check that could be *false*,
    the ask is ambiguous → escalate per the significance gate. Its AUDIT pass is the diff
@@ -59,15 +59,15 @@ Load this lane's conditional standards when needed:
 4. **Prove (scoped).** Run the **targeted** tests + typecheck / lint for what changed (not
    the whole suite) → green. Record the command + output. A tautological test that can't
    fail is not proof.
-5. **Review-lite + ship.** Self-review the diff (correctness, scope, idiom, and — if
-   `.devrites/principles.md` exists — no declared invariant broken; this is `/rite-frame`'s AUDIT
-   pass — one pass, no subagent fan-out). Show the diff, then on the user's confirm commit it
-   (Conventional Commits, atomic) — or hand to `/rite-ship` if a workspace is active. **Never push
+5. **Review-lite + ship.** Self-review the diff for correctness, scope, and idiom. If
+   `.devrites/principles.md` exists, confirm that no declared invariant is broken. This is
+   `/rite-frame`'s AUDIT pass: one pass, no subagent fan-out. Show the diff, then on the user's confirm commit it
+   (Conventional Commits, atomic), or hand to `/rite-ship` if a workspace is active. **Never push
    without the user asking.**
 
-## Escalation (mid-flight) — the Spec Drift Guard still applies
-If the "small" change turns out to be not small — a second slice appears, a real design
-decision surfaces, scope grows past the boundary, or you hit an irreversible-risk item —
+## Escalation (mid-flight): the Spec Drift Guard still applies
+If the "small" change turns out to be not small: a second slice appears, a real design
+decision surfaces, scope grows past the boundary, or you hit an irreversible-risk item:
 **STOP, say so, and route to `/rite-spec` / `/rite-define`**. Don't quietly grow a quick
 fix into an unreviewed feature; that's the exact drift the lifecycle guards against.
 
@@ -89,5 +89,5 @@ Record: <commit/PR path | .devrites/work/<slug>/evidence.md | not applicable>
 If the quick boundary does not hold or an escalation remains, use `Stopped / blocked`
 and route to the full lifecycle; do not render `Done`.
 
-**DO NOT** use this lane to dodge the gate — the express lane is for changes that are
-*actually* small, not for shipping risky work faster.
+**DO NOT** use this lane to dodge the gate: the express lane is for changes that are
+genuinely small, not for shipping risky work faster.

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

@@ -6,13 +6,13 @@ user-invocable: true
 disable-model-invocation: true
 ---
 
-# /rite-resolve — answer the human gate
+# /rite-resolve: answer the human gate
 
-`/rite-resolve` is the canonical resume verb for **async** human gates — a checkpoint that
+`/rite-resolve` is the canonical resume verb for **async** human gates: a checkpoint that
 already paused and **stopped the session** (an AFK blocking/escalating/irreversible queue, or a
 HITL pause the human walked away from), plus `--batch`. When `/rite-build` asks a gap **inline**
 via `AskUserQuestion` and the human is present, that pick resolves the gate **in place** through
-the same `devrites-engine resolve` writer — you don't type `/rite-resolve` for it. For the async case this
+the same `devrites-engine resolve` writer. You don't type `/rite-resolve` for it. For the async case this
 skill takes the human's answer (or `--drop` / `--batch`), writes it to `questions.md`, updates
 `state.md` (clears `Awaiting human`, sets `Status: running`), and recommends the next command.
 
@@ -24,8 +24,8 @@ It is **deliberately small**: one verb, one source of truth (`questions.md`), on
 
 Pull these via `Read` when shaping the resolve:
 
-- `afk-hitl.md` — gate taxonomy, `questions.md` schema, AFK exception rules.
-- `documentation.md` — record decisions and rationale where the answer changes scope.
+- `afk-hitl.md`: gate taxonomy, `questions.md` schema, AFK exception rules.
+- `documentation.md`: record decisions and rationale where the answer changes scope.
 
 ## Operating rules
 
@@ -37,16 +37,16 @@ Pull these via `Read` when shaping the resolve:
   `dropped`, refuse with the existing answer; ask the user to open a new qid that
   references the old one (the file is the audit trail).
 - **If the answer materially changes scope, architecture, or acceptance**, route it
-  through the Spec Drift Guard (`/rite-plan repair`) **after** writing the answer — do
+  through the Spec Drift Guard (`/rite-plan repair`) **after** writing the answer: do
   not modify `spec.md` / `plan.md` inside this skill.
 - **The script is the source of truth.** Always invoke
-  `devrites-engine resolve` — it keeps `questions.md` + `state.md` consistent and emits the
+  `devrites-engine resolve`. It keeps `questions.md` + `state.md` consistent and emits the
   next-action recommendation. The one `state.md` field this skill may write by hand is the
   unblocked slice's `Slice mode` (step 4, the named exception); everything else goes through
   the script, never by hand.
 - **Human gates are for human-only decisions, not the agent's work.** A `questions.md` entry the
-  human must answer is a genuine *decision* (a scope / design / risk call only the human can make)
-  — not a task the agent can do itself. If a question is really agent-doable ("should I write the
+  human must answer is a genuine *decision* (a scope / design / risk call only the human can make).
+  Not a task the agent can do itself. If a question is really agent-doable ("should I write the
   test?", "go implement X"), don't record a human answer that punts the agent's own job back to it:
   flag the mis-tag and route it to the right skill (`/rite-build`, `/rite-plan unblock`,
   `devrites-debug-recovery`). The human resolves decisions; the agent does the work.
@@ -57,16 +57,16 @@ Pull these via `Read` when shaping the resolve:
    touching the workspace.
    Then run `devrites-engine preamble` for deterministic workspace orientation.
 1. **Parse arguments.** `$ARGUMENTS` is one of:
-   - `<qid> "<answer>"` — answer the single open question.
-   - `--drop <qid>` (optional `"<reason>"`) — mark the question `dropped`; record
+   - `<qid> "<answer>"`: answer the single open question.
+   - `--drop <qid>` (optional `"<reason>"`): mark the question `dropped`; record
      the reason inline.
-   - `--batch <path-to-yaml>` — bulk resolve, one entry per qid (see
+   - `--batch <path-to-yaml>`: bulk resolve, one entry per qid (see
      [`reference/answer-protocol.md`](reference/answer-protocol.md) for the batch
      format).
 2. **Load context.** Read `state.md`, `questions.md`, and the relevant slice from
    `tasks.md`. Confirm the qid is `status: open`. If `state.md` `Status` is not
    `awaiting_human` and the question's `gate` is `blocking`, surface the inconsistency
-   before proceeding (don't auto-repair — flag it).
+   before proceeding (don't auto-repair: flag it).
 3. **Render preview.** Echo the qid, the question, the proposed answer (if any), the
    user's answer, and which slice unblocks. Stop here and ask `confirm? (y/N)` **unless**
    the answer was provided non-interactively via `--batch`.
@@ -85,17 +85,17 @@ Pull these via `Read` when shaping the resolve:
    recommend `/rite-plan repair`. Otherwise → recommend the slice's natural next action
    (typically `/rite-build` for the slice that was awaiting).
    **Completion:** the resolved state contains exactly one next command.
-6. **STOP.** This skill does not run `/rite-build` itself — the user re-enters the
+6. **STOP.** This skill does not run `/rite-build` itself: the user re-enters the
    workflow explicitly.
 
 > **Mid-flight discipline.** Don't edit `spec.md` / `plan.md` to "incorporate" the
-> answer — that's `/rite-plan repair`. Don't silently retry a build after the answer
-> lands — the user types the next command. Don't merge two open questions into one
-> answered entry — each question is independently auditable.
+> answer. That's `/rite-plan repair`. Don't silently retry a build after the answer
+> lands: the user types the next command. Don't merge two open questions into one
+> answered entry: each question is independently auditable.
 
 ## 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-resolve/reference/answer-protocol.md

@@ -1,4 +1,4 @@
-# Answer protocol — how `/rite-resolve` mutates the workspace
+# Answer protocol: how `/rite-resolve` mutates the workspace
 
 `/rite-resolve` is the single canonical writer for `questions.md` `status` flips and
 `state.md` `Awaiting human` clearance. This file is the reference for the three input
@@ -22,7 +22,7 @@ shapes, the batch file format, and the rules the underlying `devrites-engine res
 /rite-resolve --drop q-2026-05-28-002 "merged into q-...-003 after we narrowed the scope"
 ```
 
-- A drop is **not** an answer — it removes the question from the active queue without
+- A drop is **not** an answer. It removes the question from the active queue without
   recording a decision. Use it when the question is obsolete, a duplicate, or absorbed
   by a re-plan.
 - The reason is an optional single trailing string, **strongly recommended** for the
@@ -45,7 +45,7 @@ q-2026-05-28-002: clinician sign-off required at runtime, not at plan time
 ```
 
 - One qid per line. The first colon is the separator; the rest of the line is the value.
-- Order matters only for `state.md` clearance — the script processes top-to-bottom and
+- Order matters only for `state.md` clearance: the script processes top-to-bottom and
   flushes `Awaiting human` after each match.
 - Errors abort the batch at the first failing line so partial state is small and
   diagnosable. (Re-run after fixing the offending line; already-applied lines refuse to
@@ -54,7 +54,7 @@ q-2026-05-28-002: clinician sign-off required at runtime, not at plan time
 ## Never overwrite
 
 A qid that is already `answered` or `dropped` refuses to be re-resolved. The audit trail
-is the file — you do not edit history. If the original answer was wrong:
+is the file. You do not edit history. If the original answer was wrong:
 
 1. Open a new qid (the agent will, during the next `/rite-build` if the bad answer
    re-surfaces; or you write it manually).
@@ -76,7 +76,7 @@ Both terminals stamp `answered_at: <iso>` and write the answer/reason to `answer
 
 ## `state.md` clearance rules
 
-`state.md`'s `Awaiting human` block is **single-question by default** — `/rite-build`
+`state.md`'s `Awaiting human` block is **single-question by default**: `/rite-build`
 writes one block at a time and pauses. When `/rite-resolve` matches the block's qid:
 
 - the entire `Awaiting human` block is removed (header + fields);
@@ -88,7 +88,7 @@ qid (drift between the two files), `/rite-resolve` flags the inconsistency and r
 to silently fix it. Use `/rite-plan repair` to reconcile.
 
 If the answer materially changes spec/plan, **do not** edit `spec.md` or `plan.md` inside
-`/rite-resolve` — that's `/rite-plan repair`'s job. The skill's post-resolve hand-off
+`/rite-resolve`. That's `/rite-plan repair`'s job. The skill's post-resolve hand-off
 recommends `/rite-plan repair` whenever the answer touches acceptance criteria, scope,
 or architecture.
 
@@ -101,7 +101,7 @@ If a future evolution lets `/rite-build` queue multiple questions per pause, the
 - leave the rest of the list intact;
 - flip `Status: running` only when the list is empty.
 
-This shape is reserved — current `/rite-build` writes one question per pause.
+This shape is reserved: current `/rite-build` writes one question per pause.
 
 ## Why no auto-`/rite-build` after resolve