devrites 7.1.1 → 7.2.0

package/pack/generated/dsh/skills/rite-prove/SKILL.md

@@ -0,0 +1,151 @@
+---
+name: rite-prove
+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
+---
+
+<!-- loads: {"always":["devrites-lib/reference/standards/core.md","devrites-lib/reference/candidate-integrity.md","devrites-lib/reference/standards/testing.md","devrites-lib/reference/standards/spec-grammar.md","devrites-lib/reference/standards/test-proof-checklist.md","devrites-lib/reference/standards/agents.md","devrites-lib/reference/standards/gates.md","devrites-lib/reference/standards/verification-methods.md","rite-prove/reference/acceptance-proof.md","rite-prove/reference/proof-ladder.md","rite-prove/reference/failure-triage.md","rite-prove/reference/test-command-discovery.md","rite-prove/reference/anti-patterns.md","rite-build/reference/checkpoint.md"],"triggers":{"applicability":["devrites-lib/reference/standards/repository-topology.md","devrites-lib/reference/standards/data-integrity.md","devrites-lib/reference/standards/integration-reliability.md"],"browser":["devrites-lib/reference/standards/browser-proof-checklist.md","rite-prove/reference/browser-proof.md"],"devex":["devrites-lib/reference/standards/developer-experience.md"],"dod":["devrites-lib/reference/standards/definition-of-done.md"],"observability":["devrites-lib/reference/standards/observability.md"],"one-shot":["devrites-lib/reference/standards/one-shot-actions.md"],"performance":["devrites-lib/reference/standards/performance.md"],"workflow-artifacts":["devrites-lib/reference/standards/workflow-artifacts.md"]},"workspace":["brief.md","spec.md","state.md","decisions.md","assumptions.md","questions.md","decision-coverage.md","architecture.md","plan.md","tasks.md","traceability.md","eng-review.md","test-plan.md","gates.md","evidence.md","touched-files.md","browser-evidence.md"],"workspaceByRole":{"proof-runner":["spec.md","test-plan.md","tasks.md","gates.md","evidence.md","touched-files.md","browser-evidence.md","state.md"],"spec-reviewer":["brief.md","spec.md","decision-coverage.md","questions.md","decisions.md","assumptions.md","state.md"]},"rootOnly":["rite-build/reference/checkpoint.md","devrites-lib/reference/standards/workflow-artifacts.md"]} -->
+> Read-set manifest: `devrites-engine context --skills-root .dsh/skills <slug> --phase prove` bundles every file named below into one deduplicated read. Trigger names map to the conditional rules in the sections that follow.
+
+
+# /rite-prove: prove the completed feature
+
+Prove the assembled feature once. No workspace: use `/verify` or `/run`;
+pending tasks: stop for `/rite-build`.
+Never assert unobserved passes. After Polish/Review edits, repeat affected
+criteria/dependencies and bind under
+[evidence validity](../devrites-lib/reference/candidate-integrity.md#evidence-validity).
+Initial full feature proof and required mutable observations still run.
+
+## Rules
+
+Read the applicable standards: [`testing.md`](../devrites-lib/reference/standards/testing.md), [`test-proof-checklist.md`](../devrites-lib/reference/standards/test-proof-checklist.md),
+[`browser-proof-checklist.md`](../devrites-lib/reference/standards/browser-proof-checklist.md) for UI, [`spec-grammar.md`](../devrites-lib/reference/standards/spec-grammar.md), [`performance.md`](../devrites-lib/reference/standards/performance.md),
+[`observability.md`](../devrites-lib/reference/standards/observability.md), topology/data/integration rules named by the plan,
+[`developer-experience.md`](../devrites-lib/reference/standards/developer-experience.md), [`definition-of-done.md`](../devrites-lib/reference/standards/definition-of-done.md), [`one-shot-actions.md`](../devrites-lib/reference/standards/one-shot-actions.md), and
+[`workflow-artifacts.md`](../devrites-lib/reference/standards/workflow-artifacts.md). Developer surfaces require an observed flow, measured
+TTHW, and exact signal-bearing errors; never assert DX (trigger `devex`).
+
+- Each claim needs an executed positive, discriminating assertion and decisive
+  signal; green commands alone are unproven. Methods must be genuinely distinct
+  and coverage counted against an explicit denominator — apply
+  [`verification-methods.md`](../devrites-lib/reference/standards/verification-methods.md).
+- Follow [`candidate-integrity.md`](../devrites-lib/reference/candidate-integrity.md). Prove owns proof binding, not candidate
+  grammar/hashing. Spec Drift Guard owns revealed contract drift.
+- Root runs vetted gates/browser and records immutable evidence; proof runner
+  validates it. Only the bounded wright fixes product source/tests.
+- **Prove remains the controlling caller** during technical backtracking. Save
+  its cursor; run Plan repair, Recovery Vet, remediation, and re-proof inline;
+  consume nested boundaries; resume the failed rung. A strategy is spent after
+  three no-progress attempts on the exact same fingerprint; escalate it per the
+  [retry contract](../devrites-lib/reference/standards/afk-hitl.md#retry-cap-no-progress-loops-and-self-resolve)
+  instead of stopping. Closing one or exposing a distinct
+  Critical/Important invariant is progress, not a reason to hand work off.
+<!-- workflow-artifact-adapter: {"module":"devrites-lib/reference/standards/workflow-artifacts.md","entry":"Prove consumes installed Workflow Artifact or CLEANED rerun","action":"VERIFY_EXISTING or admitted proof path ending PROVE_AND_RETURN","return":"saved Prove cursor; stop before real action"} -->
+## Released-workspace refresh
+
+Only an admitted `/rite-upgrade` assessment proving a released-format candidate
+defect enters. Require legacy touched-file scope, live diff, tasks, and traceability agree unambiguously
+on every candidate path/state. Missing or
+ambiguous scope stops; never guess from Git. Preserve unrelated manifest content
+and refresh only the strict manifest from observed bytes.
+
+Discard old passes. Run all current approved real proof from scratch. Establish
+pre-proof and post-proof engine digest with `devrites-engine check candidate
+<slug>` and require equality, then write one fresh exact binding in evidence and
+browser evidence. Current failure blocks; Upgrade does not authorize source or
+test changes.
+
+## Workflow
+
+1. **Orient.** Read core, resolve active slug, require `state.md`, and read its
+   cursor. On blocked Prove cold resume, reconcile retained consumptive evidence
+   and no-progress corrections before accepting terminal none; a distinct
+   fingerprint below cap resumes offline triage without another real action.
+2. **Freeze scope.** Read spec, tasks, state, test plan, and full diff. Require
+   every slice built except a [deferred slice](../rite-plan/reference/slicing.md#deferred-slice). Missing `test-plan.md` returns to Vet inline (Prove stays the controlling
+   caller) and resumes here; it never authorizes ad hoc proof.
+3. **Approve commands.** If absent, use
+   [test-command-discovery](reference/test-command-discovery.md) over repository
+   manifests/CI. Discovery is evidence only: `test-plan.md` is the sole approved runtime
+   command list. A newly found command must return to the current Vet contract,
+   refresh readiness, then resume without user handoff.
+4. **Execute a frozen candidate.** Run `devrites-engine check candidate <slug>` and retain its digest.
+   The root runs only commands declared by `test-plan.md`, with exact approved
+   command, cwd, prerequisites, exit, and sanitized
+   decisive output, plus the test selector, runner counts
+   (collected/ran/passed/failed/skipped), and attempt number with first-attempt
+   outcome; output and exit come from one execution. Run relevant suite plus build/typecheck/lint,
+   concurrently when they share no build directory, port, or lock. Recheck the
+   candidate and require identical digest/no source mutation. Reject substituted
+   commands, malformed manifests, zero-test/skipped/filtered behavioral claims,
+   exit-status-only claims, status-masking forms, and source drift. A retry-only
+   pass is `flaky` per [`testing.md`](../devrites-lib/reference/standards/testing.md#determinism-no-flaky-tests),
+   never green. Static gates prove only their named
+   static criterion.
+   Run the acceptance ledger with `--transcripts`: `devrites-engine gates run <slug>
+   --transcripts` executes every unmet runnable gate against the same approved
+   preflight rows, records definition-bound evidence, and writes one redacted,
+   candidate-bound transcript per gate under `references/gates/<gate-id>/`;
+   `gates reverify <slug> --transcripts` re-executes all of them when any prior
+   pass is in doubt. Hand the proof runner those transcripts, never hand-built
+   logs. Attest manual gates with `gates attest
+   <slug> <id> <note>` only against observed judgment whose note cites the
+   human's own words or source; placeholder notes are unmet and an AFK run never
+   self-attests. Only gates manual at Vet are attested; runnable-to-manual
+   conversion, EXPECT loosening, or CHECK/CWD/row change here is Plan repair plus
+   re-Vet ([`gates.md`](../devrites-lib/reference/standards/gates.md)). An impossible outcome
+   is `gates abandon` plus a handoff, never a deleted row or a false pass.
+   `gates status <slug>` must reduce to `all-met` before Prove records green.
+5. **Gate consumptive actions.** Immediately before execution, apply
+   [`one-shot-actions.md`](../devrites-lib/reference/standards/one-shot-actions.md): current retained identity, bounds/sanitization,
+   injective boundary map, per-seam fault fixtures, collision mutant, terminal
+   fixtures, and cleanup-survival proof must be green. Missing/stale/disposable-
+   only evidence returns to Vet without spending an attempt. Record the admitted artifact identity before execution.
+   After failure, retained evidence is the
+   reproduction; never rerun for diagnosis. Spent authorization blocks another
+   action, but when action budget is zero it does not exhaust a newly identified
+   offline fingerprint.
+6. **Prove UI when applicable.** Use design brief/references, browser harness,
+   allowed scratch path, [proof ladder](reference/proof-ladder.md), and
+   [browser proof](reference/browser-proof.md): routes, viewports, opened and
+   described screenshots, console/network, interaction, target comparisons, and
+   every required state. Material mismatch fails.
+7. **Independent validation.** Fresh read-only `devrites-proof-runner` and
+   `devrites-spec-reviewer`, in one parallel wave, judge the same candidate/commands/evidence/acceptance map.
+   Neither runs commands; reject missing/stale, invented-ID, label-only or self-attested reports.
+8. **Map proof.** Reconcile verdicts under [acceptance-proof.md](reference/acceptance-proof.md).
+   Every criterion/scenario/interaction/key link needs discriminating evidence or a
+   blocker, including critical-path, observability, developer and wiring branches.
+9. **Recover red.** Use [failure triage](reference/failure-triage.md) and Debug
+   Recovery. Reconcile reproduction; send accepted in-scope source/test correction
+   to the sole wright; update actual manifest; rerun affected proof, both candidate
+   checks, and fresh proof runner. Recheck affected acceptance with the exact spec
+   reviewer; reconcile both validators under evidence validity. Scope growth blocks.
+
+   Agent-owned durable-plan errors run Spec Drift Guard, Plan, and Vet inline,
+   preserving Prove as origin. Consumptive failures use retained fixtures, repair,
+   and Vet, then stop for fresh GO after changed conditions. Ambiguous retained
+   evidence does not prove that no safe future acquisition design exists: treat
+   an in-scope discriminator as diagnostic-amplification Plan gap, repair its
+   finite map/collision proof, narrow-Vet, then seek fresh GO before one evidence
+   attempt. Never guess the runtime fix or reuse old GO.
+10. **Record.** Root updates `evidence.md`, optional `browser-evidence.md`,
+    traceability, and state, with exactly one observed candidate binding.
+    After independent validators are green, checkpoint remaining candidate
+    diffs per [`checkpoint.md`](../rite-build/reference/checkpoint.md). A wright
+    correction during Recover red does not commit on control until this step.
+
+> Do not claim an unobserved pass, skip browser proof, or proceed with pending
+> slices. Load `reference/anti-patterns.md` when tempted to do so.
+
+## Phase exit
+
+**Complete when:** every criterion in `acceptance-proof.md` has discriminating
+evidence bound to the current candidate digest, `gates status` reduces to
+`all-met` with no handoffs, both independent validators admit
+accounts, and `state.md` records Prove complete with no open `cannot_verify` rows.
+
+**Failing case:** narrative "all tests passed" without `evidence.md` binding and
+proof-runner admission → phase not complete; Seal blocks.

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

@@ -0,0 +1,88 @@
+# Acceptance proof
+
+Map each `spec.md` criterion to `test | command | browser | judgment` evidence
+and one-line reason. Run [`spec-grammar.md`](../../devrites-lib/reference/standards/spec-grammar.md)'s Native grammar re-read on the saved
+spec before mapping; reopen after corrections. No parser/script may replace it.
+
+Every structured WHEN/THEN scenario needs a passing asserting test. When
+`test-plan.md` exists, every acceptance/gap requirement, interactive element, and
+user flow needs a passing result. Missing coverage blocks.
+
+Apply [[`testing.md`](../../devrites-lib/reference/standards/testing.md)'s positive, discriminating proof](../../devrites-lib/reference/standards/testing.md#positive-discriminating-proof),
+including invalid-result exclusions and static/textual criterion boundaries.
+Unsupported behavioral claims are `cannot_verify` and block proof.
+
+## Silent-failure probe
+
+When tests pass but error paths, dropped results, or partial success could hide
+failure, require at least one **discriminating** check that would fail if the silent
+path regressed (assert the failure surface, not only the happy path).
+
+**Failing case:** handler returns success while logging or swallowing internally; the
+suite stays green → map `cannot_verify` unless a test asserts the user-visible or
+contract failure outcome.
+
+## Backstop disposition
+
+A `backstop` passes only on its spec-named independent held-out,
+property/metamorphic, or direct behavioral check plus discriminating observed
+output. Presence, test names without results, author judgment, or an expectation
+copied from the same implementation logic fails.
+
+Undefined/unavailable signal: `cannot_verify`, evidence
+`insufficient_spec: <missing fact or evidence surface>`, then Spec Drift; never
+judgment or pass.
+
+## Applicable system-risk proof
+
+Reconcile `spec.md`'s applicability map with the final diff. For each triggered owner:
+
+- [`repository-topology.md`](../../devrites-lib/reference/standards/repository-topology.md): prove commands ran at every affected root and both provider
+  and consumer used the same canonical contract; identify generated/vendor sources.
+- [`data-integrity.md`](../../devrites-lib/reference/standards/data-integrity.md): prove declared invariants plus relevant duplicate/retry,
+  concurrency, interruption/resume, old/new coexistence, tenant isolation, and
+  rollback/forward-recovery cases with recorded scale/counts.
+- [`integration-reliability.md`](../../devrites-lib/reference/standards/integration-reliability.md): prove relevant invalid/partial response, auth failure,
+  timeout/unknown outcome, rate limit/outage, duplicate/order, poison/backlog, cache/partition,
+  degradation, and recovery behavior.
+
+An evidence-backed dismissal is valid for an irrelevant case. An applicable case with no
+executable proof surface is `cannot_verify`; do not infer it from an implementation review
+or a mock that cannot produce the risk.
+
+## Critical-path assertion strength
+
+For regression-Critical, irreversible, and data-loss paths, require
+[[`testing.md`](../../devrites-lib/reference/standards/testing.md)'s safe perturbation](../../devrites-lib/reference/standards/testing.md#safe-perturbation).
+Missing evidence is `cannot_verify`; a green test 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 flows, or new error paths,
+trigger failure and observe the required log/metric/trace per [`observability.md`](../../devrites-lib/reference/standards/observability.md);
+record it. Skip pure internal, docs, config, and type-only changes.
+
+## Developer-facing branch
+
+For public API/CLI/SDK/webhook/config/error/onboarding, execute the real entry on
+clean state, measure time-to-hello-world, and capture verbatim failure output.
+Browser-capture docs/quickstarts when applicable. Write the scorecard to
+`devex.md` and headline evidence to `evidence.md`.
+
+## Wiring branch
+
+Exercise/follow every key `plan.md` link in the assembled feature; record each as
+`EVID-###`, or record none declared. An unwired link blocks.
+
+For every critical link, apply safe perturbation to the load-bearing input/link and observe the
+promised surface fail. Existence/registration/spy-call evidence is insufficient when a
+different path can coincidentally produce the expected result.
+
+## Baseline and environment claims
+
+Classify a failure as pre-existing or environment-specific only with a dated
+before-candidate result for the same command, working directory, prerequisites, and
+material environment. Otherwise record it as an unresolved candidate result. For time/local
+behavior, bind the instant, time zone, locale, and relevant old/new configuration.

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

@@ -0,0 +1,25 @@
+# rite-prove: anti-patterns
+
+Load this when standing a non-trivial proof decision, or when tempted to
+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 [standards/anti-patterns.md](../../devrites-lib/reference/standards/anti-patterns.md).
+
+## Phase-specific rationalizations
+
+| Excuse | Rebuttal |
+|---|---|
+| "Tests passed during build; that's enough." | Build = per-slice sanity check. Prove = whole-feature suite + build/typecheck/lint + browser. |
+| "Browser proof is overkill for this UI change." | If it's UI and a browser can run, the ladder applies. If you can't, document which rung and why. |
+| "Failure is in pre-existing code, not in this feature." | Still surfaces as a blocker, never green. `pre-existing` needs recorded same-command baseline evidence ([failure triage](failure-triage.md)); without it the result is unresolved. Feature scope = fix in scope or record + halt. |
+| "Some slices are still pending but the rest can be proved." | No: `/rite-prove` runs once, when every slice is built. Otherwise you're proving a partial system. |
+
+## Red Flags
+
+- Reporting "pass" for a command you didn't run.
+- Skipping browser-proof rungs 1-5 because rung 6 (project E2E) was easier.
+- An acceptance criterion left "unproven" without a corresponding blocker note.
+- Tests recorded green but the diff shows the test file wasn't touched (stale run).
+- About to write `evidence.md` without command + output.

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

@@ -0,0 +1,51 @@
+# Browser proof: evidence schema
+
+What `browser-evidence.md` must capture for a UI slice. Delegates to
+`devrites-browser-proof`; this is the record contract.
+
+```markdown
+# 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 + target reference 1 | playwright-mcp | <observed result> | AC-002, SLICE-002 | <none / exact gap> |
+
+## Visual Verdict
+| Criterion (source, class) | Expected | Observed (screenshot) | Verdict | Severity |
+|---|---|---|---|---|
+| <state / delta / anti-slop criterion> (<brief / reference / anti-slop / acceptance>, <ENG / A11Y / DS / AES>) | <expected> | <what is visible> | PASS / PARTIAL / FAIL / n/a | <Critical / Important / Suggestion> |
+
+## 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
+- The `## Visual Verdict` table follows [visual-verdict.md](../../devrites-browser-proof/reference/visual-verdict.md),
+  which owns its rows, verdict values and severity mapping.
+- Open every screenshot path and describe it: never assert from the filename.
+- 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 using the canonical viewport
+  set and state coverage in [quality-standards.md](../../devrites-frontend-craft/reference/quality-standards.md).
+  Apply [capture admissibility](../../devrites-lib/reference/standards/browser-proof-checklist.md)
+  before assigning a visual verdict; invalid captures leave proof `cannot_verify`.
+- 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/generated/dsh/skills/rite-prove/reference/failure-triage.md

@@ -0,0 +1,53 @@
+# Failure triage
+
+When a test/build/runtime/browser check fails, triage before fixing. Delegates the deep
+loop to `devrites-debug-recovery`.
+
+## Triage ladder
+1. **Reproduce:** for a repeatable command, run it again and capture the exact
+   error (quote it). For a consumptive action under
+   [`one-shot-actions.md`](../../devrites-lib/reference/standards/one-shot-actions.md),
+   never rerun it: use the retained bounded artifact as the reproduction input.
+2. **Classify** the failure:
+   - test is right, code is wrong → fix the code (in scope).
+   - test is wrong/outdated → that may be **spec drift** (acceptance criteria wrong).
+   - environment/setup (missing dep, wrong node/ruby) → fix it when agent-owned;
+     record a blocker only for human/access ownership, scope overflow, or exhausted
+     fingerprint recovery.
+   - pre-existing (fails without this candidate) → only with baseline evidence: the
+     same command/cwd/environment run on the baseline candidate (an earlier
+     `EVID-###`, or a base-ref run in a separate worktree), recorded. It is a named
+     blocker citing that baseline, never green; without the baseline it is unresolved.
+   - flaky (at least one fail and one pass on the unchanged candidate digest;
+     timing/order) → record every attempt and apply
+     [the Determinism standard](../../devrites-lib/reference/standards/testing.md#determinism-no-flaky-tests):
+     the green attempt proves nothing; fix it or record a blocker. Don't paper over with retries.
+   - external dependency down → record blocker; don't fake the result.
+3. **Isolate:** minimize to the smallest failing case; bisect the diff if needed.
+   If consumptive evidence maps to multiple causal seams, this is a
+   diagnostic-amplification plan gap: design and Vet an injective boundary
+   discriminator offline instead of guessing a runtime correction or declaring
+   the cleaned-away past state terminal.
+4. **Fix within scope:** the current slice/feature only. If the fix reaches outside
+   scope, stop and record a blocker in `state.md` (then `/rite-plan unblock`).
+5. **Re-run** the same command when it is repeatable, after an admitted
+   correction; confirm green and record both attempts in `evidence.md`. A green
+   rerun with no correction on an unchanged digest is `flaky` (step 2), never a
+   close. A consumptive action needs re-vetted evidence
+   completeness and any fresh authorization before a new attempt. Its spent
+   action authorization does not stop offline recovery: a retained new fingerprint
+   enters caller-owned diagnosis, correction, fixtures, and narrow Vet immediately.
+   A separately authorized diagnostic-amplification attempt may acquire the missing
+   discriminator after its evidence design passes Vet; it is not a blind rerun.
+
+## Rules
+- Quote the real error text; don't paraphrase it away.
+- Don't loosen/delete a failing assertion to get green: investigate whether it's drift.
+- Don't add blanket retries/sleeps to hide flakiness.
+- Three no-progress attempts on the exact same causal fingerprint consume the
+  shared recovery cap. A recheck that closes the reproduction is progress; a
+  different evidenced Critical/Important invariant gets its own fingerprint.
+  Preserve the reproduction and dead ends, then escalate or park per the
+  [retry contract](../../devrites-lib/reference/standards/afk-hitl.md#retry-cap-no-progress-loops-and-self-resolve).
+  Ask only when the remaining decision is human-owned.
+- A failure you can't fix in scope is a recorded **blocker**, not a silent skip.

package/pack/generated/dsh/skills/rite-prove/reference/proof-ladder.md

@@ -0,0 +1,39 @@
+# Proof ladder
+
+Prefer real runtime evidence. For UI/browser work, try tools top-down and record which
+rung you used. Detect, don't install: browser tooling setup is the user's call.
+
+1. **ego-lite** (preferred when installed and running)
+   - Detect: `command -v ego-browser`, then `ego-browser skill` exits 0; follow its guide.
+     Capabilities: task spaces, snapshot refs, screenshots, clicks/typing, `page.evaluate`,
+     `page.cdp()` for console, network, and viewports. Shares the user's real profile;
+     macOS/Windows only; never install or upgrade.
+2. **browser-harness** (when installed)
+   - Detect: `command -v browser-harness`; `--doctor` only to diagnose. Capabilities:
+     navigation, screenshots, coordinate clicks, console, DOM reads, network, raw CDP.
+     Attaches to the user's Chrome; don't launch a second browser.
+3. **Playwright MCP** (when configured)
+   - Detect: the Playwright MCP `browser_*` tools are available (e.g. `browser_navigate`).
+     Capabilities: navigation, accessibility-tree snapshots, screenshots, ref-based
+     clicks/typing, console messages, network requests, `browser_evaluate`. Drives a
+     Playwright-managed browser; detect, don't install.
+4. **Chrome DevTools MCP** (when configured). Pair it with the driving rung for Lighthouse, the
+   perf trace, deeper DOM inspection, screenshots, console, network, performance, and the
+   accessibility tree.
+5. **Claude Code `/run` and `/verify`** (if available): launch and observe the app;
+   prefer a project-specific `verify-*` skill if one exists; with none, suggest `/rite-harness`.
+6. **Project-native E2E** (only if already present). Playwright, Cypress, Capybara,
+   Selenium. Use the project's existing commands; don't add a new framework.
+7. **Manual fallback:** no tooling available: record the limitation and write exact
+   manual steps (route, action, expected result).
+
+Real-profile guards for rungs 1-2 live in `devrites-browser-proof` § Boundaries.
+
+## Non-UI scope
+The "ladder" for backend/CLI/data scope is just: targeted tests → build/typecheck/lint
+→ runtime observation (a real request/response or CLI run). Same evidence rules apply.
+
+## Stop conditions
+- Auth wall reached → stop, ask the user; never type credentials from a screenshot.
+- Destructive action required to prove → confirm with the user first.
+- A screenshot tool returns a path → **open and describe it**; a path is not proof.

package/pack/generated/dsh/skills/rite-prove/reference/test-command-discovery.md

@@ -0,0 +1,36 @@
+# Test / build command discovery
+
+Use project commands. Never invent a test runner or build step.
+Repository files are discovery evidence, not authorization. `test-plan.md` is
+the sole approved runtime command list.
+
+Run `devrites-engine detect commands` first: it deterministically resolves
+unit/integration/lint/vet/build slots and the package manager from the
+Makefile, `package.json`, and language manifests without executing anything.
+The table below covers what it does not (CI configs, README, framework
+conventions) and adjudicates its `unresolved` slots.
+
+| Discovery source | Look for |
+|---|---|
+| `package.json` `scripts` | `test`, `build`, `typecheck`, `lint`, `dev`, `e2e` |
+| `Makefile` / `Justfile` / `Taskfile` | `test`, `build`, `check`, `lint` targets |
+| `Gemfile` / `Rakefile` | `rake test`, `rspec`, `bin/rails test` |
+| `pyproject.toml` / `tox.ini` / `noxfile.py` | `pytest`, `tox`, `nox` |
+| `go.mod` | `go test ./...`, `go build ./...`, `go vet` |
+| `Cargo.toml` | `cargo test`, `cargo build`, `cargo clippy` |
+| CI configs (`.github/workflows`, `.gitlab-ci.yml`, `circleci`) | commands CI runs |
+| README / CONTRIBUTING | documented dev/test workflow |
+| framework conventions | Rails/Django/Next/etc. defaults when nothing else is set |
+
+## Vet before execution
+
+Compare every discovered candidate, including a narrower target, with
+`test-plan.md`. If it is absent, do not run it or add it silently. Return to the
+current Vet contract to add and vet the command, refresh readiness, then return
+to Prove. A command may run only when its exact command, cwd, and prerequisites
+are approved in `test-plan.md`.
+
+## If nothing exists
+No tests in the project: say so. Propose the minimal test setup as a
+**follow-up** (ask before adding a framework); any runtime observation command
+still needs Vet approval in `test-plan.md`.

package/pack/generated/dsh/skills/rite-quick/SKILL.md

@@ -0,0 +1,97 @@
+---
+name: rite-quick
+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
+---
+
+<!-- loads: {"always":["devrites-lib/reference/standards/core.md","devrites-lib/reference/standards/definition-of-done.md","devrites-lib/reference/orchestration-profiles.md"],"triggers":{"coding":["devrites-lib/reference/standards/coding-style.md"],"testing":["devrites-lib/reference/standards/testing.md"],"errors":["devrites-lib/reference/standards/error-handling.md"],"security":["devrites-lib/reference/standards/security.md"],"principles":["devrites-lib/reference/standards/principles.md"],"afk":["devrites-lib/reference/standards/afk-hitl.md"]},"workspace":["state.md"],"rootOnly":["devrites-lib/reference/orchestration-profiles.md","devrites-lib/reference/standards/afk-hitl.md"]} -->
+> Read-set manifest: `devrites-engine context --skills-root .dsh/skills <slug> --phase quick` bundles every file named below into one deduplicated read. Trigger names map to the conditional rules in the sections that follow.
+
+
+# /rite-quick: express lane for small changes
+
+The full DevRites lifecycle is right for real features; it is **ceremony** for a typo, a
+copy tweak, a one-function fix, or a small config change. `/rite-quick` keeps the
+discipline that matters (idiom, TDD, evidence, escape-to-full-lifecycle) and drops the
+artifacts that don't, in a **single pass**. Senior-engineer "right step, right time" made
+executable, not advisory. This lane uses the **Quick** depth profile from
+[`devrites-lib/reference/orchestration-profiles.md`](../devrites-lib/reference/orchestration-profiles.md).
+
+## The significance gate (the whole safety story)
+
+**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 in the irreversible-risk list. See `../devrites-lib/reference/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).
+- Security-sensitive input handling, or a measurable performance-critical path.
+- Would **break a declared project principle** (`.devrites/principles.md`) with no recorded,
+  human-approved exception: the express lane never relaxes a project gate; a needed exception is
+  a deliberate human decision, so route it to `/rite-spec`.
+
+If none hold, the change is small + reversible + unambiguous → proceed. **When in doubt,
+escalate**: the cost of the full lifecycle on a small change is minutes; the cost of the
+express lane on a risky one is the failure mode the lifecycle exists to prevent.
+
+## Rules consulted (read on demand from `.dsh/skills/devrites-lib/reference/standards/`)
+Load this lane's conditional standards when needed:
+- [`coding-style.md`](../devrites-lib/reference/standards/coding-style.md): naming, guard clauses, reuse-first.
+- [`testing.md`](../devrites-lib/reference/standards/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`](../devrites-lib/reference/standards/error-handling.md) / [`security.md`](../devrites-lib/reference/standards/security.md): only if the change touches input/errors.
+- [`principles.md`](../devrites-lib/reference/standards/principles.md): when `.devrites/principles.md` exists; a change that breaks an invariant is a gate, not a quick fix.
+- [`definition-of-done.md`](../devrites-lib/reference/standards/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`](../devrites-lib/reference/standards/core.md). If a `.devrites/` workspace is active, read its
+   `state.md` directly; `/rite-quick` does **not** require
+   a workspace and does **not** create the full tree.
+1. **Significance gate** (above). Fail → STOP, tell the user to run `/rite-spec <feature>`.
+   If the only failing item is size (more than one slice) and no risk item holds, name
+   `/rite-fast <task>` as the lighter option.
+2. **One-line contract.** Restate in 1-3 lines: the change, its **acceptance** (how you'll
+   know it works), and the **scope boundary** (what you will NOT touch). This is the entire
+   "spec + plan" for a quick change: keep it in the chat; optionally drop a `brief.md` +
+   `evidence.md` under an unused `.devrites/work/<slug>/` (no `state.md`; not a workspace
+   cursor) if the user wants a record. This is the
+   `/rite-frame` FRAME move: if the acceptance won't reduce to a check that could be *false*,
+   the ask is ambiguous → escalate per the significance gate. Its AUDIT pass is the diff
+   self-review in step 5.
+3. **Build with TDD.** Failing test first when behavior changes (see it fail for the right
+   reason) → smallest complete change in the **project's idiom** (reuse before you write,
+   anti-AI-slop) → cover every touched behavior / interactive element with a **real**
+   assertion. UI → check the states + a browser glance. The root never edits source/tests:
+   dispatch exact `devrites-slice-wright` with an exact-path contract per
+   [wright-dispatch.md § Standalone correction](../rite-build/reference/wright-dispatch.md#standalone-correction) and the
+   [source-writing boundary](../devrites-lib/reference/standards/agents.md#source-writing-boundary);
+   reject any returned path outside it.
+4. **Prove (scoped).** Run the **targeted** tests + typecheck / lint for what changed (not
+   the whole suite) → green. Record the command + output — resolve the project's real
+   typecheck/lint commands with `devrites-engine detect commands` rather than guessing.
+   Engine missing or erroring, or zero detected commands for the changed surface:
+   stop with `unproven: <what could not run>`, never green and never a guessed command.
+   A tautological test that can't
+   fail is not proof.
+5. **Review-lite + ship.** Self-review the diff for correctness, scope, and idiom. If
+   `.devrites/principles.md` exists, confirm that no declared invariant is broken. This is
+   `/rite-frame`'s AUDIT pass: one pass, no subagent fan-out. Show the diff. A change that belongs to the
+   active feature's candidate is not committed here: append its exact paths to
+   `touched-files.md`, then route to `/rite-prove` →
+   `/rite-review` → `/rite-seal` (`/rite-ship` needs Seal GO). Otherwise, on the
+   user's confirm, commit it standalone (Conventional Commits, atomic). **Never push without the user asking.**
+
+## Escalation (mid-flight): the Spec Drift Guard still applies
+If the "small" change turns out to be not small: a second slice appears, a real design
+decision surfaces, scope grows past the boundary, or you hit an irreversible-risk item:
+**STOP, say so, and route to `/rite-spec` / `/rite-define`**. Don't quietly grow a quick
+fix into an unreviewed feature; that's the exact drift the lifecycle guards against.
+
+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
+genuinely small, not for shipping risky work faster.