devrites 2.4.0 → 2.5.1

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

@@ -1,6 +1,6 @@
 ---
 name: rite-build
-description: Implement exactly ONE vertical slice of the active feature, then stop with evidence. A fresh-context `devrites-slice-wright` writes the slice (orient → TDD → verify, anti-slop, project idiom); this skill gates it (readiness, HITL/AFK, doubt loop, Spec Drift Guard) and records the evidence. Use when the user says "build the next slice", "implement slice N", "continue", "code this slice". Not for bug fixes, prototypes, refactors outside scope, or two slices in a row.
+description: Implement exactly ONE vertical slice of the active feature, then stop with evidence. Use when the user says "build the next slice", "implement slice N", "continue the build", "code this slice". Not for bug fixes, prototypes, refactors outside scope, or two slices in a row.
 argument-hint: "[slice number or name]"
 user-invocable: true
 ---
@@ -60,22 +60,26 @@ writes; read them yourself for the doubt/record gates or in the inline fallback:
   single-path — forge is the rare exception ([`reference/forge.md`](reference/forge.md)).
 
 ## Workflow ([one-slice-cycle](reference/one-slice-cycle.md))
+
+> **Running the gate helpers.** Each gated `bash` block resolves the shared runner `rites.sh` into
+> `$R` (self-contained — blocks don't share shell state), then calls a named helper:
+> `bash "$R" <helper> [args]` runs
+> `devrites-lib/scripts/<helper>.sh`, **propagates its exit code** (so the `rc=$?` checks below
+> still hold) and degrades to a printed note if the lib is absent. One locator, many helpers —
+> see [`devrites-lib/scripts/rites.sh`](../devrites-lib/scripts/rites.sh).
+
 0. **Rules + AFK + readiness check.** Read `.claude/rules/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, deterministically:
    ```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)"
+   R=.claude/skills/devrites-lib/scripts/rites.sh; [ -f "$R" ] || R="${CLAUDE_SKILL_DIR:-}/../devrites-lib/scripts/rites.sh"; [ -f "$R" ] || R=pack/.claude/skills/devrites-lib/scripts/rites.sh
+   [ -f "$R" ] && bash "$R" preamble || echo "(orientation preamble unavailable on this install — read state.md directly to orient)"
    ```
    Then **run the readiness gate** — it enforces the step-0 stop conditions by exit code,
    not by memory:
    ```bash
-   G=.claude/skills/devrites-lib/scripts/readiness.sh
-   [ -f "$G" ] || G="${CLAUDE_SKILL_DIR:-}/../devrites-lib/scripts/readiness.sh"
-   [ -f "$G" ] || G=pack/.claude/skills/devrites-lib/scripts/readiness.sh
-   [ -f "$G" ] && { bash "$G"; echo "readiness rc=$?"; } || echo "(readiness gate unavailable — apply the prose checks below)"
+   R=.claude/skills/devrites-lib/scripts/rites.sh; [ -f "$R" ] || R="${CLAUDE_SKILL_DIR:-}/../devrites-lib/scripts/rites.sh"; [ -f "$R" ] || R=pack/.claude/skills/devrites-lib/scripts/rites.sh
+   [ -f "$R" ] && { bash "$R" readiness; echo "readiness rc=$?"; } || echo "(readiness gate unavailable — apply the prose checks below)"
    ```
    A non-zero `rc` is a hard STOP: `2` → `/rite-define` (plan not approved), `3` →
    `/rite-resolve` (awaiting human), `4` → `/rite-plan` (blocked). The prose below is the
@@ -101,28 +105,35 @@ writes; read them yourself for the doubt/record gates or in the inline fallback:
    right next slice. Write the slice's `Mode` to `state.md` as `Slice mode: <HITL|AFK>` on
    **every** selection (not only on the HITL pause path); `/rite-resolve` clears or updates
    it on resume.
-2a. **HITL gate (pre-action pause).** Read the slice's `Mode`. If `HITL` → render the
-    checkpoint per [`reference/checkpoint-protocol.md`](reference/checkpoint-protocol.md):
-    append a `questions.md` entry with the slice's `Checkpoint:` + `Gate:` + `SLA:`,
-    write the `Awaiting human` block to `state.md`, set `Status: awaiting_human`, run
-    the `notify:` hook if `.devrites/AFK` defines one, then **STOP**. Resume happens
-    when the user runs `/rite-resolve <qid> "<answer>"`.
+2a. **HITL gate (pre-action pause).** Read the slice's `Mode`. If `HITL`, surface the
+    checkpoint as a ranked **option set** and resolve it **before** any code lands, per
+    [`reference/checkpoint-protocol.md`](reference/checkpoint-protocol.md). Branch on whether
+    a human is here:
+    - **Human present (interactive — no `.devrites/AFK`) → ask inline via `AskUserQuestion`.**
+      This is the default for an interactive build. Render 2–4 options, the recommended one
+      **first and labelled `(Recommended)`**, each with its dimension-tagged rationale + the
+      trade-off it accepts, plus the `Something else — I'll describe it` escape hatch. The
+      human picks; record the pick to `questions.md` (`answered`) + `decisions.md` (through the
+      `resolve.sh` writer), clear the gate, and **continue to step 3 in place** — do **not**
+      STOP, do **not** route through `/rite-resolve`.
+    - **Human absent / AFK (`.devrites/AFK` present) → auto-pick or persist + STOP.** For a gate
+      in `allow_gates`, auto-pick the recommended option (option 1) and proceed; otherwise
+      append the `questions.md` entry, write the `Awaiting human` block to `state.md`, set
+      `Status: awaiting_human`, fire the `notify:` hook, then **STOP** — resume when the user
+      runs `/rite-resolve <qid> "<answer>"`. `blocking` / `escalating` / irreversible-risk gates
+      always take this stop path, never the AFK auto-pick.
 3. **Snapshot the tree, then dispatch the build core to `devrites-slice-wright`** — one `Task`
    call, fresh context. **First**, capture the pre-dispatch tree so the reconcile gate (step 6)
    can prove you never touched source — run this immediately before the `Task` call:
    ```bash
-   RC=.claude/skills/devrites-lib/scripts/reconcile.sh
-   [ -f "$RC" ] || RC="${CLAUDE_SKILL_DIR:-}/../devrites-lib/scripts/reconcile.sh"
-   [ -f "$RC" ] || RC=pack/.claude/skills/devrites-lib/scripts/reconcile.sh
-   [ -f "$RC" ] && bash "$RC" snapshot || echo "(reconcile gate unavailable — verify by hand that only the wright wrote source)"
+   R=.claude/skills/devrites-lib/scripts/rites.sh; [ -f "$R" ] || R="${CLAUDE_SKILL_DIR:-}/../devrites-lib/scripts/rites.sh"; [ -f "$R" ] || R=pack/.claude/skills/devrites-lib/scripts/rites.sh
+   [ -f "$R" ] && bash "$R" reconcile snapshot || echo "(reconcile gate unavailable — verify by hand that only the wright wrote source)"
    ```
    Then log the dispatch so the stuck-loop detector can catch a slice that keeps being
    re-dispatched without progress (it pauses the build even under AFK):
    ```bash
-   ST=.claude/skills/devrites-lib/scripts/stuck.sh
-   [ -f "$ST" ] || ST="${CLAUDE_SKILL_DIR:-}/../devrites-lib/scripts/stuck.sh"
-   [ -f "$ST" ] || ST=pack/.claude/skills/devrites-lib/scripts/stuck.sh
-   [ -f "$ST" ] && bash "$ST" log "$(cat .devrites/ACTIVE 2>/dev/null)" dispatch "<slice id>" || true
+   R=.claude/skills/devrites-lib/scripts/rites.sh; [ -f "$R" ] || R="${CLAUDE_SKILL_DIR:-}/../devrites-lib/scripts/rites.sh"; [ -f "$R" ] || R=pack/.claude/skills/devrites-lib/scripts/rites.sh
+   [ -f "$R" ] && bash "$R" stuck log "$(cat .devrites/ACTIVE 2>/dev/null)" dispatch "<slice id>" || true
    ```
    **Forge branch — only if the selected slice is `Forge: yes`.** Instead of the single dispatch
    below, run the competitive build per [`reference/forge.md`](reference/forge.md): K=2–3 candidate
@@ -174,10 +185,8 @@ writes; read them yourself for the doubt/record gates or in the inline fallback:
    `built`.** Log each dispatch so the seal can prove doubt ran (the footprint already counts a
    `doubt` kind):
    ```bash
-   FP=.claude/skills/devrites-lib/scripts/footprint.sh
-   [ -f "$FP" ] || FP="${CLAUDE_SKILL_DIR:-}/../devrites-lib/scripts/footprint.sh"
-   [ -f "$FP" ] || FP=pack/.claude/skills/devrites-lib/scripts/footprint.sh
-   [ -f "$FP" ] && bash "$FP" log <slug> doubt "<decision id>" || true
+   R=.claude/skills/devrites-lib/scripts/rites.sh; [ -f "$R" ] || R="${CLAUDE_SKILL_DIR:-}/../devrites-lib/scripts/rites.sh"; [ -f "$R" ] || R=pack/.claude/skills/devrites-lib/scripts/rites.sh
+   [ -f "$R" ] && bash "$R" footprint log <slug> doubt "<decision id>" || true
    ``` The doubt loop honours `.devrites/AFK` (see its AFK
    exception): findings below the slice's gate ceiling become advisory entries in `questions.md`;
    destructive / auth / public-API concerns always pause regardless. A non-empty `Escalation` in
@@ -205,10 +214,8 @@ writes; read them yourself for the doubt/record gates or in the inline fallback:
    wright's reported `Files changed` paths (one per line) to
    `.devrites/work/<slug>/.reconcile-claimed`, then:
    ```bash
-   RC=.claude/skills/devrites-lib/scripts/reconcile.sh
-   [ -f "$RC" ] || RC="${CLAUDE_SKILL_DIR:-}/../devrites-lib/scripts/reconcile.sh"
-   [ -f "$RC" ] || RC=pack/.claude/skills/devrites-lib/scripts/reconcile.sh
-   [ -f "$RC" ] && { bash "$RC" check; echo "reconcile rc=$?"; } || echo "(reconcile gate unavailable — confirm by hand only the wright wrote source)"
+   R=.claude/skills/devrites-lib/scripts/rites.sh; [ -f "$R" ] || R="${CLAUDE_SKILL_DIR:-}/../devrites-lib/scripts/rites.sh"; [ -f "$R" ] || R=pack/.claude/skills/devrites-lib/scripts/rites.sh
+   [ -f "$R" ] && { bash "$R" reconcile check; echo "reconcile rc=$?"; } || echo "(reconcile gate unavailable — confirm by hand only the wright wrote source)"
    ```
    **Exit 5 → hard STOP:** a source file changed outside the wright's claimed set — code was
    edited by something other than the wright (A1 breach). Revert it and re-dispatch the wright;
@@ -217,28 +224,31 @@ writes; read them yourself for the doubt/record gates or in the inline fallback:
    **Then run the test-integrity gate (anti-reward-hacking)** — prove the slice didn't reach
    green by weakening its tests:
    ```bash
-   TI=.claude/skills/devrites-lib/scripts/test-integrity.sh
-   [ -f "$TI" ] || TI="${CLAUDE_SKILL_DIR:-}/../devrites-lib/scripts/test-integrity.sh"
-   [ -f "$TI" ] || TI=pack/.claude/skills/devrites-lib/scripts/test-integrity.sh
-   [ -f "$TI" ] && { bash "$TI"; echo "test-integrity rc=$?"; } || echo "(test-integrity gate unavailable — confirm by hand no test was deleted/skipped/loosened)"
+   R=.claude/skills/devrites-lib/scripts/rites.sh; [ -f "$R" ] || R="${CLAUDE_SKILL_DIR:-}/../devrites-lib/scripts/rites.sh"; [ -f "$R" ] || R=pack/.claude/skills/devrites-lib/scripts/rites.sh
+   [ -f "$R" ] && { bash "$R" test-integrity; echo "test-integrity rc=$?"; } || echo "(test-integrity gate unavailable — confirm by hand no test was deleted/skipped/loosened)"
    ```
    **Exit 3 → hard STOP:** a test was deleted, skipped, or de-asserted since the slice base — the
    slice went green by weakening its tests, a Critical protocol violation. Revert the weakening and
    re-dispatch the wright; do **not** mark the slice `built`.
 
    Then, from the wright's artifact, update `state.md`,
-   `evidence.md`, `touched-files.md` (and `browser-evidence.md` for UI). If the wright reported
+   `evidence.md`, `touched-files.md` (and `browser-evidence.md` for UI). **Persist every
+   `Decisions stood` entry from the wright's artifact to a `## Decisions stood` section in
+   `decisions.md`, one line each ending `— doubt: <accept | reject-resolved | MISSING>`** — the
+   verdict from step 4, or `MISSING` if step 4 was skipped for that entry. Write this ledger at
+   record-time **independent of the doubt step**, so a stood decision lands on disk even when it
+   was never doubted: `/rite-seal` cross-checks the ledger, and a `doubt: MISSING` entry is the
+   skipped-doubt finding that would otherwise leave no trace (the per-slice skip the footprint
+   count alone can't catch). If the wright stood no decisions, write `## Decisions stood` with
+   `- none` so the absence is recorded, not assumed. If the wright reported
    an approach it tried and backed out of, record it under a `## Dead ends` section in
    `decisions.md` so a retry or the next agent doesn't repeat it.
    **If the wright's `Conventions` field reports a contradiction** (the live code now
    disagrees with a held convention), record the drift — you own this bookkeeping:
    ```bash
-   C=.claude/skills/devrites-lib/scripts/conventions.py
-   [ -f "$C" ] || C="${CLAUDE_SKILL_DIR:-}/../devrites-lib/scripts/conventions.py"
-   [ -f "$C" ] || C=pack/.claude/skills/devrites-lib/scripts/conventions.py
-   command -v python3 >/dev/null 2>&1 && [ -f "$C" ] && \
-     python3 "$C" contradict --key <key> --slug <slug> --evidence "<what the live code does>" \
-       --drift-file .devrites/work/<slug>/drift.md || true
+   R=.claude/skills/devrites-lib/scripts/rites.sh; [ -f "$R" ] || R="${CLAUDE_SKILL_DIR:-}/../devrites-lib/scripts/rites.sh"; [ -f "$R" ] || R=pack/.claude/skills/devrites-lib/scripts/rites.sh
+   [ -f "$R" ] && bash "$R" conventions contradict --key <key> --slug <slug> \
+     --evidence "<what the live code does>" --drift-file .devrites/work/<slug>/drift.md || true
    ```
    It lowers the convention's band (or retires it) and appends a `convention-drift` entry to
    `drift.md`. The ledger is **promoted only at `/rite-seal` on GO** — build only records
@@ -247,10 +257,8 @@ writes; read them yourself for the doubt/record gates or in the inline fallback:
    [evidence-standard](reference/evidence-standard.md). Append a footprint record for this
    slice's wright dispatch (deterministic run-weight bookkeeping the seal reports):
    ```bash
-   FP=.claude/skills/devrites-lib/scripts/footprint.sh
-   [ -f "$FP" ] || FP="${CLAUDE_SKILL_DIR:-}/../devrites-lib/scripts/footprint.sh"
-   [ -f "$FP" ] || FP=pack/.claude/skills/devrites-lib/scripts/footprint.sh
-   [ -f "$FP" ] && bash "$FP" log <slug> wright "<slice id>" || true
+   R=.claude/skills/devrites-lib/scripts/rites.sh; [ -f "$R" ] || R="${CLAUDE_SKILL_DIR:-}/../devrites-lib/scripts/rites.sh"; [ -f "$R" ] || R=pack/.claude/skills/devrites-lib/scripts/rites.sh
+   [ -f "$R" ] && bash "$R" footprint log <slug> wright "<slice id>" || true
    ```
    If `.devrites/AFK` is present, decrement
    the budget by running `bash .claude/skills/devrites-lib/scripts/tick-afk.sh <state.md path>` —
@@ -261,10 +269,8 @@ writes; read them yourself for the doubt/record gates or in the inline fallback:
    shared footer (mirror of the step-0 preamble) so the slice meter + flow ribbon are
    deterministic, not model-typed:
    ```bash
-   PR=.claude/skills/devrites-lib/scripts/progress.sh
-   [ -f "$PR" ] || PR="${CLAUDE_SKILL_DIR:-}/../devrites-lib/scripts/progress.sh"
-   [ -f "$PR" ] || PR=pack/.claude/skills/devrites-lib/scripts/progress.sh
-   [ -f "$PR" ] && bash "$PR" || echo "(progress footer unavailable on this install)"
+   R=.claude/skills/devrites-lib/scripts/rites.sh; [ -f "$R" ] || R="${CLAUDE_SKILL_DIR:-}/../devrites-lib/scripts/rites.sh"; [ -f "$R" ] || R=pack/.claude/skills/devrites-lib/scripts/rites.sh
+   [ -f "$R" ] && bash "$R" progress || echo "(progress footer unavailable on this install)"
    ```
    It reads `state.md` (already updated in step 6), so the meter reflects the slice you
    just built. **When every slice is built** (`✅ ALL BUILT`) say so explicitly — the build

package/pack/.claude/skills/rite-build/reference/wright-dispatch.md

@@ -3,7 +3,7 @@
 How `/rite-build` hands the **build core** of one slice to `devrites-slice-wright` — the
 fresh-context, **write-capable** executor under `.claude/agents/`. Loaded on demand by
 `/rite-build`; not a skill itself. Sibling of
-[`../../rite-seal/reference/parallel-dispatch.md`](../../rite-seal/reference/parallel-dispatch.md)
+[`../../devrites-lib/reference/parallel-dispatch.md`](../../devrites-lib/reference/parallel-dispatch.md)
 (the read-only reviewer fan-out) — same isolation principle, opposite direction: this one
 **writes**.
 
@@ -92,7 +92,11 @@ set.
    it and re-dispatch, don't mark the slice built. Then persist the wright's artifact to
    `state.md`, `evidence.md`, `touched-files.md` (and `browser-evidence.md` for UI) per
    [`evidence-standard.md`](evidence-standard.md). Evidence is the wright's real command output,
-   not its say-so. Then tick AFK if `.devrites/AFK` is present (`tick-afk.sh`; exit 3 → STOP).
+   not its say-so. **Persist every `Decisions stood` entry to a `## Decisions stood` section in
+   `decisions.md`, one line each ending `— doubt: <accept | reject-resolved | MISSING>`** —
+   independent of the doubt step (step 1 above), so a skipped decision still lands on record for
+   the seal's doubt-coverage cross-check (`- none` when the wright stood nothing). Then tick AFK if
+   `.devrites/AFK` is present (`tick-afk.sh`; exit 3 → STOP).
 
 ## Forge — competing candidates (the deliberate exception)
 
@@ -119,7 +123,7 @@ same anti-slop charter; it just doesn't get the isolation. In this path the orch
 legitimately the writer, so write `.devrites/work/<slug>/.reconcile-inline` before editing — the
 reconcile gate (step 4) skips when that sentinel is present. Mirrors the reviewer-dispatch
 fallback in
-[`../../rite-seal/reference/parallel-dispatch.md`](../../rite-seal/reference/parallel-dispatch.md).
+[`../../devrites-lib/reference/parallel-dispatch.md`](../../devrites-lib/reference/parallel-dispatch.md).
 
 ## Optional pre-block hook (defense in depth)
 `reconcile.sh` is the **post-hoc** gate — it always runs and catches an A1 breach at record time.

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

@@ -1,6 +1,6 @@
 ---
 name: rite-define
-description: Decompose an approved `spec.md` into `plan.md` + vertical task slices + `state.md`; every acceptance criterion maps to ≥1 slice. Use when the user says "plan this", "break this into slices", "task breakdown". Not for writing code or repairing an existing plan (use `/rite-plan`).
+description: Decompose an approved `spec.md` into `plan.md` + vertical task slices + `state.md`; every acceptance criterion maps to ≥1 slice. Use when the user says "plan this" or "break this into slices". Not for writing code or repairing an existing plan (use `/rite-plan`).
 argument-hint: "[feature-slug]"
 user-invocable: true
 ---

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

@@ -1,6 +1,6 @@
 ---
 name: rite-doctor
-description: Diagnose DevRites install + workspace health on demand and print a full report — install integrity, a stale `.devrites/ACTIVE` pointer, a corrupt workspace, orphaned gates, and broken hook wiring. Use when the user says "rite doctor", "check my DevRites install", "is DevRites healthy", "diagnose devrites", or "why isn't the workflow picking up my feature". Not for debugging the user's own code (use `devrites-debug-recovery`) or for feature progress / next-action (use `/rite-status`).
+description: Diagnose DevRites install + workspace health on demand and print a full report — install integrity, a stale `.devrites/ACTIVE` pointer, a corrupt workspace, orphaned gates, and broken hook wiring. Use when the user says "rite doctor", "check my DevRites install", or "why isn't the workflow picking up my feature". Not for debugging the user's own code (use `devrites-debug-recovery`) or for feature progress / next-action (use `/rite-status`).
 argument-hint: ""
 user-invocable: true
 ---

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

@@ -1,6 +1,6 @@
 ---
 name: rite-frame
-description: Pre-flight + self-audit lens that applies the four classic LLM coding failure modes — silent assumption, overcomplication, out-of-scope edit, unverifiable goal — to ad-hoc and express-lane work the full lifecycle's gates never see. FRAME converts an imperative ask into a falsifiable success criterion + verify command before any code; AUDIT checks the resulting diff against the four modes, each mapped to its DevRites cure. Use at the top of `/rite-quick`, before a plain "just do X" / "quick fix" edit, or to self-review a raw diff for assumptions, bloat, scope creep, or a missing success criterion. Not a replacement for the lifecycle gates (`/rite-seal`, `/rite-review`), the adversarial subagent pre-mortem (`devrites-doubt`), or the fresh-context axis audit (`devrites-audit`) — it is the lightweight inline reflex for work that skips those.
+description: Frame an ad-hoc ask into a falsifiable success criterion before coding, then audit the diff against the four classic LLM failure modes — silent assumption, overcomplication, out-of-scope edit, unverifiable goal. Use to reframe an underspecified imperative ask, to self-audit a raw diff, or at the top of `/rite-quick`. Not a replacement for the lifecycle gates (`/rite-seal`, `/rite-review`), the adversarial pre-mortem (`devrites-doubt`), or the fresh-context axis audit (`devrites-audit`) — it is the lightweight inline reflex for work that skips those.
 argument-hint: "[task to frame | diff to audit]"
 user-invocable: true
 ---

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

@@ -1,6 +1,6 @@
 ---
 name: rite-handoff
-description: Compact the current chat into a handoff doc a fresh agent can pick up cold — syncs chat-only context into the canonical `.devrites/` files, references artifacts by path. Use when the user says "handoff", "prep for tomorrow", "I'm leaving for a while", "summarize for the next agent". Not for routine `/clear` between phases.
+description: Compact the current chat into a handoff doc a fresh agent can pick up cold — syncs chat-only context into the canonical `.devrites/` files, references artifacts by path. Use when the user says "handoff", "prep for tomorrow", or "summarize for the next agent". Not for routine `/clear` between phases.
 user-invocable: true
 argument-hint: "[what the next session will focus on]"
 ---
@@ -73,9 +73,9 @@ themselves. The workspace is the canonical store; the handoff is the chat-only d
 - `git diff` output — the next agent runs `git diff` themselves.
 - The full conversation transcript — distil.
 - Secrets (API keys, tokens, PII, credentials). Redact aggressively.
-- **New ideas the user didn't confirm.** A handoff records what *happened* and what's *next* —
-  not fresh suggestions, scope the user didn't agree to, or a redesign you thought of. Capture the
-  state, not your opinions about it.
+- **New ideas the user didn't confirm.** A handoff records what *happened* and what's *next*.
+  Leave out fresh suggestions, scope the user didn't agree to, and redesigns you thought of. Capture
+  the state, not your opinions about it.
 
 ## Output template
 

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

@@ -1,6 +1,6 @@
 ---
 name: rite-learn
-description: Review the auto-captured learning ledger and promote recurring lessons to project rules or principles — the human-gated half of the cross-feature learning loop. Capture is automatic (`/rite-seal` appends dismissed-finding classes + dead-ends to `.devrites/learnings.md` on every GO; the review skills load it before a fan-out), so the system learns without a command; this skill mines that ledger across features and decides which recurring lessons graduate into a rule (propose, don't impose). Use when the user says "what have we learned", "rite learn", "harvest lessons", "promote our learnings", or after several features ship. Not for the install (`/rite-doctor`), feature status (`/rite-status`), onboarding (`/rite-adopt`), or a diff review (`/rite-review`).
+description: Review the auto-captured learning ledger and promote recurring lessons to project rules or principles — the human-gated half of the cross-feature learning loop. Not for the install (`/rite-doctor`), feature status (`/rite-status`), onboarding (`/rite-adopt`), or a diff review (`/rite-review`).
 argument-hint: "[--mine | \"<lesson to record>\"]"
 user-invocable: true
 disable-model-invocation: true

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

@@ -1,6 +1,6 @@
 ---
 name: rite-plan
-description: Reshape an active plan — decompose / reslice / repair / reorder / split FE-BE / unblock / course-correct — without changing product behavior unless asked. Use when the user says "replan", "reslice", "repair the plan", "drift", "unblock", "change of plan", "we're pivoting", or `/rite-build` flags Spec Drift. Not for the initial plan (use `/rite-define`).
+description: Reshape an active plan — decompose / reslice / repair / reorder / split FE-BE / unblock / course-correct — without changing product behavior unless asked. Use when the user says "replan", "reslice", "repair the plan", "unblock", "we're pivoting", or `/rite-build` flags Spec Drift. Not for the initial plan (use `/rite-define`).
 argument-hint: "[mode: decompose|reslice|repair|reorder|split|unblock|course-correct]"
 user-invocable: true
 ---
@@ -66,6 +66,10 @@ reshaping slice cadence or DoD criteria.
 5. Update `plan.md`, `tasks.md`, `state.md`, and append rationale to `decisions.md`.
    If you stopped for drift, mark the `drift.md` entry resolved.
 6. If product behavior/acceptance criteria change, confirm with the user before writing.
+7. **Done when** — every slice is sized (builds + proves in one cycle; no slice scoring >3
+   left unjustified), the dependency order is acyclic, every `drift.md` entry you stopped for
+   is marked resolved, and behavior-change-vs-not is confirmed (`no`, or asked + answered).
+   If any check fails, loop back — don't hand off a half-reshaped plan.
 
 > **Mid-flight discipline.** When tempted to change product behavior without asking, absorb drift silently, or skip the user — see [`anti-patterns`](reference/anti-patterns.md). Load it the moment you reach for the excuse.
 

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

@@ -1,6 +1,6 @@
 ---
 name: rite-polish
-description: Polish the active feature before review — code polish always; UI normalize + ship-quality pass when UI is touched. Use when the user says "polish this", "finish before review", "ship-quality", "normalize the UI", "bolder", "quieter", "distill", "harden". Not for repo-wide refactors or pre-`/rite-prove` polish.
+description: Polish the active feature before review — code polish always; UI normalize + ship-quality pass when UI is touched. Use when the user says "polish this", "finish before review", "normalize the UI", or "make it bolder/quieter". Not for repo-wide refactors or pre-`/rite-prove` polish.
 argument-hint: "[target | bolder | quieter | distill | harden | normalize-only]"
 user-invocable: true
 ---

package/pack/.claude/skills/rite-polish/reference/code.md

@@ -52,6 +52,10 @@ feature only.
   cleverness that's shorter but harder to read is not simpler.
 - **Cleanup**: remove TODOs, `console.log`s, commented-out code, unused
   imports/vars; tighten naming and comments in code this feature touched.
+- **Done when** — every anti-slop charter item in the touched code is cleared
+  (the AI-tells do-not list — [anti-ai-slop.md](anti-ai-slop.md) Code section,
+  `coding-style.md`) **and** the feature's targeted tests + build re-run green.
+  An open charter item or a red check means Phase 1 isn't done.
 
 ## Phase 2 — Backend polish *(if BE touched)*
 

package/pack/.claude/skills/rite-pressure-test/SKILL.md

@@ -1,10 +1,11 @@
 ---
 name: rite-pressure-test
-description: Pressure-test a rough idea — diverge into 3-5 genuinely different options, then converge on one with the trade-off and decision hinge. Use when the user says "ideate", "refine this idea", "stress-test my plan", "I have a vague idea", or `/rite-spec` flags the concept as rough. Not for writing the spec (use `/rite-spec`).
+description: Pressure-test a rough idea — diverge into 3-5 genuinely different options, then converge on one with the trade-off and decision hinge. Use when the user says "ideate", "stress-test my plan", "I have a vague idea", or `/rite-spec` flags the concept as rough. Not for writing the spec (use `/rite-spec`).
+argument-hint: "[rough idea or plan to stress-test]"
 user-invocable: true
 ---
 
-# rite-pressure-test — diverge then converge
+# /rite-pressure-test — diverge then converge
 
 Use when the *idea* (not just the requirements) is rough. Generate options, then commit
 to one — so `/rite-spec` has a real direction to specify.

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

@@ -1,6 +1,6 @@
 ---
 name: rite-prototype
-description: Throwaway prototype answering ONE design question — either a runnable Logic harness or 2–4 radically different UI variations on one route — then delete or absorb. Use when the user says "prototype this", "sanity-check the data model", "try a few UI designs", "let me play with it", "mock it up". Not for production code.
+description: Throwaway prototype answering ONE design question — either a runnable Logic harness or 2–4 radically different UI variations on one route — then delete or absorb. Use when the user says "prototype this", "sanity-check the data model", or "try a few UI designs". Not for production code.
 user-invocable: true
 argument-hint: "[the question the prototype is answering]"
 ---
@@ -71,8 +71,10 @@ one of:
   with the question and the answer.
 - A `NOTES.md` next to the prototype if no active feature exists.
 
-If the user is around, this is a quick conversation. If they're AFK, leave a placeholder
-("VERDICT: ___") so the next pass fills it in before the prototype is deleted.
+If the user is around, this is a quick conversation. If they're AFK, the prototype is
+complete only once the verdict is actually filled in — a blank `VERDICT: ___` is not an
+answer. Leave it marked **not yet complete** and queue the open question so a later pass
+fills the verdict before the prototype is deleted.
 
 ## Where this slots in
 

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

@@ -1,6 +1,6 @@
 ---
 name: rite-prove
-description: Prove the completed feature — full tests + build + typecheck + lint + browser-proof ladder — walking `spec.md` acceptance criteria one by one. Use when the user says "prove this", "run the full tests", "is this feature really done", "check it end-to-end". Not for single-slice or pre-completion proof.
+description: Prove the completed feature against its `spec.md` acceptance criteria. Use when the user says "prove this", "run the full tests", or "check it end-to-end". Not for single-slice or pre-completion proof.
 argument-hint: "[feature-slug]"
 user-invocable: true
 ---

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

@@ -1,6 +1,6 @@
 ---
 name: rite-quick
-description: Express lane for a SMALL, reversible change — one short artifact, then build → prove → ship, collapsing the full spec → define → vet → build → prove → review → seal lifecycle into one pass. Use when the user says "quick fix", "small change", "tiny tweak", "just do X", or for a typo / copy / config / single-function / one-file change that is low-risk and unambiguous. Escalates to `/rite-spec` (full lifecycle) the moment scope, risk, or ambiguity grows. Not for auth / data-model / migration / public-API / multi-slice / ambiguous work — those need the full lifecycle.
+description: Express lane for a SMALL, reversible change. Use when the user says "quick fix" or "just do X", or for a typo / copy / config / single-function / one-file change that is low-risk and unambiguous. Escalates to `/rite-spec` (full lifecycle) the moment scope, risk, or ambiguity grows. Not for auth / data-model / migration / public-API / multi-slice / ambiguous work — those need the full lifecycle.
 argument-hint: "<what to change>"
 user-invocable: true
 ---

package/pack/.claude/skills/rite-resolve/reference/answer-protocol.md

@@ -25,8 +25,9 @@ shapes, the batch file format, and the rules the underlying `devrites-lib/script
 - A drop is **not** an answer — it removes the question from the active queue without
   recording a decision. Use it when the question is obsolete, a duplicate, or absorbed
   by a re-plan.
-- The reason is required as a single trailing string. "obsolete" / "duplicate" /
-  "absorbed by Slice N" are sufficient — but never blank.
+- The reason is an optional single trailing string, **strongly recommended** for the
+  audit trail. "obsolete" / "duplicate" / "absorbed by Slice N" are sufficient; if omitted,
+  `resolve.sh` records the reason as `dropped`.
 
 ### 3. Batch
 

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

@@ -1,6 +1,6 @@
 ---
 name: rite-review
-description: Feature-scoped multi-axis review of the polished diff — Spec + Code-review axes fan out as parallel subagents; findings under one severity scale. Use when the user says "review this", "audit my diff", "final review before seal", "check this against the spec". Not for whole-project refactors or single-slice review.
+description: Review the polished diff at feature scope across Spec + Code-review axes. Use when the user says "review this", "audit my diff", "final review before seal", "check this against the spec". Not for whole-project refactors or single-slice review.
 argument-hint: "[scope: slice N | feature]"
 user-invocable: true
 ---
@@ -13,7 +13,7 @@ if none, tell the user to run `/rite-spec <feature>`.
 > **Differs from built-in `/code-review` in:** `/code-review` is a generic
 > diff review with no workspace context. `/rite-review` reads
 > `.devrites/work/<slug>/spec.md` first, runs Spec ↔ Code-review axes as
-> parallel subagents (see [`reference/parallel-dispatch.md`](reference/parallel-dispatch.md)), and gates feeding
+> parallel subagents (see [`parallel-dispatch.md`](../devrites-lib/reference/parallel-dispatch.md)), and gates feeding
 > into `/rite-seal`. Use `/code-review` for a one-off diff; use
 > `/rite-review` for a DevRites feature where the spec is the contract.
 
@@ -86,11 +86,11 @@ pull these via `Read` when the diff demands them:
      between the axes explicitly (e.g. "Spec axis says complete, Code-review axis says
      untestable") — `/rite-seal` decides what blocks.
 4. **Reconcile, don't re-review.** With the two parallel reports in hand, the inline
-   lead reconciles — it does **not** re-run a five-axis pass over correctness /
+   lead reconciles — it does **not** re-run the code-review axes over correctness /
    readability / architecture / maintainability that `devrites-code-reviewer` already
    covered. Stay in scope ([feature-scoped-review](reference/feature-scoped-review.md)).
    Add only what the dispatched agents could not, then resolve overlaps and
-   contradictions before labeling. ([five-axis-review](reference/five-axis-review.md)
+   contradictions before labeling. ([five-axis-review.md](reference/five-axis-review.md)
    documents the axes the code-review agent applies.)
    - **UI feature?** Apply the **UX rubric**
      ([nielsen-heuristics](reference/nielsen-heuristics.md)) and the

package/pack/.claude/skills/rite-review/reference/cognitive-load.md

@@ -81,8 +81,10 @@ doesn't decide the rewrite strategy.
 
 ## What this lens **doesn't** cover
 
-- **Accessibility** — separate axis (WCAG 2.2; see `quality-standards.md`).
-- **Performance** — separate axis (Core Web Vitals; see `quality-standards.md`).
+- **Accessibility** — separate axis (WCAG 2.2; see
+  [`devrites-frontend-craft/reference/quality-standards.md`](../../devrites-frontend-craft/reference/quality-standards.md)).
+- **Performance** — separate axis (Core Web Vitals; see
+  [`performance-checklist.md`](performance-checklist.md)).
 - **Code quality** — covered by the simplification audit
   (`devrites-audit simplify`).
 - **Security** — covered by the security audit (`devrites-audit security`).

package/pack/.claude/skills/rite-review/reference/five-axis-review.md

@@ -1,4 +1,4 @@
-# Five-axis review
+# Code-review axes
 
 The axes the dispatched `devrites-code-reviewer` applies to the diff (tests first
 — always), under one severity scale (Critical / Important / Suggestion / Nit / FYI).

package/pack/.claude/skills/rite-review/reference/security-review.md

@@ -4,6 +4,11 @@ Apply when the feature involves user input, auth/authz, data storage, external
 integrations, secrets, or permissions. Delegates to `devrites-audit security`.
 
 ## OWASP-Top-10-oriented checks
+
+This is the **single-sourced OWASP-web checklist** both `/rite-review` and the
+`devrites-security-auditor` agent apply (trust-boundary + the OWASP **LLM** Top 10 live in
+[`rules/security.md`](../../../rules/security.md)). Keep the enumeration here; don't restate it.
+
 - **Injection** — parameterized queries; no string-built SQL/shell/HTML; validate &
   encode at boundaries.
 - **Broken access control** — every sensitive action checks authz server-side; no

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

@@ -1,6 +1,6 @@
 ---
 name: rite-seal
-description: Final GO / NO-GO decision gate — walk `spec.md` acceptance against `evidence.md`, fan out reviewers in parallel, block on Critical, ask y/N on Important, write the verdict to seal.md. Use when the user says "seal this", "GO / NO-GO", "is it safe to merge", "final gate", "decide if we can ship". Hands off to /rite-ship for the actual commit/push/close. Not for the irreversible ship itself (use /rite-ship), inline review, or unpolished features.
+description: Decide GO / NO-GO on the active feature. Use when the user says "seal this" or "GO / NO-GO". Hands off to /rite-ship for the actual commit/push/close. Not for the irreversible ship itself (use /rite-ship), inline review, or unpolished features.
 argument-hint: "[feature-slug]"
 user-invocable: true
 ---
@@ -42,7 +42,7 @@ Read `review.md` and the latest reviewer outputs.
 | Diff violates a declared project principle (`.devrites/principles.md`) with no recorded, human-approved exception | **NO-GO**, list each violated principle with `file:line`. Same standing as an unproven criterion (absent / empty file → none declared → not a blocker). |
 | Unresolved drift in `drift.md` | **NO-GO**, route through `/rite-plan` first. |
 | Any `questions.md` entry with `gate: validating` and `status: open` | **NO-GO** regardless of behavior impact — an open validating gate is merge-blocking by definition. A slice marked `built (pending review)` is not done. |
-| `doubt-coverage` rc=1, or a stood decision (boundary / data-model / auth / public-API / migration / branching) recorded in `decisions.md` with no `devrites-doubt` verdict | **Important** — and **NO-GO** when the undoubted decision is an irreversible-risk class (auth / public-API / migration), the same standing as an unproven acceptance criterion. `/rite-build` step 4 records the verdict + logs a `doubt` footprint; absence here means doubt was skipped. Genuinely-empty `Decisions stood` on every slice is a valid pass — confirm, don't assume. |
+| A stood decision (boundary / data-model / auth / public-API / migration / branching) in the `decisions.md` `## Decisions stood` ledger with no recorded `devrites-doubt` verdict — `doubt: MISSING` / `doubt-coverage` rc=3 | **Important** — **NO-GO** when the undoubted decision is irreversible-risk (auth / public-API / migration), the same standing as an unproven acceptance criterion. Severity rides the unverified **decision**, not the exit code: `doubt-coverage` rc=1 (zero doubt dispatched) is a **prompt to verify**, not itself a finding — confirm against the ledger, where every-slice-trivial (`- none`) passes and a skipped triggering decision is the finding. |
 
 ## Workflow
 1. **Run the shared orientation preamble** — it prints `state.md`, the artifacts present,
@@ -84,14 +84,20 @@ Read `review.md` and the latest reviewer outputs.
    [ -f "$DC" ] || DC=pack/.claude/skills/devrites-lib/scripts/doubt-coverage.sh
    [ -f "$DC" ] && { bash "$DC" <slug>; echo "doubt-coverage rc=$?"; } || echo "(doubt-coverage gate unavailable — confirm by hand each stood decision carries a devrites-doubt verdict)"
    ```
-   The script proves the **footprint half** (a `doubt` dispatch was logged per `/rite-build`
-   step 4); you prove the **verdict half**: every decision in `decisions.md` that crosses a doubt
-   trigger (boundary / data-model / auth / public-API / migration / branching / "safe" / "scales")
-   must carry a recorded `devrites-doubt` verdict — `accept`, or a `reject` whose required changes
-   were resolved. Per the severity gate: **rc=1 or a triggering decision with no verdict is an
-   Important finding**, escalating to **NO-GO** when the undoubted decision is irreversible-risk
-   (auth / public-API / migration). A genuinely-empty `Decisions stood` across every slice passes —
-   confirm it against `decisions.md`, don't assume it.
+   The script reads two records `/rite-build` writes — the `## Decisions stood` ledger in
+   `decisions.md` (each entry ends `— doubt: <accept | reject-resolved | MISSING>`) and the `doubt`
+   footprint. Read the exit code:
+   - **rc=3** — the ledger records a stood decision with `doubt: MISSING`: doubt was definitively
+     skipped for a decision on record. **Important**; **NO-GO** when that decision is irreversible-risk
+     (auth / public-API / migration). This is the per-slice skip the footprint count alone can't catch.
+   - **rc=1** — zero doubt dispatched across the build. A **prompt to verify, not a finding**: confirm
+     against the ledger — an every-slice-trivial feature (`- none`) is a valid pass; a stood triggering
+     decision (boundary / data-model / auth / public-API / migration / branching) with no verdict is
+     the finding, same severity as rc=3.
+   - **rc=0** — covered, or not assessable (an inline build logs no dispatch — verify the ledger's
+     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](reference/risk-and-rollback.md). If `strategy.md` exists (from
    `/rite-temper`), confirm its **top pre-mortem risks are mitigated** in the diff/evidence and
@@ -119,14 +125,14 @@ Read `review.md` and the latest reviewer outputs.
 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 axes**
+   `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 to the chosen DevRites
    reviewers (`.claude/agents/devrites-*`) **in parallel** (one `Task` block,
    multiple tool calls; see `.claude/rules/agents.md` — "Run independent
-   reviewers in parallel", and [`reference/parallel-dispatch.md`](reference/parallel-dispatch.md)
+   reviewers in parallel", and [`parallel-dispatch.md`](../devrites-lib/reference/parallel-dispatch.md)
    for the full dispatch shape + reconciliation procedure):
    `devrites-spec-reviewer` (does the diff implement
    the spec?), `devrites-test-analyst` (do the tests prove acceptance?),

package/pack/.claude/skills/rite-seal/reference/go-no-go.md

@@ -1,15 +1,25 @@
 # GO / NO-GO
 
 The seal verdict is binary and evidence-based. When in doubt, NO-GO with a clear blocker
-list beats a hopeful GO.
+list beats a hopeful GO. The **authoritative gate is the severity table in
+[`../SKILL.md`](../SKILL.md) ("Severity gate")**; this file is the rationale behind it — keep
+the two in sync.
 
 ## NO-GO if any of these hold
 - A **critical acceptance criterion is unproven** (no evidence, or evidence shows fail).
 - **Tests or build fail** without an explicit, user-accepted risk.
-- The UI **cannot be verified** and the UI risk is material (visible/important surface).
+- The UI **cannot be verified** and the UI risk is material (visible/important surface), or a
+  Visual Verdict `FAIL` lands on an acceptance-mapped UI criterion (`browser-evidence.md`).
 - **Unresolved spec drift** remains (a known-wrong plan or an open behavior question).
 - A **security-critical issue** remains (auth bypass, data exposure, injection).
 - A **data migration or destructive change lacks a rollback plan**.
+- A **declared project principle is violated** (`.devrites/principles.md`) with no recorded,
+  human-approved exception — same standing as an unproven criterion (absent / empty file →
+  none declared → not a blocker).
+- A **stood decision was never independently doubted** — a `## Decisions stood` entry in
+  `decisions.md` carrying `doubt: MISSING` (or `doubt-coverage.sh` rc=3) — when that decision
+  is irreversible-risk (auth / public-API / migration). Severity rides the undoubted decision,
+  not the exit code.
 - Any `questions.md` entry with `gate: validating` and `status: open` — **NO-GO
   regardless of behavior impact** (an open validating gate is merge-blocking by
   definition). A slice marked `built (pending review)` is not done.
@@ -27,6 +37,12 @@ list beats a hopeful GO.
 - Security/data/migration risks either resolved or explicitly accepted by the user with
   a rollback path.
 
+## Important findings (`Critical == 0`, `Important > 0`)
+Open `Important` findings do not auto-pass. With acceptance proven and drift resolved, render
+the interactive prompt *"`Important > 0` open. Proceed to seal? [y/N]"* — default **N**. `y`
+→ GO; otherwise NO-GO with the open Important findings listed as blockers-by-policy. Don't
+silently fold Important findings into a GO.
+
 ## Conditional GO
 If only **non-blocking follow-ups** remain, it's a GO with a recorded follow-up list —
 not a NO-GO. Distinguish "must fix to ship" (blocker) from "should do next" (follow-up).

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

@@ -1,6 +1,6 @@
 ---
 name: rite-ship
-description: Ship the sealed feature and close the task — render type-GO, run the irreversible git commit/push/tag (or open the PR), write ship.md, then archive the workspace and clear .devrites/ACTIVE. Use when the user says "ship it", "ship this", "push it out", "close the task", "finish and archive", or right after /rite-seal returns GO. Not for the GO/NO-GO decision itself (use /rite-seal) or an unsealed feature.
+description: Ship the sealed feature and close the task. Use when the user says "ship it" or "close the task", or right after /rite-seal returns GO. Not for the GO/NO-GO decision itself (use /rite-seal) or an unsealed feature.
 argument-hint: "[feature-slug]"
 user-invocable: true
 ---