devrites 3.0.4 → 3.0.6

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

@@ -5,19 +5,19 @@ argument-hint: "[task to frame | diff to audit]"
 user-invocable: true
 ---
 
-# /rite-frame — frame the goal, audit the diff
+# /rite-frame: frame the goal, audit the diff
 
 LLMs reliably get four things wrong: they **assume** silently, **overcomplicate**, edit
 **out of scope**, and run on an **unverifiable** "make it work". The full DevRites
 lifecycle catches all four at its gates (spec readiness, the Spec Drift Guard,
 `touched-files.md` + `devrites-engine reconcile`, `/rite-seal`). But the express lane and plain
-"just do X" requests **skip those gates** — and a raw diff has no gate at all.
+"just do X" requests **skip those gates**, and a raw diff has no gate at all.
 
 `rite-frame` is the gate's reflex made portable. Two moves, no workspace required:
 
-- **FRAME** (before code) — turn the imperative ask into a falsifiable success criterion
+- **FRAME** (before code): turn the imperative ask into a falsifiable success criterion
   and the command that proves it. *"Give it success criteria and watch it go."*
-- **AUDIT** (after the change) — read the diff against the four failure modes; route each
+- **AUDIT** (after the change): read the diff against the four failure modes; route each
   finding to the DevRites cure that already exists for it.
 
 It is a self-applied lens, not a subagent and not a phase. Light enough to run at the top
@@ -34,51 +34,51 @@ an adversarial second read (`devrites-doubt`) · a fresh-context axis review of
 feature (`devrites-audit <security|perf|simplify>`) · the final GO/NO-GO (`/rite-seal`).
 rite-frame is the *inline* reflex; those are the *gates*. Don't use it to dodge one.
 
-## FRAME — before you touch code
+## FRAME: before you touch code
 
 Restate the ask as a check, not a chore. Convert the verb into a condition that can be
 **false**:
 
 | Imperative ask | Falsifiable success criterion |
 |---|---|
-| "Add validation" | "Inputs `{empty, oversize, wrong-type}` are rejected with a 4xx + message — a test asserts each, and fails today." |
-| "Fix the bug" | "A test reproduces the bug (red now), and turns green after the fix — nothing else changes." |
+| "Add validation" | "Inputs `{empty, oversize, wrong-type}` are rejected with a 4xx + message: a test asserts each, and fails today." |
+| "Fix the bug" | "A test reproduces the bug (red now), and turns green after the fix: nothing else changes." |
 | "Make it faster" | "Operation X drops from `<measured baseline>` to `<target>` on `<named benchmark>`." |
 | "Refactor X" | "The existing suite is green before and after; behavior is byte-identical." |
 | "Clean this up" | *(no falsifiable criterion → the ask is ambiguous → mode 1 → ask what "clean" means, or route to `/rite-spec`)* |
 
 Checklist (copy it):
 
-- [ ] **Criterion** — one sentence: *"Done WHEN `<observable, falsifiable check>`."* If you
-      can't write one that could be false, the ask is ambiguous — **stop, name it, ask** (that
+- [ ] **Criterion**: one sentence: *"Done WHEN `<observable, falsifiable check>`."* If you
+      can't write one that could be false, the ask is ambiguous: **stop, name it, ask** (that
       is failure mode 1, surfaced early instead of after the diff).
-- [ ] **Verify command** — the exact test / build / runtime / screenshot that decides it.
+- [ ] **Verify command**: the exact test / build / runtime / screenshot that decides it.
       No command → no proof → you're about to confidence-assert. Name it now.
-- [ ] **Scope boundary** — the files/areas you will **not** touch. Anything outside is mode 3.
-- [ ] **Loop** — with a falsifiable criterion you can iterate to green unattended; with a weak
+- [ ] **Scope boundary**: the files/areas you will **not** touch. Anything outside is mode 3.
+- [ ] **Loop**, with a falsifiable criterion you can iterate to green unattended; with a weak
       one ("make it work") you'll need the user every few minutes. Sharpen the criterion until
       it can drive the loop.
 
-## AUDIT — after the change
+## AUDIT: after the change
 
 Read the diff (or `$ARGUMENTS`) against the four modes. One line per finding, severity-tagged
 (`Critical / Important / Suggestion / Nit / FYI`), each routed to its existing cure. Full
 map + worked examples: [`reference/failure-modes.md`](reference/failure-modes.md).
 
-- [ ] **1 · Silent assumption** — did I pick one reading of an ambiguous ask and run with it?
+- [ ] **1 · Silent assumption**: did I pick one reading of an ambiguous ask and run with it?
       Any value, contract, or behavior I *guessed*? → surface it; route material ones through
       the Spec Drift Guard (`core.md` #2/#3).
-- [ ] **2 · Overcomplication** — an abstraction / flag / indirection nobody asked for? 200 lines
+- [ ] **2 · Overcomplication**: an abstraction / flag / indirection nobody asked for? 200 lines
       where 50 would do? A defensive check inside trusted code? → apply the **deletion test**;
       simplify (`coding-style.md`, `patterns.md`, `devrites-audit simplify`).
-- [ ] **3 · Out-of-scope edit** — did I touch code, comments, or formatting outside the ask?
+- [ ] **3 · Out-of-scope edit**: did I touch code, comments, or formatting outside the ask?
       "While I'm here" refactors? → revert to the boundary; record the rest as an FYI follow-up
       (`core.md` #7, `touched-files.md`).
-- [ ] **4 · Unverifiable goal** — is there a command that proves this, run, with output? Or am
+- [ ] **4 · Unverifiable goal**: is there a command that proves this, run, with output? Or am
       I asserting "it works"? Tautological test that can't fail? → run the FRAME verify command;
       record command + output (`testing.md`, evidence-over-confidence).
-- [ ] **Principle check** — if `.devrites/principles.md` exists, does the change break a declared
-      invariant? A violation with no recorded, human-approved exception is a **Critical** — the
+- [ ] **Principle check**, if `.devrites/principles.md` exists, does the change break a declared
+      invariant? A violation with no recorded, human-approved exception is a **Critical**: the
       express lane is not a way around a project gate; escalate it, don't ship it (`principles.md`).
 
 The test for each changed line: **it traces directly to the criterion, and the criterion can
@@ -87,10 +87,10 @@ be proven false.** A line that fails either is a finding.
 ## Escalation
 
 If FRAME can't produce a falsifiable criterion, or AUDIT surfaces a mode-1 / mode-3 issue that
-is actually a hidden design decision (new dependency, data model, second design system, an
+is a hidden design decision (new dependency, data model, second design system, an
 auth/migration/public-API touch), or a **declared-principle violation** with no recorded
 exception → **STOP and route to `/rite-spec`** (a needed exception is a human-approved decision,
-not an inline call). Same drift guard the express lane enforces — don't quietly grow an unframed
+not an inline call). Same drift guard the express lane enforces: don't quietly grow an unframed
 ask into unreviewed work.
 
 ## Rules
@@ -99,7 +99,7 @@ ask into unreviewed work.
   active feature use `devrites-audit`.
 - FRAME before code, AUDIT after. Running AUDIT without having framed the criterion first means
   mode 4 has nothing to check against.
-- A criterion that can't be false isn't a criterion — it's a wish. Rewrite it or ask.
+- A criterion that can't be false isn't a criterion. It's a wish. Rewrite it or ask.
 - Feature/ask scope only. Out-of-scope findings become FYI follow-ups, never silent fixes.
 
 ## Output

package/pack/.claude/skills/rite-frame/reference/failure-modes.md

@@ -1,28 +1,28 @@
-# The four failure modes — mapped to their DevRites cure
+# The four failure modes: mapped to their DevRites cure
 
 The lens behind `rite-frame`. Each mode is a thing LLMs reliably get wrong; each already
 has a cure somewhere in the pack. The value of naming them here is a **portable
-vocabulary** — a fast self-check you can run on ad-hoc or express-lane work that never
+vocabulary**: a fast self-check you can run on ad-hoc or express-lane work that never
 reaches the gates where those cures normally fire.
 
 ## The map
 
 | # | Failure mode | The tell in a diff / a reply | Cure already in the pack |
 |---|---|---|---|
-| 1 | **Silent assumption** | A value, contract, edge case, or interpretation was *guessed* and run with — no note, no question. The ask had two readings and one was picked silently. | `core.md` #2 (no silent assumptions) / #3 (no guessing through confusion); the Spec Drift Guard; `devrites-doubt` for a single high-stakes call; `devrites-interview` when the ask is underspecified. |
+| 1 | **Silent assumption** | A value, contract, edge case, or interpretation was *guessed* and run with: no note, no question. The ask had two readings and one was picked silently. | `core.md` #2 (no silent assumptions) / #3 (no guessing through confusion); the Spec Drift Guard; `devrites-doubt` for a single high-stakes call; `devrites-interview` when the ask is underspecified. |
 | 2 | **Overcomplication** | An abstraction, flag, config knob, or indirection nobody asked for. 200 lines where 50 would do. A single-use factory. Defensive `try/catch` + null checks inside trusted code. A dependency added where an in-repo option exists. | `coding-style.md` (simplicity, reuse-first), `patterns.md` (avoid over-engineering), `devrites-audit simplify` (deletion test, Chesterton's Fence), the "over-defensive guarding is slop" anti-pattern. |
 | 3 | **Out-of-scope edit** | Touched code, comments, or formatting outside the ask. A "while I'm here" refactor. Renamed something orthogonal. Reflowed an import block. | `core.md` #7 (feature scope only), `touched-files.md` (the recorded diff boundary), `devrites-engine reconcile` (hard-stops a source file changed outside the claimed set), the "it's only a small refactor" anti-pattern. |
 | 4 | **Unverifiable goal** | "It works" with no command, no output, no test. A success criterion that can't be false ("make it better"). A tautological test that passes no matter what. | `rite-spec/reference/acceptance-criteria.md` (measurable acceptance), `core.md` #6 (evidence over confidence), `testing.md` (assertion strength, see it fail first), the TDD wright. |
 
-The first three are the **diseases** Karpathy named; the fourth is the **leverage** — a
+The first three are the **diseases** Karpathy named; the fourth is the **leverage**: a
 falsifiable criterion is what lets the model loop to done without a human in the loop every
-few minutes. FRAME front-loads mode 4 so the AUDIT of modes 1–3 has something to check
+few minutes. FRAME front-loads mode 4 so the AUDIT of modes 1-3 has something to check
 against.
 
 ## FRAME: the imperative → falsifiable reframe
 
 The move is to rewrite the *verb* as a *condition that can be false*. If you can't, the ask
-is ambiguous — that's mode 1, caught before the diff instead of after.
+is ambiguous. That's mode 1, caught before the diff instead of after.
 
 | Imperative ask | Weak (still a wish) | Falsifiable criterion + verify |
 |---|---|---|
@@ -38,7 +38,7 @@ pass or fail without asking you what you meant. If they'd have to ask, sharpen i
 
 ## AUDIT: worked finding lines
 
-Findings read like the rest of the pack — one line, severity-tagged, cite `file:line`, route
+Findings read like the rest of the pack: one line, severity-tagged, cite `file:line`, route
 to the cure. Severity ladder is the pack standard (`Critical / Important / Suggestion / Nit /
 FYI`).
 
@@ -49,20 +49,20 @@ utils.ts:5  FYI        mode 3 (scope): reflowed an unrelated import block. → r
 sum.spec:12 Important  mode 4 (unverifiable): test asserts `mock.called`, not the result — passes if the fn is empty. → assert the value; see it fail first (testing.md).
 ```
 
-Clean lanes say so explicitly — `1 assumption: clean` — so the audit is a positive
+Clean lanes say so explicitly (`1 assumption: clean`) so the audit is a positive
 statement, not a silent skip.
 
 ## How this differs from the heavier tools (so you don't reach past it)
 
-- **`devrites-doubt`** — adversarial *fresh-context subagent* pre-mortem on **one** decision.
+- **`devrites-doubt`:** adversarial *fresh-context subagent* pre-mortem on **one** decision.
   Heavier, independent, anti-anchoring. rite-frame is *self-applied* and covers the four modes
   broadly; escalate a single load-bearing claim to doubt.
-- **`devrites-audit <axis>`** — *fresh-context subagent* review of an **active feature's** diff
+- **`devrites-audit <axis>`:** *fresh-context subagent* review of an **active feature's** diff
   on one axis (security / perf / simplify). Needs a `.devrites/` workspace. rite-frame needs no
-  workspace and runs in your own context — cheaper, less independent.
-- **`/rite-review` · `/rite-seal`** — the **gates**: parallel reviewer fan-out, blocking
+  workspace and runs in your own context: cheaper, less independent.
+- **`/rite-review` · `/rite-seal`:** the **gates**: parallel reviewer fan-out, blocking
   severities, written verdict. rite-frame is the inline reflex for work that never reaches a
   gate; it does not replace one. If the work is a real feature, the gate is the answer.
 
-The point is not redundancy — it's a tiered ladder. rite-frame is the cheapest rung: a lens
+The point is not redundancy. It's a tiered ladder. rite-frame is the cheapest rung: a lens
 you run yourself in seconds. Climb to doubt / audit / the gates as the stakes rise.

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

@@ -6,14 +6,14 @@ disable-model-invocation: true
 argument-hint: "[what the next session will focus on]"
 ---
 
-# /rite-handoff — chat-only context, into a fresh-agent doc
+# /rite-handoff: chat-only context, into a fresh-agent doc
 
 DevRites' workspace `.devrites/work/<slug>/` already captures everything that *should*
 persist (spec, plan, tasks, decisions, evidence, drift, review). This skill captures
-what the **chat** is holding that is **not** in the workspace, so a fresh agent — or
-the same user after `/clear` — can pick the work up without re-reading the transcript.
+what the **chat** is holding that is **not** in the workspace, so a fresh agent (or
+the same user after `/clear`) can pick the work up without re-reading the transcript.
 
-Read `.claude/skills/devrites-lib/reference/standards/core.md` first — its "Persistence before stopping" discipline is
+Read `.claude/skills/devrites-lib/reference/standards/core.md` first: its "Persistence before stopping" discipline is
 exactly what this skill executes. The other rule files load on demand.
 
 Then run `devrites-engine preamble` for deterministic workspace orientation.
@@ -25,7 +25,7 @@ Then run `devrites-engine preamble` for deterministic workspace orientation.
 - **No active feature** → OS temp dir (`$TMPDIR` / `/tmp` / `%TEMP%`) as
   `rite-handoff-<ISO-timestamp>.md`. Print the absolute path after writing.
 
-## Before you write — sync, don't duplicate
+## Before you write: sync, don't duplicate
 
 For each of these, write the content into its **canonical home** first, then merely
 *note* in the handoff that the sync happened:
@@ -51,20 +51,20 @@ themselves. The workspace is the canonical store; the handoff is the chat-only d
    to the named focus. Where you were mid-thought, **quote the most recent next-step
    verbatim** from the chat (the exact sentence describing what to do next) so no nuance
    is lost to paraphrase.
-2. **What just happened in this chat** (3–5 bullets). Distil — do not transcribe.
+2. **What just happened in this chat** (3-5 bullets). Distil: do not transcribe.
 3. **External references** that exist only in chat: URLs, Figma links, screenshot paths,
    video timestamps the user pasted. List as references; do not embed.
 4. **Live assumptions the agent is acting on** that the workspace doesn't reflect yet
-   (after the sync above, this section should be near-empty — flag anything that
+   (after the sync above, this section should be near-empty: flag anything that
    remains).
-5. **How to resume** — fixed boilerplate (see template below).
+5. **How to resume:** fixed boilerplate (see template below).
 
 ## What NOT to include
 
 - Anything already in `spec.md`, `plan.md`, `tasks.md`, `state.md`, `decisions.md`,
-  `evidence.md`, `review.md` — link by path instead.
-- `git diff` output — the next agent runs `git diff` themselves.
-- The full conversation transcript — distil.
+  `evidence.md`, `review.md`: link by path instead.
+- `git diff` output: the next agent runs `git diff` themselves.
+- The full conversation transcript: distil.
 - Secrets (API keys, tokens, PII, credentials). Redact aggressively.
 - **New ideas the user didn't confirm.** A handoff records what *happened* and what's *next*.
   Leave out fresh suggestions, scope the user didn't agree to, and redesigns you thought of. Capture
@@ -90,7 +90,7 @@ Record: <absolute path to handoff.md>
 Print the absolute path in `Record:` so the user or next agent can open it without searching.
 
 ## Session hygiene
-Close with the one-line hygiene advisory + the single resume command — this skill *is* the
+Close with the one-line hygiene advisory + the single resume command. This skill *is* the
 pre-`/clear` bridge, so it's where the advisory matters most (`context-hygiene.md`):
 ```
 ↻ Hygiene: /clear

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

@@ -6,10 +6,10 @@ user-invocable: true
 disable-model-invocation: true
 ---
 
-# /rite-learn — the cross-feature learning loop
+# /rite-learn: the cross-feature learning loop
 
 Recurring corrections, dismissed review findings, timeline decisions, and health dips are durable
-signal. **Capture is automatic** — `/rite-seal` appends lessons to `.devrites/learnings.md` on every
+signal. **Capture is automatic**: `/rite-seal` appends lessons to `.devrites/learnings.md` on every
 GO (step 9a), while the engine can keep `.devrites/timeline.jsonl`,
 `.devrites/health-history.jsonl`, and per-feature review fingerprints as supporting evidence. The
 review skills load the learning ledger **before** a fan-out, so a dismissed-finding class stops
@@ -17,22 +17,22 @@ being re-flagged without anyone running a command. The system learns as it ships
 
 `/rite-learn` is the periodic **review + promote** pass on that auto-populated ledger: cluster the
 signal across features and decide which recurring lessons graduate into a project rule. **Propose,
-never impose** — promotion is the human's call, which is why it stays a deliberate command rather
+never impose**: promotion is the human's call, which is why it stays a deliberate command rather
 than firing on its own.
 
 Read-mostly. It reads the auto-populated ledger + the archive; it writes only `.devrites/learnings.md`
-(consolidation, via `devrites-engine learnings`) and drafts proposed rule/ledger edits for the user to confirm —
+(consolidation, via `devrites-engine learnings`) and drafts proposed rule/ledger edits for the user to confirm:
 it never edits source or rule files on its own.
 
 ## Modes
 
-- `/rite-learn` or `/rite-learn --mine` — **mine + propose** (the default).
-- `/rite-learn "<lesson>"` — **record one lesson** directly to the ledger and stop.
+- `/rite-learn` or `/rite-learn --mine`: **mine + propose** (the default).
+- `/rite-learn "<lesson>"`: **record one lesson** directly to the ledger and stop.
 
 ## Workflow (mine + propose)
 
 1. **Gather the signal.** Start from the **auto-populated ledger** `.devrites/learnings.md` (seal
-   appends to it on every GO — step 9a), then run `devrites-engine learnings mine` over the archive (it clusters
+   appends to it on every GO: step 9a), then run `devrites-engine learnings mine` over the archive (it clusters
    repeated finding / decision / drift phrases across shipped
    features) to surface cross-feature patterns the per-feature entries don't show on their own:
    ```bash
@@ -42,38 +42,38 @@ it never edits source or rule files on its own.
    `.devrites/work/*/review-fingerprints.jsonl` as supporting evidence when they exist; do not
    promote from those traces without the same repeated-feature threshold.
 2. **Cluster + name.** Group the recurring corrections into candidate lessons. A candidate needs
-   **≥2 occurrences across distinct features** — one-offs are noise, not a pattern. Name the
+   **≥2 occurrences across distinct features**: one-offs are noise, not a pattern. Name the
    pattern in one specific sentence (the specificity rule from `prose-style.md` applies: a lesson
    you could swap onto any project says nothing).
    **Completion:** every candidate cites two distinct features, except a single deliberate
    rejected direction with its durable reason.
 3. **Classify each candidate** into its durable home:
-   - **project rule** — a craft/standard that belongs in a `.claude/skills/devrites-lib/reference/standards/*` file or `CLAUDE.md`.
-   - **project principle** — a recurring correction that is really a *non-negotiable invariant*
+   - **project rule:** a craft/standard that belongs in a `.claude/skills/devrites-lib/reference/standards/*` file or `CLAUDE.md`.
+   - **project principle:** a recurring correction that is really a *non-negotiable invariant*
      (not just an idiom or a craft standard): graduate it to `.devrites/principles.md`
-     ([`principles.md`](../devrites-lib/reference/standards/principles.md)). This is the **trusted, gating** layer — higher
-     stakes than a rule — so `/rite-learn` **drafts** the principle + a dated Governance entry for
+     ([`principles.md`](../devrites-lib/reference/standards/principles.md)). This is the **trusted, gating** layer (higher
+     stakes than a rule) so `/rite-learn` **drafts** the principle + a dated Governance entry for
      the human to confirm; it never writes a principle silently.
-   - **conventions-ledger entry** — a proven project idiom for `.devrites/conventions.md`.
-   - **dismissed-finding class** — a pattern reviewers keep flagging that is *intentional here*;
+   - **conventions-ledger entry:** a proven project idiom for `.devrites/conventions.md`.
+   - **dismissed-finding class:** a pattern reviewers keep flagging that is *intentional here*;
      recording it stops the recurring false positive (`learnings.md`, loaded pre-fan-out).
-   - **rejected direction** — an approach or product direction weighed and ruled out with a
+   - **rejected direction:** an approach or product direction weighed and ruled out with a
      reason that outlives one feature; recording it (tag `rejected-direction`) stops ideation
      skills (`/rite-pressure-test`, `/rite-pov`) from re-proposing it. Exempt from the
-     ≥2-occurrence rule — one deliberate rejection is the whole pattern.
-   - **drop** — not durable; let it go.
+     ≥2-occurrence rule: one deliberate rejection is the whole pattern.
+   - **drop:** not durable; let it go.
 4. **Propose, don't impose.** Present the candidates with their evidence (which features, how many
-   times, the proposed home) via `AskUserQuestion` — the human picks which to promote. Never
+   times, the proposed home) via `AskUserQuestion`: the human picks which to promote. Never
    promote a lesson to a rule silently; an unproven "lesson" hardened into a rule is its own slop.
    **Completion:** every candidate is explicitly accepted, rejected, or deferred by the human.
 5. **Record the accepted.** For each the user accepts, append it with `devrites-engine learnings add <slug>
    "<lesson>" <tag>` (`tag` ∈ `rule | convention | dismiss`). If the user approves a **rule**,
    **principle**, or **ledger** promotion, draft the exact edit and let the user confirm it through
-   the normal flow — `/rite-learn` writes the ledger, not the rule or principle files. A
+   the normal flow: `/rite-learn` writes the ledger, not the rule or principle files. A
    **principle** promotion is the highest-stakes of these: draft the `.devrites/principles.md` entry
-   **plus its dated Governance line**, and let the human confirm before it lands — a principle is a
+   **plus its dated Governance line**, and let the human confirm before it lands: a principle is a
    gate, so it is amended deliberately, never auto-written. **Amendment ripple:** a confirmed
-   add/change/retire of a principle has a blast radius — grep its `P#` (and its key nouns) across
+   add/change/retire of a principle has a blast radius: grep its `P#` (and its key nouns) across
    `.devrites/` and every open `.devrites/work/*/` workspace, and append to the same dated
    Governance entry one line per referencing artifact: *still-aligned* or *needs-follow-up (what)*.
    An open plan that bakes in the now-retired or now-tightened invariant is a `needs-follow-up`
@@ -87,11 +87,11 @@ The review skills (`/rite-review`, `/rite-seal`) read `.devrites/learnings.md` b
 out: a **dismissed-finding class** suppresses the recurring false positive; a **proven
 convention** raises the bar. The ideation skills (`/rite-pressure-test`, `/rite-pov`) read the
 **rejected-direction** entries before proposing, so a ruled-out direction returns only with new
-evidence against its recorded why. The ledger is an **untrusted prior** — a fresh observation of the
+evidence against its recorded why. The ledger is an **untrusted prior**: a fresh observation of the
 live code always overrides a ledger entry (see `.claude/skills/devrites-lib/reference/standards/security.md`). Confidence in a
 recorded lesson never raises its authority.
 
-A **project principle** (`.devrites/principles.md`) is the opposite layer — prescriptive,
+A **project principle** (`.devrites/principles.md`) is the opposite layer: prescriptive,
 trusted, and **gating**. Promoting a lesson there is a deliberate amendment, not a prior the next
 fan-out can override: a violation becomes a blocking finding, not a suppressed false positive.
 That asymmetry is why principle promotion is human-confirmed and dated, never auto-written.

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

@@ -5,7 +5,7 @@ argument-hint: "[mode: decompose|reslice|repair|reorder|split|unblock|course-cor
 user-invocable: true
 ---
 
-# /rite-plan — (re)plan an active feature
+# /rite-plan: (re)plan an active feature
 
 Reshape the plan when reality and the plan disagree. **Read the active workspace
 first.** If `.devrites/ACTIVE` is empty or its workspace is missing, stop and tell the
@@ -17,17 +17,17 @@ editing source code.
 Pull `development-workflow.md` via `Read` when reshaping slice cadence or DoD criteria.
 
 ## Operating rules
-- Spec is living, not sacred — but never plan around a known-wrong assumption silently.
+- Spec is living, not sacred, but never plan around a known-wrong assumption silently.
 - If a change alters product behavior, scope, architecture, data model, UX, security,
   or migration risk → **ask the user first** (use the Spec Drift Guard question format).
 - Keep each slice small enough for one focused build → prove cycle.
-- **Slice count is derived, never dictated** — reslice when a slice fails the sizing rule
+- **Slice count is derived, never dictated:** reslice when a slice fails the sizing rule
   (multiple "and"s, can't build+prove in one cycle), not to hit a user-named tally. A
   requested count is a hint at most; slice logically and explain if it differs. See
   [`reference/slicing.md`](reference/slicing.md) ("How many slices?").
 - **Size by complexity, order by dependency.** A slice carries a `Complexity: N/5` score (from
   `/rite-define`); a slice scoring **>3** is a reslice trigger unless its inline reason justifies
-  the irreducible complexity. Honor each slice's `depends_on:` — the next *buildable* slice is the
+  the irreducible complexity. Honor each slice's `depends_on:`: the next *buildable* slice is the
   lowest pending one whose dependencies are all built (keeps one-slice-at-a-time correct, not parallel).
 
 ## Workflow
@@ -35,35 +35,35 @@ Pull `development-workflow.md` via `Read` when reshaping slice cadence or DoD cr
    Then run `devrites-engine preamble` for deterministic workspace orientation.
 1. Read `spec.md`, `plan.md`, `tasks.md`, `state.md`, `drift.md`, and the current
    `git diff` (if a repo). Read `decisions.md` and `assumptions.md`. If a code-intelligence
-   index is available — `codebase-memory-mcp` first, cross-checked with `codegraph`
+   index is available: `codebase-memory-mcp` first, cross-checked with `codegraph`
    (`.codegraph/` / `codegraph_*` tools) + `graphify` (`graphify-out/`), else standard methods
-   (LSP / `Read`/`Grep`/`Glob`); see `.claude/skills/devrites-lib/reference/standards/tooling.md` —
+   (LSP / `Read`/`Grep`/`Glob`); see `.claude/skills/devrites-lib/reference/standards/tooling.md`:
    prefer it for structural questions (what calls X, what would
    changing Y break) over reading whole files, to keep planning context lean. For an external
    dependency's current API surface, consult context7 if available.
 2. **Pick the mode** (`$ARGUMENTS` or infer):
-   - **decompose** — first/again break the feature into vertical slices.
-   - **reslice** — a slice is too large; split into thinner end-to-end slices.
-   - **repair** — a Spec Drift Guard event; fold the resolution into plan + tasks.
-   - **reorder** — fix the dependency order.
-   - **split** — separate backend/frontend contracts (see `devrites-api-interface`).
-   - **unblock** — a verification failed; re-route around the blocker.
-   - **course-correct** — a deliberate mid-build *pivot* (the user changed their mind), distinct
+   - **decompose:** first/again break the feature into vertical slices.
+   - **reslice:** a slice is too large; split into thinner end-to-end slices.
+   - **repair:** a Spec Drift Guard event; fold the resolution into plan + tasks.
+   - **reorder:** fix the dependency order.
+   - **split:** separate backend/frontend contracts (see `devrites-api-interface`).
+   - **unblock:** a verification failed; re-route around the blocker.
+   - **course-correct:** a deliberate mid-build *pivot* (the user changed their mind), distinct
      from accidental drift: classify the change, assess its impact across the remaining slices,
      decide rollback vs forward-fix, and update `spec.md` + `plan.md` + `tasks.md` + `decisions.md`
      atomically. An acceptance/behavior change still goes through the user first. When the plan
      names an `MVP cut`, offer it as the retreat option: falling back to the cut is a pre-agreed
      scope, not a new negotiation.
-   - **revise** — apply a requested planning-artifact revision and reconcile existing artifacts in
+   - **revise:** apply a requested planning-artifact revision and reconcile existing artifacts in
      any direction; propose the file edit set first, confirm each file before writing, and **never
-     edit source code**. **Gate first — revise or new?** Same intent? >50% of existing scope
+     edit source code**. **Gate first: revise or new?** Same intent? >50% of existing scope
      survives? original *not* completable without this? Two "no"s → new work: recommend
      sealing/shipping the current workspace (MVP cut if named) then `/rite-spec` for the new
      intent, and stop. Revise preserves context; a new workspace provides clarity.
    See [replan-and-repair](reference/replan-and-repair.md) for each mode's steps.
-3. Reason about dependencies — [dependency-graph](reference/dependency-graph.md).
+3. Reason about dependencies: [dependency-graph](reference/dependency-graph.md).
    **Completion:** the slice graph is cycle-free and every dependency names an existing slice.
-4. Re-slice using vertical-slice rules — [slicing](reference/slicing.md) and
+4. Re-slice using vertical-slice rules: [slicing](reference/slicing.md) and
    [task-breakdown](reference/task-breakdown.md). Prefer thin, shippable, verifiable.
    **Completion:** every slice is independently shippable/provable or carries an irreducibility reason.
 5. Update `plan.md`, `tasks.md`, `state.md`, and append rationale to `decisions.md`.
@@ -71,17 +71,17 @@ Pull `development-workflow.md` via `Read` when reshaping slice cadence or DoD cr
 6. If product behavior/acceptance criteria change, confirm with the user before writing.
    **Completion:** the change is classified, and every behavior/acceptance change has explicit
    confirmation recorded before the artifacts are updated.
-7. **Done when** — every slice is sized (builds + proves in one cycle; no slice scoring >3
+7. **Done when:** every slice is sized (builds + proves in one cycle; no slice scoring >3
    left unjustified), the dependency order is acyclic, every `drift.md` entry you stopped for
    is marked resolved, revised artifacts agree with each other, no source files changed in
    `revise` mode, and behavior-change-vs-not is confirmed (`no`, or asked + answered).
-   If any check fails, loop back — don't hand off a half-reshaped plan.
+   If any check fails, loop back: don't hand off a half-reshaped plan.
 
-> **Mid-flight discipline.** When tempted to change product behavior without asking, absorb drift silently, or skip the user — see [`anti-patterns`](reference/anti-patterns.md). Load it the moment you reach for the excuse.
+> **Mid-flight discipline.** When tempted to change product behavior without asking, absorb drift silently, or skip the user: 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/.claude/skills/rite-plan/reference/anti-patterns.md

@@ -1,4 +1,4 @@
-# rite-plan — anti-patterns
+# rite-plan: anti-patterns
 
 Load this when standing a non-trivial re-plan decision, or when the agent
 feels reluctance toward asking the user before a behavior change.
@@ -9,7 +9,7 @@ Pack-wide rationalizations + red flags: see [standards/anti-patterns.md](../../d
 
 | Excuse | Rebuttal |
 |---|---|
-| "User didn't ask for a re-plan." | A Spec Drift Guard event *is* a re-plan trigger — ask is courtesy, the route is automatic. |
+| "User didn't ask for a re-plan." | A Spec Drift Guard event *is* a re-plan trigger: ask is courtesy, the route is automatic. |
 | "I can fix the slice mid-build, no need to update tasks." | `tasks.md` is the contract `/rite-build` reads. A fix that isn't there isn't visible to the next phase. |
 | "Reordering slices is cosmetic." | Dependency order controls risk discovery; risk-first wins because it surfaces blockers early. |
 | "This drift is small enough to absorb silently." | Silent drift = unrecorded decision = future "why does this work?" debugging session. |
@@ -20,5 +20,5 @@ Pack-wide rationalizations + red flags: see [standards/anti-patterns.md](../../d
 - About to change product behavior, acceptance, or scope without asking the user.
 - `drift.md` entry unresolved while planning the next slice.
 - A "mode" invented that isn't one of `decompose / reslice / repair / reorder / split / unblock`.
-- Slices reordered without updating dependency notes — order changed, rationale didn't.
+- Slices reordered without updating dependency notes: order changed, rationale didn't.
 - Repairing a drift event by silently widening the spec rather than narrowing the plan.

package/pack/.claude/skills/rite-plan/reference/dependency-graph.md

@@ -16,7 +16,7 @@ SLICE-006 (config)  -> independent
 ```
 
 ## Within a tier: risk-first
-Among slices that are equally unblocked, do the **riskiest** first — the one most
+Among slices that are equally unblocked, do the **riskiest** first: the one most
 likely to invalidate the plan (new integration, uncertain library behavior, migration).
 Finding drift early is cheap; finding it at seal time is not.
 

package/pack/.claude/skills/rite-plan/reference/replan-and-repair.md

@@ -8,7 +8,7 @@ First (or fresh) breakdown into vertical slices. Use `task-breakdown.md` +
 
 ## reslice
 A slice proved too large (couldn't build+prove in one cycle, or its goal has multiple
-"and"s). Split into thinner end-to-end slices, preserving acceptance coverage — split
+"and"s). Split into thinner end-to-end slices, preserving acceptance coverage: split
 **by the sizing rule, not to a target count**. Update `tasks.md`; renumber; fix
 dependency edges.
 
@@ -20,7 +20,7 @@ A drift event stopped the build. Steps:
    reality. Adjust acceptance criteria if they were wrong.
 4. Mark the `drift.md` entry **resolved** with the resolution + date.
 5. Resume at the corrected slice.
-Never repair by quietly deleting the inconvenient requirement — if behavior changes,
+Never repair by quietly deleting the inconvenient requirement, if behavior changes,
 that was a user question.
 
 ## reorder
@@ -29,7 +29,7 @@ re-sort risk-first within tiers, update `plan.md`'s implementation order.
 
 ## split (backend/frontend contract)
 A slice couples two sides too tightly. Define the contract first (shape, status codes,
-errors — `devrites-api-interface`), then split into a backend slice (can land with a
+errors: `devrites-api-interface`), then split into a backend slice (can land with a
 stub consumer) and a frontend slice (can land against a mock/real contract).
 
 ## unblock

package/pack/.claude/skills/rite-plan/reference/slicing.md

@@ -25,41 +25,41 @@ A slice is the right size when it:
 
 Too big if: it touches many unrelated files, or you can't name its single observable outcome.
 **The "and" test:** if the slice's *name* needs an "and" ("create **and** list tasks"), it's two
-slices — split on the "and". → reslice.
+slices: split on the "and". → reslice.
 
 Sizing isn't cosmetic. An agent builds a small or medium slice reliably in one pass but drifts on
 an outsized one, which is why a slice over `Complexity: 3/5` reslices (the `tasks.md` slice format
 in [`rite-define`](../../rite-define/SKILL.md)). Push every slice to the smallest cut that still
 stands alone end-to-end.
 
-## How many slices? — derive, don't dictate
+## How many slices?: derive, don't dictate
 The slice **count is an output, not an input.** It falls out of the work: one slice per
 independently-shippable vertical increment that satisfies one (or a tight group of)
-acceptance criteria and passes the sizing test above. A 2-criterion feature is 1–2 slices;
+acceptance criteria and passes the sizing test above. A 2-criterion feature is 1-2 slices;
 a 12-criterion feature is however many thin end-to-end cuts those 12 need.
 
 - **Never slice to a target number.** Don't pad a small feature into "5 slices" or
   compress a large one into "3" because a figure was named.
 - **A user-supplied count is a hint at most.** If the user says "do it in 4", slice the
   work logically first; if your honest decomposition differs, present the logical count
-  and *why*, then let them redirect — don't silently force their number.
+  and *why*, then let them redirect: don't silently force their number.
 - **Re-size by the rule, not the tally** (`/rite-plan reslice`): split a slice because it
   failed the sizing test, not to hit a count.
 
-Not to be confused with `.devrites/AFK` `max_slices` — that's an AFK *iteration budget*
+Not to be confused with `.devrites/AFK` `max_slices`. That's an AFK *iteration budget*
 capping how many slices the unattended loop builds before it stops, **not** the plan's
 decomposition. The plan always holds exactly the slices the work needs; `max_slices` only
 limits how many run unattended.
 
 ## First slice
-Make slice 1 the **thinnest useful end-to-end path** — it flushes out integration and
+Make slice 1 the **thinnest useful end-to-end path**. It flushes out integration and
 convention surprises early, while changes are cheap.
 
-**Risk-first exception.** When the biggest risk is a technical *unknown* — "will this library
-even do X?", "can we hit the latency target?" — let slice 1 (or a throwaway spike ahead of it)
+**Risk-first exception.** When the biggest risk is a technical *unknown*: "will this library
+even do X?", "can we hit the latency target?": let slice 1 (or a throwaway spike ahead of it)
 prove that unknown, even if it isn't the thinnest user-facing path. Fail the risky bet first,
 while pivoting is still cheap.
 
 ## Slice independence
 Order by dependency, but minimize coupling. A slice that needs three other slices first
-is a smell — look for a thinner cut that stands alone.
+is a smell: look for a thinner cut that stands alone.

package/pack/.claude/skills/rite-plan/reference/task-breakdown.md

@@ -24,10 +24,10 @@ This reference owns decomposition; the shared schema owns field names and meanin
 ## Keep it honest
 - **Interfaces prevent cross-slice drift.** A slice-wright sees only its own contract; the
   `Interfaces` line is how it learns the names and types neighboring slices use. A function
-  called `clearLayers()` in slice 3 and `clearFullLayers()` in slice 7 is a planning bug —
+  called `clearLayers()` in slice 3 and `clearFullLayers()` in slice 7 is a planning bug:
   name shared symbols once, here.
-- Don't pre-write code in the task — describe the outcome, not the implementation.
+- Don't pre-write code in the task: describe the outcome, not the implementation.
 - Don't bundle "while we're here" work into a slice. That's scope creep; log it as a
   follow-up instead.
-- Don't slice to a target number — the count comes from the capabilities + the sizing
+- Don't slice to a target number: the count comes from the capabilities + the sizing
   rule (`slicing.md`), not a figure anyone named.