devrites 3.0.4 → 3.0.6

package/pack/.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/.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,19 +63,17 @@ 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 also inline — a first-feature walkthrough that teaches the lifecycle by running
-it. Agree on one **real, genuinely small** change, then dispatch the normal phases in order
-(spec → define → build → prove → seal → ship). Per phase, exactly two narration beats:
-before, what it will decide; after, what it wrote in `.devrites/work/<slug>/` and why. Walk
-every phase — the small change is what makes the full ceremony affordable to watch. Pause
-at each boundary for the user's go-ahead. Teach without lecturing.
+`guide` is an inline first-feature walkthrough. Agree on one **real, genuinely small**
+change, then run spec → temper → define → vet → build → prove → polish → review → seal →
+ship. Before each phase, say what it decides; after, name what it wrote and why. Pause at
+every boundary. Teach without lecturing.
 
 Specialist triggers (model-invoked inside the above):
 `devrites-frontend-craft` (UI) · `devrites-browser-proof` (UI verify) ·
@@ -94,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
 
@@ -106,9 +104,10 @@ SPEC          /rite spec               ≡    /rite-spec        investigate deep
 ADOPT         /rite adopt              ≡    /rite-adopt       onboard existing code → reverse-derive spec.md + seed conventions
 TEMPER        /rite temper             ≡    /rite-temper      optional — strategic review: scope mode + pre-mortem, harden the spec
 PLAN          /rite define             ≡    /rite-define      turn the spec into plan + task slices + state
-VET           /rite vet                ≡    /rite-vet         optional — engineering plan review: scope · architecture · tests · perf, harden the plan
+VET           /rite vet                ≡    /rite-vet         mandatory every plan — light/full engineering review by stakes
 REPLAN        /rite plan               ≡    /rite-plan        decompose / reslice / repair an active plan
 BUILD         /rite build              ≡    /rite-build       implement exactly one verified vertical slice, then stop
+CONVERGE      /rite converge           ≡    /rite-converge    recovery — append work needed to meet intent
 PROVE         /rite prove              ≡    /rite-prove       tests + build + runtime + browser evidence
 POLISH        /rite polish             ≡    /rite-polish      code polish always; UI normalize + polish if UI
 REVIEW        /rite review             ≡    /rite-review      feature-scoped multi-axis review
@@ -133,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/.claude/skills/rite/reference/menu.md

@@ -7,30 +7,30 @@ what each command does or how phases connect.
 
 | Phase | Command | Use when |
 |---|---|---|
-| Spec | `/rite-spec <feature>` | **Start here.** Investigate deeply → write spec.md. Asks you with options; gathers any design references you attach (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`. |
+| 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`. |
 | Plan | `/rite-define` | Turn the approved spec into plan + vertical task slices + state. |
-| Vet | `/rite-vet` | _Optional, before build._ Engineering review of the plan — scope · architecture · tests · perf; hardens the plan. Best on big/risky features; mandatory in `/rite-autocomplete`. |
+| 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)* →
-  `/rite-define` (plan) → *(big feature? `/rite-vet` — engineering 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`.
-- **Existing codebase**: `/rite-adopt` (onboard → spec.md + conventions) → continue at `/rite-define`.
+- **Existing codebase**: `/rite-adopt` → `/rite-define` → `/rite-vet` → build.
 - **Drift mid-build**: stop → drift question → `/rite-plan` (repair) → resume build.
 - **Resumed / adopted / stalled**: `/rite-converge` (assess live code vs intent → append the
   remaining slices) → `/rite-build` ×N → continue at `/rite-prove`.
@@ -38,5 +38,5 @@ what each command does or how phases connect.
 ## Rules this menu obeys
 
 - `/rite` never edits code or runs a phase workflow.
-- It reads `.devrites/ACTIVE` and `state.md` for status only.
+- Menu mode runs `devrites-engine first-task`; `/rite-status` owns workspace status.
 - It suggests; the user (or Claude, when appropriate) invokes the real skill.

package/pack/.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,34 +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.** The project is now in the lifecycle with a spec and a head-start ledger.
-   Point the user at `/rite-temper` (big/risky) or `/rite-define` (straightforward) — do not
-   plan or build here.
+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/.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/.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/.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/.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/.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/.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