devrites 3.0.7 → 3.2.0

package/pack/.claude/skills/rite-seal/reference/phase-contract.md

@@ -1,36 +1,5 @@
 # rite-seal phase contract
 
-## Execution spine
-
-Run the engine gates at these moments:
-
-```bash
-devrites-engine preamble
-
-devrites-engine spec-validate .devrites/work/<slug>; echo "spec-validate rc=$?"
-devrites-engine check-acceptance .devrites/work/<slug>; echo "check-acceptance rc=$?"
-devrites-engine evidence-fresh <slug>; echo "evidence-fresh rc=$?"
-devrites-engine doubt-coverage <slug>; echo "doubt-coverage rc=$?"
-
-devrites-engine footprint log <slug> reviewer devrites-<x>-reviewer
-devrites-engine footprint log <slug> skip devrites-<x>-reviewer
-devrites-engine footprint roster <slug>; echo "roster rc=$?"
-devrites-engine review-integrity <slug>; echo "review-integrity rc=$?"
-devrites-engine review-fingerprints --write <slug>
-
-devrites-engine footprint render <slug>
-devrites-engine learnings add "<slug>" "<dismissed-as-intentional class or dead-end>" dismiss
-devrites-engine health record <0..10> "<GO|NO-GO evidence summary>" --note "<top blocker or green proof>"
-devrites-engine timeline log completed --skill rite-seal --slug <slug> --outcome "<go|no-go>" --decision "<verdict>"
-
-devrites-engine progress
-```
-
-Conditional calls still obey the detailed rules below: reviewer and skip
-footprints must account for the whole roster; learnings run only on GO; progress
-is rendered before the final response from [`output.md`](output.md). Seal decides
-only; `/rite-ship` owns irreversible git/publish/deploy actions.
-
 1. **Run the shared orientation preamble:** it prints `state.md`, the artifacts present,
    the run mode (HITL/AFK), and the open-question tally by gate, so you orient deterministically
    instead of re-deriving state from raw Markdown:
@@ -80,50 +49,20 @@ only; `/rite-ship` owns irreversible git/publish/deploy actions.
      verdicts by hand).
    Either way, walk the `## Decisions stood` ledger yourself: severity rides the unverified
    **decision**, never the exit code alone.
-5. Check **security, data, migration, rollback** risk:
-   [risk-and-rollback](risk-and-rollback.md). If `strategy.md` exists (from
-   `/rite-temper`), confirm its **top pre-mortem risks are mitigated** in the diff/evidence and
-   that no **Non-goal / deferred item crept into the diff** (scope creep): either is a finding
-   (an unmitigated top risk or smuggled-in out-of-scope work).
-   - **Principles** (`principles.md`): score the final diff against each declared invariant in
-     `.devrites/principles.md`. A violation with no matching, human-approved exception in the
-     register is a **Critical** finding and a NO-GO; an exception that is stale (past its review
-     trigger) or wider than its stated scope is itself a finding. No file / no principles → skip.
-   - **Observability** (`observability.md`): if the diff added a runtime surface (endpoint,
-     job, integration, user flow, error path), a feature shipping with no way to debug it in
-     prod is an **Important** finding, not a pass: `evidence.md` should show telemetry observed
-     to emit (`/rite-prove` step 5b).
-   - **Developer experience** (`developer-experience.md`): if the diff ships a developer-facing
-     surface, reconcile `devex.md` (the `/rite-vet` predicted scorecard vs the `/rite-prove`
-     measured one: the boomerang). A broken public dev contract (a documented command that errors,
-     a getting-started flow that can't complete) or an unexplained measured DX regression is
-     **Important**. **Critical** on a frozen public surface (`principles.md`). No surface → skip.
-   - **Removal / migration** (`deprecation.md`): if the diff deletes or migrates code, an API,
-     or data, confirm it followed expand→contract, proved the old path unused before removing it,
-     and carries a rollback for every destructive step. A surprise deletion or a one-shot
-     breaking migration is a finding (and trips the irreversible-risk gate, `afk-hitl.md`).
+5. Check **security, data, migration, rollback**, strategy scope, principles,
+   observability, developer experience, and removal using
+   [risk-and-rollback](risk-and-rollback.md) and the named standards. Unmitigated top risks,
+   scope creep, missing runtime diagnostics, broken developer contracts, or unsafe removals
+   are findings. An unexcepted declared-principle violation is Critical and NO-GO.
 6. Check **frontend polish** if UI is involved (states, a11y, responsive, design-system,
    browser evidence).
-7. **Independent review:** seal is the final gate, not a re-run of `/rite-review`.
-   It **always re-spawns** the axes `/rite-review` did not cover: `devrites-test-analyst`,
-   `devrites-security-auditor`, `devrites-performance-reviewer`, and
-   `devrites-frontend-reviewer` (UI). It **only re-runs the Spec and Code-review axes**
-   (`devrites-spec-reviewer`, `devrites-code-reviewer`) when the diff changed since
-   `/rite-review` ran (compare against `review.md`); if the diff is unchanged, carry
-   review's verdicts on those axes forward rather than re-litigating them.
-   If subagents are available, fan out **in parallel** (one `Task` block, multiple tool
-   calls) to the **roster**: the seven reviewers and their checkable triggers are the single
-   source in [`parallel-dispatch.md`](../../devrites-lib/reference/parallel-dispatch.md) (dispatch
-   shape + reconciliation there too; `.claude/skills/devrites-lib/reference/standards/agents.md`. "Run independent reviewers in
-   parallel"). Dispatch every always-on reviewer and every conditional whose trigger the diff
-   meets; `devrites-devex-reviewer` runs in **measure mode**: grade the measured DX scorecard
-   and reconcile the boomerang against the `/rite-vet` prediction. Give each the workspace path +
-   diff *without the author's reasoning*. If subagents are unavailable, run the equivalent
-   reviews sequentially yourself and flag each as a fallback.
-   The reviewer **AGENTS** here (fresh context, no author reasoning) are the seal
-   GATE; `devrites-audit` is the inline single-axis pass run during build/polish.
-   The two paths are intentional, not divergent: the inline audit catches issues
-   early; the fresh-context agents are the independent gate before ship.
+7. **Independent review:** apply the complete roster, triggers, dispatch shape, and
+   reconciliation from
+   [`parallel-dispatch.md`](../../devrites-lib/reference/parallel-dispatch.md). Await
+   fresh-context batches of at most three and give reviewers only the workspace path plus
+   immutable diff, without author reasoning. Use named role → safely enforced generic fresh
+   agent → labelled inline; inline output is never independent. Carry Spec/Code verdicts only
+   for an unchanged post-review diff; rerun the other applicable axes.
    **Footprint: account for the whole roster.** For each reviewer you dispatch, append
    `devrites-engine footprint log <slug> reviewer devrites-<x>-reviewer` (the reviewer's **exact agent name**:
    the roster gate matches on it, so a freehand label like `spec` will read as unaccounted); for
@@ -131,13 +70,12 @@ only; `/rite-ship` owns irreversible git/publish/deploy actions.
    `devrites-engine footprint log <slug> skip devrites-<x>-reviewer` and note the one-line reason in `seal.md`.
    A conditional reviewer that does not apply is a *recorded skip*, never a silent omission: step 7b
    proves the roster complete before the verdict.
-7a. **Reconcile findings: confidence over volume.** Band each reviewer finding by confidence
+7a. **Reconcile findings by confidence.** Band each reviewer finding by confidence
    (1-10); a low-confidence (≤4) finding that can't be verified against the diff is **suppressed**
    to a `Suppressed (low-confidence): n` line, not a blocker. Every Critical/Important must cite
    the `file:line` (or spec line) that proves it. Surface genuine cross-reviewer disagreement
    **explicitly** rather than averaging it away, and don't let a pile of low-confidence nits
-   inflate the verdict: the gate is `Critical == 0` + acceptance + drift, not "few findings".
-   (A seal that fires noise teaches the next one to be ignored.)
+   inflate the verdict. The gate is `Critical == 0` + acceptance + drift, not "few findings".
 7b. **Account for the roster: no reviewer silently skipped.** Before the verdict, prove every
    roster reviewer carries a decision (dispatched or skip-recorded in step 7's footprint):
    ```bash
@@ -158,7 +96,7 @@ only; `/rite-ship` owns irreversible git/publish/deploy actions.
    ```
    - **rc=1:** an axis in `review.md` is silent (no finding, no justification): **Important** on the
      review's completeness. Re-run that axis or record its `No-findings:` account, then re-seal.
-   - **rc=0:** every axis has findings or a justified clean bill; proceed. (No `review.md`, or a
+   - **rc=0:** every axis has findings or a justified no-findings result; proceed. (No `review.md`, or a
      freeform one, is a clean pass: the gate keys on per-axis sections.)
    Then write stable finding IDs for learning and recurring-dismissal correlation:
    ```bash
@@ -178,20 +116,10 @@ only; `/rite-ship` owns irreversible git/publish/deploy actions.
      "acceptance": "<proven>/<total>", "test_integrity": "ok | weakened", "mutation": "<score | n/a>",
      "blockers": ["<one line each, empty on GO>"] }
    ```
-9. **On GO only: record proven conventions** to the local ledger
-   (`.devrites/conventions.md`) so later slices stop re-deriving this project's idioms:
-   the durable, *evidence-proven* commands / idioms / placement / gotchas this feature
-   established. Evidence-gated like the seal itself; the band is earned, not guessed; the
-   step degrades gracefully when unavailable. Full contract + command:
-   [conventions-ledger](conventions-ledger.md). (Skip entirely on NO-GO.)
-9a. **On GO only: auto-capture learnings** (`.devrites/learnings.md`). Learning is automatic, not a
-   command anyone must remember: append this feature's durable signal so the **next** feature's
-   review starts warmer: (a) any reviewer finding the gate **dismissed as intentional here** (a
-   "don't re-flag X in this project" class, tag `dismiss`); (b) a recurring correction or dead-end
-   worth not repeating (tag `note`). The review skills load this ledger **before** they fan out, so a
-   dismissed-finding class stops recurring. It is an untrusted prior: live code always overrides
-   (`.claude/skills/devrites-lib/reference/standards/security.md`). Promotion of a recurring lesson to a *project rule* stays the
-   human's call (`/rite-learn`: propose, don't impose). Skip on NO-GO.
+9. **On GO only:** record evidence-proven conventions through
+   [conventions-ledger](conventions-ledger.md).
+9a. **On GO only:** append durable dismissed-finding or dead-end learnings as untrusted
+   priors. Promotion to a project rule remains human-owned.
    ```bash
    devrites-engine learnings add "<slug>" "<dismissed-as-intentional class or dead-end>" dismiss
    ```
@@ -200,7 +128,14 @@ only; `/rite-ship` owns irreversible git/publish/deploy actions.
     lower for NO-GO or unresolved blockers.
     ```bash
     devrites-engine health record <0..10> "<GO|NO-GO evidence summary>" --note "<top blocker or green proof>"
-    devrites-engine timeline log completed --skill rite-seal --slug <slug> --outcome "<go|no-go>" --decision "<verdict>"
+    devrites-engine timeline log run-finished \
+      --slug <slug> \
+      --outcome "<passed|blocked>" \
+      --execution-mode named \
+      --guard-strength n/a \
+      --reason-id "<DRV-GATE-SEAL-PASSED on GO; otherwise the blocking DRV-* reason>" \
+      --host "<claude|codex>" \
+      --evidence .devrites/work/<slug>/seal.md
     ```
 
 ## `seal.md` template

package/pack/.claude/skills/rite-seal/reference/risk-and-rollback.md

@@ -25,6 +25,19 @@ For each risky step, state how to back it out:
 - A new external dependency with no failure handling is at least **Important**.
 - Record the chosen rollback path in `seal.md` → "Rollback / Recovery".
 
+## Fresh-context fallback weighting
+
+An inline final-rung review is useful signal but **not independent evidence**:
+
+- Record `independence: fallback` and a roster skip reason; never log it as a dispatched
+  reviewer or a clean fresh-context pass.
+- Preserve its findings at their normal severity. A clean inline result still leaves an
+  **Important assurance gap** and cannot silently satisfy a required axis.
+- Seal remains NO-GO until that axis runs through a fresh-context spawn, or the human
+  explicitly accepts the reduced assurance in `seal.md`. AFK never auto-accepts it.
+- Security or irreversible-risk scope has no reduced-assurance override: unavailable
+  independent review remains NO-GO.
+
 ## Destructive operations
 Confirm any destructive step with the user before shipping. Verify backups exist where
 relevant. Never treat an irreversible action as routine.

package/pack/.claude/skills/rite-ship/reference/design-memory.md

@@ -1,69 +1,64 @@
-# Design memory: roll proven design language into project `DESIGN.md`
+# Design memory: record proven design rules in `DESIGN.md`
 
-Optional, UI-only step at `/rite-ship`. A feature's design decisions live in its
-feature-scoped `design-brief.md` and are thrown away when the workspace archives. **Design
-memory** is the deliberate exception: when a UI feature ships, roll the design language it
-*proved* up into a project-level `DESIGN.md`, so the next feature's `devrites-ux-shape`
-inherits the system instead of re-discovering it.
+This optional `/rite-ship` step applies only to UI features. Feature design decisions
+live in `design-brief.md` and archive with the workspace. With the user's approval,
+copy proven, reusable design rules into the project-level `DESIGN.md` for later
+features.
 
-The consumers already exist: `devrites-ux-shape` §1 and
-`devrites-frontend-craft/reference/design-references.md` both read `DESIGN.md` when present.
-This step is the missing **producer**. It closes the loop: feature N seals its design
-language → feature N+1 builds to it.
+`devrites-ux-shape` §1 and
+`devrites-frontend-craft/reference/design-references.md` read `DESIGN.md` when present.
+This step writes that file from sealed feature evidence.
 
 ## When it runs
 - **UI features only.** No UI in the diff → skip silently.
 - **At ship, GO sealed, after the git plan, before type-GO** (step 2a), so the user sees
   the full staged change set (code + `DESIGN.md`) under the single type-GO that ships it.
-- **Opt-in and confirmed.** Persisting to a project-wide artifact is outside feature scope
-  (`standards/core.md` rule 7), so it is *never silent*. Present a ranked option set
+- **Opt in and confirm.** A project-wide artifact is outside feature scope
+  (`standards/core.md` rule 7), so never write it silently. Present a ranked option set
   (see [`afk-hitl.md`](../../devrites-lib/reference/standards/afk-hitl.md), "Option set");
   **default is skip**. The user opts to persist.
-- **AFK**: first-time `DESIGN.md` *creation* is treated as a `validating` gate (a new
-  persistent project artifact): propose + queue, don't auto-create. An *append* to an
+- **AFK:** first-time `DESIGN.md` creation is a `validating` gate because it adds a
+  persistent project artifact. Propose and queue it; do not create it automatically. An append to an
   existing `DESIGN.md` is `advisory` and may auto-proceed when `allow_gates` permits, since
   it only adds evidence-proven entries.
 
 ## Inputs (proven only)
 - `design-brief.md`: direction, color strategy, **calibration** (density / motion), key
   states, named anchors, and the per-slice **Build-time refinements**.
-- The **final diff** + `touched-files.md`: what tokens / components / states *shipped* (the evidence). Roll up only what the diff proves, not what the brief intended.
+- The **final diff** and `touched-files.md`: the tokens, components, and states that
+  shipped. Record only what the diff proves, not everything the brief intended.
 - Existing `DESIGN.md` if present: the merge target.
 
-## What to roll up: the project's *converged* system, evidence-gated
-Only entries the shipped, proven feature establishes. Each is durable, cross-feature design
-language, not this feature's one-off choices.
+## What to record
+Record only reusable rules established by the shipped, proven feature. Exclude choices
+that apply only to this feature.
 - **Tokens introduced + used:** new color roles / spacing steps / type steps / elevation
   / radius that shipped and are reusable. Names and values, mirrored from the code.
-- **Color strategy + calibration baseline:** the strategy (Restrained / Committed / …) and
-  density / motion the project keeps landing on; note a deviation as a deviation, not a new
+- **Color strategy and calibration baseline:** the strategy (Restrained / Committed / …) and
+  established density / motion; record a deviation as a deviation, not a new
   default.
 - **Type & spacing scales** in actual use; **motion** classes + easing; **materiality**
   (elevation set, hairline usage, glass / texture policy).
-- **Component behaviors:** for each shared component this feature established or extended:
-  the states it ships and its interaction model. Grows one feature at a time.
-- **Named-anchor lineage:** the anchors features steered toward, so later work stays
-  coherent with what's already built.
+- **Component behaviors:** for each shared component established or extended by the
+  feature, record its shipped states and interaction model.
+- **Named-anchor lineage:** the anchors used by shipped features.
 - **Anti-slop exceptions:** any banned default the project *intentionally* uses (with the
   why), so build / polish don't "correct" a deliberate choice.
 
 ## Merge discipline
 - **Append, don't overwrite.** Add proven entries; never silently rewrite an existing one.
-- **Conflict is a question, not an edit.** A new token / font / strategy that contradicts an
-  existing `DESIGN.md` entry → surface it to the user (the option set), don't resolve it
-  yourself. One design system per project.
-- **Never invent.** If the feature didn't prove it, it doesn't go in. `DESIGN.md` is design
-  *memory*, not design *aspiration*.
-- **Attribute + keep lean.** Tag each new entry with the feature slug so the lineage is
-  legible; one good line beats a paragraph. The file is read every future spec: keep it
-  scannable.
+- **Ask about conflicts.** If a new token, font, or strategy contradicts an existing
+  `DESIGN.md` entry, present the option set to the user. Do not resolve it yourself.
+  Keep one design system per project.
+- **Never invent.** Include only rules proven by the feature.
+- **Attribute and keep it short.** Tag each new entry with the feature slug. Future
+  specs read this file, so use concise entries.
 
 ## How it commits
-`DESIGN.md` is a tracked project artifact, so it ships **in the feature commit**:
+`DESIGN.md` is a tracked project artifact and ships **in the feature commit**:
 1. Write / update `<project-root>/DESIGN.md` from the template below.
-2. **Append `DESIGN.md` to `touched-files.md`** so the existing ship commit-scoping (SKILL
-   steps 2 + 4) stages it: the design-memory write rides the same commit and the same
-   type-GO, no second commit.
+2. **Append `DESIGN.md` to `touched-files.md`** so the existing commit scope (SKILL
+   steps 2 and 4) stages it under the same type-GO. Do not create a second commit.
 3. Note the rollup in `ship.md` (what was added, or "design-memory: skipped by user").
 
 ## `DESIGN.md` template (project-level, stack-agnostic)

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

@@ -5,18 +5,17 @@ argument-hint: "<feature or idea>"
 user-invocable: true
 ---
 
-# /rite-spec: investigate deeply, write the spec
+# /rite-spec: investigate and write the spec
 
-The spec phase. Turn a request (even a vague one) into a **fully-covered, correctly-placed
-`spec.md`** by investigating deeply and closing every material gap with the human, so
-`/rite-define` can plan it and nothing is missed. **No plan, tasks, or code here**. Those
-are `/rite-define` and `/rite-build`.
+Turn a request into a **fully covered, correctly placed `spec.md`** by investigating
+the existing system and resolving every material gap found during authoring.
+`/rite-clarify` audits the full topology before `/rite-define` plans it. **Do not write
+a plan, tasks, or code here.** Those belong to `/rite-define` and `/rite-build`.
 
-> **Too small to spec? Use `/rite-quick`.** A typo, copy tweak, config bump, or one-function
-> fix does **not** need a full workspace + lifecycle. Stop and run `/rite-quick <change>`: its
-> express lane (one contract → TDD build → scoped prove → ship) escalates back here the moment
-> the change turns out to touch auth / data / a migration / a public API / more than one slice.
-> Spec is for real features; don't pay its ceremony for a one-off.
+> **Use `/rite-quick` for a small change.** A typo, copy edit, config bump, or
+> one-function fix does not need a full workspace and lifecycle. Run
+> `/rite-quick <change>`. It returns here if the work touches auth, data, a migration, a
+> public API, or more than one slice.
 
 ## Rules consulted (read on demand from `.claude/skills/devrites-lib/reference/standards/`)
 Pull `documentation.md` via `Read`
@@ -27,35 +26,34 @@ Pull `spec-grammar.md` and `devrites-lib/reference/workspace-artifact-schema.md`
 acceptance for a behavioral / high-risk requirement (auth,
 data model, state machine, public API, money, migration): the structured `### Requirement:` /
 `#### Scenario:` (SHALL · WHEN/THEN) form, lint-checked by `devrites-engine spec-validate`. Simple criteria
-stay flat `AC-###` bullets; the grammar is opt-in by rigor, never forced.
+stay flat `AC-###` bullets; the grammar is opt-in by rigor, never forced. Use
+[`reference/acceptance-criteria.md`](reference/acceptance-criteria.md) to keep each
+criterion independently observable and binary.
 
 ## Operating rules (DevRites core)
 - No silent assumptions · no guessing through confusion · prefer existing conventions ·
   ask the human when an answer changes scope, placement, data model, UX, security,
   migration risk, or acceptance.
-- **Author section by section, not in one dump.** Draft the spec one section at a time
-  (problem → goal → requirements → acceptance → edge cases), and pause after each: a section
-  that carries real risk (a contested requirement, a boundary, an unstated assumption) can be
-  deepened right there with a fitting technique from
-  [`elicitation.md`](../devrites-lib/reference/standards/elicitation.md) before moving on. A spec
-  written a section at a time is where sharper thinking lands cheaply; a wall-of-text spec hides
-  the weak section.
+- **Root authority:** the controlling chat asks every human question, makes decisions, and
+  writes the workspace. Read-only evidence work follows the fresh-context contract in
+  [`agents.md`](../devrites-lib/reference/standards/agents.md).
+- **Author one section at a time.** Draft problem → goal → requirements → acceptance →
+  edge cases, pausing after each section. If a section contains a contested requirement,
+  boundary, or unstated assumption, apply a relevant technique from
+  [`elicitation.md`](../devrites-lib/reference/standards/elicitation.md) before continuing.
 
 ## Workflow
 0. **Read `.claude/skills/devrites-lib/reference/standards/core.md`:** the always-on operating rules and anti-rationalizations.
    Then run `devrites-engine preamble` for deterministic workspace orientation.
-0a. **Brownfield check: onboard before speccing onto un-adopted existing code.** If this is an
-   **existing codebase** (real source predating DevRites) that has **never been adopted** (no
+0a. **Check whether existing code needs adoption.** If this is an
+   **existing codebase** that has **never been adopted** (no
    `.devrites/conventions.md`, no prior `.devrites/work`, `.devrites/features`, or `.devrites/archive`) the build has no
-   conventions ledger to follow and the first slice would guess the project's idioms. Route
-   through `/rite-adopt` **first**, carrying `$ARGUMENTS` as its *next objective*: adopt
-   reverse-derives the baseline `spec.md`, **seeds the conventions ledger**, and proposes
-   principles, so this feature is specced on top of an onboarded project (adopt owns the
-   onboarding; `/rite-spec` only detects and routes: no duplicated logic). In **HITL** present a
-   ranked option (recommended: *adopt first, then spec this on top*; escape hatch: *spec-only, skip
-   onboarding*); in **AFK** (adoption allowed) run `/rite-adopt` first automatically. **Greenfield
-   (no pre-existing source) or an already-onboarded project → skip silently**: never block a spec
-   for the absence of adoption (the same no-op discipline as the principles gate). Cheap probe:
+   conventions ledger, route through `/rite-adopt` **first** and pass `$ARGUMENTS` as its
+   next objective. Adopt derives the baseline `spec.md`, seeds conventions, and proposes
+   principles; `/rite-spec` only detects and routes. In **HITL**, present a ranked option:
+   recommend adoption first and include a spec-only escape hatch. In **AFK**, when adoption
+   is allowed, run `/rite-adopt` automatically. **Skip this check silently for greenfield or
+   already-onboarded projects.** Never block a spec only because adoption is absent. Probe:
    ```bash
    if [ ! -f .devrites/conventions.md ] && [ ! -d .devrites/archive ] \
       && [ -z "$(ls .devrites/work .devrites/features 2>/dev/null)" ] \
@@ -63,137 +61,88 @@ stay flat `AC-###` bullets; the grammar is opt-in by rigor, never forced.
      echo "brownfield, not yet adopted → recommend /rite-adopt first (carry this idea as its next objective)"
    else echo "greenfield or already onboarded → continue spec"; fi
    ```
-1. **Understand the request** (`$ARGUMENTS`). Restate the goal and the *real problem
-   behind it* in a sentence or two.
-   **Completion:** one sentence states both requested outcome and underlying problem.
+1. **Understand the request** (`$ARGUMENTS`). State the requested outcome and the
+   underlying problem in one or two sentences.
+   **Completion:** one sentence includes both.
 1a. **Local dedupe.** Search local issues/PRDs and archived specs before creating a new workspace:
    ```bash
    devrites-engine spec-dedupe "$ARGUMENTS"
    ```
    If it finds a close match, ask the user: extend existing / adopt / new spec. Record the choice in
    `decisions.md` once the workspace exists. No match → continue silently.
-2. **Investigate deeply:** [investigation](reference/investigation.md). Produce, and
-   later write into the spec: **current behavior**; **placement** (which module/layer/
-   file/component should own it, the seam, patterns to reuse, and integration points:
-   callers, dependents, data, APIs/events); **what it resolves**; **issues**
-   (conflicts/constraints); **gaps** (unknowns); **blast radius**. Use a code-intelligence
-   index **if available**: `codebase-memory-mcp` first, cross-checked with `codegraph`
-   (`.codegraph/` / `codegraph_*`) + `graphify` (`graphify-out/`), else standard methods
-   (LSP / `Read`/`Grep`/`Glob`); see `.claude/skills/devrites-lib/reference/standards/tooling.md`:
-   for placement/callers/impact instead of broad file reads; fall back to reading files. For
-   uncertain external library/framework facts that bear on placement or feasibility, consult
-   context7 if available. When a material decision turns on a fact outside the codebase: a
-   common UX pattern, a standard, a prevailing best practice, how comparable products solve it:
-   **search the web if available** (brave MCP preferred; see `.claude/skills/devrites-lib/reference/standards/tooling.md`), and
-   carry the cited finding into the option you put to the human at step 4.
-   Also discover the project's **test / build/typecheck/lint** commands and the
-   frontend/backend systems; read `PRODUCT.md` / `DESIGN.md` / `CLAUDE.md` / `AGENTS.md` if
-   present (`AGENTS.md` is the cross-tool agent-conventions standard (treat it as project
-   conventions the build must follow, same standing as `CLAUDE.md`), and read
-   `.devrites/principles.md` if present) the declared invariants the feature must respect.
-   **Consult the capability ledger**: the living record of what the system already does
+2. **Investigate:** follow [investigation](reference/investigation.md) through its
+   complete findings and done-when gate. Also discover the project's **test /
+   build/typecheck/lint** commands, frontend/backend systems, and declared project guidance
+   (`PRODUCT.md`, `DESIGN.md`, `CLAUDE.md`, `AGENTS.md`, and `.devrites/principles.md` when
+   present).
+   **Consult the capability ledger**, which records current system behavior
    ([`ledger.md`](../rite-ship/reference/ledger.md)): `devrites-engine ledger list` for the
    capabilities on record, then `devrites-engine ledger show <capability>` for any this feature
    touches. Also search prior decisions with `devrites-engine decisions search "<2-4 feature nouns>"`
-   before asking the human to re-decide a settled architecture/API/auth choice. Starting from the proven contract (not a cold re-derive) is what makes the spec store
-   compound across features; it also tells you which requirements are new vs a change to existing
-   behavior, which decides the delta kind in step 5.
-3. **Gather design references (optional):** [references-intake](reference/references-intake.md).
-   The human **may** attach screenshots, mockups, a Figma link, a video, or links, or
-   **none at all** (perfectly normal; skip this step then). If any are given: **view/fetch**
+   before asking the human to revisit a settled architecture, API, or auth choice. The
+   ledger shows whether each requirement is new or changes existing behavior, which
+   determines the delta kind in step 5.
+   Identify proof constraints now: human-only credentials, unavailable environments, approval
+   windows, or acceptance not observable through existing test/runtime/browser surfaces.
+   Split independent placement, blast-radius, and external-fact questions into at most three
+   bounded `devrites-evidence-scout` packets on one frozen baseline. Await and reconcile every
+   cited dossier before step 4. The scout supplies facts only; it never asks the human or writes
+   the spec.
+3. **Gather design references when provided:** [references-intake](reference/references-intake.md).
+   The human may attach screenshots, mockups, a Figma link, a video, links, or nothing.
+   Skip this step when none are provided. Otherwise, **view or fetch**
    them, **save local files** into `.devrites/work/<slug>/references/`, and index them in
    `references.md` as target, constraint, or inspiration. Later phases honor that role
    rather than treating every reference as a fidelity target.
    **Completion:** every supplied reference is saved and classified, or absence is explicit.
-3a. **Shape the UX/UI before code (if the feature touches UI)**, when this feature is
-   frontend ([frontend-trigger](../rite-build/reference/frontend-trigger.md)), apply
-   `devrites-ux-shape` **now**, woven into the spec, not as a separate phase. It turns the
-   references + the spec into a feature-level **`design-brief.md`** (design direction, key
+3a. **Shape UX/UI before code when the feature is frontend**
+   ([frontend-trigger](../rite-build/reference/frontend-trigger.md)). Apply
+   `devrites-ux-shape` within the spec phase. It turns the
+   references and spec into a feature-level **`design-brief.md`** (design direction, key
    states, interaction model, optional Figma/image visual-direction probe) that `/rite-build`
-   targets so the UI is built to plan, not guessed. In HITL it pauses for the human to
+   targets for the build. In HITL it pauses for the human to
    confirm the direction; in AFK it asserts the best guess and logs it. Pure
    backend/data/CLI features skip this.
-4. **Close the gaps with the human. You recommend, the human decides.** Every material gap
-   (one that moves **objective · scope · placement · data model · UX · integration ·
-   non-functional · security · migration risk · acceptance**) is **put to the human as a ranked
-   option set**, one gap at a time, via the harness `AskUserQuestion` in HITL: **2-4 concrete
-   options, your recommended one first and marked `(Recommended)`**, each with a one-line
-   rationale + trade-off tagged by the dimensions that matter, plus an escape hatch (*Something
-   else. I'll describe it*). Render contract + AFK behaviour: the **Option set** section of
-   [`afk-hitl.md`](../devrites-lib/reference/standards/afk-hitl.md); spec-phase question discipline:
-   [question-protocol](reference/question-protocol.md). Your job is to **investigate, rank, and
-   recommend**, not to settle a material decision yourself. **Confidence changes the *cost* of
-   the question, not its *owner*:** when you're near-certain, you still present the set (the
-   human just confirms your `(Recommended)` option in one pick) you do **not** silently decide
-   it because you predicted the answer. Only a **genuinely reversible, low-impact** detail is
-   auto-decided and logged to `assumptions.md`; when unsure whether a gap is material, ask.
-   (Vague ask → `devrites-interview`; rough idea → `/rite-pressure-test`.) For a vague ask,
-   load [`reference/interview-patterns.md`](reference/interview-patterns.md), **map the decision
-   tree**, and resolve each branch depth-first; **cover every dimension**:
-   each resolved by a human pick or explicitly deferred (logged, non-blocking), never silently
-   skipped. Aim for **zero blocking gaps**. *If a gap is genuinely undecidable on paper (state
-   machine that may deadlock, data shape ambiguity, "which UX wins") → suggest a
-   scoped detour to `/rite-prototype` to answer that ONE question before
-   continuing.* **Invariant conflict is a blocking gap:** if a requirement or acceptance
-   criterion can only be satisfied by breaking a declared principle (`.devrites/principles.md`),
-   surface it: the principle wins by default; breaking it needs a recorded, scoped exception a
-   human approves, never a spec that silently contradicts an invariant.
-5. **Create the workspace** + set `.devrites/ACTIVE`
-   ([state-workspace](reference/state-workspace.md)). Write compact `README.md`,
-   `brief.md`, and `spec.md` ([spec-template](reference/spec-template.md)). WHAT/WHY,
-   technology-agnostic, with requirements, acceptance, edge cases, scope boundaries, links
-   to future `architecture.md` / `traceability.md`, and measurable acceptance
-   ([acceptance-criteria](reference/acceptance-criteria.md)). For a
-   behavioral / high-risk requirement, write the acceptance as a structured
-   `### Requirement:` (SHALL) + `#### Scenario:` (WHEN/THEN) block per
-   [`spec-grammar.md`](../devrites-lib/reference/standards/spec-grammar.md), nesting the `AC-###` id inside each scenario
-   so `/rite-seal` still grades it; routine criteria stay flat `AC-###` bullets. **When a
-   capability the ledger already holds is changing, write those requirements as deltas**:
-   `## ADDED / MODIFIED / REMOVED Requirements — capability: <c>` (spec-grammar.md § Delta form):
-   so the change, not just the end state, is explicit and `/rite-ship` folds it cleanly; a
-   capability with no ledger entry stays flat (the first sync seeds it). Also
-   write `brief.md`, `references.md`, `questions.md`, `decisions.md`, `assumptions.md`,
-   and an initial compact `state.md` (phase: spec) from
-   [state-workspace](reference/state-workspace.md). When the feature touches
-   UI, `design-brief.md` is written here too (by `devrites-ux-shape`, step 3a).
-   Populate `## Edge Coverage` with the deterministic boundary classes implied by each requirement
-   (empty/huge input, rounding, timezone, ordering, permissions, races, migration) and `## Prohibitions (must-NOT)`
-   only for bespoke constraints. If the feature touches model calls, RAG, agents, evals, or LLM output,
-   also create `ai-spec.md` from [ai-spec-template](reference/ai-spec-template.md). Then refresh any
-   managed project context block so `AGENTS.md` / `CLAUDE.md` point at the new active workspace:
+4. **Resolve human-owned gaps.** Recommend an option and let the human decide. Apply
+   [question-protocol](reference/question-protocol.md), the shared
+   [`afk-hitl.md` option-set and decision-ownership rules](../devrites-lib/reference/standards/afk-hitl.md#decision-ownership-search-before-asking),
+   and [`interview-patterns.md`](reference/interview-patterns.md) for a vague ask. Every
+   material dimension is resolved by a human pick or explicitly deferred as non-blocking;
+   only genuinely reversible, low-impact details go to `assumptions.md`. A paper-only
+   uncertainty may take one scoped `/rite-prototype` detour. A declared-principle conflict
+   remains blocking until the human approves a recorded, scoped exception.
+4a. **Build-interruption forecast.** Search first, then list and close foreseeable human needs:
+   product/acceptance ambiguity, irreversible/external approval, or human-only access. Record
+   owned prerequisites. Keep a build checkpoint only for unavailable pre-code evidence or a
+   mandatory action-time approval. **Completion:** no foreseeable human choice is deferred.
+5. **Create the workspace** + set `.devrites/ACTIVE` from
+   [state-workspace](reference/state-workspace.md). Write every required artifact and
+   conditional annex exactly from [spec-template](reference/spec-template.md), including its
+   grammar/delta, coverage-seed, edge/prohibition, UI, and AI rules. Then refresh any managed
+   project context block so `AGENTS.md` / `CLAUDE.md` point at the new active workspace:
    ```bash
    devrites-engine context sync || true
    ```
-5a. **Score the spec prose: "unit tests for English"** ([spec-checklists](reference/spec-checklists.md)).
-   Emit `.devrites/work/<slug>/checklists/<domain>.md` (one per requirement domain the spec covers:
-   functional · data-model · interaction · non-functional · edge-cases). Each tests the *requirement
-   prose* for completeness / clarity / measurability: "is 'prominent' quantified?", "is every
-   enumeration closed?", **not** the implementation. Fix each CRITICAL fail by editing the spec
-   (not by softening the question); minor fails are logged. The checklists feed the readiness gate.
-6. **Run the spec readiness gate** (bottom of spec-template): no blocking
-   `[NEEDS CLARIFICATION]`, placement decided, all material gaps resolved, any design
-   references provided are saved, **UX/UI shaped into `design-brief.md` if the feature is
-   UI**, requirements testable, success criteria measurable, **one-sentence intent** (the whole
-   change states its intent in a single sentence (if it can't, it is two features: split it or
-   narrow the scope), **every `checklists/<domain>.md` at
-   `Verdict: pass`**, and **any structured requirement blocks are grammar-valid**) run
-   `devrites-engine spec-skeleton` first, then `devrites-engine spec-validate` with
-   `--against .devrites/specs` so any delta sections are also
-   reconciled against the ledger (an ADDED that already exists, or a MODIFIED/REMOVED that doesn't,
-   is a blocking failure to fix, not soften):
+5a. **Check the spec prose** with [spec-checklists](reference/spec-checklists.md).
+   Emit every applicable domain checklist and fix each CRITICAL by correcting the spec,
+   never by softening the question.
+6. **Run the complete readiness gate** at the bottom of
+   [spec-template](reference/spec-template.md), then validate structure and ledger deltas:
    ```bash
    devrites-engine spec-skeleton ".devrites/work/<slug>"
    devrites-engine spec-validate ".devrites/work/<slug>" --against .devrites/specs
    ```
    **Do not run `devrites-engine analyze` in this phase:** `tasks.md` deliberately does not
    exist yet. `/rite-define` owns the first analyze pass after it writes the slices.
-   Treat edge/prohibition findings as blocking just like grammar findings. When it passes, write `Spec gate: passed <iso>` to `state.md`.
-6a. **Review-before-code digest.** Before handing off to planning, render the cheap human review:
+   Any failure blocks. The interruption forecast must be resolved, owned, or a justified
+   action-time gate. Then write `Spec gate: passed <iso>`.
+6a. **Review-before-code digest.** Before planning, render the compact human review:
    `Intent` (one sentence), `Done means` (top acceptance/scenario IDs), `Scope/risk` (what is in/out
    plus the hard gates), and `Build exactly this?` (yes → next phase; no → revise now). The digest
    is a view over `spec.md`, not a new artifact. **Stop** after the digest.
 
-> **Mid-flight discipline.** When tempted to skip investigation depth, gap-closing, or placement decisions: see [`anti-patterns`](reference/anti-patterns.md) (Common Rationalizations + Red Flags). Load it the moment you reach for the excuse.
+> **Mid-flight discipline.** Do not skip investigation, gap resolution, or placement
+> decisions. See [`anti-patterns`](reference/anti-patterns.md).
 
 ## Output
 
@@ -204,12 +153,12 @@ Default success shape:
 Done: spec ready for <slug>; placement decided and gaps closed.
 Changed: spec.md, decisions.md, assumptions.md, questions.md, references/ <updated|n/a>
 Evidence: checklists passed; grammar <valid | n/a flat acceptance>; design brief <path | n/a>
-Open: <none | n non-blocking questions | Alternative: /rite-define for small reversible work>; review digest: intent + done-means + scope/risk rendered
-Next: /rite-temper
+Open: <none | n non-blocking questions | Alternative: /rite-quick if express-lane eligible>; review digest: intent + done-means + scope/risk rendered
+Next: /rite-clarify
 Record: .devrites/work/<slug>/spec.md
-↻ Hygiene: /clear before the next phase; /rite-handoff if away > a few hours
+↻ Hygiene: /clear before /rite-clarify; /rite-handoff if away > a few hours
 ```
-If a workspace with the slug already exists, update its spec rather than overwriting blindly:
+If a workspace with the slug already exists, update its spec rather than overwriting it,
 and **show the human a short diff of what changed** in `spec.md` (acceptance criteria added /
 removed / reworded) before proceeding. A spec edit reviewed as a diff catches silent scope
 drift that a full re-read buries; this is the spec-review view (`/rite-spec --review` renders