devrites 2.6.1 → 3.0.1

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

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

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

@@ -1,7 +1,8 @@
 ---
 name: rite-prototype
-description: Throwaway prototype answering ONE design question — either a runnable Logic harness or 2–4 radically different UI variations on one route — then delete or absorb. Use when the user says "prototype this", "sanity-check the data model", or "try a few UI designs". Not for production code.
+description: User-invoked throwaway prototype for one logic or UI design question; delete or absorb after the answer.
 user-invocable: true
+disable-model-invocation: true
 argument-hint: "[the question the prototype is answering]"
 ---
 
@@ -12,7 +13,7 @@ chooses the shape — get the shape wrong and the whole prototype wastes the use
 
 ## 0. Read core rules
 
-Read `.claude/rules/core.md` first — the operating rules and the "capture the answer"
+Read `.claude/skills/devrites-lib/reference/standards/core.md` first — the operating rules and the "capture the answer"
 persistence discipline apply even to throwaway code. The other rule files load on demand.
 
 ## 1. Name the question
@@ -87,3 +88,23 @@ fills the verdict before the prototype is deleted.
 
 After the prototype answers the question and the answer is recorded, return to the
 calling phase. The prototype itself does **not** ship.
+
+## Output
+
+Reply-contract exception: scoped prototype detour. Run `devrites-engine progress` only when
+an active workspace exists; otherwise skip it. Use the compact labels from the shared
+completion reply contract
+([`devrites-lib/reference/reply-contract.md`](../devrites-lib/reference/reply-contract.md)).
+
+```
+Done: prototype answered <question>.
+Changed: <prototype path | deleted after absorption>; decisions.md or NOTES.md
+Evidence: run command <cmd -> result>; verdict <one line>
+Open: <none | non-blocking delete/absorb follow-up>
+Next: <single command returning to the calling phase>
+Record: <.devrites/work/<slug>/decisions.md | NOTES.md path>
+↻ Hygiene: /clear after the answer is recorded; delete or absorb throwaway code before shipping
+```
+
+If the verdict is missing, use the shared `Awaiting human` form. The prototype is
+not `Done`, and `Resume:` points to the queued verdict question.

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

@@ -1,6 +1,6 @@
 ---
 name: rite-prove
-description: Prove the completed feature against its `spec.md` acceptance criteria. Use when the user says "prove this", "run the full tests", or "check it end-to-end". Not for single-slice or pre-completion proof.
+description: Prove a completed feature with tests and the full test suite, build/typecheck/lint, end-to-end/browser evidence, screenshots, commands, and outputs for seal. Not for single-slice proof.
 argument-hint: "[feature-slug]"
 user-invocable: true
 ---
@@ -10,14 +10,12 @@ user-invocable: true
 Turn "I think it works" into recorded evidence for the **whole feature**. Read the active
 workspace first; if none, run `/rite-spec <feature>`.
 
-> **Differs from built-in `/verify` and `/run` in:** `/verify` proves a
-> single change; `/run` launches the app. `/rite-prove` is feature-scoped:
-> it walks `spec.md` acceptance criteria one-by-one, runs the full relevant
-> test suite + build/typecheck/lint, ascends the browser-proof ladder
-> (Playwright MCP → DevTools MCP → `/run`+`/verify` → project E2E →
-> manual), and writes `evidence.md` + `browser-evidence.md` keyed to the
-> active `.devrites/work/<slug>/`. Use `/verify` or `/run` on their own
-> when there is no DevRites feature workspace.
+> **Differs from built-in `/verify` and `/run`:** those prove a single change /
+> launch the app. `/rite-prove` is feature-scoped — it walks `spec.md` acceptance
+> criteria one-by-one, runs the full relevant test suite + build/typecheck/lint,
+> ascends the browser-proof ladder (step 4),
+> and writes `evidence.md` + `browser-evidence.md` keyed to the active
+> `.devrites/work/<slug>/`. No DevRites workspace → use `/verify` or `/run` alone.
 
 ## Gate: all slices must be built first
 Read `tasks.md` + `state.md`. **If ANY slice is still pending/unbuilt, STOP** and tell the
@@ -32,10 +30,11 @@ it can be **re-run scoped** afterwards: when `/rite-polish` or `/rite-review` ed
 the existing `evidence.md` no longer post-dates the change, so re-run `/rite-prove` over
 the affected criteria/routes to refresh proof before `/rite-seal`.
 
-## Rules consulted (read on demand from `.claude/rules/`)
-**Step 0:** Read `.claude/rules/core.md` first. The other rule files load on demand;
-pull these via `Read` when relevant:
+## Rules consulted (read on demand from `.claude/skills/devrites-lib/reference/standards/`)
+Pull these via `Read` when relevant:
 - `testing.md` — pyramid, determinism, no-flake discipline.
+- `test-proof-checklist.md` — compact proof-quality gate for tests and recorded evidence.
+- `browser-proof-checklist.md` — for UI scope, the required browser states and Visual Verdict evidence.
 - `spec-grammar.md` — when the spec uses structured `### Requirement:` / `#### Scenario:`
   blocks, each scenario (WHEN/THEN) is one observable behavior to walk and prove.
 - `performance.md` — measure first when perf is in scope.
@@ -44,6 +43,8 @@ pull these via `Read` when relevant:
 - `developer-experience.md` — when the change ships a developer-facing surface (API / CLI / SDK /
   webhook / config / error messages / getting-started): **measure** the DX scorecard (run the flow,
   time time-to-hello-world, capture the verbatim error text), don't assert it.
+- `definition-of-done.md` — standing Done bar: acceptance mapped, fresh proof, no open hard gates, scoped edits, rollback/docs where needed.
+
 
 ## Operating rules
 - Evidence over confidence. Feature scope only — fix within the feature or record a
@@ -52,108 +53,52 @@ pull these via `Read` when relevant:
   drift (`rite-build/reference/spec-drift-guard.md`).
 
 ## Workflow
-0. Read `.claude/rules/core.md` first (the always-on operating rules); pull the
+0. Read `.claude/skills/devrites-lib/reference/standards/core.md` first (the always-on operating rules); pull the
    on-demand rules above when relevant.
-   Then **run the shared orientation preamble** — it prints `state.md`, the artifacts present,
-   the run mode (HITL/AFK), and the open-question tally by gate, so you orient deterministically
-   instead of re-deriving state from raw Markdown:
-   ```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)"
-   ```
+   Then run `devrites-engine preamble` for deterministic workspace orientation.
 1. **Confirm the gate** (all slices built). Read `spec.md` (acceptance criteria +
    "Commands discovered"), `tasks.md`, `state.md`, `test-plan.md` if present (the vetted
    coverage target from `/rite-vet`), and the full `git diff`.
 2. **Discover commands** if not recorded —
    [test-command-discovery](reference/test-command-discovery.md): README, package
    scripts, Makefile, CI configs, Gemfile/Rakefile, pyproject, go.mod, Cargo.toml.
+   **Completion:** exact runnable test/build/typecheck/lint commands are recorded or explicitly unavailable.
 3. **Run the full relevant test suite** for the feature (not a single slice), then the
    relevant **build / typecheck / lint**.
-4. **UI feature?** Run the browser proof ladder over the feature's routes —
+4. **UI feature?** Read `design-brief.md` + `references.md`, then run the browser proof ladder over the feature's routes —
    [proof-ladder](reference/proof-ladder.md) + [browser-proof](reference/browser-proof.md)
    (`devrites-browser-proof`): routes, viewports, screenshots (opened + described),
-   console, network, interaction paths, and design-reference match if references exist.
-5. **Map results to acceptance** — walk `spec.md` acceptance criteria; note which are now
-   proven and which aren't. **If the spec uses the structured grammar** (`### Requirement:` /
-   `#### Scenario:` blocks — `spec-grammar.md`), walk it **per scenario**: each `#### Scenario:`
-   WHEN/THEN is one observable behavior that needs a passing asserting test (the WHEN is the
-   arrange, the THEN the assert). A scenario with no covering result is an unproven gap =
-   blocker, the same standing as an uncovered acceptance criterion. Re-run the grammar gate
-   first so a requirement hand-edited to malformed since `/rite-spec` can't masquerade as proven:
-   ```bash
-   SV=.claude/skills/devrites-lib/scripts/spec-validate.sh
-   [ -f "$SV" ] || SV="${CLAUDE_SKILL_DIR:-}/../devrites-lib/scripts/spec-validate.sh"
-   [ -f "$SV" ] || SV=pack/.claude/skills/devrites-lib/scripts/spec-validate.sh
-   [ -f "$SV" ] && { bash "$SV" ".devrites/work/<slug>"; echo "spec-validate rc=$?"; } || true
-   ```
-   If `test-plan.md` exists, also walk its acceptance→test map and
-   per-gap requirements — a planned test (especially a regression-Critical) with no covering
-   result is an unproven gap, not a pass. **Also walk the test-plan interaction inventory**
-   (every interactive element + user flow): each must have a passing asserting test. An
-   element/flow with no asserting result is an **unproven gap = blocker** — a NO-GO at
-   `/rite-seal`, the same standing as an unproven acceptance criterion (`testing.md`
-   "Completeness"). For UI, the browser proof (step 4) demonstrates the flows; the asserting
-   tests prove the elements.
-5a. **Assertion-strength spot check (critical paths).** For each regression-Critical /
-   irreversible / data-loss path, confirm the covering test actually *can* fail: reject
-   tautological assertions (`toBeDefined`-only, asserting the mock), and **fault-inject** —
-   break the code on purpose (flip a comparison, drop a guard) and confirm the test goes red,
-   then revert. Run the project's mutation-testing tool over the touched criticals if it has
-   one. A test that stays green on deliberately broken code is an unproven gap, not a pass
-   (`testing.md` "Assertion strength"). Record what was fault-checked in `evidence.md`.
-   Run the deterministic gates rather than eyeballing:
-   ```bash
-   D=.claude/skills/devrites-lib/scripts
-   [ -d "$D" ] || D="${CLAUDE_SKILL_DIR:-}/../devrites-lib/scripts"
-   [ -d "$D" ] || D=pack/.claude/skills/devrites-lib/scripts
-   [ -f "$D/test-integrity.sh" ] && { bash "$D/test-integrity.sh"; echo "test-integrity rc=$?"; } || true   # exit 3 = a test was weakened to pass → NO-GO
-   [ -f "$D/mutation-gate.sh" ]  && bash "$D/mutation-gate.sh" || true                                      # changed-files mutation score → band the seal verdict
-   ```
-   For a parser / serializer / encoder / auth-token / pure-transform criterion, add a **round-trip
-   or metamorphic property** check (`decode(encode(x))==x`, `parse∘print==id`) over generated inputs —
-   example tests miss the edge cases these explore. If the same unit regenerated from a paraphrased
-   spec (or a second sample) **diverges in behaviour on shared inputs**, treat that as a low-confidence
-   signal: under AFK it blocks an auto-GO and routes to HITL.
-5b. **Observability check (runtime surface only).** If the feature added an endpoint, job,
-   queue consumer, external integration, user-facing flow, or a new error path, apply the
-   on-call test (`observability.md`): are the signals needed to debug a prod failure present —
-   structured logs on the failure path, a metric/counter on errors, a trace id across any
-   boundary? Then **observe them fire**: trigger the path and confirm the log line / metric /
-   span actually emits, and record that observation in `evidence.md`. Instrumentation never seen
-   emitting is unproven, not done. Skip entirely for pure-internal / docs / config / type-only
-   changes — don't instrument a typo fix.
-5c. **Developer-experience measure (developer-facing surface only).** If the feature ships a public
-   API, CLI, SDK/library, webhook, config/env contract, error/exit path, or the getting-started flow
-   (`developer-experience.md`), **exercise it** rather than reading it: run the getting-started steps
-   on a clean state and **time time-to-hello-world**; invoke the CLI `--help` / call the endpoint /
-   import the package; trigger the failure path and capture the **verbatim** error text. For a docs or
-   quickstart page, capture it through the browser-proof ladder (`devrites-browser-proof`) and describe
-   the screenshot. Write the **measured** scorecard to `devex.md` (beside the `/rite-vet` prediction the
-   boomerang reconciles at `/rite-seal`) and the headline numbers + error strings to `evidence.md`. A
-   scorecard from "the code looks fine" is Source mode, not proof. Skip entirely when no developer-facing
-   surface is in scope — don't DX-measure an internal refactor.
+   console, network, interaction paths, and the brief's proof targets. Compare screenshots
+   with target references, record deltas, fix/re-render, and do not pass with an unresolved
+   material mismatch.
+5. **Map proof completely.** Follow
+   [`reference/acceptance-proof.md`](reference/acceptance-proof.md) for acceptance/scenario
+   coverage and the conditional critical-path, observability, developer-surface, and wiring
+   branches. Completion: every criterion, planned interaction, and declared key link has a
+   proof class plus passing evidence, or is recorded as a blocker.
 6. **On failure** → [failure-triage](reference/failure-triage.md) +
    `devrites-debug-recovery`. Reproduce → isolate → fix within scope → re-run; if a fix
    would exceed scope, record a blocker.
-7. Update `evidence.md`, `browser-evidence.md` (if UI), and `state.md`.
+7. Update `evidence.md`, `browser-evidence.md` (if UI), `traceability.md`, and
+   `state.md`. New proof goes to `evidence.md` (`proof.md` is a read-only alias —
+   see `devrites-lib/reference/workspace-artifact-schema.md`).
 
 > **Mid-flight discipline.** When tempted to claim an un-observed pass, skip a rung of the browser-proof ladder, or proceed with slices pending — see [`anti-patterns`](reference/anti-patterns.md). Load it the moment you reach for the excuse.
 
 ## Output
 
-**Footer first** — render the slice meter + flow ribbon by running the progress footer (`progress.sh`, resolved like the step-0 preamble — canonical snippet in `devrites-lib/SKILL.md`); keep the fact lines below it terse (`key value · key value`). 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:
 ```
-Proved: <feature>
-Acceptance criteria proven: <n / total>
-Scenarios proven: <n / total | n/a (flat acceptance)>
-Tests:  <cmd → pass/fail (counts)>
-Build:  <cmd → pass/fail>   Lint: <cmd → pass/fail>
-Browser: <ladder rung used + summary | n/a>
-DevEx:  <measured TTHW + getting-started/error-message verdict → devex.md | n/a (no dev-facing surface)>
-Unresolved failures / blockers: <none | list>
-Next: /rite-polish   (finish the feature → /rite-review → /rite-seal)
-↻ Hygiene: /clear before /rite-polish (evidence.md + browser-evidence.md captured; debug trails noisy). See rules/context-hygiene.md.
+Done: feature proof complete for <slug>.
+Changed: evidence.md, browser-evidence.md <updated|n/a>, devex.md <updated|n/a>, state.md
+Evidence: acceptance <total>/<total> (judgment-only <n>); scenarios <total>/<total|n/a>; key links <n>/<n|none>; tests/build/lint/browser <pass summary>
+Open: none
+Next: /rite-polish
+Record: .devrites/work/<slug>/evidence.md
+↻ Hygiene: /clear before /rite-polish
 ```
-— (see hard rule above).
+If any check fails, a blocker remains, or a criterion is unproven, use the shared
+`Stopped / blocked` form and route `Fix:` to the failing check or `/rite-build`; do
+not recommend `/rite-polish`.

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

@@ -0,0 +1,48 @@
+# Acceptance proof
+
+Map every `spec.md` acceptance criterion to evidence and label its proof class:
+`test`, `command`, `browser`, or `judgment` with a one-line reason. Re-run the
+structured grammar gate before mapping scenarios:
+
+```bash
+devrites-engine spec-validate ".devrites/work/<slug>" --against .devrites/specs
+```
+
+Each structured WHEN/THEN scenario needs a passing asserting test. If `test-plan.md`
+exists, every acceptance mapping, per-gap requirement, interactive element, and user
+flow needs a passing result. Missing coverage is an unproven blocker.
+
+## Critical-path assertion strength
+
+For regression-Critical, irreversible, and data-loss paths, fault-inject a small
+behavior break and confirm the covering test goes red, then revert. Use the existing
+mutation tool when present. Run:
+
+```bash
+devrites-engine test-integrity
+devrites-engine mutation-gate
+devrites-engine package-existence
+```
+
+A test that stays green on broken code is unproven. Pure transforms also get a
+round-trip or metamorphic property check when applicable.
+
+## Runtime observability branch
+
+For endpoints, jobs, consumers, integrations, user-facing flows, or new error paths,
+apply the on-call test from `observability.md`: trigger the failure path and observe the
+required log, metric, or trace emit. Record the observation. Skip pure internal, docs,
+config, and type-only changes.
+
+## Developer-facing branch
+
+For a public API, CLI, SDK, webhook, config contract, error path, or getting-started
+flow, execute the real entry point on clean state. Measure time-to-hello-world and
+capture verbatim failure output. Browser-capture docs/quickstarts when applicable.
+Write the measured scorecard to `devex.md` and headline evidence to `evidence.md`.
+
+## Wiring branch
+
+Walk every key link declared by `plan.md` and exercise or follow it in the assembled
+feature. Record each as `EVID-###`; if none are declared, record that fact. An unwired
+link is a blocker.

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

@@ -5,7 +5,7 @@ report a pass you didn't observe, skip a rung of the browser-proof ladder,
 or proceed without all slices built.
 
 Pack-wide rationalizations + red flags (incl. observed-but-not-recorded):
-see [rules/anti-patterns.md](../../../rules/anti-patterns.md).
+see [standards/anti-patterns.md](../../devrites-lib/reference/standards/anti-patterns.md).
 
 ## Phase-specific rationalizations
 

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

@@ -4,23 +4,46 @@ What `browser-evidence.md` must capture for a UI slice. Delegates to
 `devrites-browser-proof`; this is the record contract.
 
 ```markdown
-## Slice <N> — <name>  (<date>)
-- Tooling: playwright-mcp | devtools-mcp | /run+/verify | <e2e> | manual
-- Route(s): <url(s) exercised>
-- Viewports: 375 / 768 / 1280  (note which were checked)
-- Screenshots: <path(s)>  — described: <what is actually visible>
-- Console: <errors/warnings, or "clean">
-- Network: <failures, or "no failures">
-- Interaction path: <the clicks/inputs performed and the result>
-- Accessibility: <focus order / labels / contrast spot-check>
-- Responsive: <what changed across viewports; any breakage>
-- Limitations: <what could not be verified and why>
+# Browser Evidence
+
+## Browser evidence
+| Evidence ID | Route | State/input | Viewport | Compared with | Tooling | Result | Related IDs | Limitation |
+| --- | --- | --- | --- | --- | --- | --- | --- | --- |
+| EVID-003 | <route> | empty/keyboard | 375 | brief Proof targets + R1 | playwright-mcp | <observed result> | AC-002, SLICE-002 | <none / exact gap> |
+
+## Visual Verdict
+| State | Result | Notes |
+| --- | --- | --- |
+| default | PASS / FAIL | <what is visible> |
+| loading | PASS / FAIL | <what is visible> |
+| error | PASS / FAIL | <what is visible> |
+
+## Comparison deltas
+| State / viewport | Target | Material delta observed | Disposition | Result |
+| --- | --- | --- | --- | --- |
+| empty / 375 | design-brief.md + R1 | <hierarchy/layout/spacing/type/behavior difference> | fixed + re-rendered / accepted with reason | PASS / FAIL |
+
+## Run notes
+- Screenshots: <path(s)> — opened and described above.
+- Console: <errors/warnings, or "clean">.
+- Network: <failures, or "no failures">.
+- Interaction path: <clicks/inputs performed and result>.
+- Accessibility: <focus order / labels / contrast spot-check>.
+- Responsive: <what changed across viewports; any breakage>.
 ```
 
 ## Rules
 - Open every screenshot path and describe it — never assert from the filename.
-- Check at least a small (375) and a large (1280) viewport for layout slices.
+- Read `design-brief.md` + `references.md` first. Compare fidelity only with references
+  classified **target**; check constraints as rules and never pixel-match inspiration.
+- Render every proof target named by the brief/slice. At minimum check a small (375) and a
+  large (1280) viewport for layout slices.
+- Compare structure before decoration: hierarchy/layout → responsive/state behavior →
+  type/spacing/color → polish. Record each material delta, fix it, and re-render. A visual
+  PASS requires zero unresolved material deltas; an accepted departure needs its reason in
+  the design brief's build-time refinements.
 - A clean console + no layout shift are part of the evidence, not extras.
 - If no browser can run, write the manual verification steps a human would follow and
   mark the slice's browser proof as **pending (manual)**.
-```
+- Every browser evidence row uses `EVID-###` and names the related `AC-###` and
+  `SLICE-###`; `/rite-prove` mirrors the evidence ID in `traceability.md`.

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

@@ -1,6 +1,6 @@
 ---
 name: rite-quick
-description: Express lane for a SMALL, reversible change. Use when the user says "quick fix" or "just do X", or for a typo / copy / config / single-function / one-file change that is low-risk and unambiguous. Escalates to `/rite-spec` (full lifecycle) the moment scope, risk, or ambiguity grows. Not for auth / data-model / migration / public-API / multi-slice / ambiguous work — those need the full lifecycle.
+description: Express lane for a small reversible change: typo/copy/config, rate-limit constant, error message, local variable rename, feature flag, README link, one-file/function fix.
 argument-hint: "<what to change>"
 user-invocable: true
 ---
@@ -18,7 +18,7 @@ executable, not advisory.
 **Run this first. If ANY of these holds, STOP and route to `/rite-spec` — do NOT use the
 express lane:**
 - Touches **auth / authz**, a **data migration**, a **public API contract**, or any
-  **destructive / data-loss** path (the irreversible-risk list — `rules/afk-hitl.md`).
+  **destructive / data-loss** path (the irreversible-risk list — `standards/afk-hitl.md`).
 - Spans **more than one vertical slice**, or more than a couple of files of real logic.
 - **Ambiguous scope** — you'd have to guess what "done" means, or the ask hides a design
   decision (data model, new dependency, second design system).
@@ -32,12 +32,14 @@ escalate** — the cost of the full lifecycle on a small change is minutes; the
 express lane on a risky one is the failure mode the lifecycle exists to prevent.
 
 ## Rules consulted
-Read `.claude/rules/core.md` first. Then the small set this lane actually needs:
+Load this lane's conditional standards when needed:
 - `coding-style.md` — naming, guard clauses, reuse-first.
 - `testing.md` — TDD, **completeness** (every touched behavior/element asserted) +
   **assertion strength** (no tautological tests; see it fail first), scaled to the change.
 - `error-handling.md` / `security.md` — only if the change touches input/errors.
 - `principles.md` — when `.devrites/principles.md` exists; a change that breaks an invariant is a gate, not a quick fix.
+- `definition-of-done.md` — standing Done bar: acceptance mapped, fresh proof, no open hard gates, scoped edits, rollback/docs where needed.
+
 
 ## Workflow
 0. **Orient.** Read `core.md`. If a `.devrites/` workspace is active, run the preamble to
@@ -70,17 +72,22 @@ decision surfaces, scope grows past the boundary, or you hit an irreversible-ris
 fix into an unreviewed feature; that's the exact drift the lifecycle guards against.
 
 ## Output
-**Footer first** — render the flow ribbon by running the progress footer (`progress.sh`,
-resolved like the step-0 preamble — canonical snippet in `devrites-lib/SKILL.md`) when a
-workspace is active; otherwise skip it. Then:
+Run `devrites-engine progress` when a workspace is active; otherwise skip it. Then use the
+shared completion reply contract
+([`devrites-lib/reference/reply-contract.md`](../devrites-lib/reference/reply-contract.md)).
+Default success shape:
 ```
-Quick change: <one line>
-Scope: <files touched>   (boundary held? yes)
-Tests: <cmd → pass>   ·   Assertion check: <real asserts, saw red | n/a>
-Diff: <summary>
-Next  ▸ commit (Conventional) on your confirm  ·  or /rite-ship if tracked
-↻ Hygiene: /clear after commit — the change is small and self-contained.
+Done: quick change complete — <one line>.
+Changed: <files touched>
+Evidence: tests <cmd -> pass>; assertion check <real asserts saw red | n/a>; boundary held yes
+Open: <none | non-blocking follow-up | tracked workspace needs ship>
+Next: <single recommended command>
+Record: <commit/PR path | .devrites/work/<slug>/evidence.md | not applicable>
+↻ Hygiene: /clear after commit
 ```
 
+If the quick boundary does not hold or an escalation remains, use `Stopped / blocked`
+and route to the full lifecycle; do not render `Done`.
+
 **DO NOT** use this lane to dodge the gate — the express lane is for changes that are
 *actually* small, not for shipping risky work faster.

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

@@ -1,8 +1,9 @@
 ---
 name: rite-resolve
-description: Resolve open `questions.md` entries on the active feature — answer one, drop one, or batch-resolve from a file — and clear `state.md` `Awaiting human` so the workflow resumes. Use when the user says "answer that question", "drop that question", or a HITL checkpoint / AFK blocking question needs an answer. Not for raising new questions or editing answered ones.
+description: User-invoked resume verb for answering, dropping, or batch-resolving open `questions.md` gates.
 argument-hint: "<qid> \"<answer>\"  |  --drop <qid> [\"<reason>\"]  |  --batch <path-to-yaml>"
 user-invocable: true
+disable-model-invocation: true
 ---
 
 # /rite-resolve — answer the human gate
@@ -11,17 +12,17 @@ user-invocable: true
 already paused and **stopped the session** (an AFK blocking/escalating/irreversible queue, or a
 HITL pause the human walked away from), plus `--batch`. When `/rite-build` asks a gap **inline**
 via `AskUserQuestion` and the human is present, that pick resolves the gate **in place** through
-the same `resolve.sh` writer — you don't type `/rite-resolve` for it. For the async case this
+the same `devrites-engine resolve` writer — you don't type `/rite-resolve` for it. For the async case this
 skill takes the human's answer (or `--drop` / `--batch`), writes it to `questions.md`, updates
 `state.md` (clears `Awaiting human`, sets `Status: running`), and recommends the next command.
 
 It is **deliberately small**: one verb, one source of truth (`questions.md`), one cursor
 (`state.md`). The full AFK / HITL contract lives in
-[`afk-hitl.md`](../../rules/afk-hitl.md).
+[`afk-hitl.md`](../devrites-lib/reference/standards/afk-hitl.md).
 
-## Rules consulted (read on demand from `.claude/rules/`)
+## Rules consulted (read on demand from `.claude/skills/devrites-lib/reference/standards/`)
 
-Read `.claude/rules/core.md` first. Then pull these via `Read` when shaping the resolve:
+Pull these via `Read` when shaping the resolve:
 
 - `afk-hitl.md` — gate taxonomy, `questions.md` schema, AFK exception rules.
 - `documentation.md` — record decisions and rationale where the answer changes scope.
@@ -39,7 +40,7 @@ Read `.claude/rules/core.md` first. Then pull these via `Read` when shaping the
   through the Spec Drift Guard (`/rite-plan repair`) **after** writing the answer — do
   not modify `spec.md` / `plan.md` inside this skill.
 - **The script is the source of truth.** Always invoke
-  `devrites-lib/scripts/resolve.sh` — it keeps `questions.md` + `state.md` consistent and emits the
+  `devrites-engine resolve` — it keeps `questions.md` + `state.md` consistent and emits the
   next-action recommendation. The one `state.md` field this skill may write by hand is the
   unblocked slice's `Slice mode` (step 4, the named exception); everything else goes through
   the script, never by hand.
@@ -52,17 +53,9 @@ Read `.claude/rules/core.md` first. Then pull these via `Read` when shaping the
 
 ## Workflow
 
-0. **Read `.claude/rules/core.md`** (operating rules + persistence discipline) before
+0. **Read `.claude/skills/devrites-lib/reference/standards/core.md`** (operating rules + persistence discipline) before
    touching the workspace.
-   Then **run the shared orientation preamble** — it prints `state.md`, the artifacts present,
-   the run mode (HITL/AFK), and the open-question tally by gate, so you orient deterministically
-   instead of re-deriving state from raw Markdown:
-   ```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)"
-   ```
+   Then run `devrites-engine preamble` for deterministic workspace orientation.
 1. **Parse arguments.** `$ARGUMENTS` is one of:
    - `<qid> "<answer>"` — answer the single open question.
    - `--drop <qid>` (optional `"<reason>"`) — mark the question `dropped`; record
@@ -77,7 +70,7 @@ Read `.claude/rules/core.md` first. Then pull these via `Read` when shaping the
 3. **Render preview.** Echo the qid, the question, the proposed answer (if any), the
    user's answer, and which slice unblocks. Stop here and ask `confirm? (y/N)` **unless**
    the answer was provided non-interactively via `--batch`.
-4. **Mutate.** Run `bash .claude/skills/devrites-lib/scripts/resolve.sh` with the same
+4. **Mutate.** Run `devrites-engine resolve` with the same
    arguments. The script:
    - flips the qid's `status` to `answered` / `dropped` and stamps `answered_at` + `answer`;
    - if the qid is in `state.md`'s `Awaiting human` block (single-question pause), clears
@@ -91,6 +84,7 @@ Read `.claude/rules/core.md` first. Then pull these via `Read` when shaping the
 5. **Post-resolve hand-off.** If the answer changes product behavior or acceptance →
    recommend `/rite-plan repair`. Otherwise → recommend the slice's natural next action
    (typically `/rite-build` for the slice that was awaiting).
+   **Completion:** the resolved state contains exactly one next command.
 6. **STOP.** This skill does not run `/rite-build` itself — the user re-enters the
    workflow explicitly.
 
@@ -101,13 +95,15 @@ Read `.claude/rules/core.md` first. Then pull these via `Read` when shaping the
 
 ## Output
 
-**Footer first** — render the slice meter + flow ribbon by running the progress footer (`progress.sh`, resolved like the step-0 preamble — canonical snippet in `devrites-lib/SKILL.md`); keep the fact lines below it terse (`key value · key value`). 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:
 ```
-Resolved: <qid> (<gate>, slice <N>)
-Answer:   <one-line summary>
-Workspace updates:
-  - questions.md: q-... status open → answered
-  - state.md:     Awaiting human cleared; Status running
-Next: <recommended command — usually /rite-build or /rite-plan repair>
-↻ Hygiene: no /clear needed (read-only on code; the answer is now persisted).
+Done: resolved <qid> for <gate> at <slice/phase>.
+Changed: questions.md, state.md, decisions.md <updated|n/a>
+Evidence: not applicable; answer persisted before resume
+Open: <none | remaining questions | plan repair needed>
+Next: <single recommended command>
+Record: .devrites/work/<slug>/questions.md
+↻ Hygiene: no /clear needed; the answer is persisted
 ```