devrites 2.6.0 → 3.0.0

package/pack/.claude/skills/devrites-ux-shape/SKILL.md

@@ -1,6 +1,6 @@
 ---
 name: devrites-ux-shape
-description: Plan the UX/UI before any code — produce the feature-level `design-brief.md` the build then targets. Use when `/rite-spec` detects UI, or the user says "shape the UX" or "plan the UI before coding". Not for building (use `devrites-frontend-craft`), polishing a built UI (use `/rite-polish`), or throwaway exploration (use `/rite-prototype`).
+description: Plan UX/UI before code: design direction, design brief, visual direction, key states, interaction model for screens/forms/dashboards/settings pages. Use when shaping UI. Not for building/polish.
 user-invocable: false
 ---
 
@@ -31,7 +31,8 @@ gathered:
   proven component behaviors) earlier features sealed via `../rite-ship/reference/design-memory.md`;
   treat it as the inherited system — read it before re-discovering, depart only on signal.
 - `references.md` + `references/` — the screenshots / Figma / video / links the human
-  supplied. When present they are the **build target**, not inspiration.
+  supplied. Honor each recorded role: **target** = fidelity contract, **constraint** =
+  required rule, **inspiration** = extract only the cited principle.
 
 ## 2. Discovery — one round, assert-then-confirm
 Understand the feature deeply enough to make excellent design calls — **no code, no
@@ -42,10 +43,12 @@ confirm** ("reads as Restrained — confirm?"), don't offer a four-option menu.
 - **Purpose & user** — who, in what state of mind (rushed / exploring / anxious / focused).
 - **Content & data** — realistic ranges (0 / typical / many), dynamic content, real
   media/assets the surface needs.
-- **Anti-goals** — what this must NOT be; the biggest risk of getting it wrong.
+- **Preserve + anti-goals** — identity, IA, behavior, content voice, SEO/analytics hooks,
+  existing accessibility wins, or assets that must survive; what this must NOT become;
+  the biggest risk of getting it wrong.
 
 ## 3. Design direction — the direction set (commit, don't hedge)
-One deliberate visual decision on four fronts, each anchored in an existing reference so
+One deliberate visual decision on five fronts, each anchored in an existing reference so
 the call is checkable, not taste:
 - **Scene sentence** — who / where / ambient light / mood, per
   `../devrites-frontend-craft/reference/design-references.md`. Forces dark-vs-light and
@@ -59,6 +62,9 @@ the call is checkable, not taste:
   launch hero → Airy + Expressive).
 - **Named anchor references** — 2-3 *specific* products / brands / objects to steer toward
   (not adjectives like "modern" or "clean"), plus the saved `references/` files.
+- **Visual thesis** — the focal point and hierarchy in one sentence, plus one memorable
+  move (or `none — system continuity`) and the obvious-but-wrong direction rejected. This
+  creates intentional distinction without forcing novelty into product UI.
 
 Respect the existing identity (default, ~90%); depart only on an explicit signal.
 
@@ -73,8 +79,10 @@ List every state the feature needs and what the user must see/feel in each (defa
 loading initial+subsequent, empty→next-action, error→recovery, success, disabled/
 no-permission, long-content/overflow), the information hierarchy (what's seen 1st / 2nd /
 3rd; primary action unmistakable), responsive reflow, a11y must-haves, and the interaction
-model (inline vs navigated vs — rarely — modal; optimistic vs pending; feedback). Canonical
-state list: `../devrites-frontend-craft/reference/shape.md`.
+model (inline vs navigated vs — rarely — modal; optimistic vs pending; feedback). Name the
+representative states, viewports, input modes, and target R-ids that will prove the result;
+"looks polished" is not a proof target. Canonical state list:
+`../devrites-frontend-craft/reference/shape.md`.
 
 ## 6. Visual-direction probe — capability-gated
 When the work is net-new or directionally ambiguous and fidelity ≥ mid-fi, pressure-test
@@ -93,7 +101,7 @@ the brief than in the build.
 Write `design-brief.md` ([reference/brief-template.md](reference/brief-template.md)) —
 **compact** (3-5 bullets) when discovery was crisp, **full** when the surface is ambiguous
 or multi-screen. Don't pad a clear brief to look thorough; don't skip the pause to look
-fast. Then honor the run mode (`../../rules/afk-hitl.md`):
+fast. Then honor the run mode (`../devrites-lib/reference/standards/afk-hitl.md`):
 - **HITL** — present the brief and **STOP for explicit confirmation**. The pause is the
   point: shape ends at the user's "go", not at your own certainty. Disagreement → revisit
   the relevant discovery question.
@@ -101,6 +109,10 @@ fast. Then honor the run mode (`../../rules/afk-hitl.md`):
   `questions.md` entry, and proceed. A direction touching the irreversible-risk list still
   pauses.
 
+Completion: the smallest useful brief exists; primary action, states, interaction, proof
+targets, and reference role/usage are explicit; the run-mode gate is resolved. Only then may
+UI code start.
+
 ## Output
 ```
 UX/UI shaped: <slug>
@@ -116,6 +128,7 @@ Next: /rite-define (UI slices map to the brief's states) — or /rite-build refi
 - Never finalize the brief without naming the **primary action** and the **full state set**
   (not just the happy path).
 - Never decide visual direction by taste when the project has a system — discover first.
+- Never treat an **inspiration** reference as a fidelity target — honor its recorded role.
 - Never skip the HITL confirmation pause "because the brief is obviously right" — ask once,
   wait.
 - Never re-derive the brief from scratch in `/rite-build` — refine the existing one.

package/pack/.claude/skills/devrites-ux-shape/reference/brief-template.md

@@ -15,9 +15,12 @@ step. Don't pad a clear brief into a long one to look thorough.
 Slug: <kebab>   Shaped: <iso>   Register: brand | product   Fidelity: <sketch|mid-fi|high-fi|production>
 
 - **Building**: <one line — what + who it's for + the primary action>
-- **Direction**: <color strategy> · density <airy|balanced|dense>/motion <minimal|standard|expressive> · "<scene sentence>" · anchors: <ref A, ref B>  (+ references/<file> R-ids)
+- **Thesis**: <focal point + hierarchy> · memorable move: <one move | none — system continuity> · preserve/avoid: <identity + anti-goal>
+- **Direction**: <color strategy> · density <airy|balanced|dense>/motion <minimal|standard|expressive> · "<scene sentence>" · targets: <R-ids> · constraints: <R-ids> · inspiration: <R-ids>
+- **Locks**: accent <token> · radius <scale> · theme <light|dark>
 - **States**: <the states this surface needs, comma-listed>
 - **Interaction**: <inline / navigated / modal · feedback · entry→completion in a phrase>
+- **Proof**: <states × viewports × input modes; target R-ids; zero material visual mismatches>
 - **Confirm or override?** <the one or two things you still want the user to confirm>
 ```
 
@@ -27,7 +30,9 @@ Slug: <kebab>   Shaped: <iso>   Register: brand | product   Fidelity: <sketch|mi
 Slug: <kebab>   Shaped: <iso>   Register: brand | product
 
 ## 1. Summary
-What this is, who it's for, what it must accomplish (2-3 sentences).
+What this is, who it's for, what it must accomplish, what existing identity/behavior must
+survive — including IA, content voice, SEO/analytics hooks, and accessibility wins — and
+the anti-goal (2-3 sentences).
 
 ## 2. Primary action
 The single most important thing the user does or understands here. Everything else is secondary.
@@ -36,7 +41,11 @@ The single most important thing the user does or understands here. Everything el
 - Color strategy: Restrained | Committed | Multi-role | Saturated — why (from the scene, not the category).
 - Calibration: density Airy | Balanced | Dense · motion Minimal | Standard | Expressive — from the scene (`../../devrites-frontend-craft/reference/quality-standards.md` — Calibration).
 - Scene sentence: "<who uses it, where, under what light, in what mood>".
-- Named anchors: <2-3 specific products / brands / objects> + saved references (R-ids → references/<file>).
+- Visual thesis: <focal point + 1st/2nd/3rd hierarchy> · memorable move: <one | none — system continuity>.
+- References by role: targets <R-ids> · constraints <R-ids> · inspiration <R-ids>.
+- Locks: one accent <token> · one radius scale · one theme — held page-wide
+  (`../../devrites-frontend-craft/reference/quality-standards.md` — Consistency locks).
+- Rejected direction: <the obvious-but-wrong direction + why>.
 - Departure: default (preserve identity) | departing because <explicit signal>.
 
 ## 4. Scope  *(task-scoped — not persisted to PRODUCT.md / DESIGN.md)*
@@ -64,7 +73,8 @@ every action; the flow from entry to completion.
 ## 8. Content & copy
 Labels, empty/error messages, microcopy in the product's voice. Realistic dynamic ranges.
 For image-led surfaces: required media roles + likely source (project asset / generated /
-SVG-CSS / icon library / accepted omission).
+SVG-CSS / icon library / accepted omission) and the shippable provenance/usage recorded in
+`references.md`.
 
 ## 9. Responsive & a11y
 Reflow 320→1440 (what stacks / collapses / scrolls); focus order, labels, contrast,
@@ -74,20 +84,25 @@ keyboard, target size. Floor: `../../devrites-frontend-craft/reference/quality-s
 Which probe ran (figma / images / prototype / skipped — no tool), which direction won, what
 changed in the brief because of it. Artifacts saved under `references/`.
 
-## 11. Open questions
+## 11. Proof targets
+Representative states × viewports × input modes, the target R-ids or brief rules each
+render is compared with, and the exact interaction/accessibility checks. A visual pass
+requires zero unresolved **material** mismatch; accepted departures are recorded below.
+
+## 12. Open questions
 Genuinely unresolved only. If you'd write "Recommend: X", decide X instead.
 
 ## Build-time refinements  *(appended by devrites-frontend-craft per slice)*
-- Slice <N>: <decision made while building this surface + why>.
+- SLICE-001: <decision made while building this surface + why>.
 ```
 
 ## How downstream phases use it
-- `/rite-define` — UI slices map to the **Key states** + **Interaction model**; each UI
-  slice names which states it covers.
+- `/rite-define` — UI slices map to the **Key states**, **Interaction model**, and **Proof
+  targets**; each UI slice names the visual acceptance it proves.
 - `/rite-build` + `devrites-frontend-craft` — build **to** the brief; refine per slice;
   append refinements above instead of re-deriving.
-- `/rite-prove` + `browser-evidence.md` — verify the built UI against the brief's states +
-  references.
+- `/rite-prove` + `browser-evidence.md` — render the proof targets, compare against the
+  brief + target references, and close material deltas.
 - `/rite-polish` — Phase 4 reads the brief so polish honors the agreed direction.
 - `/rite-seal` + `devrites-frontend-reviewer` — check the UI matches the brief (states
   covered, direction held, references matched).

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

@@ -6,8 +6,8 @@ DevRites-native answer to "build it according to the design (Figma, images)": sh
 direction, get a reaction, then write the brief.
 
 ## When to run (all true)
-- The work is **net-new** or directionally **ambiguous**. An existing surface to match →
-  skip; the supplied references already ARE the target.
+- 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
   install APIs or tooling. If none is available, **announce the skip in one line** and

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

@@ -1,6 +1,6 @@
 ---
 name: rite
-description: DevRites menu + router. Without args, renders the menu. With a verb (e.g. `spec`, `build`, `review`), dispatches to the matching `rite-<verb>` skill — `/rite spec foo` is equivalent to `/rite-spec foo`. Use when the user types `/rite` or names a phase verb.
+description: User-invoked DevRites menu and router; no args renders the menu, a verb dispatches to the matching `rite-<verb>` skill.
 argument-hint: "[verb [args...]]"
 user-invocable: true
 disable-model-invocation: true
@@ -10,8 +10,11 @@ disable-model-invocation: true
 
 You are the DevRites entry point. Two modes:
 
-- **No args** → render the menu (below), then stop. Do not execute a workflow phase. Do not read `state.md` / run evidence checks / list artifacts — that's `/rite-status`.
-- **Verb arg** → dispatch to the matching `rite-<verb>` skill (see "Dispatch" below). The router is a pass-through: `/rite spec foo` ≡ `/rite-spec foo`; the called skill owns the output.
+- **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).
+When they ask how phases connect, load [`reference/menu.md`](reference/menu.md).
 
 ## Dispatch
 
@@ -24,40 +27,56 @@ F=.claude/skills/rite-$V/SKILL.md
 # Then Read "$F" and follow its workflow with $ARGS as that skill's $ARGUMENTS.
 ```
 
-| Verb | Equivalent shortcut | Skill |
-|---|---|---|
-| `spec [feature]` | `/rite-spec` | start a feature — investigate + write spec.md |
-| `adopt [area]` | `/rite-adopt` | onboard an existing codebase — reverse-derive spec.md + seed conventions |
-| `temper [--mode]` | `/rite-temper` | optional strategic spec review (scope mode + pre-mortem) before define |
-| `define` | `/rite-define` | turn the spec into plan + task slices |
-| `vet [--cross-model]` | `/rite-vet` | optional engineering plan review (scope · architecture · tests · perf) before build |
-| `plan [mode]` | `/rite-plan` | reshape / reslice / repair an active plan |
-| `build [slice]` | `/rite-build` | implement exactly one vertical slice, then stop |
-| `prove` | `/rite-prove` | full tests + browser proof |
-| `polish [mode]` | `/rite-polish` | code + UI polish |
-| `review [scope]` | `/rite-review` | multi-axis feature review |
-| `seal` | `/rite-seal` | final GO / NO-GO decision |
-| `ship` | `/rite-ship` | type-GO + commit/push/tag, then archive the task |
-| `status [slug]` | `/rite-status` | active feature, next action, evidence |
-| `doctor` | `/rite-doctor` | health check — install integrity, stale ACTIVE, orphaned gates, hook wiring |
-| `learn [--mine \| "<lesson>"]` | `/rite-learn` | review the captured learning ledger → promote recurring lessons to project rules / principles |
-| `use <slug>` | (inline) | switch the active feature — re-point `.devrites/ACTIVE` |
-| `resolve <qid> "<answer>"` | `/rite-resolve` | answer a HITL gate |
-| `prototype [question]` | `/rite-prototype` | throwaway prototype |
-| `handoff [focus]` | `/rite-handoff` | compact chat → handoff doc |
-| `zoom-out` | `/rite-zoom-out` | structural map of unfamiliar code |
-| `pressure-test` | `/rite-pressure-test` | diverge → converge on a rough idea |
-| `autocomplete [idea] [--ship]` | `/rite-autocomplete` | run the whole lifecycle unattended |
-| `quick [change]` | `/rite-quick` | express lane — one small reversible change, build → prove → ship |
-| `frame [task]` | `/rite-frame` | pre-flight goal-reframe + four-failure-mode self-audit for ad-hoc / express work |
-
-The `/rite-<verb>` standalones remain user-invocable as direct shortcuts; both forms hit the same skill. Use whichever reads more naturally — the menu form (`/rite spec`) for discovery, the shortcut (`/rite-spec`) for muscle memory.
+What each verb does lives once, in the Menu below; this table is the dispatch map only.
+
+| Verb | Skill |
+|---|---|
+| `spec [feature]` | `/rite-spec` |
+| `adopt [area]` | `/rite-adopt` |
+| `temper [--mode]` | `/rite-temper` |
+| `define` | `/rite-define` |
+| `vet [--cross-model]` | `/rite-vet` |
+| `plan [mode]` | `/rite-plan` |
+| `build [slice]` | `/rite-build` |
+| `converge [slug]` | `/rite-converge` |
+| `prove` | `/rite-prove` |
+| `polish [mode]` | `/rite-polish` |
+| `review [scope]` | `/rite-review` |
+| `seal` | `/rite-seal` |
+| `ship` | `/rite-ship` |
+| `status [slug]` | `/rite-status` |
+| `doctor [--code | --reindex]` | `/rite-doctor` |
+| `learn [--mine \| "<lesson>"]` | `/rite-learn` |
+| `explain [concept \| diff \| idea \| recap]` | `/rite-explain` |
+| `pov [candidate]` | `/rite-pov` |
+| `dogfood [--port N]` | `/rite-dogfood` |
+| `pr-feedback [PR\|thread]` | `/rite-pr-feedback` |
+| `customize [override <agent> \| extension <name>]` | `/rite-customize` |
+| `use <slug>` | (inline) |
+| `guide` | (inline) |
+| `resolve <qid> "<answer>"` | `/rite-resolve` |
+| `prototype [question]` | `/rite-prototype` |
+| `handoff [focus]` | `/rite-handoff` |
+| `zoom-out` | `/rite-zoom-out` |
+| `pressure-test` | `/rite-pressure-test` |
+| `autocomplete [idea] [--ship]` | `/rite-autocomplete` |
+| `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.
 
 `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 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.
+
 Specialist triggers (model-invoked inside the above):
 `devrites-frontend-craft` (UI) · `devrites-browser-proof` (UI verify) ·
 `devrites-source-driven` (uncertain library) · `devrites-doubt` (non-trivial
@@ -68,20 +87,20 @@ reference (see [`devrites-lib/reference/parallel-dispatch.md`](../devrites-lib/r
 
 ## What to output
 
-1. **Verb in `$ARGUMENTS`** → dispatch per the table above. The called skill owns the response.
-2. **No args** → render the menu below, then stop.
+Reply-contract exception: `/rite` is the menu/router, not a workspace completion step.
+Called phase skills own the shared completion reply contract
+([`reply-contract.md`](../devrites-lib/reference/reply-contract.md)).
+
+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.
 
-## Gotchas
-- No args → render the menu and stop. Don't execute a phase, read `state.md`, or summarize status — that's `/rite-status`.
-- Unrecognized first token → list the known verbs and stop; never guess which phase the user meant.
-- Pure pass-through: dispatch to the `rite-<verb>` skill and let it own the output; don't do the phase's work in the router.
-
 ## Menu
 
 ```
 DevRites — disciplined senior-engineer workflow
+Recommended start: <greenfield: /rite spec <feature> | brownfield-unadopted: /rite adopt | active-feature: /rite status | dirty-worktree: /rite frame or /rite quick | branch-ahead: /rite ship/status | clean-default: /rite spec <feature>>
                               menu form           direct shortcut
 SPEC          /rite spec               ≡    /rite-spec        investigate deeply → write spec.md
 ADOPT         /rite adopt              ≡    /rite-adopt       onboard existing code → reverse-derive spec.md + seed conventions
@@ -96,13 +115,19 @@ REVIEW        /rite review             ≡    /rite-review      feature-scoped m
 SEAL          /rite seal               ≡    /rite-seal        final GO / NO-GO decision (no git)
 SHIP          /rite ship               ≡    /rite-ship        type-GO + commit/push/tag, then archive + clear ACTIVE
 STATUS        /rite status             ≡    /rite-status      active feature, next action, evidence, risks
-DOCTOR        /rite doctor             ≡    /rite-doctor      health check — install · stale ACTIVE · orphaned gates · hook wiring
+DOCTOR        /rite doctor ...         ≡    /rite-doctor      health check; --reindex refreshes structural indexes
 LEARN         /rite learn ...          ≡    /rite-learn       review captured lessons → promote to project rules / principles
+EXPLAIN       /rite explain ...        ≡    /rite-explain     grounded concept/diff/idea/recap explainer
+POV           /rite pov ...            ≡    /rite-pov         decide adopt / trial / hold / reject for an external option
+DOGFOOD       /rite dogfood ...        ≡    /rite-dogfood     browser QA by changed user journey
+PR FEEDBACK   /rite pr-feedback ...    ≡    /rite-pr-feedback fix and resolve PR review threads
+CUSTOMIZE     /rite customize ...      ≡    /rite-customize   author overrides/extensions without forking the pack
 SWITCH        /rite use <slug>                                re-point .devrites/ACTIVE to another feature (inline)
+GUIDE         /rite guide                                     first feature, guided — full lifecycle on one small real change (inline)
 RESUME        /rite resolve ...        ≡    /rite-resolve     answer a HITL checkpoint
 AUTO          /rite autocomplete ...   ≡    /rite-autocomplete  run the whole lifecycle unattended (--ship to push)
 QUICK         /rite quick <change>     ≡    /rite-quick       express lane — one small reversible change (escalates if it grows)
-UTILITY       /rite frame | prototype | handoff | zoom-out | pressure-test  (or direct /rite-* shortcuts)
+UTILITY       /rite frame | prototype | handoff | zoom-out | pressure-test  (or direct shortcuts)
 ```
 
 > **Small one-off change?** A typo, copy tweak, config bump, or one-function fix → **`/rite-quick`**
@@ -112,6 +137,6 @@ UTILITY       /rite frame | prototype | handoff | zoom-out | pressure-test  (or
 
 ## Core operating rules (every DevRites skill enforces)
 
-The operating rules live in `.claude/rules/core.md`; DevRites skills Read it as
+The operating rules live in `.claude/skills/devrites-lib/reference/standards/core.md`; DevRites skills Read it as
 their first step, and the other rule files load on demand. See
-[`.claude/rules/README.md`](../../rules/README.md) for the full index.
+[`.claude/skills/devrites-lib/reference/standards/README.md`](../devrites-lib/reference/standards/README.md) for the full index.

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

@@ -14,13 +14,14 @@ what each command does or how phases connect.
 | 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`. |
 | 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`. |
 | 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. |
+| 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
@@ -31,6 +32,8 @@ what each command does or how phases connect.
   `/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`.
 - **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`.
 
 ## Rules this menu obeys
 

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

@@ -1,6 +1,6 @@
 ---
 name: rite-adopt
-description: Bring an EXISTING codebase under DevRites — reverse-derive a `spec.md` of current behavior, placement, and architecture, and seed the project conventions ledger from the idioms the code already follows, then hand off to the lifecycle. Use when the user says "adopt this project" or "reverse-engineer a spec from the existing app". Not for a brand-new feature or idea (use `/rite-spec`), planning an approved spec (`/rite-define`), or just mapping unfamiliar code without onboarding it (`/rite-zoom-out`).
+description: Adopt an existing or legacy codebase into DevRites by reverse-engineering current behavior, seeding conventions, and establishing the workflow. Use for inherited or live applications.
 argument-hint: "[path or area to adopt] [+ what you want to build next]"
 user-invocable: true
 ---
@@ -20,9 +20,9 @@ lifecycle (`/rite-temper` → `/rite-define` → `/rite-build` …) takes over.
 > unfamiliar code without creating a workspace or ledger. `/rite-adopt` is the heavier move:
 > it *commits the project to the lifecycle*. Pick zoom-out to look, adopt to begin.
 
-## Rules consulted (read on demand from `.claude/rules/`)
-**Step 0:** Read `.claude/rules/core.md` first. Pull `documentation.md` when recording
-the adoption decisions (why-not-what) in `decisions.md`; pull `principles.md` when the code
+## Rules consulted (read on demand from `.claude/skills/devrites-lib/reference/standards/`)
+Pull `documentation.md` when recording the adoption decisions (why-not-what) in
+`decisions.md`; pull `principles.md` when the code
 upholds invariants worth proposing as project principles (step 4a).
 
 ## Operating rules (DevRites core)
@@ -31,13 +31,8 @@ upholds invariants worth proposing as project principles (step 4a).
   objective is unclear.
 
 ## Workflow
-0. **Read `.claude/rules/core.md`**, then run the shared orientation preamble:
-   ```bash
-   P=.claude/skills/devrites-lib/scripts/preamble.sh
-   [ -f "$P" ] || P="${CLAUDE_SKILL_DIR:-}/../devrites-lib/scripts/preamble.sh"
-   [ -f "$P" ] || P=pack/.claude/skills/devrites-lib/scripts/preamble.sh
-   [ -f "$P" ] && bash "$P" || echo "(orientation preamble unavailable on this install — read state.md directly to orient)"
-   ```
+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
    is missing, ask once (it shapes the spec's acceptance); if the area is ambiguous, confirm
@@ -45,7 +40,7 @@ upholds invariants worth proposing as project principles (step 4a).
 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/rules/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,
@@ -57,11 +52,23 @@ upholds invariants worth proposing as project principles (step 4a).
    **current behavior as the baseline** and the **next objective** (what adoption is for) with
    measurable acceptance. Also write `decisions.md`, `assumptions.md`, `questions.md`, and
    `state.md` (phase: spec).
+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
+   ([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
+   devrites-engine ledger diff .devrites/work/<slug>   # preview
+   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* —
    [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
@@ -69,12 +76,13 @@ upholds invariants worth proposing as project principles (step 4a).
    **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`](../../rules/principles.md)). Propose, don't impose — an unratified candidate
+   ([`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.
+   **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
@@ -82,14 +90,15 @@ upholds invariants worth proposing as project principles (step 4a).
 
 ## Output
 
-**Footer first** — render the progress footer (`progress.sh`, resolved like the step-0
-preamble). Then:
+**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:
 ```
-Adopted: <slug>
-Baseline: <one-line summary of current behavior>   Placement: <where it lives>
-Next objective: <what we'll build on top>
-Conventions seeded: <n> (commands · idioms · placement · gotchas)
-Principles proposed: <n ratified → .devrites/principles.md | none rose to an invariant>
-Next: big / risky? → /rite-temper   ·   straightforward? → /rite-define
-↻ Hygiene: /clear before the next phase (spec.md + decisions.md + the seeded ledger captured). See rules/context-hygiene.md.
+Done: adopted existing behavior into <slug>; baseline spec and placement recorded.
+Changed: spec.md, decisions.md, conventions ledger, principles proposals <updated|none>
+Evidence: not applicable; reverse-derived behavior is recorded for review
+Open: <none | adoption questions | Alternative: /rite-define for straightforward follow-up>
+Next: /rite-temper
+Record: .devrites/work/<slug>/spec.md
+↻ Hygiene: /clear before the next phase
 ```

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

@@ -10,8 +10,8 @@ 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
   (where endpoints / components / models / migrations / tests go). Prefer a code-intelligence
-  index if available — codebase-memory-mcp first, cross-checked with codegraph + graphify, else standard methods (LSP / Read/Grep/Glob) (see
-  `../../../rules/tooling.md`) — for structure, callers, and impact.
+  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
   guess). Verify uncertain framework facts at the source.
 - **Idioms** — naming + casing, layering, the error model, the result/exception style, the
@@ -35,24 +35,21 @@ existing code** so the first slice isn't blind. Keep the seeds honest:
   (raising the band) or, per fresh-observation-wins, contradict it.
 
 ```bash
-C=.claude/skills/devrites-lib/scripts/conventions.py
-[ -f "$C" ] || C="${CLAUDE_SKILL_DIR:-}/../devrites-lib/scripts/conventions.py"
-[ -f "$C" ] || C=pack/.claude/skills/devrites-lib/scripts/conventions.py
 SLUG="$(cat .devrites/ACTIVE 2>/dev/null | tr -d '[:space:]')"
-if command -v python3 >/dev/null 2>&1 && [ -f "$C" ]; then
-  python3 "$C" promote --slug "${SLUG}-adopt" \
+if command -v devrites-engine >/dev/null 2>&1; then
+  devrites-engine conventions promote --slug "${SLUG}-adopt" \
     --key test-runner --kind test \
     --statement "tests run with <runner>, <file layout>" \
     --evidence "observed during /rite-adopt onboarding (not yet slice-proven)"
   # …one promote per durable convention the investigation actually observed
   # (test-runner, build-cmd, error-model, http-client, endpoint-placement, …).
 else
-  echo "(conventions ledger unavailable — python3 or script missing; skipping seed)"
+  echo "(conventions ledger unavailable — devrites-engine missing; skipping seed)"
 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/rules/security.md`](../../../rules/security.md) § Prompt-injection resistance),
+([`.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
 needless contradiction later.

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

@@ -1,6 +1,6 @@
 # /rite-adopt — anti-patterns
 
-Start with the universal table in [`../../../rules/anti-patterns.md`](../../../rules/anti-patterns.md).
+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.
 
 ## Adoption-specific rationalizations