devrites 2.6.1 → 3.0.1

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

@@ -1,6 +1,6 @@
 ---
 name: rite-temper
-description: Temper a readied `spec.md` before planning. Use when the user says "temper this", "strategy review", "pre-mortem the spec", "are we over/under-building", or before defining a big or risky feature. Not for a rough idea (`/rite-pressure-test`), a mid-build decision (`devrites-doubt`), a code diff (`/rite-review`), or the final gate (`/rite-seal`).
+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
 ---
@@ -15,11 +15,12 @@ canonical contract, so `/rite-define` plans the **hardened** spec. Optional for
 `/rite-autocomplete`. **Read the active workspace first**; if there's no readied
 `spec.md`, tell the user to run `/rite-spec`.
 
-## Rules consulted (read on demand from `.claude/rules/`)
-**Step 0:** Read `.claude/rules/core.md` first. Pull on demand: `patterns.md` +
+## Rules consulted (read on demand from `.claude/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).
+(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).
 
 ## Operating rules
 - **Ambition on outcomes, minimalism on the surface.** Raise the success bar and solve the
@@ -41,15 +42,8 @@ invent one), `documentation.md` (ADR-style `decisions.md` entries), `afk-hitl.md
   fail that re-opens the readiness gate.
 
 ## Workflow
-0. **Read `.claude/rules/core.md`**. Then **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:
-   ```bash
-   P=.claude/skills/devrites-lib/scripts/preamble.sh
-   [ -f "$P" ] || P="${CLAUDE_SKILL_DIR:-}/../devrites-lib/scripts/preamble.sh"
-   [ -f "$P" ] || P=pack/.claude/skills/devrites-lib/scripts/preamble.sh
-   [ -f "$P" ] && bash "$P" || echo "(orientation preamble unavailable on this install — read state.md directly to orient)"
-   ```
+0. **Read `.claude/skills/devrites-lib/reference/standards/core.md`**, then run
+   `devrites-engine preamble` for deterministic workspace orientation.
    Then read the workspace: `spec.md` (+ `decisions.md`,
    `assumptions.md`, `design-brief.md` if UI), `state.md`. Require `Spec gate: passed` — else
    STOP → `/rite-spec`. If a plan already exists, scope changes route through `/rite-plan
@@ -58,16 +52,27 @@ invent one), `documentation.md` (ADR-style `decisions.md` entries), `afk-hitl.md
    / shape-not-meaning work → write the one-line `skipped — low stakes (<trigger>)` verdict to `strategy.md`,
    set `state.md` `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).
-   Diverge on the *outcome* (the 10-star version of the real problem), then commit **exactly
-   one** scope mode (`expand` opt-in · `selective` · `hold-rigor` · `reduce-to-MVP`) with its
-   rationale and the **hinge** (what would change the call). `$ARGUMENTS` `--mode` is a hint, not
-   a command.
+   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
+   sharpest scope-creep signal there is; recommend splitting the spec (or narrowing this one) before
+   tempering further. Then diverge on the *outcome* (the 10-star version of the real problem), and
+   commit **exactly one** scope mode (`expand` opt-in · `selective` · `hold-rigor` · `reduce-to-MVP`)
+   with its rationale and the **hinge** (what would change the call). `$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).
+   - **Deepen on demand.** When a specific scope call, requirement, or risk needs sharper thinking
+     than the default pre-mortem gives, pull the 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 one
+     section**. Record what it changed, not that you ran it. Optional — the default passes stand on
+     their own.
 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. **Walk the findings WITH the human — do not batch-dump.** The artifact is the *output* of an
    interactive review, not a substitute for it: surface each material scope call / finding via
    `AskUserQuestion`, one at a time, best-guess + **why**. Each material scope call ends as a
@@ -104,16 +109,18 @@ invent one), `documentation.md` (ADR-style `decisions.md` entries), `afk-hitl.md
 
 ## Output
 
-**Footer first** — render the slice meter + flow ribbon by running the progress footer (`progress.sh`, resolved like the step-0 preamble — canonical snippet in `devrites-lib/SKILL.md`); keep the fact lines below it terse (`key value · key value`). Then:
+**Progress first** — run `devrites-engine progress`, then use the shared completion reply contract
+([`devrites-lib/reference/reply-contract.md`](../devrites-lib/reference/reply-contract.md)).
+Default success shape:
 ```
-Tempered: <slug>
-Significance: full | skipped — low stakes (<trigger>)
-Mode: <expand|selective|hold-rigor|reduce-to-MVP> — <one-line rationale> (hinge: <what would change it>)
-Scope: +<n expanded> / -<n reduced> / <n deferred to Non-goals>   (all via Spec Drift Guard)
-Pre-mortem: <n top risks> mitigated → bound to slices
-Dimensions: floor = <strong|adequate|thin|broken> on <weakest dimension>   Reviewer loop: <n> iter
-Spec readiness: re-checked → passes | <blocker>
-Next: /rite-define   (plans the hardened spec)
-↻ Hygiene: /clear before /rite-define (strategy.md + spec edits + decisions.md + assumptions.md captured). See rules/context-hygiene.md.
+Done: spec tempered for <slug>; mode <expand|selective|hold-rigor|reduce-to-MVP|skipped-low-stakes>.
+Changed: strategy.md, spec.md, decisions.md, assumptions.md
+Evidence: dimension floor <band>; reviewer loop <n>; spec readiness re-checked pass
+Open: <none | n deferred non-goals>
+Next: /rite-define
+Record: .devrites/work/<slug>/strategy.md
+↻ Hygiene: /clear before /rite-define
 ```
+If readiness is blocked, use the shared `Stopped / blocked` form and route `Fix:`
+to `/rite-spec`; do not recommend `/rite-define`.
 **DO NOT plan, slice, or write code here** — that's `/rite-define` and `/rite-build`.

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

@@ -1,7 +1,7 @@
 # /rite-temper — anti-patterns
 
 Universal rationalizations + red flags live in
-[`../../../rules/anti-patterns.md`](../../../rules/anti-patterns.md) — read it when the
+[`../../devrites-lib/reference/standards/anti-patterns.md`](../../devrites-lib/reference/standards/anti-patterns.md) — read it when the
 reluctance is broader than this phase. Below are the temper-specific ones.
 
 ## Phase rationalizations

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

@@ -15,7 +15,7 @@ Diverge on the *real problem*, not the obvious path. Ask:
 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 (a code-intelligence
-index if available — see `../../../rules/tooling.md`) — don't invent greenfield scope a
+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)

package/pack/.claude/skills/rite-temper/reference/significance.md

@@ -14,7 +14,7 @@ auth rewrite is the cheapest insurance you'll buy. Gate on stakes and shape, not
   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
-  `../../../rules/tooling.md` — or an honest estimate) crosses
+  `../../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).

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

@@ -1,6 +1,6 @@
 ---
 name: rite-vet
-description: Vet a defined plan before any code with a senior-engineer plan review. Use when the user says "vet the plan", "engineering review", "lock in the plan", or before building a feature. Not for the spec's strategy (`/rite-temper`), a mid-build decision (`devrites-doubt`), a code diff (`/rite-review`), or the final gate (`/rite-seal`).
+description: Vet a defined plan before code with senior-engineer engineering review. Use when the user says "vet the plan", "engineering review", "lock in the plan", or before building. Not for code review or final seal.
 argument-hint: "[slug] [--cross-model] [--full]"
 user-invocable: true
 ---
@@ -21,8 +21,8 @@ different-model second opinion. **Read the active workspace first**; if there's
 This is the engineering counterpart to `/rite-temper` (which is strategic, on the *spec*).
 Temper decides *the right thing*; vet decides *the right way to build it*.
 
-## Rules consulted (read on demand from `.claude/rules/`)
-**Step 0:** Read `.claude/rules/core.md` first. Pull on demand: `principles.md` (the project
+## Rules consulted (read on demand from `.claude/skills/devrites-lib/reference/standards/`)
+Pull on demand: `principles.md` (the project
 invariants gate — how `.devrites/principles.md` is scored pass/fail), `patterns.md` +
 `coding-style.md` (the over-engineering / reuse-first / YAGNI rubric — reuse the pack's
 standard), `testing.md` (the test-coverage axis) + `spec-grammar.md` (when the spec uses
@@ -31,7 +31,12 @@ map), `performance.md` (the perf axis),
 `error-handling.md` (failure-mode coverage), `development-workflow.md` (parallel lanes,
 definition of done), `afk-hitl.md` (irreversible-risk list + gate ceiling),
 `developer-experience.md` (when the plan ships a developer-facing surface — API / CLI / SDK /
-webhook / config / error messages / getting-started — predict the DX scorecard here).
+webhook / config / error messages / getting-started — predict the DX scorecard here),
+`elicitation.md` (the move-set to deepen an axis finding or a risky design choice — selected by
+the section's risk: Tournament for two viable designs, Delphi for a shaky estimate, Assumption
+Audit for a plan resting on unstated beliefs).
+- `definition-of-done.md` — standing Done bar: acceptance mapped, fresh proof, no open hard gates, scoped edits, rollback/docs where needed.
+
 
 ## Operating rules
 - **Review the plan, not the spec's ambition.** The spec's scope/ambition is `/rite-temper`'s
@@ -54,22 +59,20 @@ webhook / config / error messages / getting-started — predict the DX scorecard
   the weakest finding, not an average. Record every call's *why*.
 
 ## Workflow
-0. **Read `.claude/rules/core.md`** first.
+0. **Read `.claude/skills/devrites-lib/reference/standards/core.md`** first.
    Then **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:
    ```bash
-   P=.claude/skills/devrites-lib/scripts/preamble.sh
-   [ -f "$P" ] || P="${CLAUDE_SKILL_DIR:-}/../devrites-lib/scripts/preamble.sh"
-   [ -f "$P" ] || P=pack/.claude/skills/devrites-lib/scripts/preamble.sh
-   [ -f "$P" ] && bash "$P" || echo "(orientation preamble unavailable on this install — read state.md directly to orient)"
+   devrites-engine preamble
+   devrites-engine snapshot
    ```
    Then the workspace: `plan.md`, `tasks.md`, `spec.md`
    (for intent + acceptance), `strategy.md` (if `/rite-temper` ran), `decisions.md`,
    `assumptions.md`, `design-brief.md` (if UI), `state.md`. Require a `plan.md` whose
    Readiness gate passes (or `Plan approved`) — else STOP → `/rite-define`. Prefer a
-   code-intelligence index if available — codebase-memory-mcp first, cross-checked with codegraph + graphify, else standard methods (LSP / Read/Grep/Glob)
-   (see `.claude/rules/tooling.md`) — for placement / blast-radius / reuse checks.
+   code-intelligence index if available (see
+   `.claude/skills/devrites-lib/reference/standards/tooling.md`) for placement / blast-radius / reuse checks.
 1. **Calibrate depth — never skip** — [`reference/depth.md`](reference/depth.md). Every plan is
    vetted; what scales is the *depth*. A simple, single-module, reversible plan with no
    irreversible-risk / data-model / new-pattern trigger → **light pass** (brief scope check + a
@@ -77,18 +80,24 @@ webhook / config / error messages / getting-started — predict the DX scorecard
    **full pass** below. There is no skip: every feature leaves a recorded engineering verdict and
    a `test-plan.md` coverage map.
 2. **Scope Challenge (blocking gate)** — [`reference/review-axes.md`](reference/review-axes.md)
-   §0. What already exists that solves a sub-problem (reuse vs rebuild)? The minimum diff for the
+   §0. Search prior archived decisions for the plan's main nouns before asking the human to re-decide:
+   `devrites-engine decisions search "<2-4 plan nouns>"` (run `decisions index` first if needed).
+   What already exists that solves a sub-problem (reuse vs rebuild)? The minimum diff for the
    stated acceptance? Complexity smell (the plan touches **>8 files** or adds **>2 new
    services/modules**) → **STOP and ask** before any axis. Verify each new pattern / infra choice
    against a built-in (dispatch `devrites-source-driven`); completeness check (with AI, full
    coverage is ~100× cheaper than the human-hours saved by a shortcut — prefer complete); and a
    distribution check for any new artifact.
 2a. **Cross-artifact analyze gate + principles / charter / conventions gate.** Before the axes, run
-   one read-only consistency+coverage pass over `spec.md` + `plan.md` + `tasks.md` (+ `coverage.md`
+   one read-only consistency+coverage pass over `spec.md` + `plan.md` + `tasks.md` (+ `traceability.md`
    if present); any **CRITICAL** — an acceptance criterion with no slice, a slice satisfying no
-   criterion, a contradiction across artifacts — **blocks `/rite-build`** until resolved. Then score
+   criterion, a contradiction across artifacts, a requirement stated twice with conflicting terms —
+   **blocks `/rite-build`** until resolved. The engine covers the deterministic floor (AC coverage,
+   orphan slices, vague adjectives); you add the semantic passes it can't: **terminology drift**
+   (the same concept named differently across artifacts — normalize to the spec's term) and
+   **duplicated or conflicting requirements**. Then score
    the three project gates as explicit **pass/fail** on the planned approach:
-   - **Principles** (`.devrites/principles.md`, rubric in [`principles.md`](../../rules/principles.md))
+   - **Principles** (`.devrites/principles.md`, rubric in [`principles.md`](../devrites-lib/reference/standards/principles.md))
      — the authored invariants the project will not break. A plan that bakes in a violation of a
      declared principle with **no recorded, human-approved exception** is a **top-severity** finding,
      walked **first**, and **blocks `/rite-build`**. Absent or empty file → none declared → passes;
@@ -100,64 +109,50 @@ webhook / config / error messages / getting-started — predict the DX scorecard
      no second caller, or a dependency where an in-repo option exists is a **top-severity** violation.
    **Re-check all three after the axes harden the plan** (post-design). Write the result to `analysis.md`.
    ```bash
-   A=.claude/skills/devrites-lib/scripts/analyze.sh
-   [ -f "$A" ] || A="${CLAUDE_SKILL_DIR:-}/../devrites-lib/scripts/analyze.sh"
-   [ -f "$A" ] || A=pack/.claude/skills/devrites-lib/scripts/analyze.sh
-   [ -f "$A" ] && { bash "$A"; echo "analyze rc=$?"; } || echo "(analyze.sh unavailable — do the cross-artifact pass by hand: every AC↔slice mapped, no contradiction across spec/plan/tasks)"
+   devrites-engine analyze; echo "analyze rc=$?"
    ```
 3. **Four-axis review** — [`reference/review-axes.md`](reference/review-axes.md), through the
    senior-engineer lenses in [`reference/eng-lenses.md`](reference/eng-lenses.md): **Architecture
    → Plan code-quality → Test-coverage design → Performance**, ≤8 findings per axis, each
    `[severity] (confidence: N/10) <ref> — finding`. **Walk findings WITH the human, one at a
    time** via `AskUserQuestion` (best-guess + why + options with effort/risk/maintenance, mapped
-   to a rule) — the artifact is the *output* of the review, not a substitute for it. (AFK ceiling
+   to a rule) — the artifact is the *output* of the review, not a substitute for it.
+   When an axis finding hinges on a genuinely open design choice or a shaky estimate, deepen that
+   one finding with a fitting technique from
+   [`elicitation.md`](../devrites-lib/reference/standards/elicitation.md) (Tournament for two viable
+   designs, Delphi for the estimate, Assumption Audit for unstated beliefs) before you band it. (AFK ceiling
    single-sourced in [`reference/depth.md`](reference/depth.md): hardening /
    coverage-increasing findings auto-apply; **anything that grows scope or changes acceptance is a
    blocking pause**; irreversible-risk always pauses.)
-4. **Required outputs** — the test-coverage diagram + per-gap test requirements (the **regression
-   rule** is mandatory, no question). When the spec uses the structured grammar
-   (`spec-grammar.md`), the diagram maps **each `#### Scenario:` (WHEN/THEN) to ≥1 planned
-   test** — an unmapped scenario is a coverage gap the build must close. Then the failure-mode
-   table, "NOT in scope", "What already exists",
-   and the worktree parallelization strategy. Shapes in [`reference/review-axes.md`](reference/review-axes.md).
-   **Developer-facing surface?** If the plan ships one (`developer-experience.md` — API / CLI / SDK /
-   webhook / config / error messages / getting-started), predict the DX scorecard: the time-to-hello-world
-   estimate plus the getting-started, error-message, and ergonomics friction the plan bakes in. Write it
-   to `devex.md` as the **prediction the boomerang measures against** at `/rite-prove` / `/rite-seal`.
-   Absent surface → skip, no `devex.md` (greenfield no-op, like the principles gate).
-   Also a **PRP one-pass-implementable check** per slice brief (the build's pre-flight): confirm each
-   slice's Consumes/Produces, Known-Gotchas, validation commands, and reuse targets are present and
-   concrete — a brief that can't be built in one pass is a finding; harden the slice until it clears,
-   before `/rite-build`.
-4a. **Forge gate (rare — confirm or clear).** For each slice carrying `Forge: yes` (proposed by
-   `/rite-define`), and any slice the architecture axis showed has **≥2 genuinely-viable approaches
-   with no clear winner at Complexity ≥4**, confirm the flag: name the 2–3 candidate strategies that
-   actually differ (different data shape, different seam, reuse-vs-build — not variations of one), and
-   confirm the slice's acceptance + `test-plan.md` give the judge an objective scorecard. **Clear**
-   `Forge: yes` back to `no` when the review settled on one approach, the slice is below the complexity
-   bar, or you can't name two real strategies — competing a decided or trivial slice burns K× the build
-   for nothing. Forge is a **build-cost** decision, not an irreversible one: it never bypasses a gate,
-   and under AFK its K candidates count against the slice budget. Record the confirmed strategies in
-   the slice brief so `/rite-build` competes them
-   ([`rite-build/reference/forge.md`](../rite-build/reference/forge.md)). No flagged slice → nothing to do.
+4. **Required outputs** — write every shape and fold-back required by
+   [`reference/artifacts.md`](reference/artifacts.md), using the review rules in
+   [`reference/review-axes.md`](reference/review-axes.md). Ground parallelization in:
+   ```bash
+   devrites-engine lanes plan "$(cat .devrites/ACTIVE 2>/dev/null)"
+   ```
+   Completion: every scenario and acceptance criterion maps to planned proof, every slice is
+   one-pass implementable, and developer-facing plans have a predicted `devex.md` scorecard.
+4a. **Forge gate (only when `Forge: yes`).** Apply the eligibility and scorecard contract in
+   [`rite-build/reference/forge.md`](../rite-build/reference/forge.md). Confirm and record
+   genuinely distinct strategies, or clear the flag; an ineligible Forge never reaches build.
 5. **Write `eng-review.md` + `test-plan.md`, fold back** — [`reference/artifacts.md`](reference/artifacts.md).
    `eng-review.md` is the durable record; `test-plan.md` is the build-readable coverage target
    (`/rite-build` and `/rite-prove` read it). Harden `plan.md` / `tasks.md` directly for
    behavior-preserving refinements; route every acceptance/behavior-changing delta through the
    **Spec Drift Guard** (`drift.md` + recorded decision + `/rite-plan repair`). Append
-   `decisions.md` (one ADR per material call) and `assumptions.md`. Update `state.md`:
+   `decisions.md` (one ADR per material call) and `assumptions.md`. Re-run the gate after
+   every fold-back so a task edit cannot invalidate the earlier pass:
+   ```bash
+   devrites-engine analyze; echo "final analyze rc=$?"
+   ```
+   Any non-zero result blocks the handoff. Then update `state.md`:
    `Phase: vet`, `Next step: /rite-build`; on a blocking pause write the `Awaiting human` block +
    `Status: awaiting_human` before stopping.
-6. **Adversarial verification loop (full pass)** — dispatch [`devrites-plan-reviewer`](../../agents/devrites-plan-reviewer.md)
-   (fresh context, **only** `plan.md` + `tasks.md` + `spec.md` + the rubric — no authoring
-   reasoning). Resolve actionable findings, re-dispatch; **cap ≤3 iterations**. An axis still
-   below bar after 3 → blocking question (HITL) or AFK gate-ceiling entry. On a **light pass**
-   the fresh-context loop is skipped — the per-axis scan + the `test-plan.md` coverage map are the
-   verdict (escalate to this loop if the light scan surfaces a real finding). With `--cross-model`,
-   add one genuinely different-model pass — [`reference/cross-model.md`](reference/cross-model.md)
-   (informational until the human approves each finding). If sub-agents are unavailable, do the
-   independent rubric pass yourself in a separate read, discarding the authoring reasoning (a
-   flagged fallback, not an independent review).
+6. **Adversarial verification loop.** Apply the light/full branching contract in
+   [`reference/depth.md`](reference/depth.md). Full mode dispatches the fresh-context plan
+   reviewer, plus the devex predictor when applicable, for at most three repair iterations;
+   [`reference/cross-model.md`](reference/cross-model.md) owns the optional outside voice.
+   Completion: the final axis floor clears or a blocking gate is recorded.
 7. **STOP.** Report the scope verdict, the per-axis floor, the coverage gaps closed, and the
    failure-mode criticals; recommend `/rite-build`.
 
@@ -168,20 +163,18 @@ webhook / config / error messages / getting-started — predict the DX scorecard
 
 ## Output
 
-**Footer first** — render the slice meter + flow ribbon by running the progress footer (`progress.sh`, resolved like the step-0 preamble — canonical snippet in `devrites-lib/SKILL.md`); keep the fact lines below it terse (`key value · key value`). Then:
+**Progress first** — run `devrites-engine progress`, then use the shared completion reply contract
+([`devrites-lib/reference/reply-contract.md`](../devrites-lib/reference/reply-contract.md)).
+Default success shape:
 ```
-Vetted: <slug>
-Depth: light | full (<trigger that escalated it>)
-Scope: reuse <n found> / minimum-diff <ok|trimmed N> / complexity <ok|smell: N files, M new services → asked>
-Axes (floor → verdict):  Architecture <band> · Code-quality <band> · Tests <band> · Performance <band>
-Findings: <Critical n / Important n / Suggestion n>   (suppressed low-confidence: n)
-Coverage: <x/y paths> planned (<s/t scenarios mapped | n/a>) · GAPS closed <n> · regressions flagged <n>  → test-plan.md
-Failure modes: <n> mapped (<n critical: no test + no handling + silent>)
-Parallelization: <n lanes — n parallel / n sequential> | sequential (no opportunity)
-Forge: <n slices flagged — strategies named | none>   (competed candidate builds at /rite-build)
-Reviewer loop: <n> iter · cross-model: ran (codex) | off
-Plan: hardened in place | <n> deltas routed via Spec Drift Guard → /rite-plan repair
-Next: /rite-build   (builds the vetted plan)
-↻ Hygiene: /clear before /rite-build (eng-review.md + test-plan.md + plan edits + decisions.md captured). See rules/context-hygiene.md.
+Done: plan vetted for <slug>; depth <light|full> with axis floor <band>.
+Changed: eng-review.md, test-plan.md, plan.md, decisions.md
+Evidence: coverage <x/y> planned; open findings Critical 0 / Important 0 / Suggestion <n>; reviewer loop <n>; outside-voice <ran|skipped-unavailable|disabled>
+Open: none
+Next: /rite-build
+Record: .devrites/work/<slug>/eng-review.md
+↻ Hygiene: /clear before /rite-build
 ```
+If a blocker or Spec Drift Guard delta remains, use the shared `Stopped / blocked`
+form and route `Fix:` to `/rite-plan`; do not recommend `/rite-build`.
 **DO NOT write code, slice, or run the build here** — that's `/rite-build`. Vet reviews and hardens the plan; it never implements.

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

@@ -1,7 +1,7 @@
 # /rite-vet — anti-patterns
 
 Universal rationalizations + red flags live in
-[`../../../rules/anti-patterns.md`](../../../rules/anti-patterns.md) — read it when the
+[`../../devrites-lib/reference/standards/anti-patterns.md`](../../devrites-lib/reference/standards/anti-patterns.md) — read it when the
 reluctance is broader than this phase. Below are the vet-specific ones.
 
 ## Phase rationalizations

package/pack/.claude/skills/rite-vet/reference/cross-model.md

@@ -8,13 +8,15 @@ thoroughly. It is **opt-in** for `/rite-vet` (the flag) and **off by default in
 
 ## When it runs
 Only when `$ARGUMENTS` contains `--cross-model` **and** a different-model reviewer is available.
-The default path (no flag) relies on `devrites-plan-reviewer` for independence — that is a
-complete review on its own; cross-model is an enhancement, not a requirement.
+First run `devrites-engine reviewers list`; configured aliases there are preferred over ad-hoc
+model choices. The default path (no flag) relies on `devrites-plan-reviewer` for independence —
+that is a complete review on its own; cross-model is an enhancement, not a requirement.
 
 ## Dispatch
 After the in-model reviewer loop converges (or in parallel with its final iteration), hand the
-**same fresh inputs** to a different model — preferentially the `codex:codex-rescue` agent (it
-runs Codex through the shared runtime). Give it only the contract, never the authoring reasoning:
+**same fresh inputs** to a different model — preferentially a configured `codex` reviewer alias,
+then the `codex:codex-rescue` agent if no alias exists. Give it only the contract, never the
+authoring reasoning:
 
 > Independent engineering review of a defined implementation plan, before any code.
 > Read only `.devrites/work/<slug>/plan.md`, `tasks.md`, and `spec.md`. Judge: architecture &
@@ -30,7 +32,7 @@ the absence as a pass.
 ## Integration rule (the important one)
 Cross-model findings are **informational until the human approves each one** — even when you
 agree with them, even when they overlap the in-model reviewer. Cross-model **consensus** is a
-strong signal: surface it as such ("both reviewers flagged Slice 3's missing timeout test"), but
+strong signal: surface it as such ("both reviewers flagged SLICE-003's missing timeout test"), but
 the human still makes the call via `AskUserQuestion`. In AFK, the same gate ceiling applies:
 a cross-model finding that *hardens* the plan auto-applies and is recorded; one that *grows
 scope* or changes acceptance is a blocking pause.

package/pack/.claude/skills/rite-vet/reference/depth.md

@@ -16,7 +16,7 @@ recorded engineering verdict and a coverage plan.
   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
-  `../../../rules/tooling.md` — or an honest estimate) crosses
+  `../../devrites-lib/reference/standards/tooling.md` — or an honest estimate) crosses
   module/service boundaries or has many dependents.
 - **Complexity** — `plan.md` touches **>8 files** or adds **>2 new services/modules/classes**.
 - **Multi-slice / multi-day**, or a new dependency / pattern / second design system.

package/pack/.claude/skills/rite-vet/reference/review-axes.md

@@ -13,7 +13,7 @@ Before reviewing *how* the plan builds, challenge *whether it should build this
 implementation-scope discipline (the spec's ambition is settled — that was `/rite-temper`).
 
 1. **What already exists?** For each sub-problem in the plan, find the existing code/flow that
-   already solves it (use a code-intelligence index if available — see `../../../rules/tooling.md`).
+   already solves it (use a code-intelligence index if available — see `../../devrites-lib/reference/standards/tooling.md`).
    Can the plan **capture outputs from an existing
    flow** instead of building a parallel one? Reuse → extend → build new, in that order
    (`coding-style.md`). List every reuse opportunity the plan misses.
@@ -54,7 +54,7 @@ within the gate ceiling (`depth.md`). If an axis genuinely has no issue, say "No
 moving on" and continue — don't manufacture findings.
 
 ### 1. Architecture
-- Component boundaries, coupling, data-flow patterns, single points of failure.
+- Component boundaries, coupling, data-flow patterns, single points of failure. Architecture records invariants, not scaffolding: each medium+ decision should state `Binds:` and `Prevents:` so the builder knows what divergence it prevents.
 - Scaling characteristics; where the plan's approach breaks under real load.
 - Security architecture at the seams (auth, data access, API boundaries) — does the plan name
   the trust boundary for each untrusted input?
@@ -75,7 +75,7 @@ moving on" and continue — don't manufacture findings.
 The differentiator: design the tests *before* the code, so the build writes them alongside.
 - **Framework detection** — find the project's existing test runner + conventions; match them
   (never introduce a new runner to prove one change — `testing.md`).
-- **Map acceptance → tests.** Every spec acceptance criterion must map to ≥1 planned test.
+- **Map acceptance → tests.** Every spec acceptance criterion must map to ≥1 planned, surface-anchored test (the API response/UI state/CLI output the criterion names, not an internal proxy).
 - **Tool per path** — unit (pure logic, single function, edge cases), integration/E2E (a user
   flow spanning 3+ components, an auth/payment/data-loss path, a mock-hides-failure boundary),
   eval (an LLM/prompt change that needs a quality bar).

package/pack/.claude/skills/rite-zoom-out/SKILL.md

@@ -1,8 +1,9 @@
 ---
 name: rite-zoom-out
-description: Zoom out one abstraction layer in unfamiliar code — return a structural map (modules, callers, callees, ADR/decisions touching the area) in the project's vocabulary. Use when the user says "zoom out", "map this", or "what calls this". Not for implementing changes (read-only) or one-symbol lookups (use grep).
+description: User-invoked read-only structural map of unfamiliar code: modules, callers, callees, and relevant decisions.
 argument-hint: "[symbol | file | area to map]"
 user-invocable: true
+disable-model-invocation: true
 ---
 
 # /rite-zoom-out — step up one abstraction layer
@@ -11,7 +12,7 @@ When the agent (or the user) is staring at unfamiliar code without a working men
 model of how it fits the larger system. Stops the "open more files" reflex by returning
 a single, structured map instead.
 
-Read `.claude/rules/core.md` first — chiefly its vocabulary / existing-conventions
+Read `.claude/skills/devrites-lib/reference/standards/core.md` first — chiefly its vocabulary / existing-conventions
 disciplines, which keep the map in the project's own language. The other rule files load
 on demand.
 
@@ -37,7 +38,7 @@ If the project has them — `codebase-memory-mcp` (`get_architecture` / `search_
 cross-checked with `codegraph` (`.codegraph/`) and `graphify` (`graphify-out/`) — use them. For
 codegraph, `codegraph_context` + one `codegraph_explore` return the map in two calls — vastly
 cheaper than a file-walk and more accurate for callers/callees. Fall back to standard methods
-(LSP, then `Grep` + `Read`) when no index is available. See `.claude/rules/tooling.md`.
+(LSP, then `Grep` + `Read`) when no index is available. See `.claude/skills/devrites-lib/reference/standards/tooling.md`.
 
 ## Vocabulary discipline
 
@@ -53,24 +54,22 @@ end; don't try to fix it here.
   `Grep`.
 - You need to design or change something — that's `/rite-spec` (new feature) or
   `/rite-define` (plan an approved spec).
-- You want a project-wide architecture audit — that's `improve-codebase-architecture`,
-  out of DevRites' feature-scoped remit.
+- You want a project-wide architecture audit — use the project's normal architecture
+  review process; this skill is a read-only feature-area map.
 
 ## Output shape
+Reply-contract exception: read-only mapping utility. It skips `devrites-engine progress` when
+there is no active workspace, but follows
+[`devrites-lib/reference/reply-contract.md`](../devrites-lib/reference/reply-contract.md).
 
 ```
-Area: <one line, project's vocabulary>
-Modules:
-  - path/x.ts — <purpose>
-  - path/y.ts — <purpose>
-Callers (in):
-  - <module> — <how it calls in>
-Calls (out):
-  - <module> — <what it calls for>
-Decisions touching it:
-  - ADR-NNNN / decisions.md entry — <one-line claim>
-Smallest sensible change-scope: <where a fix would land>
-FYI (optional): <fuzzy term / suspected drift / open question>
+Done: mapped <area> in the project's vocabulary.
+Changed: workspace only
+Evidence: modules <n>; callers <n>; callees <n>; decisions <n>
+Open: <none | fuzzy term | suspected drift | open question>
+Next: <single recommended command>
+Record: <decision/ADR path | not applicable>
+↻ Hygiene: /clear if this was only orientation; /rite-handoff if it informs active work
 ```
 
 Print the path of any decisions/ADR files referenced so the user can open them.

package/pack/generated/README.md

@@ -0,0 +1,10 @@
+# Generated DevRites Host Artifacts
+
+This directory is generated by `scripts/build-host-artifacts.sh`.
+
+- `claude/` contains Claude Code-native skills, agents, and settings.
+- `codex/` contains Codex-native skill mirrors, custom-agent TOML, hook
+  blocks, and AGENTS bridge content.
+
+Do not edit these files by hand. Edit `pack/.claude/` or
+`scripts/codex-generate.sh`, then rebuild.