devrites 5.10.2 → 5.12.0

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

@@ -0,0 +1,108 @@
+# `design-brief.md` template: the UX/UI contract
+
+The feature-level design decision, produced **before** code by `devrites-ux-shape` (at
+`/rite-spec` when UI is detected) and the **target** the build, polish, and seal check
+against. `devrites-frontend-craft` refines it per slice and appends build-time decisions;
+it is never re-derived from scratch.
+
+Pick the shape by how clear the answers are. **Compact** is the default for a crisp prompt;
+**full** when the surface is ambiguous, multi-screen, or the user asked to shape it as a
+step. Don't pad a clear brief into a long one to look thorough.
+
+## Compact form (default)
+```markdown
+# Design brief: <feature>
+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>
+- **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>
+```
+
+## Full form
+```markdown
+# Design brief: <feature>
+Slug: <kebab>   Shaped: <iso>   Register: brand | product
+
+## 1. Summary
+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.
+
+## 3. Design direction
+- 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>".
+- 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)*
+Fidelity · breadth · interactivity · time intent.
+
+## 5. Layout & hierarchy
+What gets emphasis; what's seen 1st / 2nd / 3rd; how information flows. Hierarchy, not CSS.
+
+## 6. Key states
+Every state + what the user needs to see and feel:
+| State | User sees / feels | Notes |
+|---|---|---|
+| default / populated | | |
+| loading | | initial + subsequent |
+| empty | | welcoming + the next action |
+| error | | what happened + how to recover |
+| success | | |
+| disabled / no-permission | | |
+| long-content / overflow / many items | | |
+
+## 7. Interaction model
+Inline vs navigated vs (rarely) modal; optimistic vs pending; focus & keyboard; feedback on
+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) and the shippable provenance/usage recorded in
+`references.md`.
+
+## 9. Responsive & a11y
+Reflow 320→1440 (what stacks / collapses / scrolls); focus order, labels, contrast,
+keyboard, target size. Floor: `../../devrites-frontend-craft/reference/quality-standards.md`.
+
+## 10. Visual-direction probe
+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. 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-001: <decision made while building this surface + why>.
+```
+
+## How downstream phases use it
+- `/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`: 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/generated/devin/skills/devrites-ux-shape/reference/visual-direction-probe.md

@@ -0,0 +1,48 @@
+# 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 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.
+
+## When to run (all true)
+- 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 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.
+
+## Pick the probe by what's available (first match)
+1. **Figma reference supplied** → pull design context with the Figma integration (frames,
+   tokens, components, a screenshot of the target). Record what it dictates. A Figma frame
+   that conflicts with the project's design system is a **question for the user**, not a
+   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
+   *direction tests*, not final UI.
+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)
+   and read the relevant intent (tone, density, interaction).
+5. **Nothing available** → one-line skip, proceed.
+
+## How to use the result
+- 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.
+- 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
+  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
+  note.

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

@@ -0,0 +1,150 @@
+---
+name: rite
+description: User-invoked DevRites menu and router; no args renders the menu, a verb invokes the matching `rite-<verb>` skill.
+argument-hint: "[verb [args...]]"
+triggers:
+  - user
+---
+<!-- loads: {"always":["devrites-lib/reference/standards/core.md"],"triggers":{"intent":["devrites-lib/reference/intent-map.md"],"menu":["rite/reference/menu.md"],"dispatch":["devrites-lib/reference/parallel-dispatch.md"],"reply":["devrites-lib/reference/reply-contract.md"]}} -->
+> Read-set manifest: `devrites-engine context [slug] --skill rite` bundles every file named below into one deduplicated read. Trigger names map to the conditional rules in the sections that follow.
+
+# /rite: DevRites menu + router
+
+Two modes:
+
+- **No args** → render the menu and stop. Do not execute a phase or infer
+  workspace status; `/rite-status` owns that.
+- **Verb arg** → pass-through invocation of 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
+
+If `$ARGUMENTS` starts with a verb in this table, **load the matching skill and execute its workflow** with the remainder of `$ARGUMENTS` as that skill's argument. Resolve the installed skill path:
+
+```bash
+V=<verb>; ARGS="<remaining args>"
+F=.devin/skills/rite-$V/SKILL.md
+# Then Read "$F" and follow its workflow with $ARGS as that skill's $ARGUMENTS.
+```
+
+`use` and `guide` are handled inline per the sections below, not via a skill file.
+
+What each verb does lives once, in the Menu below; this table is the invocation map only.
+
+| Verb | Skill |
+|---|---|
+| `spec [feature]` | `/rite-spec` |
+| `adopt [area]` | `/rite-adopt` |
+| `clarify [feature]` | `/rite-clarify` |
+| `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` | `/rite-doctor` |
+| `upgrade [slug]` | `/rite-upgrade` |
+| `learn ["<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` |
+| `watch-pr [PR\|URL]` | `/rite-watch-pr` |
+| `customize [instruction \| skill \| agent \| plugin]` | `/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 call the same skill. The menu supports discovery; `/rite-<verb>` is the direct form.
+
+`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 an inline walkthrough for the first feature. Agree on one **real, small**
+change, then run spec → clarify → 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 and explain only what the user needs for the next decision.
+
+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
+decision) · `devrites-api-interface` (cross-boundary) ·
+`devrites-audit <security|perf|simplify>` (single-axis review/polish pass) ·
+`devrites-debug-recovery` (failures). Parallel reviewer fan-out at seal is a shared
+reference (see [`devrites-lib/reference/parallel-dispatch.md`](../devrites-lib/reference/parallel-dispatch.md)).
+
+## What to output
+
+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`** → invoke the matching skill 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" → point at `/rite spec <feature>` (or `/rite-spec`). Don't summarize state yourself: `/rite status` (or `/rite-status`) owns that.
+
+## Menu
+
+```
+DevRites — disciplined senior-engineer workflow
+                              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
+CLARIFY       /rite clarify            ≡    /rite-clarify     close the complete decision surface before planning
+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         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       one slice/wright; HITL stops, `.devrites/AFK` may chain
+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
+SEAL          /rite seal               ≡    /rite-seal        final GO / NO-GO decision (no git)
+SHIP          /rite ship               ≡    /rite-ship        pre-GO read-only; fresh GO → commit; optional approved push/tag/PR → archive
+STATUS        /rite status             ≡    /rite-status      active feature, next action, evidence, risks
+DOCTOR        /rite doctor             ≡    /rite-doctor      installation and native host diagnostics
+UPGRADE       /rite upgrade ...        ≡    /rite-upgrade     audit an older workspace; route only proven gaps
+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
+WATCH PR      /rite watch-pr ...       ≡    /rite-watch-pr    observe PR/CI once without mutation
+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  unattended lifecycle; `--ship` stops at Ship preflight
+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 shortcuts)
+```
+
+> **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` when the change is no longer small, reversible, and unambiguous. Use the
+> full lifecycle above for features.
+
+## Core operating rules (every DevRites skill enforces)
+
+The operating rules live in `.devin/skills/devrites-lib/reference/standards/core.md`; DevRites skills Read it as
+their first step, and the other rule files load on demand. See
+[`.devin/skills/devrites-lib/reference/standards/README.md`](../devrites-lib/reference/standards/README.md) for the full index.

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

@@ -0,0 +1,48 @@
+# Menu reference
+
+Phase-ordered `/rite` reference. Load only for command detail or phase connections.
+
+## Phases and commands
+
+| Phase | Command | Use when |
+|---|---|---|
+| Spec | `/rite-spec <feature>` | **New feature.** Investigate → 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 and propose project guidance. |
+| Clarify | `/rite-clarify` | _Required after spec._ Topology-first decision-coverage scan; zero-question fast path when already clear. |
+| Temper | `/rite-temper` | _Optional, before define._ Strategic review of the spec: scope mode (expand/selective/hold-rigor/reduce) + pre-mortem; hardens the spec. Best on big/risky features; mandatory in `/rite-autocomplete`. |
+| Plan | `/rite-define` | Turn the approved spec into plan + vertical task slices + state. |
+| Vet | `/rite-vet` | _Required before build._ Review every plan: scope · architecture · tests · perf; light for simple/reversible, full for high stakes. |
+| Re-plan | `/rite-plan` | The active plan is too big, wrong, stale, ambiguous, or blocked. |
+| Build | `/rite-build` | One slice/wright; HITL stops; `.devrites/AFK` lets root bounded-chain slices. |
+| Converge | `/rite-converge` | _Recovery._ Code drifted from or falls short of intent after a resume, adoption, or stalled build: compare live code with spec/plan/tasks and append 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; normalize and polish UI when 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` | Pre-GO read-only; fresh GO → commit → optional approved push/tag/PR → archive/close. |
+| Status | `/rite-status` | See where the active feature stands. |
+| Doctor | `/rite-doctor` | Diagnose install integrity and native host configuration. |
+| Upgrade | `/rite-upgrade` | _Explicit compatibility._ Audit an older released workspace; route cited defects through Clarify/Plan repair/Converge/Vet or current Prove/Polish/Review/Seal, preserve history, and never synthesize old proof. |
+| Learn | `/rite-learn` | Review native memory and archived evidence → propose durable project guidance. |
+
+## Typical orderings
+
+- **Every feature**: `/rite-spec` (spec) → `/rite-clarify` (decision coverage) →
+  *(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` → `/rite-clarify` → `/rite-define` → `/rite-vet` → build.
+- **Drift mid-build**: classify → bounded recovery for objective defects, `/rite-plan`
+  repair for a wrong durable plan, or one user decision for real product/risk drift.
+- **Older workspace cannot resume**: `/rite-upgrade` audits first → only proven gaps use
+  Clarify/Plan repair/Converge/Vet or Prove/Polish/Review/Seal → resume. It never
+  migrates cursor format or invents a prior pass.
+- **Resumed / adopted / stalled**: `/rite-converge` (assess live code vs intent → append the
+  remaining slices) → `/rite-vet` → `/rite-build` ×N → continue at `/rite-prove`.
+
+## Rules this menu obeys
+
+- `/rite` never edits code or runs a phase workflow.
+- Menu mode is static; `/rite-status` owns workspace status.
+- It suggests; the user (or Claude, when appropriate) invokes the real skill.

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

@@ -0,0 +1,53 @@
+---
+name: rite-adopt
+description: Adopt an existing codebase into DevRites by reverse-engineering current behavior and establishing a baseline workspace.
+argument-hint: "[path or area to adopt] [+ what you want to build next]"
+---
+<!-- loads: {"always":["rite-adopt/reference/adoption.md","rite-adopt/reference/anti-patterns.md","rite-polish/reference/ledger.md"],"triggers":{}} -->
+> Read-set manifest: `devrites-engine context [slug] --skill rite-adopt` bundles every file named below into one deduplicated read. Trigger names map to the conditional rules in the sections that follow.
+
+# /rite-adopt: onboard existing code
+
+Reverse-engineer current behavior into `spec.md`; do not rewrite product code or create a
+parallel convention system.
+
+## Workflow
+
+0. **Pre-flight (workspace anchor).** Resolve the repo root; take the target slug from
+   the user (ask once if material); a missing/ambiguous slug, wrong repo root, or
+   unwritable `.devrites/` blocks Adopt. **Failing case:** adopt infers the slug from
+   cwd alone → stop.
+
+1. Read core; resolve repository/sub-area and next objective. Ask once only if material.
+2. Follow [`reference/adoption.md`](reference/adoption.md): inspect current
+   behavior, architecture and placement, callers, reusable seams, repository/CI
+   commands, visible code/test patterns, non-obvious constraints, and any touched
+   load-bearing seam that needs **characterize-before-modify** (record disposition:
+   `characterized` with see-it-fail stub, or `deferred` with evidence why safe).
+   **Failing case:** plan touches auth middleware with no characterize row → Adopt
+   fails until disposition is recorded. Read existing `AGENTS.md`, `CLAUDE.md`, product,
+   and design guidance.
+3. Create the workspace and write `spec.md`, `decisions.md`, `assumptions.md`,
+   `questions.md`, and `state.md`. The spec separates the current baseline from
+   the measurable next objective.
+4. For a structured baseline, follow the ledger's read workflow in
+   [`ledger.md`](../rite-polish/reference/ledger.md) § Reading in Spec and Adopt:
+   list ledger specs with the host filesystem and read only the touched capabilities;
+   classify against current file content, never memory. The native preview/write
+   workflow runs during Polish, not Adopt.
+5. For a verified non-obvious policy or recurring/costly mistake, prefer existing hook/lint/
+   CI/type/schema enforcement; else propose one evidence-cited nearest-scope instruction edit.
+   Apply only after review; never create convention bands, scores, or a command cache.
+6. A genuine non-negotiable invariant may be proposed for
+   `.devrites/principles.md`; the human must ratify it.
+7. Set the next step to `/rite-clarify` and stop. Do not plan or build.
+
+## Output
+
+```text
+Done: adopted <scope> into <slug>.
+Changed: <workspace artifacts>; project guidance <proposed | unchanged>
+Evidence: <source/CI paths inspected>
+Open: <questions | none>
+Next: /rite-clarify
+```

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

@@ -0,0 +1,19 @@
+# Adoption: reverse-investigation
+
+Loaded by `/rite-adopt`; record code reality before forward work.
+
+Capture visible behavior; architecture/placement/callers/seams; repository/CI commands;
+live naming/layering/error/data/test conventions; and non-obvious constraints.
+
+For each next-objective load-bearing seam without a discriminating test, append after its
+source in `spec.md` existing behavior's `Current evidence` cell:
+
+```text
+Characterization: characterize-before-modify; risk: <risk>; first touch: <slice|unknown>
+```
+
+This is a touched-behavior ratchet, not repository-wide coverage.
+
+Use current code/search/docs; source and CI beat history. Put baseline/objective in
+`spec.md`, uncertainty in `assumptions.md`, durable choices in `decisions.md`, and guidance
+in nearest scoped instructions—never ledgers, scores, confidence bands, or command caches.

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

@@ -0,0 +1,19 @@
+# /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.
+
+## Adoption-specific rationalizations
+
+| 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 *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.

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

@@ -0,0 +1,147 @@
+---
+name: rite-autocomplete
+description: Run the full DevRites lifecycle unattended; --ship continues to the final Git approval boundary. Use for one-shot autonomous work; not for a single phase.
+argument-hint: "[idea] [--ship|--yolo] [--max-slices N] [--parallel N] [--full] [--cross-model]"
+---
+
+<!-- loads: {"always":["devrites-lib/reference/standards/core.md","devrites-lib/reference/standards/afk-hitl.md","devrites-lib/reference/standards/one-shot-actions.md","devrites-lib/reference/orchestration-profiles.md","devrites-lib/reference/standards/acceptance-preserving-reslice.md","rite-autocomplete/reference/decision-policy.md","rite-autocomplete/reference/loop.md","rite-autocomplete/reference/stop-conditions.md"],"triggers":{"workflow-artifacts":["devrites-lib/reference/standards/workflow-artifacts.md"]},"workspace":["state.md","spec.md","plan.md","tasks.md","questions.md","decisions.md","drift.md","evidence.md","test-plan.md"]} -->
+> Read-set manifest: `devrites-engine context <slug> --phase autocomplete` bundles every file named below into one deduplicated read. Trigger names map to the conditional rules in the sections that follow.
+
+
+# /rite-autocomplete: full lifecycle, unattended
+
+Run every phase after one clarification window. Irreversible-risk,
+escalating,<!-- pack-scan-ignore: negated statement: gates are NOT disabled -->
+access, unanswered blocking with no recommended option, and remaining NO-GO
+still pause. Open blocking questions that already name a ranked recommended
+option auto-resolve; they are not a user handoff. Use the Standard native
+profile by default and Full for high-risk scope or explicit `--full`; see
+[`orchestration-profiles.md`](../devrites-lib/reference/orchestration-profiles.md).
+
+## Required rules
+
+Read [`core.md`](../devrites-lib/reference/standards/core.md) and [`afk-hitl.md`](../devrites-lib/reference/standards/afk-hitl.md) first. Read
+[`one-shot-actions.md`](../devrites-lib/reference/standards/one-shot-actions.md) before any stop/continue or execution decision involving a
+consumptive action. Before honoring a terminal cursor that names missing
+executable controller/harness/bundle bytes or a missing writer, read
+[`workflow-artifacts.md`](../devrites-lib/reference/standards/workflow-artifacts.md)
+(trigger `workflow-artifacts` — only when a workspace declares them). Before classifying any Reslice, read `.devin/skills/devrites-lib/reference/standards/acceptance-preserving-reslice.md`.
+
+<!-- BEGIN RESLICE ROUTE-TO-ACTION -->
+- `FOLD` → keep Plan repair/affected Vet internal; no stop solely for topology/count.
+- `GUARD_AND_REPAIR` → enter Spec Drift Guard/Clarify; pause only at an existing human-owned gate; resume Plan/Vet internally.
+- `BLOCKED_INPUT` → no planning writes; stop internal branch; exact diagnostic; recover authority; reclassify.
+<!-- END RESLICE ROUTE-TO-ACTION -->
+
+## Invariants
+
+- Use one initial human window: Spec, topology-first Clarify, and
+  `Decision coverage: CLEAR`. Only then arm AFK. Record later reversible choices
+  under [decision policy](reference/decision-policy.md).
+- Safety is not bypassable. `--ship`/`--yolo` reaches only the exact-plan
+  literal-GO and native-approval boundary; it never authorizes Git.
+- **Treat technical readiness as routing, not completion.** `NEEDS REPLAN` is a backward edge
+  to Plan repair and narrow Vet. `NEEDS REPLAN` cold resume follows a valid
+  technical return cursor before forward work or any reply. Clarification is
+  likewise internal when current authority resolves it.
+- Always follow agent-owned backward edges through repair, affected Vet,
+  correction, and proof. A nested `STOP`/`Next step` is not a user handoff.
+  Pause only for a shared human/safety/access/exhaustion condition.
+- **Do not confuse an action budget with recovery exhaustion.** Spent action
+  authority blocks another real execution, not offline correction of retained
+  Critical/Important evidence. Stop for fresh GO only after changed conditions
+  and READY Vet.
+- Every exact causal fingerprint gets at most three no-progress corrections.
+  Closing one is progress; a distinct Critical/Important invariant has its own
+  budget. Lower severity cannot prolong recovery.
+- Do not stop on `--max-slices`, sentinel `max_slices`, `max_agents`,
+  `max_minutes`, or `max_review_queue`. Count failed, malformed, and
+  unavailable leaf calls.
+- Parse flags only from this invocation. `--ship`, `--yolo`, `--max-slices`,
+  `--parallel`, `--full`, and `--cross-model` activate only as exact standalone
+  tokens in `$ARGUMENTS`; examples or earlier messages can never arm them.
+  `--max-slices` must occur once and be followed by a positive base-10 integer;
+  `--parallel` must occur once and be followed by a base-10 integer in `1`–`10`.
+  Missing, repeated, malformed, or conflicting values stop before any write.
+- Temper always runs after Clarify. Auto-apply the recommended mode, including
+  `expand` and extra acceptance; record the ADR and fold via Spec Drift Guard.
+  Irreversible-risk still pauses.
+- Vet every plan. Cross-model is off unless the current invocation arms it.
+
+## Workflow
+
+1. **Orient and parse.** Resolve the explicit or active slug; when a workspace exists,
+   require its `state.md` and read its cursor; a fresh idea starts empty at step 2.
+   Before honoring `blocked` with terminal `next_action`,
+   reconcile retained consumptive evidence and fingerprint attempts from
+   `drift.md`/`evidence.md`; a retained fingerprint below its cap resumes offline
+   recovery.
+<!-- workflow-artifact-adapter: {"module":"devrites-lib/reference/standards/workflow-artifacts.md","entry":"lifecycle cursor encounters admitted set or resumable journal","action":"invoke classifier; execute returned route internally","return":"saved phase/action; zero intermediate reply"} -->
+   Reconstruct a missing return cursor only from
+   the current phase and exact approved action in `test-plan.md`/evidence, never
+   from chat. After compaction or a resumed session, read `.devrites/ACTIVE`, then
+   the `state.md` cursor, `questions.md`, `decisions.md`, and `test-plan.md`/`evidence.md`.
+   Normalize current arguments to idea, `ship_preflight: yes|no`,
+   `max_slices: unlimited`, `parallel: N|default`, `profile: standard|full`,
+   and `cross_model: yes|no`.
+   **Completion:** normalized state is unambiguous and no sentinel or workspace file has been written.
+2. **Specify and clarify.** Run `devrites-interview`, `/rite-spec`, and
+   `/rite-clarify` as one window. Partial/Missing material coverage never arms
+   AFK. **Completion:** `Decision coverage: CLEAR` is durable.
+3. **Arm AFK once.** Apply the loop's
+   [one-write AFK contract](reference/loop.md#arm-afk-once): preserve valid
+   existing bytes or create the sentinel once (`allow_gates: [advisory, validating]`); never
+   rewrite it after Vet except to write or replace only `max_parallel: N` when
+   this invocation contains `--parallel N`. Preserve an existing sentinel
+   byte-for-byte otherwise. **Failing case:** leftover `max_parallel: 1` keeps
+   the run serial after `--parallel 5`.
+   **Completion:** a valid read-only AFK sentinel exists.
+4. **Drive phases.** Follow [the loop](reference/loop.md): `/rite-spec` →
+   `/rite-clarify` → `/rite-temper` → `/rite-define` → `/rite-vet` →
+   `/rite-build` batch loop → `/rite-prove` → `/rite-polish` →
+   `/rite-review` → `/rite-seal`. Read and execute each skill; durable files, not
+   chat, carry state. Apply the mutable post-vet budget before first Build.
+   Build runs the largest eligible path-disjoint batch (cap: this invocation's
+   `--parallel N`, else sentinel `max_parallel`, else 10) and recomputes after
+   every completed round until no pending slice remains; a one-slice round is serial for that round only, then
+   selection runs again (host isolation still forces serial when concurrent writers
+   cannot be separated). When `--parallel N`
+   is present, pass it into `/rite-build` and do not consult leftover sentinel
+   `max_parallel`.
+   **Completion:** loop reaches Seal GO or persists a valid stop before any later phase.
+5. **Apply stops.** At every gate use
+   [stop-conditions.md](reference/stop-conditions.md). A `blocked` label alone is not a stop condition:
+   route agent-owned red results through bounded recovery.
+   Red gates block forward advancement and enter caller-owned recovery. Stop on
+   hard risk, escalating, irreversible-risk, access, blocking with no
+   recommended option, remaining NO-GO, or the exact fingerprint's proven
+   exhaustion. An open blocking question that already names a ranked recommended
+   option (`proposed` or option 1 labelled Recommended) auto-resolves through
+   `devrites-engine state resolve` and continues; do not emit `/rite-resolve` as
+   a user handoff. Technical exhaustion records terminal
+   `Next step: none`, never a routine phase command. **Completion:** no stop is active, or its cursor and reason are durable.
+6. **Seal boundary.** Without a ship flag, stop at Seal GO with `/rite-ship` —
+   unless `continue_sequence` is armed and sequence budget remains, in which case
+   leave the sealed workspace unshipped and open the next recorded continuation
+   ([loop.md § Sequence continuation](reference/loop.md#sequence-continuation));
+   report the sequence position on every stop.
+   With a ship flag, perform Ship preflight, disclose the exact Git plan, and stop for
+   fresh literal `GO` plus native approval. **Completion:** performed no Git action before fresh literal `GO` plus native approval.
+
+## Reply and resume
+
+HITL Build returns after one slice; Autocomplete ignores `--max-slices` and
+keeps chaining pending slices. One Autocomplete invocation owns all internal
+backtracking. Context pressure, compaction, or a nested completion footer does
+not create a stop; persist and resume the cursor.
+
+Use one terse line:
+
+```text
+Autocomplete: <slug>
+spec <done|stopped> · clarify <clear|stopped> · temper <done|stopped> · define <done|stopped> · vet <ready|stopped> · build <n/N|stopped> · prove <done|stopped> · polish <done|stopped> · review <done|stopped> · seal <GO|NO-GO|stopped>
+```
+
+Final state is `Shipped`, `Stopped`, `Awaiting human`, `NO-GO`, or `GO`; do not
+write a narrative recap. Require a clean or accepted baseline, land a local
+unpushed checkpoint after each green check, and never auto-pass a red gate.

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

@@ -0,0 +1,43 @@
+# 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.
+
+Authority: `.devin/skills/devrites-lib/reference/standards/acceptance-preserving-reslice.md`.
+
+<!-- BEGIN RESLICE ROUTE-TO-ACTION -->
+- `FOLD` → keep Plan repair/affected Vet internal; no stop solely for topology/count.
+- `GUARD_AND_REPAIR` → enter Spec Drift Guard/Clarify; pause only at an existing human-owned gate; resume Plan/Vet internally.
+- `BLOCKED_INPUT` → no planning writes; stop internal branch; exact diagnostic; recover authority; reclassify.
+<!-- END RESLICE ROUTE-TO-ACTION -->
+
+## The rule
+
+For each non-trivial choice, pick the option the **relevant specialist favours**, and
+write the choice + the one-line rationale to `decisions.md`. Do not coin-flip, and do
+not pick the option that's merely easiest to implement.
+
+| Choice type | Defer to | Then |
+|---|---|---|
+| Uncertain framework / library behaviour | `devrites-source-driven` (check the docs/source) | record the source in `evidence.md` |
+| Risky boundary / data-model / API decision | `devrites-doubt` (+ `devrites-doubt-reviewer`) | record the trade-off in `decisions.md` |
+| Cross-boundary contract (FE/BE split, API shape) | `devrites-api-interface` | contract-first slice |
+| UI surface / states / a11y | `devrites-frontend-craft` | shape before code |
+| Two reasonable designs, no clear winner | the simpler one that meets acceptance | note why in `decisions.md` |
+
+## Defaults autocomplete may assume (record them)
+
+- 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`](../../devrites-lib/reference/standards/coding-style.md)).
+- When two options are equivalent on the evidence, choose the lower-risk / more
+  reversible one.
+
+## When a choice is NOT autocomplete's to make
+
+Irreversible-risk, escalating, access, and blocking questions with no ranked
+recommended option stay human. A blocking question that already names option 1
+`(Recommended)` or `proposed:` is autocomplete's to resolve: pick that option
+via `devrites-engine state resolve` and continue. Recommended temper `expand`
+auto-applies; do not invent product intent.