devrites 5.10.2 → 5.12.0

package/pack/generated/devin/skills/rite-spec/reference/spec-template.md

@@ -0,0 +1,154 @@
+# `spec.md` template
+
+Contract WHAT users get, WHY, success, and scope. HOW belongs in `plan.md`,
+topology in `architecture.md`/`flows.md`, coverage in `traceability.md`.
+
+Use `[NEEDS CLARIFICATION: <question>]` (blocking stops `/rite-clarify`); before readiness
+every surviving marker converts to a gated `Q-###` open question ([`spec-grammar.md`](../../devrites-lib/reference/standards/spec-grammar.md) §
+Unresolved-question markers — fail closed). Stable `REQ-001`/`AC-001` IDs; link, never
+duplicate, source artifacts; over-budget requires `Budget override: <reason>`.
+
+```markdown
+# Spec: <Feature>
+Slug: <kebab-case>
+Status: Draft | Ready
+Created: <date>
+
+## Problem
+<What is broken, missing, or costly.>
+
+## Goal
+<User-visible outcome and why it matters.>
+
+Capability impact: <affected capability/ies and change | none — specific justification>
+
+## Non-goals
+- <Explicitly out of scope.>
+
+## Existing behavior to preserve
+List affected observable public/security/data/operational outcomes that MUST
+survive; map preserving REQ/AC plus current test/runtime/contract/source evidence.
+No implementation detail. True greenfield: `none — no existing behavior in the affected scope`.
+
+| Existing outcome | Preserved by | Current evidence |
+| --- | --- | --- |
+| <outcome that must not regress> | REQ-001 / AC-001 | <current evidence> |
+
+Each preservation row **must** cite current evidence (test, runtime, contract, or
+observed behavior). An empty or vague evidence cell blocks Spec readiness.
+
+**Failing case:** row lists REQ-001 with evidence "none" or "TBD" → readiness gate
+fails until evidence is named or the outcome is removed from scope.
+
+## Stakeholders and priorities
+| Actor/stakeholder | Observable outcome | Conflict / priority rule |
+| --- | --- | --- |
+| <actor or affected owner> | <goal, protection, or operational need> | <none or how competing goals resolve> |
+
+## Constraints and invariants
+- INV-001: <fact that MUST remain true across success, failure, retry, and recovery>.
+- <security/privacy/accessibility/performance/compatibility/data/operational constraint,
+  or `none — <specific reason>` for a materially relevant category>.
+
+## Requirements
+- REQ-001: The system MUST <observable product behavior>.
+- REQ-002: The system MUST NOT <prohibited behavior>.
+
+## Acceptance criteria
+Binary/evidence-backed; each maps to a requirement and later a traceability slice.
+
+- [ ] AC-001: Given <state>, when <action>, then <outcome>. (REQ-001)
+- [ ] AC-002: Given <state>, when <action>, then <outcome>. (REQ-002)
+
+Behavioral/high-risk work uses this grammar, with the AC ID inside the scenario:
+
+### Requirement: <name>
+The system SHALL <core observable behavior>.
+
+#### Scenario: <name>
+- [ ] AC-003: **WHEN** <trigger> **THEN** <observable outcome>. (REQ-001)
+
+## Edge Coverage
+Use `covered | backstop | dismissed | unresolved`; target an existing REQ/AC
+unless dismissed. `backstop` requires a named independent held-out,
+property/metamorphic, or direct behavioral check plus the wrong behavior it
+discriminates. If unavailable, use `unresolved`; presence/prose/self-judgment cannot pass.
+
+| Edge ID | Requirement/AC | Class | Status | Reason/backstop |
+| --- | --- | --- | --- | --- |
+| EDGE-001 | AC-001 | empty/error/permission/race/migration | covered | <evidence/rationale> |
+
+## Prohibitions (must-NOT)
+Bespoke only; generic security/privacy stays in standards. Status:
+`resolved/test | resolved/judgment | dismissed | unresolved`.
+
+| Prohibition ID | Requirement/AC | Status | Test/evidence |
+| --- | --- | --- | --- |
+| PROH-001 | REQ-002 | resolved/test | <test/evidence link> |
+
+## Failure and recovery behavior
+| Trigger / partial state | User-visible outcome | System state | Recovery / retry rule | Requirement/AC |
+| --- | --- | --- | --- | --- |
+| <timeout, invalid input, interruption, dependency loss> | <clear bounded outcome> | <unchanged/pending/reconciling> | <who/what can safely recover> | <REQ/AC> |
+
+## Applicability map
+Use `applies | not applicable`; a non-applicable row needs a specific reason. The
+status routes Define/Vet/Build/Prove to the named standard without copying it here.
+
+| Concern | Status and trigger | Affected REQ/AC/invariant |
+| --- | --- | --- |
+| Repository topology (nested/mono/multi-repo, languages, services, generated/vendor) | <status + reason> | <ids> |
+| Data integrity (writes, schema/migration, concurrency, tenant, retention/privacy) | <status + reason> | <ids> |
+| Integration reliability (API/webhook/queue/job/cache/cross-service) | <status + reason> | <ids> |
+| Security boundary (authn/authz, hostile input/files, secrets, privilege) | <status + reason> | <ids> |
+| UI/accessibility/i18n/time-zone behavior | <status + reason> | <ids> |
+| Compatibility/delivery (old/new versions, config, flag, rollout/rollback) | <status + reason> | <ids> |
+
+## Edge cases
+- <Boundary note not captured above.>
+
+## AI-SPEC annex
+- Model/RAG/agent/eval/LLM-output scope: `ai-spec.md` from `ai-spec-template.md`.
+- Otherwise: not applicable.
+
+## Success metrics
+- <Metric or observable proof.>
+
+## Scope boundaries
+- Owns: <surface/behavior>.
+- Does not own: <adjacent area>.
+- Placement summary: <module/layer>; full map in `architecture.md`.
+
+## Coverage seed
+- Actors/journeys/components: <material surfaces>.
+- States/data/contracts/integrations: <material boundaries>.
+- Operations/proof: <config, observability, rollout/rollback, evidence constraints>.
+
+## References
+- `brief.md`: request/outcome/scope; `architecture.md`: placement/integration;
+  `flows.md`: Mermaid-first diagrams (optional `visual/<flow>.html`+`.outline.md` companion
+  + link when richer presentation earns it — load playbooks via
+  [`index.md`](../../devrites-lib/reference/visual-playbooks/index.md)); `decisions.md`: decisions;
+  `decision-coverage.md`: Clarify topology/verdict; `traceability.md`: Define coverage;
+  `design-brief.md`: UI direction.
+
+## Open questions
+| Question ID | Gate | Question | Impact |
+| --- | --- | --- | --- |
+| Q-001 | blocking | [NEEDS CLARIFICATION: <question>] | AC-001 |
+
+## Readiness gate
+- [ ] No blocking clarification or open `blocking`/`escalating` question; REQ/AC IDs are valid and ACs independently provable.
+- [ ] Stakeholder conflicts/priority rules, constraints, and invariants are explicit;
+      implementation preferences are not disguised as requirements.
+- [ ] Existing affected behavior maps to preserving REQ/AC + current evidence, or uses the exact justified greenfield `none`.
+- [ ] Edge rows target REQ/AC or justify dismissal; every backstop names independent discriminating evidence, else `unresolved`.
+- [ ] Prohibitions resolve/dismiss; `resolved/test` links evidence.
+- [ ] Each material failure/partial state names user outcome, system state, recovery,
+      and REQ/AC; no silent success or blind retry remains.
+- [ ] Every applicability row is `applies` with affected IDs or has a specific
+      evidence-backed `not applicable` reason.
+- [ ] AI has `ai-spec.md` and UI has `design-brief.md`; out-of-scope work states not applicable.
+- [ ] Non-goals/scope are explicit; capability impact is singular/specific and matches ledger deltas.
+- [ ] Architecture/flows/decisions are linked, not duplicated; Coverage seed names Clarify surfaces.
+```

package/pack/generated/devin/skills/rite-spec/reference/state-workspace.md

@@ -0,0 +1,232 @@
+# `.devrites/` state workspace
+
+This is the writer-facing companion to the canonical schema in
+[`devrites-lib/reference/workspace-artifact-schema.md`](../../devrites-lib/reference/workspace-artifact-schema.md).
+Load that schema before creating or updating workspace artifacts.
+
+## Layout
+
+```text
+.devrites/
+  ACTIVE
+  work/
+    <feature-slug>/
+      README.md                  # compact workspace map
+      brief.md
+      spec.md
+      checklists/                # from /rite-spec step 5a
+      architecture.md            # from /rite-define
+      flows.md                   # optional Mermaid-first; only when useful
+      visual/                    # optional HTML+outline companions (never readiness)
+      decisions.md
+      assumptions.md
+      questions.md
+      decision-coverage.md       # from /rite-clarify
+      strategy.md                # from /rite-temper
+      plan.md                    # from /rite-define
+      tasks.md                   # from /rite-define
+      traceability.md            # from /rite-define
+      eng-review.md              # from /rite-vet
+      test-plan.md               # from /rite-vet
+      state.md
+      evidence.md                # from /rite-build or /rite-prove
+      browser-evidence.md        # UI only
+      drift.md                   # drift only
+      touched-files.md           # from /rite-build
+      design-brief.md            # UI only
+      handoff.md                 # from /rite-handoff
+      references.md
+      references/
+  archive/
+    <feature-slug>/
+```
+
+## `flows.md` (optional Mermaid-first)
+
+Write `flows.md` only when sequence/state/data/lifecycle diagrams clarify the feature.
+Keep **Mermaid in `flows.md`** when that is enough. When a richer reviewable presentation
+is needed, **also** emit `.devrites/work/<slug>/visual/<flow>.html` +
+`visual/<flow>.outline.md` and link the pair from `flows.md`.
+
+Before any HTML:
+
+1. Open matching playbooks via
+   [`../../devrites-lib/reference/visual-playbooks/index.md`](../../devrites-lib/reference/visual-playbooks/index.md)
+   (progressive; never preload all seven).
+2. Copy required outline headings from
+   [`outline-template.md`](../../devrites-lib/reference/visual-playbooks/outline-template.md).
+3. Dual-read: agents treat the outline as SSOT; **outline wins** on conflict. No Lavish
+   runtime; this is not a new lifecycle phase and never inflates readiness.
+
+`/rite-spec` may seed a thin `flows.md` when investigation already needs a diagram;
+`/rite-define` owns richer architecture/flow companions beside `architecture.md`.
+
+## Creation rules
+
+- Create or reuse the slug exactly under the canonical schema's
+  [Slug identity](../../devrites-lib/reference/workspace-artifact-schema.md#slug-identity)
+  contract.
+- `/rite-spec` creates the workspace map, `brief.md`, `spec.md`, `decisions.md`,
+  `assumptions.md`, `questions.md`, `state.md`, optional `references.md` /
+  `references/`, optional `flows.md` when a diagram already clarifies investigation,
+  and optional `design-brief.md` for UI.
+- `/rite-clarify` adds `decision-coverage.md`.
+- `/rite-define` adds `architecture.md`, `plan.md`, `tasks.md`, and
+  `traceability.md`; may add or enrich `flows.md` and optional `visual/` HTML+outline
+  companions when Mermaid alone is not enough.
+- `/rite-vet` adds `eng-review.md` and `test-plan.md`.
+- Later phases add only the artifact they own. Do not create optional files as
+  empty placeholders; absence means the phase has not produced that artifact.
+- Each artifact starts with a summary and links to deeper source files instead of
+  copying their content.
+- Use stable IDs: `REQ-001`, `AC-001`, `EDGE-001`, `PROH-001`, `SLICE-001`,
+  `DEC-001`, `ASM-001`, `DRIFT-001`, `EVID-001`; apply the canonical schema's
+  append-only ID contract. Queued questions use `q-YYYY-MM-DD-NNN` below.
+
+## README.md template
+
+```markdown
+# <Feature> Workspace
+phase: spec
+status: running
+next_action: /rite-clarify after spec readiness passes
+last_updated: <date>
+
+## Artifact map
+| File | Job |
+| --- | --- |
+| brief.md | Objective and bounds |
+| spec.md | Product contract |
+| decision-coverage.md | Clarification verdict; absent until /rite-clarify |
+| strategy.md | Temper record; absent until /rite-temper |
+| architecture.md | Technical map; absent until /rite-define |
+| plan.md | Technical approach; absent until /rite-define |
+| tasks.md | Vertical slices; absent until /rite-define |
+| traceability.md | Coverage dashboard; absent until /rite-define |
+| evidence.md | Proof log; absent until /rite-build or /rite-prove |
+
+## Read next
+| Phase / role | Read |
+| --- | --- |
+| Spec | brief.md, spec.md, questions.md |
+| Clarify | spec.md, decisions.md, assumptions.md, questions.md |
+| Build | state.md, decision-coverage.md, eng-review.md, test-plan.md, tasks.md, plan.md |
+| Review | traceability.md, evidence.md, decisions.md |
+
+## Blocking gates
+None.
+```
+
+## state.md template
+
+```markdown
+# State
+
+## Cursor
+| Key | Value |
+| --- | --- |
+| phase | spec |
+| status | running |
+| active_slice | none |
+| slice_mode | none |
+| risk | none |
+| next_action | <single command + reason, or terminal: none — technical recovery exhausted for an unchanged causal fingerprint> |
+| return_phase | <originating later phase; clarification or agent-owned technical backtracking only> |
+| return_next_action | <saved originating command> |
+
+## Awaiting human
+Only present when status is awaiting_human.
+| Key | Value |
+| --- | --- |
+| question_id | q-YYYY-MM-DD-NNN |
+| gate | blocking |
+| blocking_slices | SLICE-001 |
+```
+
+`state.md` is a compact cursor, not a history file. Put proof in `evidence.md`,
+decisions in `decisions.md`, assumptions in `assumptions.md`, and drift in
+`drift.md`. Omit both `return_*` rows outside a later-phase `/rite-clarify`
+retrofit or agent-owned technical backtracking chain.
+
+Before an active caller moves backward, it copies its current phase and
+non-empty action into the two return rows. Nested Plan, Vet, Build, and proof
+work preserves that valid cursor. Once the prerequisite chain is green, the
+controlling caller restores the saved phase/action and removes both rows in one
+rewrite. A real HITL or exhausted-recovery stop retains the cursor for cold
+resume. Never overwrite an existing valid return cursor, and preserve every
+unrelated Markdown byte. `/rite-clarify` applies its stricter native cursor protocol in `/rite-clarify`.
+
+On cold resume, a terminal `next_action` is a claim to verify, not a counter.
+Reconcile the exact fingerprint and its attempts in `drift.md` / `evidence.md`.
+If a consumptive action retained a distinct fingerprint below the no-progress
+cap, rewrite the cursor into caller-owned recovery and preserve or reconstruct
+the return rows only from the current phase and approved recorded action. The
+spent action authorization blocks another execution, not that rewrite.
+
+`afk_slices_remaining` is mutable runtime state, not `.devrites/AFK`
+configuration. Only the controlling root writes it under the shared
+[`afk-hitl.md`](../../devrites-lib/reference/standards/afk-hitl.md#the-sentinel-devritesafk)
+contract and Build's
+[`afk-discipline.md`](../../rite-build/reference/afk-discipline.md#iteration-cap).
+Ordinary workspace creation preserves the field without initializing,
+increasing, renaming, or deleting it. Released bullet workspaces spell it `AFK
+slices remaining`; preserve that presentation rather than migrating it.
+
+When the brief records a [sequence continuation](../../rite-plan/reference/slicing.md#continuation-workspaces),
+seed the `sequence_parent`, `sequence_position`, `sequence_workspaces_remaining`,
+and — for the release entry — `sequence_role` rows at creation per that contract.
+Without them `state merge-manifest` cannot walk the chain and the release-union
+gate never engages.
+
+## questions.md entry format
+
+```markdown
+## q-YYYY-MM-DD-NNN
+status: open | answered | dropped
+slice: spec | plan | SLICE-001
+gate: advisory | validating | blocking | escalating
+route: <specialist tag> (escalating only; omit otherwise)
+question: <one crisp sentence>
+options:
+  1. <recommended> (Recommended) - <trade-off>
+  2. <alternative> - <trade-off>
+proposed: <best current answer>
+raised_at: <iso>
+answered_at:
+answer:
+impact: <affected AC/REQ/slice IDs>
+```
+
+No open blocking/escalating question may remain before define/build/prove gates.
+For a new entry, scan every `## q-YYYY-MM-DD-NNN` header for the current date,
+choose one above the highest suffix (or `001` when none exist), advancing until
+it is unused, then re-read
+`questions.md` immediately before the append and recompute. If the candidate is
+no longer unused, retry the scan; never reserve or derive it with an engine
+command.
+
+## brief.md template
+
+```markdown
+# Brief: <Feature>
+
+## Objective
+<One sentence.>
+
+## Non-goals
+- <Explicitly out of scope.>
+
+## Success definition
+<One sentence that says what "done" means.>
+
+## Route
+Size: <small | standard | large>
+Profile: <quick | standard | full>
+Why: <one line — the significance signals that picked the profile>
+```
+
+## Compactness
+
+High-traffic files should stay within the budgets in
+[`workspace-artifact-schema.md`](../../devrites-lib/reference/workspace-artifact-schema.md). If a file truly must exceed its budget, add
+`Budget override: <reason>` near the top.

package/pack/generated/devin/skills/rite-status/SKILL.md

@@ -0,0 +1,66 @@
+---
+name: rite-status
+description: "User-invoked read-only active-feature report: phase, active slice, next action, evidence, open questions, drift, risks, and handoff readiness."
+argument-hint: "[feature-slug]"
+triggers:
+  - user
+---
+<!-- loads: {"always":["devrites-lib/reference/standards/core.md"],"workspace":["state.md","tasks.md","questions.md"]} -->
+> Read-set manifest: `devrites-engine context [slug] --skill rite-status` bundles every file named below into one deduplicated read.
+
+# /rite-status: active feature status
+
+Read-only. Report the active workspace; do not run a phase or write files.
+
+## Load
+
+Use the supplied slug or `.devrites/ACTIVE`; require its authoritative
+`state.md` and read the cursor directly. Read question, evidence, and risk
+artifacts only as needed. Never infer lifecycle state from `README.md` or chat.
+
+If no workspace exists: when archived workspaces record an unfinished
+[continuation sequence](../rite-plan/reference/slicing.md#continuation-workspaces),
+list each next command (`/rite-spec <parent>-<n> "<objective>"`); otherwise
+recommend `/rite-spec <feature>`. Then stop.
+
+If `state.md` is unreadable/malformed: report a gap with the defect and stop — never infer the phase from other files; `/rite-doctor`/`/rite-upgrade` own repair.
+
+## Report
+
+1. feature and one-line objective;
+2. phase, run mode, and active slice;
+3. status from `state.md`;
+4. the single `Next step` recorded in `state.md`;
+5. proven versus unproven evidence;
+6. open questions by gate, including the exact resolving command when awaiting
+   a human; list `gate: escalating` entries separately under **Escalating:**
+   with their `route:` specialist tag (do not mix with synchronous blockers);
+7. unresolved drift and material risks;
+8. handoff readiness.
+
+A workspace is handoff-ready when it records one next action, all unresolved
+questions, non-obvious decisions, load-bearing assumptions, current drift
+status, and evidence for its claims. If chat contains missing durable context,
+recommend `/rite-handoff` before the lifecycle command.
+`devrites-engine handoff [slug]` emits the deterministic resume record (cursor,
+`awaiting_human`, blocking question gates, ledger reduction, dead ends,
+read-next order) — cite it for items 3–6 and the handoff-readiness verdict
+rather than re-deriving them. When `metrics.jsonl` exists,
+`devrites-engine metrics summary <slug>` rolls up dispatch/return counts and
+bundle bytes per phase — cite it for dispatch accounting rather than
+re-counting the ledger.
+
+Do not derive a command from host identity or invent one from phase names. Read
+the persisted `Next step`.
+
+## Output
+
+```text
+Feature: <slug> — <objective>
+Phase: <phase>; slice: <slice|n/a>; mode: <HITL|AFK>; status: <status>
+Evidence: <fresh/proven summary | gaps>
+Open: <questions/drift/blockers | none>
+Escalating: <qid route:tag … | none>
+Handoff: <ready | missing durable context>
+Next: <single persisted command>
+```

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

@@ -0,0 +1,133 @@
+---
+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]"
+---
+
+<!-- loads: {"always":["devrites-lib/reference/standards/core.md","devrites-lib/reference/orchestration-profiles.md","devrites-lib/reference/standards/agents.md","rite-temper/reference/significance.md","rite-temper/reference/scope-modes.md","rite-temper/reference/review-dimensions.md","rite-temper/reference/strategy-template.md","rite-temper/reference/anti-patterns.md"],"triggers":{"afk":["devrites-lib/reference/standards/afk-hitl.md"],"applicability":["devrites-lib/reference/standards/repository-topology.md","devrites-lib/reference/standards/data-integrity.md","devrites-lib/reference/standards/integration-reliability.md"],"documentation":["devrites-lib/reference/standards/documentation.md"],"elicitation":["devrites-lib/reference/standards/elicitation.md"],"yagni":["devrites-lib/reference/standards/patterns.md","devrites-lib/reference/standards/coding-style.md"]},"workspace":["brief.md","spec.md","state.md","decisions.md","assumptions.md","questions.md","decision-coverage.md","strategy.md","design-brief.md"],"workspaceByRole":{"strategy-reviewer":["brief.md","spec.md","decision-coverage.md","decisions.md","strategy.md","state.md"]}} -->
+> Read-set manifest: `devrites-engine context <slug> --phase temper` bundles every file named below into one deduplicated read. Trigger names map to the conditional rules in the sections that follow.
+
+
+# /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 `.devin/skills/devrites-lib/reference/standards/`)
+Pull on demand: [`patterns.md`](../devrites-lib/reference/standards/patterns.md) +
+[`coding-style.md`](../devrites-lib/reference/standards/coding-style.md) (the over-engineering / YAGNI rubric, trigger `yagni`; reuse the pack's standard, don't
+invent one), [`documentation.md`](../devrites-lib/reference/standards/documentation.md) (ADR-style `decisions.md` entries), [`afk-hitl.md`](../devrites-lib/reference/standards/afk-hitl.md)
+(irreversible-risk list + gate ceiling), [`elicitation.md`](../devrites-lib/reference/standards/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`](../devrites-lib/reference/standards/repository-topology.md), [`data-integrity.md`](../devrites-lib/reference/standards/data-integrity.md), or [`integration-reliability.md`](../devrites-lib/reference/standards/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. HITL confirms expand;
+  autocomplete auto-applies it. Irreversible-risk still pauses.
+- **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`](../devrites-lib/reference/standards/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 ([`spec-checklists.md`](../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 `.devin/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) — autocomplete applies
+   the recommended mode including `expand`; 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.
+   Unapproved irreversible choices set `Awaiting human`. Autocomplete expand does
+   not. Objective below-bar findings continue correction.
+7. **Adversarial verification loop:** ask the exact
+   [`devrites-strategy-reviewer`](.devin/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/devin/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`.