devrites 4.1.0 → 4.2.0

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

@@ -7,165 +7,107 @@ user-invocable: true
 
 # /rite-prove: prove the completed feature
 
-Prove the **whole feature**. Read the active workspace; if absent, run
-`/rite-spec <feature>`.
+Read the active workspace and prove the whole assembled feature once. Without
+one, use `/verify` or `/run`; if any task is pending, stop for `/rite-build`.
+Never report an unobserved pass. After Polish/Review code edits, repeat affected
+criteria and bind evidence to the changed candidate digest.
 
-> **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`.
+## Rules
 
-## Gate: all slices must be built first
-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.
-
-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`: 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`: runtime telemetry must be observed to emit.
-- `repository-topology.md`, `data-integrity.md`, `integration-reliability.md`: only
-  for applicable spec/plan rows; their required proof cases cannot be replaced by a generic green suite.
-- `developer-experience.md`: for developer surfaces, run the flow and measure TTHW plus exact
-  signal-bearing error text with typed redactions; never assert DX.
-- `definition-of-done.md`: acceptance, proof, gates, scope, rollback/docs.
-- `one-shot-actions.md`: pre-attempt evidence completeness and no-rerun handling for
-  consumptive proof actions.
-- `workflow-artifacts.md`: exact root-owned executable proof/controller/harness
-  artifacts under the active feature workspace.
-
-
-## 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/records; runner validates; wright fixes.** Under
-  [`agents.md`](../devrites-lib/reference/standards/agents.md), root owns vetted gates, browser,
-  verdict, and canonical writes; read-only proof runner checks immutable evidence; each source/
-  test fix is one bounded wright task. Root materializes exact Vet-ready `.devrites/**`
-  executables under `workflow-artifacts.md`; they are not product writer work.
-- **Prove remains the controlling caller during technical backtracking.** Save
-  its return cursor, invoke Plan/Vet or bounded remediation inline, consume each
-  nested phase boundary, then resume the failed Prove step. Never make the human
-  submit an agent-owned repair, re-vet, or proof-rerun command. Apply `afk-hitl.md`
-  progress accounting: only three no-progress attempts on the exact same fingerprint
-  exhaust recovery; a closed prior finding or a genuinely new
-  Critical/Important fingerprint continues inside this invocation.
+Read the applicable standards: `testing.md`, `test-proof-checklist.md`,
+`browser-proof-checklist.md` for UI, `spec-grammar.md`, `performance.md`,
+`observability.md`, topology/data/integration rules named by the plan,
+`developer-experience.md`, `definition-of-done.md`, `one-shot-actions.md`, and
+`workflow-artifacts.md`. Developer surfaces require an observed flow, measured
+TTHW, and exact signal-bearing errors; never assert DX.
 
+- Evidence over confidence. Apply positive, discriminating proof to every
+  behavioral claim; a green command without executing assertion and decisive
+  signal is unproven.
+- Follow `candidate-integrity.md`. Prove owns proof binding, not candidate
+  grammar/hashing. Spec Drift Guard owns revealed contract drift.
+- Root executes vetted gates/browser and records evidence. A read-only proof
+  runner validates immutable evidence. The sole bounded wright fixes product
+  source/tests; root never does.
+- **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. Recovery exhausts after
+  three no-progress attempts on the exact same fingerprint. 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 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.
+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 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.
+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
-0. Read core, load relevant rules above, then resolve the active slug,
-   require its `state.md`, and read the cursor directly. On a blocked Prove cold
-   resume, reconcile any retained consumptive-action artifact against recorded
-   no-progress corrections before accepting `next_action: none`; a distinct
-   fingerprint below its cap resumes offline triage without another real action.
-1. **Confirm all slices built.** Read `spec.md`, `tasks.md`, `state.md`,
-   `test-plan.md`, and the full diff.
-   A missing `test-plan.md` enters caller-owned Vet backtracking; invoke Vet
-   inline and resume this step. 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.
-   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 inline, refresh readiness, then return to Prove without a user handoff.
-   **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/prerequisites, exit code, and sanitized decisive output per
-   [`security.md` § Secrets](../devrites-lib/reference/standards/security.md#secrets). Never retain
-   raw secrets; lost signal is `cannot_verify` plus a safe manual step. Run the full relevant 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.
-   Immediately before any consumptive action, apply `one-shot-actions.md` to the
-   live candidate: require the vetted retained-artifact identity, bounds,
-   sanitization, injective boundary map, per-seam fault fixtures, collision mutant,
-   terminal-path fixtures, and cleanup-survival proof. A missing,
-   stale, or disposable-only evidence surface returns to Vet inline and consumes
-   no attempt. Record the admitted artifact identity before execution. After a
-   failed consumptive action, triage from that artifact; never reproduce it by
-   rerunning the action. Consuming its authorization blocks only another real
-   execution. If the artifact identifies a new Critical/Important fingerprint,
-   continue offline recovery inside this Prove invocation; do not label the new
-   fingerprint exhausted because the action budget is zero.
-4. **UI feature?** The root applies the browser proof ladder with
-   `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.** 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 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`; 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.
-   If triage shows an agent-owned durable-plan error, apply the Spec Drift
-   Guard's inline return contract: preserve Prove as the origin, run repair and
-   Vet inside this invocation, and resume the exact failed proof rung. Ask only
-   for a human-owned decision; causal-fingerprint exhaustion stops once with a
-   technical blocker rather than another phase command.
-   For a consumptive-action failure, use fixtures or another non-consumptive
-   reproduction to fix and re-vet the retained fingerprint. Once the failure
-   condition is demonstrably changed, stop at the fresh-authorization boundary;
-   only a new human GO may admit the next real attempt.
-   If the retained fingerprint is missing or ambiguous, the lost past evidence
-   does not prove that no safe future acquisition design exists. Treat an in-scope
-   discriminator as a diagnostic-amplification Plan gap: repair and narrow-Vet the
-   boundary map and collision proof inline, then stop for fresh GO before one
-   evidence-acquisition attempt. Do not guess the runtime fix or reuse the old GO.
-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.
+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. Missing `test-plan.md` invokes caller-owned Vet and returns
+   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 candidate check 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. Run relevant suite plus build/typecheck/lint. 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, and source drift. Static gates prove only their named
+   static criterion.
+5. **Gate consumptive actions.** Immediately before execution, apply
+   `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.** Dispatch exact fresh read-only
+   `devrites-proof-runner` and `devrites-spec-reviewer` on the same candidate,
+   commands, immutable evidence, and acceptance map. Reject missing/stale,
+   invented-ID, label-only, or self-attested reports; neither executes commands.
+8. **Map proof.** Reconcile both verdicts and
+   [acceptance-proof.md](reference/acceptance-proof.md). Every criterion,
+   scenario, interaction, and planned key link gets positive discriminating
+   evidence or a blocker, including applicable 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. 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.
+
+> Do not claim an unobserved pass, skip browser proof, or proceed with pending
+> slices. Load `reference/anti-patterns.md` when tempted to do so.

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

@@ -8,186 +8,133 @@ user-invocable: true
 # /rite-vet: review the plan before build
 
 Vet every plan before code for scope, architecture, quality, proof, performance,
-failure modes, and parallel safety. Cite findings, fold accepted technical hardening
-into the plan, and design Build tests. Risk sets depth; `/rite-autocomplete` has
-Vet and `--cross-model` adds one opinion. Missing `plan.md` routes to `/rite-define`.
+failure modes, and writer safety. Cite findings; fold accepted technical
+hardening into planning artifacts; design Build tests. Temper owns product
+scope, Vet owns implementation; current `$ARGUMENTS` selects depth under
+[`orchestration-profiles.md`](../devrites-lib/reference/orchestration-profiles.md), never removing the exact plan-reviewer gate.
 
-`/rite-temper` owns product scope/strategy; Vet owns implementation. Quick/Standard/Full
-comes from [`orchestration-profiles.md`](../devrites-lib/reference/orchestration-profiles.md),
-but every profile keeps the exact plan-reviewer gate.
+## Rules
 
-## Rules consulted (read on demand from `.claude/skills/devrites-lib/reference/standards/`)
-Pull the standard named by the active axis: `principles.md`, `patterns.md`,
-`coding-style.md`, `testing.md`, `spec-grammar.md`, `performance.md`,
-`error-handling.md`, `development-workflow.md`, `afk-hitl.md`,
-`one-shot-actions.md`, `developer-experience.md`, `elicitation.md`, and
-`definition-of-done.md`. Load `repository-topology.md`, `data-integrity.md`, and
-`integration-reliability.md` only when the spec applicability map or live plan triggers them.
+Read the active standard from: `principles.md`, `patterns.md`, `coding-style.md`,
+`testing.md`, `spec-grammar.md`, `performance.md`, `error-handling.md`,
+`development-workflow.md`, `afk-hitl.md`, `one-shot-actions.md`,
+`developer-experience.md`, `elicitation.md`, and `definition-of-done.md`. Load
+repository topology, data integrity, and integration reliability only when
+triggered. Before classifying any Reslice, read `.claude/skills/devrites-lib/reference/standards/acceptance-preserving-reslice.md`.
+When a
+plan declares a root-authored executable workflow file, read
+`workflow-artifacts.md`.
 
+<!-- BEGIN RESLICE ROUTE-TO-ACTION -->
+- `FOLD` → fold technical topology; invalidate Vet/readiness; affected Vet before Build.
+- `GUARD_AND_REPAIR` → no planning writes; Spec Drift Guard → Clarify → Plan repair → affected Vet.
+- `BLOCKED_INPUT` → no planning writes; exact diagnostic; recover input; reclassify.
+<!-- END RESLICE ROUTE-TO-ACTION -->
 
-## Operating rules
-- **Review implementation, not ambition.** Temper's product scope is settled; challenge
-  only implementation creep, complexity, proof, and risk.
-- **Root hardens; reviewers judge.** Root alone asks, decides, folds back, writes, and sets
-  readiness. Write behavior-preserving test, boundary, ordering, error, and failure-mode
-  refinements into `plan.md`/`tasks.md`/`test-plan.md`. Acceptance/product changes require
-  the Spec Drift Guard: `drift.md`, recorded decision, then `/rite-plan repair` for reslicing.
-  Build scope never grows without a recorded human decision.
-- **Support every finding.** Cite its plan/spec/code source and confidence. Unverified or
-  confidence ≤4 stays suppressed per [`review-axes.md`](reference/review-axes.md).
-- **Apply maximum caution to hard-to-reverse changes.** Auth, migration, public API, and
-  data-model changes always pause under the irreversible-risk list.
-- **Use the lowest axis band.** Never round `thin` up to `ready`; do not average the
-  axes. Record the reason for every decision.
-- **Search before asking.** Verify facts and fold reversible technical hardening into the
-  plan; ask only human-owned choices under `afk-hitl.md`. Dispatch uses the bounded
-  [`agents.md`](../devrites-lib/reference/standards/agents.md) contract.
-- **Honor a recovery origin.** Preserve a valid technical-backtracking return
-  cursor throughout review. Agent-owned `NEEDS REPLAN` returns internally to the
-  controlling caller; it never becomes a request for the human to invoke Plan.
-- **Recovery recheck is bounded.** A valid technical-backtracking cursor plus a
-  recorded open fingerprint enters the Recovery recheck below. Recovery recheck
-  does not start another Full Vet or repeat unaffected axes/reviewers.
+## Invariants
 
+- Review implementation, not ambition. Challenge creep, complexity, proof, and
+  risk without changing accepted product scope.
+- Root alone asks, decides, folds, writes, and sets readiness. Reviewers judge;
+  they add no route policy. Cite every finding and confidence; suppress
+  unverified or confidence ≤4 findings under `review-axes.md`.
+- Auth, migration, public API, and data-model changes use maximum caution and the
+  irreversible-risk stop. Project principles never become trade-offs.
+- Use the lowest axis band; never average or round thin to ready. Search before
+  asking and resolve reversible technical choices. Ask only human-owned choices.
+- Preserve a valid technical return cursor. Agent-owned `NEEDS REPLAN` returns
+  internally to its caller, not to the human.
+- **Recovery recheck is bounded.** A valid cursor plus open fingerprint enters
+  Recovery recheck; it does not start another Full Vet or repeat unaffected
+  axes/reviewers.
+<!-- workflow-artifact-adapter: {"module":"devrites-lib/reference/standards/workflow-artifacts.md","entry":"plan declares root-authored executable workflow file","action":"emit exact admission; stale/missing authority uses PLAN_VET_REPAIR","return":"Vet READY cursor or exact technical replan"} -->
 ## Workflow
-0. **Read `.claude/skills/devrites-lib/reference/standards/core.md`** first.
-   Then resolve the active slug from `.devrites/ACTIVE`, require its
-   `state.md`, and read the workspace: `plan.md`, `tasks.md`, `spec.md`,
-   `decision-coverage.md`
-   (for intent + acceptance), `strategy.md` (if `/rite-temper` ran), `decisions.md`,
-   `assumptions.md`, `design-brief.md` (if UI), `state.md`. Require a `plan.md` whose
-   Readiness gate passes (or `Plan approved`): else STOP → `/rite-define`. Require
-   `Decision coverage: CLEAR`: else STOP → `/rite-clarify`. Prefer a
-   code-intelligence index if available (see
-   `.claude/skills/devrites-lib/reference/standards/tooling.md`) for placement / blast-radius / reuse checks.
-1. **Set review depth. Never skip this step.** Apply
-   [`reference/depth.md`](reference/depth.md) exactly. Every plan leaves a recorded
-   engineering verdict and `test-plan.md` coverage map. For an admitted Recovery
-   recheck, retain the prior depth and proceed to step 1b instead of starting a new
-   depth/pass.
-1a. **Independent pass at every initial depth.** Freeze the candidate; dispatch exact
-   `devrites-plan-reviewer` fresh/read-only and validate its report. Add exact
-   `devrites-devex-reviewer` for developer surfaces and require the current exact
-   `devrites-strategy-reviewer` verdict after significant Temper. Missing accounts
-   block; never substitute inline work.
-1b. **Recovery recheck.** Require the valid return cursor, prior accepted findings,
-   exact open fingerprint/reproduction, repaired candidate identity, changed
-   paths/criteria, and affected evidence from `drift.md` / `evidence.md`. Freeze
-   that packet and dispatch each exact owning reviewer once, fresh/read-only and
-   limited to those inputs. Do not rerun unaffected reviewers or the broad steps
-   2-4 inventory. Mark the prior fingerprint resolved only when discriminating
-   evidence closes its reproduction; otherwise record one no-progress outcome.
-   A newly caused or exposed Critical or Important finding may block only with a
-   different failed invariant, exact evidence in the changed/affected boundary,
-   and a new fingerprint. A Suggestion, Nit, or FYI cannot keep recovery open.
-   Reconcile the common artifact/readiness gates below, then return to the caller
-   or its next repair; never convert the nested result into a human command.
-2. **Scope challenge (blocking gate):** apply §0 of
-   [`reference/review-axes.md`](reference/review-axes.md). Search accepted ADRs and
-   relevant workspace `decisions.md` files directly. Harden to the smallest
-   behavior-preserving plan; ask only when that changes acceptance or explicit architecture policy.
-2a. **Cross-artifact/project gates.** Check spec/tasks/traceability: every AC/REQ maps by
-   ID/meaning to slice/proof and back. Check terms, conflicts, principles, anti-slop, conventions;
-   Critical blocks and principle exceptions are human-owned. Recheck, then write `analysis.md`.
-2b. **Build-entry preflight.** Using [`reference/artifacts.md`](reference/artifacts.md), verify
-   exact command/cwd/tool/version/prerequisite; output filters must preserve upstream failure or
-   check producer status separately. Verify packages against authoritative source and nearest
-   manifest/lockfile; parser-sensitive syntax in an isolated fixture;
-   applicable UI/browser harnesses. Remeasure decision-bearing counts/versions/state
-   claims read-only: live facts win; conflicts mark stale artifacts;
-   unmeasurable conflict = gap. Record complete SHA-256 provenance inputs. Require
-   every behavioral mapping to name a positive,
-   discriminating assertion and decisive signal, not merely a command or expected exit zero.
-   Identify every consumptive action under `one-shot-actions.md`. Before admitting
-   it, require the exact durable retention surface, trust-safe diagnostic schema,
-   cleanup ordering, terminal-path coverage, a finite injective boundary map,
-   per-boundary fault fixtures, and an executed collision mutant in `test-plan.md`.
-   Every retained failure fingerprint must identify one actionable seam; a broad
-   operation/cause shared by multiple emit sites is a gap. Missing or stale one-shot evidence completeness is a technical
-   preflight gap; do not spend the action to learn what cleanup would erase.
-   Preflight observes; it need not make future behavior pass.
-2c. **Implementation-readiness audit.** Goal-backward map every REQ/AC/NFR, interaction,
-   edge/prohibition, and decision-coverage row to a slice and executable proof. Verify
-   UX/spec/architecture alignment, producer-consumer contracts, slice independence/order and
-   wiring, exact prerequisites, failure paths, operations, observability, rollout, and rollback.
-   Check `plan.md`'s canonical `Shared contract proof`: every changed API/event/schema or other
-   provider/consumer boundary needs one reused artifact and two asserting tests that consume it;
-   no boundary change needs the specific no-impact statement. Missing, one-sided, duplicated-contract,
-   vague, or non-consuming proof fails closed.
-   Fold technical fixes into the plan. Product/risk gaps are `NEEDS CLARIFICATION` →
-   `/rite-clarify`; technical plan/preflight gaps are `NEEDS REPLAN` → `/rite-plan repair`.
-   Neither becomes a build qid.
-3. **Review four axes:** apply [`reference/review-axes.md`](reference/review-axes.md)
-   through [`reference/eng-lenses.md`](reference/eng-lenses.md). Fold verified,
-   behavior-preserving technical findings into the plan. Walk only human-owned decisions with
-   the human, one coherent option set at a time. The AFK ceiling remains owned by
-   [`reference/depth.md`](reference/depth.md): scope/acceptance changes and irreversible risk pause.
-4. **Required outputs:** prepare every shape and fold-back in
-   [`reference/artifacts.md`](reference/artifacts.md), using the review rules in
-   [`reference/review-axes.md`](reference/review-axes.md). Derive dependency order
-   from the plan; let the native host schedule independent read-only work while
-   keeping source writers serial.
-   Completion: every scenario and acceptance criterion maps to planned positive,
-   discriminating proof, every slice is
-   one-pass implementable, the Build-entry preflight is green or names an owned prerequisite,
-   and developer-facing plans have a predicted `devex.md` scorecard. Durable proof commands
-   are portable repository commands; host-local wrappers belong only in observed
-   recorded execution evidence.
-5. **Write and fold back every artifact required by
-   [`reference/artifacts.md`](reference/artifacts.md).** Route every
-   acceptance/behavior-changing delta through the **Spec Drift Guard** (`drift.md` +
-   recorded decision + `/rite-plan repair`). After any edit to
-   `brief.md`, `spec.md`, `decisions.md`, `assumptions.md`, or `questions.md`, re-scan the
-   affected coverage rows, assumption audit, residual uncertainty, and closed gates.
-   Partial/Missing, an unowned material assumption, or an open blocking/escalating question is
-   `NEEDS CLARIFICATION` → `/rite-clarify`/HITL; never refresh past it.
-   After each fold-back rerun step 2a; missing/meaning-changing mappings block.
-   Keep `state.md` non-READY for step 6.
-6. **One narrow recheck after edits.** If the candidate changed, dispatch exact
-   `devrites-plan-reviewer` once per correction/fingerprint with accepted findings,
-   changed paths/criteria, and new identity. Within that same correction, no full
-   or third loop; if it changes the plan, repeat step 5. If the recheck closes its
-   input fingerprint but discovers a distinct Critical/Important invariant, return
-   that new fingerprint to the controlling caller as progress. It may start the
-   next bounded Plan/Recovery-Vet cycle; the prior reviewer count is not exhaustion.
-   Then close the matrix and rerun step 2a's ID-and-meaning audit.
 
-6a. **Build readback.** From the final owning artifacts, add a cited five-line
-   readback to `eng-review.md` §7: outcome/ACs; IN/OUT and must-NOT boundaries;
-   UI direction when applicable plus chosen architecture/rationale and
-   critical happy/error flow; slice order and first slice; decisive proof and
-   justified action-time gates. Ask whether a fresh implementer could explain and
-   build it without inventing a product, design, architecture, or proof decision.
-   Contradictory, ownerless, or materially ambiguous statements block READY:
-   human-owned behavior, policy, or acceptance returns to `/rite-clarify`;
-   technical architecture,
-   slicing, or proof returns to `/rite-plan repair`.
-   The readback is a derived view and MUST NOT override its cited owners.
+0. **Orient.** Read core. Resolve active slug, require state, and read plan,
+   tasks, spec, decision coverage, optional strategy/design brief, decisions,
+   assumptions, and state. Require approved Plan and `Decision coverage: CLEAR`;
+   otherwise stop for Define or Clarify. Use code intelligence for placement,
+   blast radius, and reuse.
+1. **Select depth.** Apply `reference/depth.md` exactly; never skip. Every initial
+   pass records an engineering verdict and test-plan coverage. A valid Recovery
+   recheck retains prior depth and enters 1b.
+1a. **Independent initial pass.** Freeze candidate and dispatch exact fresh
+   read-only plan reviewer. Add developer-experience reviewer for developer
+   surfaces and current strategy reviewer after significant Temper. Missing
+   required account blocks.
+1b. **Recovery recheck.** Require valid return cursor, accepted prior finding,
+   exact fingerprint/reproduction, repaired candidate identity, changed
+   paths/criteria, and affected drift/evidence. Freeze that packet and dispatch
+   each exact owning reviewer once, fresh/read-only, limited to it. Do not rerun
+   broad inventory or unaffected reviewers. Close the prior fingerprint only
+   with discriminating evidence. Otherwise record one no-progress outcome. A
+   different Critical/Important invariant needs exact evidence and a new
+   fingerprint; a Suggestion, Nit, or FYI cannot keep recovery open. Reconcile
+   shared artifact/readiness gates and return to caller or next repair.
+2. **Challenge scope.** Apply review-axes §0 and search accepted decisions.
+   Harden to the smallest contract-complete plan, using marked topology action.
+   Then verify bidirectional ID-and-meaning traceability across spec/tasks/
+   acceptance, terms, principles, anti-slop, and conventions. Critical gaps and
+   unexcepted principle breaches block; write `analysis.md` after recheck.
+3. **Preflight Build entry.** Under `reference/artifacts.md`, verify exact
+   command/cwd/tool/version/prerequisite; output filters must preserve upstream
+   failure. Verify dependencies from authoritative source plus nearest manifest.
+   Run parser-sensitive syntax only in isolated fixtures. Remeasure mutable facts;
+   live evidence wins, conflict marks stale, and unmeasurable conflict is a gap.
+   Record complete SHA-256 provenance. Every behavioral mapping names a positive
+   discriminating assertion and decisive signal, never only exit zero.
 
-   Write one typed field to `eng-review.md`: `Implementation readiness: READY`,
-   `NEEDS CLARIFICATION`, or `NEEDS REPLAN`. Root alone sets READY after every
-   exact account, checklist, proof preflight, and final sweep passes with no
-   foreseeable human choice except a justified action-time checkpoint. Write
-   `Phase: vet`, `Next step: /rite-build`, then emit the one exact
-   `Readiness inputs SHA-256` line with `devrites-engine check readiness
-   --emit-binding <slug>` only after this recheck. Normal `devrites-engine check
-   readiness <slug>` must then pass; otherwise record the blocker. Technical failure
-   records repro and `/rite-plan repair`, no qid; a human-owned gap routes
-   `/rite-clarify` and awaiting-human.
-   [`reference/cross-model.md`](reference/cross-model.md) owns the optional explicit
-   cross-model integration.
-   Completion: the final axis floor clears, an objective technical blocker is recorded, or a
-   genuine human-owned gate is recorded.
-   When READY has no pending remediation slice and a valid technical return
-   cursor exists, restore and consume the return cursor instead of defaulting to
-   `/rite-build`, then return the nested result to the controlling caller. If
-   vetted remediation remains, preserve the cursor while the caller follows it;
-   only a real stop condition reaches the human.
-7. **STOP.** Show the Build readback, scope verdict, lowest axis band, closed coverage
-   gaps, preflight, action-time checkpoints, and failure-mode criticals; recommend
-   `/rite-build` only when the entry contract is ready.
+   For each consumptive action, one-shot evidence completeness must bind durable
+   retention, trust-safe diagnostics, cleanup order, terminal coverage, finite
+   injective boundary map, per-boundary fault fixtures, and an executed collision mutant.
+   Every fingerprint identifies one actionable seam; aliasing multiple
+   emit sites is a gap. Preflight observes but need not make future behavior pass.
+4. **Audit readiness.** Goal-backward map every requirement, criterion, NFR,
+   interaction, edge/prohibition, and decision row to one slice and executable
+   proof. Verify UX/spec/architecture alignment, contracts, dependency order,
+   slice independence/wiring, prerequisites, failure/observability/rollback, and
+   ownership. The plan's `Shared contract proof` names one reused boundary
+   artifact plus two consuming tests for every changed API/event/schema/provider-
+   consumer seam, or an explicit no-impact statement. Missing, one-sided,
+   duplicated-contract, vague, or non-consuming proof fails closed.
 
-> **Mid-flight discipline.** Do not replace the interactive review with
-> `eng-review.md`, change acceptance through plan hardening, score without source
-> evidence, or ignore unexplained complexity. See
-> [`reference/anti-patterns.md`](reference/anti-patterns.md).
+   Technical gaps are `NEEDS REPLAN` and Plan repair. Product/risk gaps are
+   `NEEDS CLARIFICATION` and Clarify. Neither becomes a Build qid.
+5. **Review axes.** Apply `review-axes.md` through `eng-lenses.md`. Fold verified
+   behavior-preserving technical findings; walk only human-owned decisions.
+   Profile gate ceiling and Reslice marked action remain authoritative.
+6. **Write outputs.** Produce every artifact in `reference/artifacts.md`. After
+   editing intent/decision/assumption/question owners, re-scan affected coverage,
+   assumptions, uncertainty, and gates. Keep state non-READY. Every scenario and
+   criterion needs positive, discriminating proof; every slice must be one-pass
+   implementable; developer plans need a predicted scorecard. Durable commands
+   are portable repository commands, not host wrappers.
+7. **Narrow recheck after edits.** Dispatch exact plan reviewer once per
+   correction/fingerprint (`per correction/fingerprint`) with accepted findings,
+   changed paths/criteria, and new
+   identity. Within one correction, no broad third loop. If it changes plan,
+   fold again. A closed input plus a distinct Critical/Important invariant returns
+   that new fingerprint as progress. Then close matrix and rerun ID/meaning audit.
+8. **Build readback and readiness.** Add a cited five-line readback to
+   `eng-review.md`: outcome/ACs; IN/OUT/must-NOT; UI direction and architecture/
+   critical flow; slice order/first slice; decisive proof/action-time gates. A
+   fresh implementer must need no product, architecture, or proof invention.
+   Contradiction, ownerlessness, or material ambiguity blocks via Clarify or Plan.
+
+   Write exactly one `Implementation readiness: READY`, `NEEDS CLARIFICATION`,
+   or `NEEDS REPLAN`. Root alone sets READY after every account, checklist,
+   preflight, and sweep is green. Write phase/next step and emit one
+   `Readiness inputs SHA-256` with
+   `devrites-engine check readiness --emit-binding <slug>`; normal readiness check
+   must pass. Technical failure records reproduction, not qid. Human gap awaits
+   Clarify. Optional cross-model follows `reference/cross-model.md`.
+
+   With READY, no pending remediation, and a valid technical return cursor,
+   restore and consume the return cursor instead of defaulting to Build. Preserve
+   it through admitted remediation. Only a real stop reaches the human.
+9. **Stop at the Vet boundary.** Show Build readback, scope verdict, lowest axis,
+   closed gaps, preflight, action checkpoints, and critical failures. Recommend
+   Build only when READY.
+
+> Do not replace interactive review with artifacts, change acceptance through
+> hardening, score without source evidence, or ignore unexplained complexity.

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

@@ -4,13 +4,21 @@ Universal rationalizations + red flags live in
 [`../../devrites-lib/reference/standards/anti-patterns.md`](../../devrites-lib/reference/standards/anti-patterns.md): read it when the
 reluctance is broader than this phase. Below are the vet-specific ones.
 
+Authority: `.claude/skills/devrites-lib/reference/standards/acceptance-preserving-reslice.md`.
+
+<!-- BEGIN RESLICE ROUTE-TO-ACTION -->
+- `FOLD` → fold technical topology; invalidate Vet/readiness; affected Vet before Build.
+- `GUARD_AND_REPAIR` → no planning writes; Spec Drift Guard → Clarify → Plan repair → affected Vet.
+- `BLOCKED_INPUT` → no planning writes; exact diagnostic; recover input; reclassify.
+<!-- END RESLICE ROUTE-TO-ACTION -->
+
 ## Phase rationalizations
 
 | Excuse | Rebuttal |
 |---|---|
 | "I'll write all the findings into `eng-review.md` and let the user read it." | The artifact is the *output* of an interactive review, not a substitute for it. A material finding's path to "done" goes **through `AskUserQuestion`**, one at a time, with a recommendation + why. Dumping findings into one write and moving on is the exact failure this skill exists to prevent. |
 | "The plan doesn't handle X: flag it." (without checking) | Quote the line first. If you can't quote where the plan handles X, you also can't be sure it doesn't: force confidence ≤4 and suppress. The "field/case doesn't exist" finding is the most common false positive; the verification gate exists to kill it. |
-| "It's an obvious fix. I'll just edit the plan." | An obvious *plan refinement* (a test requirement, an error path, tighter scope) you write directly. That's vet's job. A fix that **changes an acceptance criterion or product behavior** is not obvious enough to skip the human: route it through the Spec Drift Guard with a recorded decision. |
+| "It's an obvious fix. I'll just edit the plan." | Verified plan hardening is Vet's job; topology uses the marked action. |
 | "This dimension is thin but the others are strong: net it's fine." | The gate is the **floor**, not the average. A plan `broken` on test-coverage does not pass because it's `strong` on architecture. |
 | "I can see it's adequate. I'll note the band, the evidence is obvious." | Cite the quoted evidence **before** the band. Score-first-justify-later is how a reviewer waves through a plan it already likes. |
 | "8+ files but it all needs to change: proceed." | The complexity smell is a **STOP-and-ask**, not a note. Name the overbuilt part, propose the smaller version that still meets acceptance, and let the human decide before any axis runs. Maybe it's justified (record *why*) but the gate fires first. |
@@ -18,11 +26,15 @@ reluctance is broader than this phase. Below are the vet-specific ones.
 | "Performance looks fine." | "Looks fine" is not a measurement. A perf finding is "measure X against budget Y" or it's nothing: don't recommend speculative tuning, and don't wave past an N+1 you can quote. |
 | "Cross-model agrees, so apply it." | Cross-model consensus is a strong *signal*, not an approval. Every cross-model finding is informational until the human approves it (or, in AFK, until the gate ceiling clears a hardening-only change). |
 
+## Reslice classifier rationalizations
+
+**RSLICE-VET-001** — Slice/topology growth alone does not stop; fewer slices do not prove scope reduction; remediation does not grow product.
+
 ## Red flags
 - `eng-review.md` / `test-plan.md` written but `plan.md` / `tasks.md` **not** hardened: the build
   follows the plan, so the review changed nothing.
 - A finding raised with confidence ≥7 but **no quoted source line**, that defeats the verification gate.
-- A scope-growing finding auto-applied in AFK (it must pause), or any irreversible-risk touch that didn't pause.
+- Acceptance/product-behavior growth auto-applied in AFK, or an orthogonal human-owned gate that did not pause.
 - A failure-mode table with rows but no verdict column filled: a "no test + no handling + silent" row not marked Critical.
 - The reviewer loop running past 3 iterations, or the reviewer / cross-model being handed the author's reasoning (defeats the fresh-context point).
 - The skill writing code, implementing a slice, or running the build. That's `/rite-build`. Vet reviews and hardens the plan; it never implements.