devrites 3.2.27 → 4.0.0

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

@@ -1,47 +1,43 @@
 ---
 name: rite-pov
-description: Project-grounded verdict for adopting, switching, rejecting, or revisiting a named external technology, library, platform, CVE, or pattern. Use when deciding whether this project should commit to an outside option.
+description: Project-grounded verdict for adopting, switching, rejecting, or revisiting a named external technology, library, platform, CVE, or pattern.
 argument-hint: "[candidate/link/question]"
 user-invocable: true
-required-agent-roles: none
 ---
 
 # /rite-pov: project-grounded external verdict
 
-Decide whether **this project** should adopt, trial, hold, reject, or ignore a named outside candidate. Chat verdict first; durable record only when the user asks or the decision changes an active feature.
-
-## Rules consulted
-Step 0: Read `.claude/skills/devrites-lib/reference/standards/core.md`. Pull `source-driven`, `security`, or `deprecation` standards only when the candidate touches those risks.
-
-## Operating rules
-- Verdict only after two floors clear: one verified project fact and one verified external source.
-- Named candidate only. If the user asks "what should we use?" over an open field, route to `/rite-pressure-test` or `/rite-spec` to surface criteria first.
-- Reversibility sizes rigor: two-way config/dependency < bounded internal migration < public/security/legal/data decision.
+Decide whether this project should adopt, trial, hold, reject, or ignore one
+named outside candidate.
 
 ## Workflow
-1. **Frame.** Parse `$ARGUMENTS` into candidate, intent (`adopt|switch|compare|CVE/deprecation impact|second opinion`), and reversibility tier. If intent is ambiguous, ask one blocking question before research.
-   **Completion:** candidate, decision intent, and reversibility tier are explicit.
-2. **Project floor.** Verify at least one concrete project fact: incumbent dependency/call site, current absence plus integration point, prior ADR/decision, or affected surface. Use `devrites-engine profile get`; on `MISS`, run `devrites-engine profile refresh` once, then inspect candidate-specific files fresh. Completion: at least one `file:line` or local doc pointer is in notes, or the verdict is `Hold: project floor missing`.
-3. **External floor.** Read primary docs/advisory/release notes/source for the candidate. Prefer official sources; web summaries are supporting only. Completion: at least one dated source URL/title is in notes, or the verdict is `Hold: external floor missing`.
-4. **Compare.** Weigh fit, migration cost, reversibility, project principles, security/licensing/deprecation risk, and simpler alternatives already present.
-   **Completion:** every comparison dimension has project evidence or an explicit unknown.
-5. **Verdict.** Return exactly one grade: `Adopt`, `Trial`, `Hold`, `Reject`, or `Not-our-problem`. Include next step: `/rite-spec`, `/rite-define`, spike, `/rite-learn` record, or done.
-6. **Optional record.** If the user asks to persist, append the decision to the active workspace `decisions.md`; if no active workspace, suggest an ADR. A persisted `Reject` also lands in the cross-feature ledger so ideation skills stop re-proposing it: `devrites-engine learnings add <slug> "<candidate> — <why rejected>" rejected-direction`.
+
+1. Frame the candidate, decision intent, and reversibility tier. Route an
+   open-ended market search to `/rite-pressure-test` or `/rite-spec`.
+2. Inspect the live repository for at least one concrete project fact: an
+   incumbent dependency/call site, integration seam, relevant ADR/decision, or
+   confirmed absence. No profile cache.
+3. Verify the external claim from current primary documentation, source,
+   advisory, or release notes.
+4. Compare fit, existing alternatives, migration cost, reversibility, project
+   principles, security, licensing, and deprecation risk.
+5. Return exactly one verdict: `Adopt`, `Trial`, `Hold`, `Reject`, or
+   `Not-our-problem`.
+6. Persist only when asked: use the active feature's `decisions.md` for a
+   feature-scoped choice or propose an ADR for a durable architecture decision.
+   Do not write a parallel rejection or learning index.
 
 ## Output
-Reply-contract exception: decision utility; may run outside a workspace.
 
-```
-Verdict: <Adopt|Trial|Hold|Reject|Not-our-problem> — <one sentence>
-Tier: <two-way|bounded-one-way|high-stakes>
-Project floor: <file:line/local doc>
-External floor: <source>
-Why: <3 bullets max>
-Next: <single command or done>
-Record: <path|not written>
+```text
+Verdict: <grade> — <one sentence>
+Tier: <two-way | bounded-one-way | high-stakes>
+Project evidence: <file:line or local doc>
+External evidence: <primary source>
+Why: <three bullets max>
+Next: <one action | done>
+Record: <path | not written>
 ```
 
-## Gotchas
-- No project floor, no verdict. A generic "X is good" answer is failure.
-- Do not let a strong blog post compensate for no local call site, incumbent, or integration point.
-- Do not enumerate a whole market here; bounded candidate decisions only.
+No project evidence or no primary external source means `Hold`, not a generic
+technology opinion.

package/pack/.claude/skills/rite-pr-feedback/SKILL.md

@@ -4,7 +4,6 @@ description: Explicit utility for resolving GitHub PR review feedback.
 argument-hint: "[PR number|thread URL|blank for current branch]"
 user-invocable: true
 disable-model-invocation: true
-required-agent-roles: none
 ---
 
 # /rite-pr-feedback: resolve PR review threads

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

@@ -3,7 +3,6 @@ name: rite-pressure-test
 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
-required-agent-roles: none
 ---
 
 # /rite-pressure-test: diverge then converge
@@ -18,9 +17,9 @@ Read `.claude/skills/devrites-lib/reference/standards/core.md` first: its operat
 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.
+- Search the current `decisions.md`, accepted ADRs, and directly relevant archived
+  Markdown for prior rejected directions. Reconsider one only when new evidence answers
+  its recorded reason; cite both the rejection and the new evidence.
 - 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).
@@ -54,15 +53,9 @@ existing conventions) shape the divergence. The other rule files load on demand.
   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).
+  output of convergence: it hands `/rite-spec` its scope boundary. When a cut is
+  durable, offer to record the reason in the active feature's `decisions.md` or
+  a durable ADR rather than a parallel rejection index.
 
 ```
 Done: pressure test complete for <goal>.

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

@@ -4,7 +4,6 @@ description: User-invoked throwaway prototype for one logic or UI design questio
 user-invocable: true
 disable-model-invocation: true
 argument-hint: "[the question the prototype is answering]"
-required-agent-roles: none
 ---
 
 # /rite-prototype: answer one question with throwaway code
@@ -91,11 +90,6 @@ 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

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

@@ -3,124 +3,129 @@ 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
-required-agent-roles: devrites-proof-runner
 ---
 
 # /rite-prove: prove the completed feature
 
-Record evidence for the **whole feature**. Read the active workspace first; if none,
-run `/rite-spec <feature>`.
+Prove the **whole feature**. Read the active workspace; if absent, run
+`/rite-spec <feature>`.
 
-> **Scope:** built-in `/verify` proves one change and `/run` launches the app.
-> `/rite-prove` covers a feature. 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.
+> **Scope:** `/verify` proves one change; `/run` launches the app. `/rite-prove`
+> walks feature acceptance, relevant suite/build/typecheck/lint, and browser
+> proof, writing evidence under the active workspace. Without one, use
+> `/verify` or `/run`.
 
 ## Gate: all slices must be built first
-Read `tasks.md` + `state.md`. **If ANY slice is still pending/unbuilt, STOP** and tell the
-user to finish it with `/rite-build`: `/rite-prove` runs once, when the full task is
-complete, not after each slice. (Each slice already got its own targeted tests during
-`/rite-build`; this phase proves the assembled feature as a whole.)
+Read `tasks.md` + `state.md`. If any slice is pending, stop for `/rite-build`.
+This phase proves the assembled feature once, after per-slice tests.
 
 **Never report an unobserved pass.** If a command could not run, report that and give
 exact manual steps.
 
-**Scoped reruns are allowed.** `/rite-prove` runs once when the full feature is assembled.
-After `/rite-polish` or `/rite-review` edits code,
-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`.
+After polish/review edits, rerun affected criteria/routes so evidence binds the
+changed candidate digest before Seal.
 
 ## 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.
+- `browser-proof-checklist.md`: required UI 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.
-- `observability.md`: when the change has a runtime surface (endpoint, job, integration,
-  user flow): telemetry must be present **and observed to emit**, not assumed.
+- `observability.md`: runtime telemetry must be observed to emit.
 - `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,
   measure time-to-hello-world, and capture verbatim error text), rather than asserting it.
-- `definition-of-done.md`: standing Done bar: acceptance mapped, fresh proof, no open hard gates, scoped edits, rollback/docs where needed.
+- `definition-of-done.md`: acceptance, proof, gates, scope, rollback/docs.
 
 
 ## Operating rules
 - Evidence over confidence. Feature scope only: fix within the feature or record a
   blocker; don't refactor unrelated code.
+- Apply `testing.md`'s positive, discriminating proof rule to every behavioral claim.
+  A green command without an executing assertion and decisive observed signal is unproven.
+- Follow the shared
+  [`candidate-integrity.md`](../devrites-lib/reference/candidate-integrity.md).
+  Prove owns proof binding, not manifest grammar or candidate hashing.
 - Spec Drift Guard applies: if tests/evidence reveal the spec is wrong, stop and handle
   drift (`rite-build/reference/spec-drift-guard.md`).
-- **Root executes; runner validates; root records; wright fixes.** Use the file-backed
+- **Root executes; runner validates; root records; wright fixes.** Use the native
   fresh-context contract in
   [`agents.md`](../devrites-lib/reference/standards/agents.md). The root owns exact
   vetted gate execution, browser capability, the evidence verdict, and canonical
   writes. The proof runner is read-only and validates immutable logs/artifacts.
-  Every accepted source/test correction is one bounded `devrites-slice-wright`
-  packet, never an inline edit.
+  Every accepted source/test correction is one bounded
+  `devrites-slice-wright` task, never an inline edit.
+
+## Released-workspace refresh entry
+
+Only an admitted `/rite-upgrade` assessment that proves a released-format candidate
+defect may enter this branch. Normal Prove never reconstructs candidate scope.
+
+Before proof, require that the legacy touched-file scope, live diff, tasks, and traceability agree unambiguously on every candidate path and state. Missing, unknown, or
+ambiguous scope is a recorded gap and HITL stop; never guess from Git alone. When they
+agree, preserve unrelated `touched-files.md` content and refresh only its strict manifest
+from the currently observed project bytes under the workspace schema.
+
+Discard every old pass as proof. Run all current approved real proof from scratch under
+the positive, discriminating rules below, and establish the pre-proof and post-proof engine digest
+with `devrites-engine check candidate <slug>`. Require an identical digest,
+then write one fresh exact binding in `evidence.md` and in `browser-evidence.md` when it
+exists. Historical evidence cannot substitute for any current gate. A current proof
+failure is a blocker; this Upgrade admission never authorizes source or test changes.
 
 ## Workflow
-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 `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`.
+0. Read core, load relevant rules above, then resolve the active slug,
+   require its `state.md`, and read the cursor directly.
+1. **Confirm all slices built.** Read `spec.md`, `tasks.md`, `state.md`,
+   `test-plan.md`, and the full diff.
+   A missing `test-plan.md` returns to Vet; it never authorizes ad hoc proof.
 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. **Execute proof against a frozen candidate.** Freeze and hash the candidate.
-   The root runs only commands authorized byte-for-byte by `test-plan.md` and the
-   immutable proof packet, with exact cwd and prerequisites, capturing exit code,
-   decisive output, artifact hashes, and before/after candidate identity in secure
-   external scratch. Run the full relevant test suite plus **build / typecheck /
-   lint**. Reject synthesized or substituted commands and any source drift.
+   Discovery only supplies evidence. `test-plan.md` is the sole approved runtime
+   command list. If a discovered command is absent from it, do not run or
+   silently approve the command: return to the current Vet contract to add and
+   vet it, refresh readiness, then return to Prove.
+   **Completion:** exact commands are approved in `test-plan.md` or unavailable.
+3. **Execute proof against a frozen candidate.** Run
+   `devrites-engine check candidate <slug>` before any approved proof and retain
+   its exact digest. The root runs only commands declared by `test-plan.md`,
+   byte-for-byte, with exact cwd and prerequisites, capturing exit code and
+   decisive output in secure external scratch. Run the full relevant test suite
+   plus **build / typecheck / lint**. Then rerun the candidate check: require the
+   identical digest and no candidate-source mutation. Reject synthesized or
+   substituted commands, malformed manifests, zero-test/skipped/filtered results used as
+   behavioral proof, success inferred only from exit status, and any source drift. Static
+   gates prove only their named static criterion.
 4. **UI feature?** The root applies the browser proof ladder with
-   `design-brief.md`, `references.md`, packet-listed routes, browser harness, and
+   `design-brief.md`, `references.md`, the requested routes, browser harness, and
    allowed scratch path:
    [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 the brief's proof targets. Compare screenshots
    with target references and record deltas. An unresolved material mismatch is a failed
    result; the root handles any accepted correction at step 7 before re-rendering.
-5. **Validate proof in fresh context.** Dispatch `devrites-proof-runner` with the
-   frozen candidate identity, exact approved command list, immutable root-produced
-   logs/screenshots/traces, acceptance map, and hashes. Await its non-empty
-   `agent-result/v1`; reject mismatched, missing, stale, or self-attested evidence.
-   The runner executes no command and writes no canonical evidence.
-6. **Map proof completely.** Follow
+5. **Validate proof in fresh context.** In parallel, dispatch the exact read-only
+   `devrites-proof-runner` on candidate identity, approved commands, immutable
+   root evidence, and acceptance map, and `devrites-spec-reviewer` on the same
+   candidate. Wait for both; reject missing/stale, invented-ID, label-only, or
+   self-attested evidence. Neither executes commands.
+6. **Map proof completely.** Reconcile both exact verdicts, then 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.
+   proof class plus positive, discriminating passing evidence, or is recorded as a blocker.
 7. **On failure** → [failure-triage](reference/failure-triage.md) +
    `devrites-debug-recovery`. The root reconciles the reproduction. Send an accepted,
-   in-scope correction to the sole writer, `devrites-slice-wright`; then freeze the new
-   candidate and dispatch a fresh proof runner for affected checks. If a fix would exceed
+   in-scope correction to the sole writer, `devrites-slice-wright`; update the
+   manifest from its actual scoped diff, rerun affected real proof and both
+   candidate checks, then dispatch a fresh proof runner. If a fix would exceed
    scope, record a blocker.
-8. The root updates `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`).
+8. The root updates `evidence.md`, `browser-evidence.md` (when present),
+   `traceability.md`, and `state.md`. Record exactly one binding for the observed
+   digest in evidence and browser evidence. New proof goes to canonical
+   `evidence.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
-
-**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:
-```
-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
-```
-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

@@ -1,47 +1,51 @@
 # 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:
+Map each `spec.md` criterion to `test | command | browser | judgment` evidence
+and one-line reason. Run `spec-grammar.md`'s Native grammar re-read on the saved
+spec before mapping; reopen after corrections. No parser/script may replace it.
 
-```bash
-devrites-engine spec-validate ".devrites/work/<slug>" --against .devrites/specs
-```
+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.
 
-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.
+Behavioral proof MUST be positive, discriminating, and observed under `testing.md`:
+assertion/output changes when behavior is absent or wrong. Skipped, focused,
+filtered, pending, zero-test, assertion-free, tautological, or unexecuted results
+do not count. Build/compile/typecheck/lint prove only their static criterion;
+discriminating shell assertions and golden/text comparisons may prove text/CLI.
 
-## Critical-path assertion strength
+## 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.
 
-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:
+Undefined/unavailable signal: `cannot_verify`, evidence
+`insufficient_spec: <missing fact or evidence surface>`, then Spec Drift; never
+judgment or pass.
 
-```bash
-devrites-engine test-integrity
-devrites-engine mutation-gate
-```
+## Critical-path assertion strength
 
-A test that stays green on broken code is unproven. Pure transforms also get a
-round-trip or metamorphic property check when applicable.
+For regression-Critical, irreversible, and data-loss paths, inject a small break,
+confirm the covering test turns red, then revert; use the existing mutation tool.
+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-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.
+For endpoints, jobs, consumers, integrations, user flows, or new error paths,
+trigger failure and observe the required log/metric/trace per `observability.md`;
+record it. 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`.
+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
 
-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.
+Exercise/follow every key `plan.md` link in the assembled feature; record each as
+`EVID-###`, or record none declared. An unwired link blocks.

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

@@ -1,30 +1,31 @@
 # Test / build command discovery
 
-Use the project's own commands. Never invent a test runner or build step. Discover from
-these sources, in roughly this order of authority:
+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.
 
-| Source | Look for |
+| Discovery source | Look for |
 |---|---|
-| `spec.md` → "Commands discovered" | already-found commands (trust first) |
+| `spec.md` → "Commands discovered" | previously found candidates |
 | `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`) | the exact commands CI runs: the source of truth for "green" |
+| 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 |
 
-## Targeted first
-Run the **narrowest** command that exercises the slice (a single test file/path),
-then widen. A full suite is slower and noisier; use it for the final check, not the
-inner loop.
+## Vet before execution
 
-## Record what you found
-Write the discovered commands back into `spec.md` → "Commands discovered" so later
-phases (and `/rite-seal`) don't rediscover them. Note the runner version if it matters.
+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), and prove the slice via runtime observation meanwhile.
+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/.claude/skills/rite-quick/SKILL.md

@@ -3,7 +3,6 @@ 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
-required-agent-roles: none
 ---
 
 # /rite-quick: express lane for small changes
@@ -12,7 +11,8 @@ The full DevRites lifecycle is right for real features; it is **ceremony** for 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.
+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)
 
@@ -43,8 +43,9 @@ Load this lane's conditional standards when needed:
 
 
 ## Workflow
-0. **Orient.** Read `core.md`. If a `.devrites/` workspace is active, run the preamble to
-   see it; `/rite-quick` does **not** require one and does **not** create the full tree.
+0. **Orient.** Read `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>`.
 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
@@ -72,21 +73,6 @@ decision surfaces, scope grows past the boundary, or you hit an irreversible-ris
 **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.
 
-## Output
-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:
-```
-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`.
 

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

@@ -4,7 +4,6 @@ description: User-invoked resume verb for answering, dropping, or batch-resolvin
 argument-hint: "<qid> \"<answer>\"  |  --drop <qid> [\"<reason>\"]  |  --batch <path-to-yaml>"
 user-invocable: true
 disable-model-invocation: true
-required-agent-roles: none
 ---
 
 # /rite-resolve: answer the human gate
@@ -13,7 +12,7 @@ required-agent-roles: none
 **stopped the session** (an AFK blocking/escalating/irreversible queue, or a HITL pause
 left unanswered), plus `--batch`. When `/rite-build` asks a question **inline**
 via `AskUserQuestion` and the human is present, that pick resolves the gate **in place** through
-the same `devrites-engine resolve` writer. You don't type `/rite-resolve` for it. For the async case this
+the `devrites-engine state 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.
 
@@ -41,7 +40,7 @@ Pull these via `Read` when shaping the resolve:
   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-engine resolve`. It keeps `questions.md` + `state.md` consistent and emits the
+  `devrites-engine state 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.
@@ -56,7 +55,7 @@ Pull these via `Read` when shaping the resolve:
 
 0. **Read `.claude/skills/devrites-lib/reference/standards/core.md`** (operating rules + persistence discipline) before
    touching the workspace.
-   Then run `devrites-engine preamble` for deterministic workspace orientation.
+   Then read the explicit or active workspace's `state.md` directly.
 1. **Parse arguments.** `$ARGUMENTS` is one of:
    - `<qid> "<answer>"`: answer the single open question.
    - `--drop <qid>` (optional `"<reason>"`): mark the question `dropped`; record
@@ -72,8 +71,7 @@ Pull these via `Read` when shaping the resolve:
    user's explicit consent for this local workspace mutation. Echo the qid, answer/drop,
    and slice being unblocked, then continue immediately; do not ask the user to confirm the
    command they just typed.
-4. **Mutate.** Run `devrites-engine resolve` with the same
-   arguments. The script:
+4. **Mutate.** Run `devrites-engine state resolve` with those arguments. It:
    - 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
      that block and sets `Status: running`;
@@ -94,18 +92,3 @@ Pull these via `Read` when shaping the resolve:
 > answer. That's `/rite-plan repair`. Don't silently retry a build after the answer
 > lands: the user types the next command. Don't merge two open questions into one
 > answered entry: each question is independently auditable.
-
-## Output
-
-**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:
-```
-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
-```

package/pack/.claude/skills/rite-resolve/reference/answer-protocol.md

@@ -2,7 +2,7 @@
 
 `/rite-resolve` is the single canonical writer for `questions.md` `status` flips and
 `state.md` `Awaiting human` clearance. This file is the reference for the three input
-shapes, the batch file format, and the rules the underlying `devrites-engine resolve` obeys.
+shapes, the batch file format, and the `devrites-engine state resolve` rules.
 
 ## Three input shapes
 
@@ -30,7 +30,7 @@ skill applies it once after validation and reports the result instead of asking
   by a re-plan.
 - The reason is an optional single trailing string, **strongly recommended** for the
   audit trail. "obsolete" / "duplicate" / "absorbed by Slice N" are sufficient; if omitted,
-  `devrites-engine resolve` records the reason as `dropped`.
+  `devrites-engine state resolve` records it as `dropped`.
 
 ### 3. Batch