devrites 5.5.0 → 5.7.0

package/pack/generated/pi/skills/rite-temper/SKILL.md

@@ -0,0 +1,130 @@
+---
+name: rite-temper
+description: Temper a readied spec before planning. Use when the user says "temper this", "strategy review", "pre-mortem the spec", or asks if we are over/under-building. Not for code review or final seal.
+argument-hint: "[feature-slug] [--mode expand|selective|hold|reduce]"
+user-invocable: true
+---
+
+# /rite-temper: review scope and risk before planning
+
+Review the readied spec for ambition, scope, pre-mortem risk and unnecessary surface. Fold accepted decisions into the canonical contract before
+`/rite-define`. This step is optional for small work and skips low-stakes specs, but
+`/rite-autocomplete` always invokes it. **Read the active workspace first**; if there
+is no readied `spec.md`, tell the user to run `/rite-spec`. Review depth follows
+[`devrites-lib/reference/orchestration-profiles.md`](../devrites-lib/reference/orchestration-profiles.md);
+the required exact strategy reviewer never changes with profile.
+
+## Rules consulted (read on demand from `.pi/skills/devrites-lib/reference/standards/`)
+Pull on demand: `patterns.md` +
+`coding-style.md` (the over-engineering / YAGNI rubric (reuse the pack's standard, don't
+invent one), `documentation.md` (ADR-style `decisions.md` entries), `afk-hitl.md`
+(irreversible-risk list + gate ceiling), `elicitation.md` (the move-set to deepen a section
+that needs more than the default pre-mortem) selected by the section's risk). Load
+`repository-topology.md`, `data-integrity.md`, or `integration-reliability.md` only when
+the spec applicability map triggers that risk family.
+
+## Operating rules
+- **Raise outcome ambition without expanding the solution unnecessarily.** Solve the
+  underlying problem without adding speculative capability or abstraction.
+- **Route every scope change through the Spec Drift Guard.** A scope change takes effect
+  only when `spec.md` records the confirmed decision. Expansion is **opt-in** (HITL
+  confirm; AFK pauses: see autocomplete policy). Nothing auto-grows into the build.
+- **Apply maximum caution to hard-to-reverse changes.** Auth, migration, public API, and
+  data-model changes always pause under the irreversible-risk list.
+- **Honest verdict.** Never round "needs work" up to "ready"; record every scope call's *why*.
+- **Search before asking.** Apply `afk-hitl.md` decision ownership; only human-owned calls
+  enter the interactive walk.
+- **You write; the reviewer judges.** You are the single canonical writer (`strategy.md` +
+  the spec edits); the reviewer agent is read-only.
+- **Require spec-quality checklists for significant features.** Before hardening,
+  confirm `checklists/<domain>.md` exist and pass (`rite-spec/reference/spec-checklists.md`); a
+  scope expansion you fold in **adds its own** rows (new Success/Acceptance criteria get
+  checklist rows too). A folded expansion with an unquantified criterion is a CRITICAL
+  failure that reopens the readiness gate.
+
+## Workflow
+0. **Read `.pi/skills/devrites-lib/reference/standards/core.md`**, then
+   resolve the active slug, require its `state.md`, and read the cursor directly.
+   Then read the workspace: `spec.md`, `decision-coverage.md` (+ `decisions.md`,
+   `assumptions.md`, `design-brief.md` if UI), `state.md`. Require `Spec gate: passed`: else
+   STOP → `/rite-spec`. Require `Decision coverage: CLEAR`: else STOP →
+   `/rite-clarify`. If a plan already exists, scope changes route through `/rite-plan
+   repair` (record in `drift.md`), not a blind spec edit.
+1. **Significance test:** [`reference/significance.md`](reference/significance.md). Low-stakes
+   / shape-not-meaning work → write the exact one-line `skipped — low stakes (<trigger>)` verdict to `strategy.md`,
+   set `state.md` `Phase: temper` + `Next step: /rite-define`, and recommend it. Otherwise fire the full pass below.
+2. **FORWARD pass + mode selection:** [`reference/scope-modes.md`](reference/scope-modes.md).
+   First, the **one-sentence-intent test**: state the whole change's intent in a single sentence.
+   If you can't without an "and" that joins two unrelated outcomes, it is **two features**: the
+   scope-creep signal; recommend splitting or narrowing the spec before continuing.
+   Apply the same test to size: a spec whose honest decomposition would exceed the
+   [feature ceiling](../rite-plan/reference/slicing.md#feature-ceiling-split-an-epic-never-override-the-budget)
+   (roughly ten slices or more than ~20 acceptance criteria) is a feature sequence;
+   recommend the thinnest shippable subset now and name the continuations as Non-goals.
+   Then consider the 10-star outcome for the underlying problem and choose **exactly one**
+   scope mode (`expand` opt-in · `selective` · `hold-rigor` · `reduce-to-MVP`) with its
+   rationale and the condition that would change the choice. `$ARGUMENTS` `--mode` is a
+   hint, not a command.
+3. **INVERSION pass:** pre-mortem in past tense ("it shipped and failed: what went wrong"),
+   each top risk carrying likelihood + mitigation + the slice it will bind to; then the **YAGNI
+   ledger** (each candidate scope item gets the "imagine the later refactor" test; defer unless
+   now-cost is trivial AND deferred-cost is large).
+   **Interruption pre-mortem:** audit the spec forecast and assumptions for unresolved behavior,
+   proof prerequisites, approvals, access, and irreversible gates. Resolve facts and reversible
+   details now; retain only unavailable-pre-code or mandatory action-time checkpoints.
+   Challenge each `not applicable` decision against live evidence and each applicable
+   topology/data/integration row against its worst credible partial-state/recovery case.
+   - **Deepen on demand.** When a scope decision, requirement, or risk needs more analysis
+     than the default pre-mortem provides, choose 3-5 techniques from
+     [`elicitation.md`](../devrites-lib/reference/standards/elicitation.md) whose *when-to-reach-for-it* matches that
+     section's risk (irreversible decision → Red-Team/Blue-Team + Assumption Audit; sizing → Delphi;
+     vague requirement → Steelman-then-Attack), offer them, and run the chosen one **on that
+     section**. Record what changed, not the technique name. The default passes remain
+     sufficient when no deeper analysis is needed.
+4. **Score the 9 dimensions:** [`reference/review-dimensions.md`](reference/review-dimensions.md).
+   Cite evidence *before* the band; **gate on the floor** (the weakest dimension, not an average).
+   **Completion:** all nine dimensions have cited evidence, a band, and one explicit floor verdict.
+5. **Review human-owned findings with the human; do not batch them.** `strategy.md`
+   records the interactive review but does not replace it. Present each material scope decision through
+   `AskUserQuestion`, one at a time, best-guess + **why**. Each material scope call ends as a
+   **recorded decision**: a resolved `questions.md` qid (HITL) or a `decisions.md` ADR (AFK):
+   so the review leaves an auditable record outside chat. (AFK gate policy —
+   [`reference/significance.md`](reference/significance.md) — `hold-rigor` + `reduce-to-MVP`
+   auto-apply, **any `expand` is a blocking pause**, irreversible-risk always pauses.)
+   Apply objective clarity, mitigation, and assumption fixes directly.
+6. **Write `strategy.md` + fold back:** [`reference/strategy-template.md`](reference/strategy-template.md).
+   **Choose the drift path based on whether a plan exists:** *no `plan.md` yet* (the normal pre-define
+   case) → update `spec.md` **through the Spec Drift Guard**. *Success metrics* (outcome-level, no AC id)
+   **and** *Acceptance criteria* for each opt-in expansion / cut, **Non-goals** for every deferred item,
+   *Constraints and invariants*, with top failure modes + mitigations folded into *Failure and recovery
+   behavior* rows, and the *Open questions* table; *`plan.md`
+   already exists* → do **not** edit `spec.md` here: write the deltas to `drift.md` and hand off
+   to `/rite-plan repair`. Either way, append `decisions.md` (one ADR per scope call: context ·
+   decision · why-not · what-would-change-it) and `assumptions.md` (every "we'll probably need X" →
+   assumption-to-verify). (every delta carries the step-5 recorded decision; an untraceable
+   fold is invalid). **Re-check the spec Readiness gate** (it fails if
+   any folded scope delta lacks its decision or leaves a foreseeable human build choice).
+   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 routes `/rite-clarify`/HITL. Only after the
+   matrix is re-closed may the phase advance.
+   Set `Phase: temper`; `Next step: /rite-define` only after verification.
+   Human-owned expansion/unapproved irreversible choices set `Awaiting human` +
+   `Status: awaiting_human`; objective below-bar findings continue correction.
+7. **Adversarial verification loop:** ask the exact
+   [`devrites-strategy-reviewer`](.pi/agents/devrites-strategy-reviewer.md)
+   through the native fresh-context contract in
+   [`agents.md`](../devrites-lib/reference/standards/agents.md), with **only** the hardened
+   spec + rubric, no authoring reasoning. Fold technical findings into one correction;
+   exact strategy reviewer rechecks open findings and affected coverage/regressions under
+   [the canonical retry contract](../devrites-lib/reference/standards/afk-hitl.md#retry-cap-no-progress-loops-and-self-resolve):
+   Product/scope choices and unapproved irreversible risk remain human gates;
+   technical exhaustion preserves blocker/reproduction.
+   If the named agent is unavailable, stop for HITL. After an accepted edit to a
+   coverage-bound input, repeat step 6's native coverage revalidation before handoff.
+8. **STOP.** Report the mode, the scope deltas, and the floor verdict; recommend `/rite-define`.
+
+> **Mid-flight discipline.** Do not replace the interactive review with `strategy.md`,
+> expand implementation surface without need, grow scope outside the Drift Guard, or score
+> before citing evidence. See [`reference/anti-patterns.md`](reference/anti-patterns.md).

package/pack/generated/pi/skills/rite-temper/reference/anti-patterns.md

@@ -0,0 +1,30 @@
+# /rite-temper: anti-patterns
+
+For cross-phase issues, read [universal anti-patterns](../../devrites-lib/reference/standards/anti-patterns.md).
+
+## Phase rationalizations
+
+| Excuse | Rebuttal |
+|---|---|
+| "I'll write all the findings into `strategy.md` and let the user read it." | Fold and recheck objective corrections preserving scope, behavior, and risk policy. Ask human-owned strategy/acceptance choices with recommendations and await answers. Recording alone resolves nothing; never silently expand or trim the spec. |
+| "Bigger is better: let's add the extra capability while we're thinking big." | Ambition belongs on the **outcome**, not the **solution surface**. A speculative capability/abstraction is gold plating. Expand the problem + acceptance; never the machinery. |
+| "The user obviously wants the ambitious version. I'll add it to the spec." | Expansion is **opt-in**, recorded, and confirmed (HITL) or paused (AFK). Adding acceptance the human didn't approve is silent scope growth: route it through the Spec Drift Guard or don't add it. |
+| "It's over-scoped, I'll just trim those criteria." | Reducing scope is **still a spec change**. Cut acceptance only as a recorded Spec-Drift-Guard decision, and park the rest in Non-goals with a revisit note: never a silent trim. |
+| "This dimension is weak but the others are strong: net it's fine." | The gate is the **floor**, not the average; strong clarity cannot offset broken risk. |
+| "I can see it's adequate. I'll note the band, evidence is obvious." | Cite spec evidence **before** the band; never score first and rationalize later. |
+| "It's a strategy doc, the implementation concerns don't apply yet." | Cross-cutting concerns (security/data/observability/modifiability) are where strategy breaks down. Address each or mark it explicitly N/A: silent omission is a gap. |
+| "This greenfield design is elegant." | Ground ambition in live seams/blast radius; a new dependency or second design system needs an explicit decision. |
+
+## Red flags
+- An accepted strategy change recorded in `strategy.md` but not reflected in its
+  owning spec acceptance/Non-goals. A clean review does not require gratuitous spec edits.
+- An `expand` decision auto-applied in AFK, an unapproved risk-policy change, or an
+  irreversible operation without its required authorization.
+- A pre-mortem with risks listed but no mitigation + owning slice: a risk without an owner is a
+  wish.
+- Repeating an exhausted causal failure under the shared no-progress rule in
+  [`afk-hitl.md`](../../devrites-lib/reference/standards/afk-hitl.md), or stopping a
+  distinct cause solely because the total review round exceeds three.
+- The reviewer being handed the author's reasoning as independent evidence
+  (defeats the fresh-context point).
+- The skill writing a `plan.md`, slicing, or touching code. That's `/rite-define` / `/rite-build`.

package/pack/generated/pi/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`) 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 a
+   code-intelligence index 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 `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/pi/skills/rite-temper/reference/scope-modes.md

@@ -0,0 +1,53 @@
+# Scope modes + the two passes
+
+The heart of `/rite-temper`: two ordered passes (heat, then quench), converging on exactly
+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 a
+code-intelligence index if available (see `../../devrites-lib/reference/standards/tooling.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` 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 |
+| **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
+The bigger the bet, the more it must be reversible. Irreversible-risk areas (auth, migrations,
+public API, data model) get the **opposite** of ambition: maximum conservatism, explicit
+rollback, and they **always pause** regardless of mode (the `afk-hitl.md` irreversible-risk
+list is honored verbatim). Size big bets so that if the whole thing vanished tomorrow, you'd be
+fine.
+
+## 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/pi/skills/rite-temper/reference/significance.md

@@ -0,0 +1,46 @@
+# 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`
+  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 a code-intelligence index if available (see
+  `../../devrites-lib/reference/standards/tooling.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).
+- **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 under the AFK gate ceiling: `hold-rigor` and
+`reduce-to-MVP` auto-apply (they never grow acceptance); **any `expand` is a blocking pause**;
+irreversible-risk findings always pause. Expansion is never auto-grown unattended.

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

@@ -0,0 +1,90 @@
+# `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 `questions.md` qid or a
+    `decisions.md` ADR): 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.
+- Add `strategy.md` to the workspace between `spec.md` and `plan.md`; `/rite-define` and
+  `/rite-ship` read it.

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

@@ -0,0 +1,121 @@
+---
+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
+---
+
+# /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 `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.
+  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`.
+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. 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` (`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`;
+   - candidate-affecting capability-ledger, `DESIGN.md`, or ADR rollups still deferred by
+     an old Ship-era workspace → `/rite-polish`;
+   - 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
+```