devrites 7.1.2 → 7.2.0

package/pack/generated/dsh/skills/rite-temper/reference/review-dimensions.md

@@ -0,0 +1,66 @@
+# Review dimensions and floor-gate rubric
+
+Score the spec on nine dimensions. A strong dimension cannot offset a failed one, so
+the gate uses the **lowest band**, not an average.
+
+## The nine dimensions
+1. **Problem choice and ambition:** does the spec solve the underlying problem, or only
+   make a minor improvement to the obvious path? It may also reach beyond the actual need.
+   Both insufficient outcome ambition and over-building are failures.
+2. **Scope and boundary:** are non-goals explicit? Is there a Minimum Usable Subset and
+   a clear IN/OUT line? Flag unrelated bundles and a missing "Won't-have-this-time".
+3. **Premise and alternatives:** are the consequential premises stated and challenged, and is at
+   least one genuinely different approach (different data model / flow / boundary) considered
+   with its trade-off? ("Alternatives considered" is one of the most useful parts of a spec.)
+4. **Pre-mortem risk coverage:** assess the feature as if it shipped and failed. Each top risk carries likelihood
+   + mitigation + the slice that owns it. The interruption pre-mortem accounts for foreseeable
+   human prerequisites and action-time approvals instead of deferring generic uncertainty to
+   build. **Unmitigated top risks are gating.**
+5. **Over-engineering / YAGNI:** speculative capability, unused extension points, premature
+   abstraction, second-system bloat. Apply the pack's standard ([`patterns.md`](../../devrites-lib/reference/standards/patterns.md)) and the YAGNI
+   ledger test (scope-modes.md Pass 2).
+6. **Acceptance testability and completion:** every acceptance criterion measurable, technology-
+   agnostic, and comparable **down to a baseline** ("better than the current workaround"), not
+   up to an unbounded ideal. Vague adjectives ("fast/robust/intuitive") and "handles X
+   gracefully" are flagged.
+7. **Irreversibility & blast radius:** are auth / migration / public-API / data-model touches
+   treated with conservatism + rollback, and is the blast radius understood (from
+   codebase-memory `trace_path` if available)?
+8. **Cross-cutting coverage:** security/trust-boundary, data & migration, observability, and
+   modifiability each explicitly addressed **or explicitly N/A**: no silent omission.
+9. **Convention fit & placement realism:** does the ambition fit the codebase's existing seams
+   and patterns, or assume greenfield freedom a constrained space doesn't have? Prefer existing
+   conventions; flag a new dependency / second design system for explicit decision.
+
+UI specs also inherit [`anti-ai-slop.md`](../../rite-polish/reference/anti-ai-slop.md) at the cross-cutting
+dimension (design-system fit, anti-AI-slop), but `/rite-temper` reviews the *spec/design-brief*,
+not pixels; the built UI is judged later by `devrites-frontend-reviewer`.
+
+## Rubric
+Score each dimension on a **labeled band**, never a 1-10 float or composite number:
+
+| Band | Meaning |
+|---|---|
+| **strong** | Addressed well; no action needed. |
+| **adequate** | Addressed; minor sharpening only (Suggestion/Nit). |
+| **thin** | Under-addressed; a real gap to close before planning (Important). |
+| **broken** | Missing or wrong in a way that will cost a redo (Critical). |
+
+**Cite evidence before assigning the band.** Name the spec line or absence that
+justifies it. Review a borderline dimension twice if needed and use the **lower** band.
+
+## The floor-gate
+- **Pass** only when every dimension is `adequate` or `strong` **and** no unmitigated top
+  pre-mortem risk remains. The verdict is the **weakest** dimension: a spec strong on clarity
+  but `broken` on risk does **not** pass.
+- Individual findings carry the pack's standard severity labels (**Critical / Important /
+  Suggestion / Nit / FYI**) so they compose with `/rite-review` and `/rite-seal`. `broken` →
+  Critical, `thin` → Important; **FYI is band-independent**: an observation on a `strong` /
+  `adequate` dimension, not a failing band.
+- **Do not double-count overlap.** Some dimensions use the same evidence (e.g. #7
+  irreversibility & #9 convention-fit both touch codebase realism; #1 ambition & #2 scope both
+  touch over/under-reach). Don't fail two dimensions for the *same* root cause: cite the
+  evidence once and assign one band so one problem does not create two floor failures.
+- Below-bar blocks readiness; objective fixes return to the caller under
+  [the canonical retry contract](../../devrites-lib/reference/standards/afk-hitl.md#retry-cap-no-progress-loops-and-self-resolve).
+  Human-owned scope/risk choices keep their gate; exhaustion blocks technically.

package/pack/generated/dsh/skills/rite-temper/reference/scope-modes.md

@@ -0,0 +1,52 @@
+# Scope modes + the two passes
+
+`/rite-temper`: two ordered passes (heat, then quench), converging on one scope mode. Ambition is a **generative** move followed by a **required convergence**: the
+divergence is never the spec; the converged sweet spot is.
+
+## Pass 1: FORWARD (heat: raise ambition on the outcome)
+Diverge on the *real problem*, not the obvious path. Ask:
+- What would an order-of-magnitude-better **outcome** look like (the 10-star version)? Design
+  the extreme, then come back to the feasible sweet spot: don't ship the extreme.
+- Is a **premise** load-bearing and wrong? Name the assumptions the spec rests on; challenge
+  the one that, if false, changes everything.
+- Where is **under-reaching** the real risk: a timid improvement to a path we should reframe?
+
+Ambition aims at the **outcome** (problem definition, success bar, user value) and at
+complexity-**neutral** future-proofing. It never aims at the **solution surface** (that's Pass 2's
+job to prune). Ground every ambitious idea in the codebase's real seams and blast radius. Use
+codebase-memory `get_architecture` and `trace_path` if available (see `../../devrites-lib/reference/standards/code-navigation.md`). Don't invent greenfield scope a
+constrained codebase can't absorb.
+
+## Pass 2: INVERSION (quench: pre-mortem + prune)
+Invert. Two subtractive moves:
+- **Pre-mortem (prospective hindsight).** State it in past tense: *"It's six months out. This
+  shipped and failed. What went wrong?"* List the top failure modes; for each: likelihood,
+  mitigation, and the slice that will own the mitigation. Unmitigated top risks are **gating**.
+- **YAGNI ledger.** Each candidate scope item gets the "imagine the later refactor" test: if
+  adding it *later* isn't materially more expensive, **defer it** (with a revisit note).
+  Bias hard toward defer: most presumed-needed features are never used. Reuse the
+  pack's existing [`patterns.md`](../../devrites-lib/reference/standards/patterns.md) standard ('no speculative abstraction or pattern
+  without a current need'). Don't invent a new YAGNI rule.
+
+## The four modes: commit exactly one
+Mode selection is the first convergence move. Record the chosen mode + rationale + the
+**hinge** (what would change the call) in `strategy.md` and `decisions.md`.
+
+| Mode | When | What it does | YAGNI / Drift Guard |
+|---|---|---|---|
+| **EXPAND** *(opt-in, default OFF)* | Under-reaching on the outcome is the real risk | Raise the success bar / reframe to the deeper problem; thinner-but-more-complete path to a bigger target | Expands the *problem + acceptance*, not machinery. Each added criterion is a Drift-Guard-recorded, human-confirmed (HITL) decision: never auto-grown. Under AFK it escalates via `ask_user_question` and the fold **holds** until the human answers; an unattended run never auto-applies it |
+| **SELECTIVE** | One or two high-leverage dimensions deserve more; the rest is right | Expand only the high-upside dimension; hold the rest at spec scope | Each selected expansion routes through the Guard; everything not selected is parked in Non-goals so it's neither dropped nor re-injected mid-build |
+| **HOLD-RIGOR** | The spec is right-sized (default for irreversible-risk-heavy or already-tight specs) | No scope change: pure hardening: pre-mortem, risk mitigations, acceptance sharpening, cross-cutting coverage | Adds zero surface; trivially Drift-Guard-clean (no acceptance change) |
+| **REDUCE-TO-MVP** | Over-scoped: second-system bloat, ~all must-haves, gold-plating | Hammer scope to the Minimum Usable Subset; move the rest to Non-goals with one-line reasons + revisit notes | Strongest YAGNI alignment. Cutting acceptance is **still a spec change**: record it via the Guard, never a silent trim |
+
+## Bound ambition by reversibility
+Bigger bets need more reversibility. Auth, migrations, public API, and data-model
+changes need maximum conservatism, full review, and explicit rollback.
+Pause only for actual [canonical irreversible-risk items](../../devrites-lib/reference/standards/afk-hitl.md#irreversible-risk-list-always-pause)
+or unresolved human-owned decisions, not an already-approved reversible internal
+data-model change. Size bets to tolerate their disappearance tomorrow.
+
+## Effort foresight (frame it now, not "later")
+While choosing scope, surface the late-stage questions early: *"What will surprise us at
+integration? What will we wish we'd planned for at polish/test time?"* Turn each into a
+constraint, a risk, or a deferred Non-goal **now**, not a "figure it out later".

package/pack/generated/dsh/skills/rite-temper/reference/significance.md

@@ -0,0 +1,55 @@
+# Significance test: fire the full review, or skip it
+
+`/rite-temper` is **significance-gated**: full strategic rigor only when the work is big
+enough to earn it, a one-line skip otherwise. This is the shared definition used by both the
+optional `/rite-temper` path and the always-run (significance-gated) `/rite-autocomplete` step,
+so they agree on when it fires.
+
+## Fire the FULL review when ANY trips
+- **Irreversible-risk contact:** the slice/spec touches anything on the [`afk-hitl.md`](../../devrites-lib/reference/standards/afk-hitl.md)
+  irreversible-risk list: destructive data migration, auth/authz boundary, public-API break,
+  external-service contract, filesystem destruction outside the workspace.
+- **Data model:** new/changed entities, relationships, or persistence shape.
+- **Cross-module blast radius:** the impact (from codebase-memory `trace_path` per
+  `../../devrites-lib/reference/standards/code-navigation.md`, or an honest estimate) crosses
+  module/service boundaries or has many dependents.
+- **Greenfield / ambiguous scope:** a new surface with no existing seam to follow, or a spec
+  whose "right size" is genuinely open (multiple defensible scopes).
+- **Low detectability:** no existing test, gate, or monitor would show a wrong result
+  in the affected area (no suite there, silent data change), so a mistake ships unseen.
+- **Multi-slice / multi-day:** the work decomposes into several slices (large enough that a
+  wrong scope call is expensive to unwind).
+- **The user asked:** "think bigger", "is this ambitious enough", "scope check", "pre-mortem",
+  an explicit `/rite-temper` invocation, or a chosen `--mode`. An explicit ask always fires.
+
+## Skip (low stakes) when ALL hold
+- Single-module, reversible, behavior-shaped-not-structural change.
+- No irreversible-risk contact; blast radius contained to the touched files.
+- Scope is unambiguous: there's one obvious right size and the spec already has it.
+
+On skip, **don't run the passes**. Write only the one-line verdict to `strategy.md`:
+
+```markdown
+# Strategy: <slug>
+Tempered: <iso>
+
+## 1. Significance
+skipped — low stakes (<trigger>)
+Next: /rite-define
+```
+
+Then recommend `/rite-define`. A skip is a *recorded* decision, not a silent omission: the
+seal can see the call was made deliberately.
+
+## In `/rite-autocomplete`
+Autocomplete runs the significance test every feature. On skip → straight to `/rite-define`
+(no pause). On fire → run the full review, then apply the mode under the AFK rule in
+[`scope-modes.md`](scope-modes.md): `hold-rigor`, `reduce-to-MVP`, and a skip apply unattended.
+`expand` and any extra acceptance **do not** apply unattended — acceptance is never auto-grown.
+When the review lands on `expand` or any acceptance growth, the agent presents the scope call as a
+ranked `ask_user_question` option set per the HITL rule, records the open `questions.md` qid, and
+**holds the fold**: do not write *Success metrics* or *Acceptance criteria* rows, do not fold via
+Spec Drift Guard, and do not recommend `/rite-define` until a human answers the qid. A self-written
+`decisions.md` ADR is not that human answer (see [`strategy-template.md`](strategy-template.md)
+§ Write discipline); the growth stays blocked until the qid resolves. Irreversible-risk findings
+always pause.

package/pack/generated/dsh/skills/rite-temper/reference/strategy-template.md

@@ -0,0 +1,101 @@
+# `strategy.md` template + fold-back rules
+
+`/rite-temper` produces two kinds of output. The `strategy.md` artifact is the durable
+**record** of the review; the **fold-back edits** are what the build follows. The
+record without the fold-back is dead prose: the build reads `spec.md`, not `strategy.md`.
+
+## `strategy.md`: the record
+Write to `.devrites/work/<slug>/strategy.md`. If one exists for the slug, **update** it, don't
+clobber.
+
+```markdown
+# Strategy: <slug>
+Tempered: <iso>
+
+## 1. Significance
+full | skipped — low stakes (<trigger>)        # if skipped, stop here (see significance.md)
+
+## 2. Scope mode
+Mode: expand | selective | hold-rigor | reduce-to-MVP
+Rationale: <why this mode>
+Hinge: <what evidence/answer would change the call>
+
+## 3. Forward pass (ambition)
+10-star outcome (the deliberate overshoot): <one or two lines>
+Premises challenged: <load-bearing assumption(s) + verdict>
+Converged sweet spot: <where we landed and why — this, not the overshoot, is what folds in>
+
+## 4. Pre-mortem (inversion)
+| Failure mode (past tense) | Likelihood | Mitigation | Owning slice/criterion |
+|---|---|---|---|
+| It shipped and <…> | high/med/low | <mitigation> | <slice or FR it binds to> |
+
+## 5. YAGNI ledger
+| Candidate scope item | later-refactor cost | Verdict |
+|---|---|---|
+| <item> | trivial / large | build-now / defer (revisit: <trigger>) |
+
+## 6. Cross-cutting coverage
+| Concern | Addressed? |
+|---|---|
+| Security / trust boundary | <how | N/A — why> |
+| Data & migration | <… | N/A> |
+| Observability | <… | N/A> |
+| Modifiability | <… | N/A> |
+
+## 7. Dimension scores (floor-gate)
+| Dimension | Band | Evidence |
+|---|---|---|
+| Problem altitude & ambition | strong/adequate/thin/broken | <spec line / absence> |
+| … (all 9) | … | … |
+Floor verdict: <weakest band> on <dimension> → pass | blocked
+
+## 8. Deferred / Won't-have-this-time
+- <item> — <one-line reason> (revisit when: <trigger>)
+
+## 9. Reviewer loop
+- iter 1: <findings → resolution> · iter 2: … (≤3)
+- Final: floor = <band>; unresolved → <none | blocking qid>
+```
+
+## Fold-back: the part the build follows
+Apply through the **Spec Drift Guard** (these are spec changes, not free edits). If a plan
+already exists, record in `drift.md` and route via `/rite-plan repair` instead of editing
+`spec.md` blind.
+
+- **`spec.md`:** these are the spec template's actual section headings. Edit each named one;
+  don't collapse pairs.
+  - Add to *Success metrics* **and** *Acceptance criteria* (separate sections) for
+    every opt-in **expansion**; remove (via the Guard) from both for every **reduction**. Each
+    must stay measurable + technology-agnostic.
+  - *Non-goals*: append every deferred item (from the YAGNI ledger + the Deferred register), so
+    it is neither silently dropped nor silently re-injected mid-build.
+  - *Constraints and invariants*: tighten where the pre-mortem demands; top failure modes +
+    mitigations go to *Failure and recovery behavior* rows.
+  - *Open questions* table: one row per scope call (options offered → decision → owner).
+  - **Re-run the Readiness gate** at the bottom of the spec after edits; it must still pass, and
+    **every folded scope delta must trace to a recorded decision**: a reduction or non-growth
+    delta traces to a `questions.md` qid **or** a `decisions.md` ADR, but an **acceptance-growth**
+    delta (`expand` or any added *Success metrics* / *Acceptance criteria* row) traces **only** to a
+    **resolved human `questions.md` qid** (`status: answered` plus an unindented, lowercase `answered_by: human` line; a qid without exactly
+    that line, including every qid written before the field existed, does not satisfy growth traceability).
+    A `decisions.md` ADR written by the same run is **not**
+    the human approval that growth requires, so an ADR-only growth fold is untraceable and the
+    Readiness gate fails closed — `/rite-define` step 0 hard-blocks while it is unresolved. An
+    untraceable change is the batch-dump failure.
+- **`decisions.md`:** one ADR-style entry per scope call and accepted trade-off:
+  `context · decision · why-not-the-alternative · what-would-change-it`.
+- **`assumptions.md`:** every "we'll probably need X" demoted to an explicit
+  **assumption-to-verify**, never smuggled into scope as a fact.
+
+## Write discipline
+- **Single canonical writer.** The skill writes `strategy.md` and edits the canonical files; the
+  `devrites-strategy-reviewer` agent is **read-only** and only returns findings + bands.
+- **No silent scope.** An expansion that the human didn't opt into, or a reduction that drops an
+  acceptance criterion without a recorded decision, is a defect, not a convenience.
+- **An ADR is not its own approval.** A `decisions.md` ADR the run writes about its own scope call
+  records *why* it chose that mode; it never stands in for the human's answer. Acceptance growth
+  stays blocked until a resolved human `questions.md` qid lands, so an unattended run cannot fold
+  an expansion by citing its own record.
+- Add `strategy.md` to the workspace between `spec.md` and `plan.md`; `/rite-define` and
+  `/rite-ship` read it.

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

@@ -0,0 +1,142 @@
+---
+name: rite-upgrade
+description: Audit and reconcile an older released DevRites workspace. Proves a current-contract defect, then routes its phase owner while preserving completed work and history.
+argument-hint: "[feature-slug]"
+user-invocable: true
+disable-model-invocation: true
+---
+<!-- loads: {"always":["devrites-lib/reference/standards/core.md","devrites-lib/reference/standards/agents.md"],"triggers":{"reslice":["rite-plan/reference/slicing.md"]},"workspace":["state.md","spec.md","plan.md","tasks.md","decisions.md","questions.md","evidence.md","touched-files.md","review.md","seal.md","polish-report.md","browser-evidence.md"],"workspaceByRole":{"upgrade-planner":["state.md","spec.md","plan.md","tasks.md","decisions.md","questions.md"]}} -->
+> Read-set manifest: `devrites-engine context --skills-root .dsh/skills <slug> --skill rite-upgrade` (no workspace: `--out <path>`) bundles every file named below into one deduplicated read.
+
+# /rite-upgrade: reconcile a released workspace safely
+
+Use when an unfinished workspace from an older release cannot resume. This is an
+audit/orchestrator—not a pack update, cursor conversion, release replay,
+structural migration, or generic cleanup.
+
+## Rules consulted
+
+Read [`core.md`](../devrites-lib/reference/standards/core.md), its agent and workspace-schema
+references, and only current phase contracts needed for the observed gap.
+
+## Invariants
+
+- Upgrade writes no workspace artifact and never edits source, tests, dependencies,
+  or Git. It observes, admits, invokes current owners, and re-audits only.
+- Recognize only released workspace forms: `.devrites/work/<slug>/state.md` with v1/v2
+  bullet fields (`- Phase:`, `- Next step:`, optional `- qid:`) or the v3 cursor table.
+  A cursor with no `schema` row (every v1/v2 form, older v3 tables) is refused by the
+  engine until the human runs the `migrate` command its refusal names (step 0). Otherwise
+  preserve its encoding; only its owning rite may change fields. Never create aliases,
+  journals, telemetry, version markers, or an engine migrator.
+- Older provenance, cursor form, or pack version alone is never a defect. A repair requires
+  a current rule, exact workspace evidence, affected gate, owning rite, exact paths, and
+  the smallest behavior-neutral delta.
+- Existing rites own semantic changes. Upgrade may sequence `/rite-clarify`,
+  `/rite-plan repair|revise|course-correct`, `/rite-converge`, `/rite-vet`, `/rite-prove`, `/rite-polish`,
+  `/rite-review`, and `/rite-seal`; it never reimplements them or starts Build or Ship.
+  `/rite-doctor` owns install/config diagnosis.
+- An admitted candidate route may name only the exact current gate artifacts its owner
+  must refresh: `touched-files.md`, `evidence.md`, optional `browser-evidence.md`,
+  `polish-report.md`, `review.md`, `seal.md`, and the owner's `state.md` fields as
+  applicable. Source, completed-slice identities, answers, decisions, and unrelated
+  history remain protected. Each owner preserves unrelated content and normal gates.
+- Archived/`done` workspaces are no-ops. Unknown or unverifiable inputs stop without
+  writes. There is no legacy fallback: never synthesize or guess scope, bytes, proof,
+  freshness, or a historical pass.
+- The explicit invocation authorizes only admitted, behavior-neutral workspace repairs.
+  Product/policy choices, acceptance changes, irreversible risk, and human-only actions
+  remain HITL.
+
+## Workflow
+
+0. **Orient read-only.** Apply `/rite-doctor`. Resolve the explicit or active slug.
+   Archive-only is `current`; otherwise require contained regular `state.md` and read its
+   cursor. A damaged/mismatched install stops at Doctor; missing live work routes
+   `/rite-spec`; `done` is `current`. An unknown cursor is `unsupported`.
+   A `state.md` whose cursor carries no `schema` row — or any engine refusal naming the
+   workspace schema — means the workspace predates the current engine schema: structural
+   normalization is a human-approved engine step that precedes this audit, not part of
+   it. Stop and surface the refusal verbatim (it names the fail-closed `migrate`
+   command with `--dry-run`/`--answer`); after the human runs it, restart at step 0.
+1. **Freeze preservation evidence.** Record `git status --short`, cursor form/fields,
+   `devrites-engine orient <slug>` (cursor, `task_graph`, `artifact_budgets`,
+   `bulk_files`), and
+   hashes of completed-slice fields, candidate gate artifacts, existing answers/decisions,
+   and protected history. Inventory every path that could change; absence is evidence,
+   never permission to synthesize history. **Rerun after a mid-run stop:** frozen hashes die
+   with the stopped run, so never re-baseline over bytes its owners may have changed. The
+   durable baseline is `HEAD`: a workspace path that differs from it is recorded
+   `pre-changed` with its diff, not frozen as clean, and step 5 accepts it only as an
+   admitted path of this run's assessment, else `gap`. An untracked workspace has no durable
+   baseline: if its `state.md` cursor shows an owner's HITL/blocked stop, stop for the human
+   to confirm the current bytes as baseline before step 2. For a post-Build workspace, also retain the
+   exact result of `devrites-engine check candidate <slug>`; at or after Seal retain the
+   exact result of `devrites-engine check seal <slug>`.
+2. **Assess from fresh context.** Dispatch exact `devrites-upgrade-planner` with the named
+   installed contracts, workspace paths, cursor form, current phase, and frozen baseline.
+   Require one read-only typed assessment. It writes and asks nothing.
+3. **Admit the assessment fail closed.** Accept `current` only when every applicable axis has
+   cited evidence and no finding. Accept `repairable` only when every finding names the
+   current rule, exact workspace evidence, affected gate, owning rite, exact writable paths,
+   minimal delta, and protected invariants. Missing fields become `gap`.
+   Unsupported shapes remain untouched. Reject version-only, speculative, alias-creating,
+   source-changing, history-changing, or acceptance-changing advice.
+4. **Route; do not duplicate.** For `repairable`, invoke only the admitted current owners,
+   one at a time:
+   - decision coverage or a material assumption → `/rite-clarify`;
+   - stale/inconsistent planning or traceability with settled intent → `/rite-plan repair`;
+   - over-budget `state.md` or planning artifacts carrying checkpoint narrative, or
+     packets/traces in the workspace root → `/rite-plan revise` (verbatim relocation to
+     `history/` / `packets/`, current view only; IDs, meaning, answers and decisions
+     unchanged; nothing deleted);
+   - unbuilt slices beyond the [feature ceiling](../rite-plan/reference/slicing.md#feature-ceiling-split-an-epic-never-override-the-budget)
+     → `/rite-plan course-correct` (trigger `reslice` loads [`slicing.md`](../rite-plan/reference/slicing.md);
+     `MVP cut` plus the named continuation sequence;
+     built slices and their evidence stay);
+   - live code and recorded intent disagreement → `/rite-converge`;
+   - any changed planning input or readiness defect → `/rite-vet`;
+   - a missing/malformed strict manifest, missing/malformed/mismatched evidence binding,
+     a browser-binding defect when that file exists, or current candidate-check failure
+     → `/rite-prove`;
+   - required candidate-affecting capability-ledger, `DESIGN.md`, or ADR rollups still
+     deferred by an old Ship-era workspace → `gap`: no admitted route. STOP with an
+     explicit `/rite-polish` handoff for separate user authorization; never invoke
+     those rollup writes inside Upgrade. After authorization outside Upgrade, normal
+     affected Prove → Review → Seal applies;
+   - workspace-only Polish refresh → `/rite-polish` only when its exact paths remain
+     within the admitted gate artifacts and no candidate-affecting rollup is required;
+   - a missing, stale, or mismatched review binding → `/rite-review`;
+   - a missing, stale, or mismatched seal binding or failed Seal gate → `/rite-seal`.
+
+   Sequence only applicable owners; candidate owners stay in the Prove → Polish → Review
+   → Seal order above. Each owner keeps normal gates/write limits. Stop on HITL/blocked.
+   Never infer `/rite-customize --import-legacy`; that mode requires the exact token in the
+   user's current invocation.
+5. **Re-audit and prove preservation.** Re-dispatch the planner once against the changed
+   candidate. `gap`, `unsupported`, or a remaining finding stops. Compare the frozen hashes
+   and Git status; only admitted paths may differ. Cursor changes must match the owning
+   rite while preserving form. Any unadmitted, protected, or source change is a gap and
+   stops; Upgrade never restores it itself.
+   For a post-Build workspace, run `devrites-engine check candidate <slug>` and require
+   the assessed bindings to match it. At or after Seal, also run
+   `devrites-engine check seal <slug>`. Run readiness where applicable:
+   ```bash
+   devrites-engine check readiness <slug>; echo "readiness rc=$?"
+   ```
+   Any nonzero result or mismatch remains a `gap` and stops.
+6. **STOP.** Do not advance to Build or Ship. A repeated `/rite-upgrade` is a no-op only
+   when the fresh assessment independently returns `current`; no marker may manufacture
+   that result.
+
+## Output
+
+```text
+Done: workspace <slug> compatibility <current | reconciled>.
+Changed: <admitted active-workspace paths | none>
+Evidence: assessment=current; candidate rc=<n|n/a>; seal rc=<n|n/a>; readiness rc=<n|n/a>; protected history/source unchanged
+Open: <none | exact unsupported shape, evidence gap, or human gate>
+Next: <state.md next action | one owning rite>
+Record: <owning rite's state.md — written by the owner, not Upgrade>
+↻ Hygiene: /clear before the next lifecycle step
+```