devrites 2.6.1 → 3.0.1

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

@@ -1,6 +1,6 @@
 ---
 name: rite-autocomplete
-description: Run the entire DevRites lifecycle end-to-end, unattended — no per-phase human iteration; `--ship` auto-confirms the final gate. Use when the user says "autocomplete", "one-shot this feature", or "ship it autonomously". Not for a single phase (use the specific `/rite-*` skill) or when the user wants to drive each step.
+description: Run the DevRites lifecycle end-to-end unattended; --ship confirms the final gate. Use when the user says "autocomplete", "one-shot this feature", or "ship it autonomously". Not for a single phase.
 argument-hint: "[idea] [--ship|--yolo] [--max-slices N]"
 user-invocable: true
 ---
@@ -12,8 +12,8 @@ prompt may be vague — autocomplete asks its clarifying questions **up front**,
 runs to completion. It does **not** disable the safety gates: hard irreversible-risk,<!-- pack-scan-ignore: negated statement — gates are NOT disabled -->
 blocking / escalating gates, and any NO-GO still pause.
 
-## Rules consulted (read on demand from `.claude/rules/`)
-**Step 0:** Read `.claude/rules/core.md` and `.claude/rules/afk-hitl.md` first.
+## Rules consulted (read on demand from `.claude/skills/devrites-lib/reference/standards/`)
+**Step 0:** Read `.claude/skills/devrites-lib/reference/standards/core.md` and `.claude/skills/devrites-lib/reference/standards/afk-hitl.md` first.
 
 ## Operating rules
 - **One human window.** Clarifying questions are batched up front via
@@ -47,15 +47,7 @@ blocking / escalating gates, and any NO-GO still pause.
   pause. Cross-model is off unless `--cross-model` was armed.
 
 ## Workflow
-1. **Orient + parse args.** 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)"
-```
+1. **Orient + parse args.** Run `devrites-engine preamble` for deterministic workspace orientation.
    The idea + flags: `--ship` / `--yolo` (auto-confirm the final
    type-GO), `--max-slices N` (OPTIONAL *lower* safety cap for a partial run; default =
    the plan's slice count, i.e. run all planned slices).
@@ -64,10 +56,13 @@ P=.claude/skills/devrites-lib/scripts/preamble.sh
 3. **Arm AFK.** Write `.devrites/AFK` with `allow_gates: [advisory]`; set the slice budget
    from the plan's count after `/rite-vet` (the slice count is only final post-vet), or from
    an explicit `--max-slices` ([reference/loop.md](reference/loop.md)). validating / blocking / escalating +
-   irreversible-risk still pause.
+   irreversible-risk still pause. Also `touch .devrites/CHECKPOINT` — an unattended run is the
+   case checkpoint mode earns its keep, so each proven slice is committed local-only as
+   crash-survivable `WIP` ([rite-build/reference/checkpoint.md](../rite-build/reference/checkpoint.md));
+   `/rite-ship` collapses them into the one feature commit.
 4. **Drive the phases** ([reference/loop.md](reference/loop.md)): `/rite-spec` →
    **`/rite-temper`** → `/rite-define` → **`/rite-vet`** → `/rite-build` (loop until all slices
-   built; `tick-afk.sh` each) → `/rite-prove` → `/rite-polish` → `/rite-review` → `/rite-seal`.
+   built; `devrites-engine tick-afk` each) → `/rite-prove` → `/rite-polish` → `/rite-review` → `/rite-seal`.
    Run each by Reading its `SKILL.md` and executing its workflow; state is carried by the
    workspace files, not chat.
 5. **Apply stop conditions at every gate** ([reference/stop-conditions.md](reference/stop-conditions.md)):
@@ -81,18 +76,23 @@ P=.claude/skills/devrites-lib/scripts/preamble.sh
 > Autonomy is for the routine path; the gates exist for everything else.
 
 ## Output
-A phase-by-phase progress log, then the final status. **End with the progress footer** —
-run `progress.sh` (resolved like the step-0 preamble — canonical snippet in
-`devrites-lib/SKILL.md`) as the last lines so the final slice meter + flow ribbon match the
-rest of the lifecycle (it reads the lifecycle position the run reached, e.g. `ship ✓` or the
-phase it stopped at):
+A compact phase-by-phase log, then the final status. **Progress first for the final
+status** — run `devrites-engine progress`, then use the shared typed states from
+[`devrites-lib/reference/reply-contract.md`](../devrites-lib/reference/reply-contract.md):
+`Shipped`, `Stopped`, `Awaiting human`, `NO-GO`, or `GO`.
+
+Keep the log terse:
 ```
 Autocomplete: <slug>
-spec ✓  temper ✓ (mode <m> | skipped)  define ✓  vet ✓ (depth <light|full>, floor <band>)  build ✓ (N slices)  prove ✓  polish ✓  review ✓  seal: GO
-→ SHIPPED  <sha> on <branch>            (--ship)
-   — or —
-→ STOPPED — awaiting human at <phase>: <reason>
-   Resume: <single command>
+spec <done|stopped> · temper <done|skipped|stopped> · define <done|stopped> · vet <done|stopped> · build <n/N|stopped> · prove <done|stopped> · polish <done|stopped> · review <done|stopped> · seal <GO|NO-GO|stopped>
 ```
 
-End with `↻ Hygiene` per `.claude/rules/context-hygiene.md` (`/clear` between long phases).
+Final state examples: `Shipped: <feature>`, `Stopped: <reason>`, `Awaiting human:
+<qid> · <gate> · <slice/phase>`, `NO-GO: <verdict>`, or `GO: feature cleared to ship`.
+Do not write a narrative recap.
+
+## Clean baseline and checkpoint mode
+- Before an autonomous run, require a clean or explicitly accepted baseline: refuse unrelated dirty work and record expected planning artifacts.
+- Arm `.devrites/CHECKPOINT` for the run so each proven slice can be checkpointed local-only; `/rite-ship` owns collapsing those checkpoints.
+- Stop on risky steps, red gates, NO-GO, stale evidence, or budget exhaustion.
+- Autocomplete gets one approved pass through the lifecycle; `/rite-build` still builds exactly one slice per invocation.

package/pack/.claude/skills/rite-autocomplete/reference/loop.md

@@ -38,7 +38,7 @@ the last left off — there is nothing to thread through chat.
 | 2 | `/rite-temper` | significance-gated strategic review; harden spec + write `strategy.md`. Skip low-stakes specs in one line. AFK: `hold-rigor` / `reduce-to-MVP` auto-apply; **any `expand` pauses (blocking)**; irreversible-risk pauses |
 | 3 | `/rite-define` | reads `strategy.md`; `plan.md` + `tasks.md`; record `Plan approved` |
 | 4 | `/rite-vet` | engineering plan review on **every** plan (light pass on simple plans, full on big/risky; never skipped); harden `plan.md` / `tasks.md` + write `eng-review.md` + `test-plan.md`. AFK: hardening / coverage findings auto-apply; **any scope-growing / acceptance-changing finding pauses (blocking)**; irreversible-risk pauses. Set the slice budget after this (vet may split a slice) |
-| 5 | `/rite-build` ×N | **loop** while any slice is `pending`; build one (the slice-wright reads `test-plan.md` for coverage), then run `bash .claude/skills/devrites-lib/scripts/tick-afk.sh state.md` — exit 3 (budget hit) ⇒ STOP |
+| 5 | `/rite-build` ×N | **loop** while any slice is `pending`; build one (the slice-wright reads `test-plan.md` for coverage), then run `devrites-engine tick-afk state.md` — exit 3 (budget hit) ⇒ STOP |
 | 6 | `/rite-prove` | once all slices `built`; walks `test-plan.md`; on failure → `devrites-debug-recovery` within scope |
 | 7 | `/rite-polish` | re-verify after code edits (evidence must stay fresh) |
 | 8 | `/rite-review` | apply in-scope fixes; re-prove if code changed |
@@ -50,5 +50,5 @@ the last left off — there is nothing to thread through chat.
 - Re-read the active workspace before each phase (don't trust chat memory).
 - After a phase that edits code (build, polish, review), evidence may be stale — let
   the next gate re-prove rather than carrying a stale pass (see
-  `.claude/rules/development-workflow.md`).
+  `.claude/skills/devrites-lib/reference/standards/development-workflow.md`).
 - Check [stop-conditions.md](stop-conditions.md) at every gate **before** advancing.

package/pack/.claude/skills/rite-autocomplete/reference/stop-conditions.md

@@ -35,7 +35,7 @@ Regardless of `allow_gates` or `--ship`:
   direction. Do not round NO-GO up to GO.
 - **Spec Drift Guard fires** (`/rite-build` finds the plan is wrong and the change
   alters product behaviour) → stop; route through `/rite-plan repair`.
-- **Budget exhausted with slices still pending** — `tick-afk.sh` exit 3 while `tasks.md`
+- **Budget exhausted with slices still pending** — `devrites-engine tick-afk` exit 3 while `tasks.md`
   still has unbuilt slices (only when an explicit `--max-slices` capped the run below the
   plan's count) → stop; report slices remaining. Exhausting the default budget = all
   planned slices built = normal completion → continue to `/rite-prove`, don't pause.

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. 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.
+description: Build one approved vertical slice, then stop with evidence. Use when the next planned slice should be implemented. Not for multiple slices.
 argument-hint: "[slice number or name]"
 user-invocable: true
 ---
@@ -16,8 +16,8 @@ pre-flight (readiness, slice select, HITL pause), dispatch the wright for the bu
 run the post-return gates (doubt, fail-on-red, record, stop). See
 [`reference/wright-dispatch.md`](reference/wright-dispatch.md).
 
-## Rules consulted (read on demand from `.claude/rules/`)
-DevRites skills Read `.claude/rules/core.md` as their first step (workflow step 0). The
+## Rules consulted (read on demand from `.claude/skills/devrites-lib/reference/standards/`)
+Read `.claude/skills/devrites-lib/reference/standards/core.md` first (workflow step 0). The
 following load on demand — **the wright reads them** (they are named in its contract) while it
 writes; read them yourself for the doubt/record gates or in the inline fallback:
 - `coding-style.md` — naming, function shape, guard clauses, comments, reuse-first.
@@ -26,11 +26,20 @@ writes; read them yourself for the doubt/record gates or in the inline fallback:
 - `patterns.md` — composition over inheritance, avoid premature abstraction.
 - `principles.md` — the project invariants (`.devrites/principles.md`) the slice must honor; the wright reads them as **binding**, not priors.
 - `security.md` — when the slice touches user input, auth, data, or external integrations.
+- `definition-of-done.md` — standing Done bar: acceptance mapped, fresh proof, no open hard gates, scoped edits, rollback/docs where needed.
+
 
 ## Operating rules
 - **One slice at a time. DO NOT** start the next slice without the user asking.
 - Evidence over confidence. Prefer existing conventions. Feature scope only — no
   drive-by refactors.
+- **Noticed, not touched.** An adjacent smell the wright sees outside `touched-files.md` is
+  recorded as an FYI follow-up in `decisions.md`, never fixed inline — the slice's change summary
+  states what it *deliberately left alone* ([`git-workflow.md`](../devrites-lib/reference/standards/git-workflow.md) "Things
+  I didn't touch"), so the reviewer reads a feature-scoped diff, not a renovation. The `devrites-engine reconcile`
+  gate (step 6) enforces this by exit code.
+- **Don't re-run an unchanged check.** Re-running the same build/test command on code that hasn't
+  changed since proves nothing new — it's motion, not evidence. Re-verify after an edit, not before.
 - Surface material assumptions; ask before adding dependencies or a second design
   system. The [Spec Drift Guard](reference/spec-drift-guard.md) is active throughout.
 - **Avoid AI slop while writing.** `devrites-slice-wright` enforces the anti-slop charter **at
@@ -39,7 +48,7 @@ writes; read them yourself for the doubt/record gates or in the inline fallback:
   idiom, reusing before building; **you verify the charter held on return** — you do not re-list
   it and you do not fix slop by editing source. Polish catches what slips; build prevents.
   The **prose you write yourself** — `evidence.md`, `decisions.md`, the slice report — follows
-  the human-voice charter (`.claude/rules/prose-style.md`; depth in `devrites-prose-craft`): no
+  the human-voice charter (`.claude/skills/devrites-lib/reference/standards/prose-style.md`; depth in `devrites-prose-craft`): no
   filler openers, no marketing adjectives, exact commands and identifiers kept verbatim.
 - **Honor declared project principles.** The wright reads `.devrites/principles.md` and treats
   each invariant as **binding** (not a prior to weigh like a convention) — a slice it cannot build
@@ -50,7 +59,7 @@ writes; read them yourself for the doubt/record gates or in the inline fallback:
 - **You never edit source — the wright is the only writer of code + tests.** You write only
   `.devrites/` bookkeeping. On any red gate, doubt finding, or coverage gap your only remedies
   are **continue the same wright once** (it fixes in its own context) or **stop + escalate** —
-  never patch the code yourself. The `reconcile.sh` gate (step 6) enforces this by exit code:
+  never patch the code yourself. The `devrites-engine reconcile` gate (step 6) enforces this by exit code:
   any source file changed outside the wright's claimed set is a hard STOP.
 - **A `Forge: yes` slice competes candidates — one author still lands.** When `/rite-vet`
   flagged the slice a genuine architecture fork, step 3 runs K=2–3 candidate wrights in
@@ -59,258 +68,17 @@ writes; read them yourself for the doubt/record gates or in the inline fallback:
   never edit source, and reconcile runs against the winner's claimed set. The default slice is
   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
-   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
-   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
-   same gate for installs without the script.
-   Orient from its digest. If `Status == awaiting_human` → **STOP**, tell the user to run
-   `/rite-resolve <qid> "<answer>"`. If `state.md` has no `Plan approved: <iso>` field
-   → **STOP**, tell the user the plan isn't approved yet (`/rite-define` writes it when
-   the human confirms). If `.devrites/AFK` is present, re-derive the remaining AFK budget
-   from `state.md`'s `AFK slices remaining: <n>` field (initialized from `.devrites/AFK`
-   `max_slices` on the first AFK build); if it is `0` → **STOP** (forced HITL stop; raise
-   the count in `state.md` or remove the sentinel to continue). See
-   [`reference/afk-discipline.md`](reference/afk-discipline.md).
-1. Read `spec.md`, `plan.md`, `tasks.md`, `assumptions.md`, `drift.md`, and `test-plan.md`
-   if present (the vetted coverage target from `/rite-vet` — the slice's tests come from
-   here when it exists). `state.md` and the open-`questions.md` tally are already in the
-   preamble digest from step 0 — re-read `questions.md` only for the full text of a flagged
-   blocking question.
-   If a **blocking `[NEEDS CLARIFICATION]`** remains or the spec/plan readiness gates
-   don't pass, stop → `/rite-spec` (to resolve) or `/rite-plan` (to repair). Don't build
-   on an unresolved spec.
-2. Select the next pending slice (or the one in `$ARGUMENTS`). **Restate its goal,
-   acceptance criteria, and scope boundary** in one short block. Confirm it's still the
-   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`, 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
-   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
-   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
-   wrights, each in an **isolated git worktree** on the distinct strategy `/rite-vet` named, then a
-   fresh-context [`devrites-forge-judge`](../../agents/devrites-forge-judge.md) scores them against
-   acceptance + `test-plan.md` + `.devrites/principles.md` + the anti-slop charter, and you land
-   exactly **one** winner's diff in the working tree, graft any cheap runner-up improvement by
-   continuing the winning wright once, and write `forge-report.md`. Forge returns the **same shape**
-   a single wright does (one structured artifact, for the winner), so steps 4–7 (doubt, fail-on-red,
-   reconcile against the winner's claimed set, record, stop) run **unchanged**. If you cannot give
-   the judge an objective scorecard (the slice lacks acceptance / `test-plan.md` coverage) or cannot
-   name two genuinely different strategies, the flag is stale — clear it and build single-path. The
-   single-writer invariant is intact: each candidate owns its own tree, exactly one author's diff
-   lands. Then **stop** here for this slice; the steps below are the default single-path dispatch.
-
-   Then assemble the slice contract and send it per
-   [`reference/wright-dispatch.md`](reference/wright-dispatch.md): the slice goal, acceptance
-   criteria, and **scope boundary**; the paths it may touch (`touched-files.md`); the context
-   paths to read (`spec.md`, `plan.md`, `decisions.md`, `assumptions.md`, `.devrites/principles.md`
-   when present — the binding invariants the slice must honor — plus `test-plan.md`
-   when present — its per-gap test requirements + regression-criticals for this slice are the
-   coverage the wright must write — and `design-brief.md`
-   when the slice touches UI per [frontend-trigger](reference/frontend-trigger.md)); and the
-   `.claude/rules/` files in scope. The wright **orients** on the project's idiom (using 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/rules/tooling.md` — for
-   placement/callers/impact), writes the **failing test first** when
-   behaviour changes ([tdd](reference/tdd.md)), implements the **smallest complete** version in
-   the project's style (applying `devrites-frontend-craft` to `design-brief.md` for UI, and
-   `devrites-source-driven` — with context7 if available — for uncertain framework facts), runs the slice's **targeted tests**
-   (plus typecheck / lint / build where the project has them), and returns a structured artifact
-   — **code + tests only; it does not write the workspace files.** If the slice is UI but no `design-brief.md` exists (e.g. a spec written before
-   shaping), shape it via `devrites-ux-shape` before the wright codes. If the `Task` tool is
-   unavailable, run the wright's discipline **inline** as a flagged fallback (see the reference)
-   — same one-slice cycle, no isolation; in that case write
-   `.devrites/work/<slug>/.reconcile-inline` so the reconcile gate skips (you are legitimately
-   the writer in this fallback).
-4. **Doubt the decisions it stood up.** For each entry in the wright's `Decisions stood`
-   (branching, boundary crossing, data model, auth, public API, migration, user-flow change,
-   "this is safe/scales") apply `devrites-doubt` **before accepting the slice** — the writer
-   doesn't grade its own decisions. Each `devrites-doubt` invocation **dispatches the
-   `devrites-doubt-reviewer` subagent** (doing the adversarial pass inline is the writer grading
-   itself — the thing this step exists to forbid). **Completion criterion (checkable):** step 4
-   is done only when **every** `Decisions stood` entry carries a recorded `devrites-doubt`
-   verdict — `accept`, or `reject` + the required changes — in `decisions.md` (accepted
-   trade-offs) / `questions.md` (open gates). A `Decisions stood` entry with **no verdict on
-   record** means doubt did not run for it: **do not enter step 5 and do not mark the slice
-   `built`.** Log each dispatch so the seal can prove doubt ran (the footprint already counts a
-   `doubt` kind):
-   ```bash
-   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
-   the artifact is handled here too: irreversible-risk / blockers → blocking question + set
-   `Status: awaiting_human`; a scope-changing answer → `/rite-plan repair` (Spec Drift Guard),
-   never silently into the slice. **If an irreversible-risk item shows up under the wright's
-   `Decisions stood` rather than `Escalation`**, treat that misclassification as itself a
-   blocking protocol violation — pause and re-dispatch with the item flagged out-of-bounds, do
-   **not** doubt-and-accept it. (The wright's return is the not-yet-load-bearing moment — the
-   slice isn't `built` or merged yet — so this post-return doubt is still pre-commit.)
-   **Principle check (same standing):** a wright return that breaks a declared principle
-   (reported in its `Principles` field, or that you detect against `.devrites/principles.md`) is
-   handled here like an irreversible-risk item — block, route to a human-approved scoped
-   exception in the register or stop; never doubt-and-accept a principle violation into the slice.
-5. **Fail-on-red.** If the wright's `Gates` were red (targeted tests / types / lint) or it
-   couldn't verify: do **not** mark the slice `built`, and **do not fix the code yourself**.
-   First remedy — **continue the same wright once** (`SendMessage` to it, carrying the failing
-   gate + its real output) so it fixes in its own context. This retry is for **objective
-   failures only** — red gate / type / lint / missing test coverage / UI browser-proof fail —
-   never a contested decision (that routes to `/rite-plan repair`). **Still red after the one
-   retry** → escalate: AFK → append a blocking question to `questions.md` (gate=blocking,
-   slice's SLA) + set `Status: awaiting_human`; HITL → pause as a blocking gate. Either way,
-   `Next step: /rite-plan unblock` until resolved.
-6. **Record — you are the canonical writer.** **First, run the reconcile gate (A1):** write the
-   wright's reported `Files changed` paths (one per line) to
-   `.devrites/work/<slug>/.reconcile-claimed`, then:
-   ```bash
-   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;
-   do **not** mark the slice `built`.
-
-   **Then run the test-integrity gate (anti-reward-hacking)** — prove the slice didn't reach
-   green by weakening its tests:
-   ```bash
-   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). **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
-   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
-   contradictions, never new conventions. **Evidence is the
-   wright's real command output, not its say-so.** Capture per
-   [evidence-standard](reference/evidence-standard.md). Append a footprint record for this
-   slice's wright dispatch (deterministic run-weight bookkeeping the seal reports):
-   ```bash
-   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>` —
-   it decrements `state.md`'s `AFK slices remaining` field, prints the new value, and exits `3`
-   when it hits 0. **Exit 3 → STOP** (forced HITL stop; the cap is exhausted). Never rewrite
-   `.devrites/AFK` `max_slices` in place — it is read-only initial budget.
-7. **STOP.** Render the progress footer, then report and recommend the next step. Run the
-   shared footer (mirror of the step-0 preamble) so the slice meter + flow ribbon are
-   deterministic, not model-typed:
-   ```bash
-   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
-   phase is complete, the next phase is `/rite-prove` — don't leave completion implicit.
+## Workflow
 
-> **Mid-flight discipline.** The wright (or you, in the inline fallback) must resist doing two slices, skipping TDD, adding a defensive check, or wandering outside `touched-files.md`; you must resist skipping the post-return `devrites-doubt` because the wright "seems confident" — see [`anti-patterns`](reference/anti-patterns.md). Load it the moment you reach for the excuse.
+Run the full execution contract in
+[`reference/phase-contract.md`](reference/phase-contract.md). It is not optional:
+it contains the gated one-slice workflow, including readiness, HITL/AFK handling,
+wright dispatch, forge, doubt, fail-on-red, record gates, and stop behavior.
 
 ## Output
 
-The `progress.sh` footer (step 7) prints the first three lines — the header rule, the
-**slice meter** (how many of N are built), and the **flow ribbon**. Your fact lines sit
-under it. Two shapes:
-
-**Slices still pending:**
-```
-── rite-build ──────────────────────────────
-Slice 3/5  ██████░░░░  csv-streaming ✓
-Flow   spec ✓ define ✓ build ◉ prove ○ polish ○ review ○ seal ○ ship ○
-Built     slice 3 — csv-streaming   (by devrites-slice-wright | inline fallback)
-Acceptance ✓ met · Tests <cmd → pass> · Browser <summary | n/a> · Drift <none | handled>
-Next  ▸ /rite-build  (slice 4 — pagination)
-↻ Hygiene  /clear between slices (state.md + touched-files.md + evidence.md carry forward); /rite-handoff if away > a few hours.
-```
-
-**All slices built (build phase complete — say it):**
-```
-── rite-build ──────────────────────────────
-Slices 5/5  ██████████  ✅ ALL BUILT
-Flow   spec ✓ define ✓ build ◉ prove ○ polish ○ review ○ seal ○ ship ○
-Built     slice 5 — error-states   (by devrites-slice-wright | inline fallback)
-Acceptance ✓ met · Tests <cmd → pass> · Browser <summary | n/a> · Drift <none | handled>
-✅ Feature implemented — every slice built. Build phase done.
-Next  ▸ /rite-prove  (prove the completed feature)
-↻ Hygiene  /clear (state.md + evidence.md captured); /rite-handoff if away > a few hours.
-```
-
-Keep fact lines terse — one `key value` per fact, `·` between, no prose. The meter, the
-`✅ ALL BUILT` marker, and the ribbon carry the progress; don't restate them in words.
-
-For a **forged slice**, the `Built` line names the competition and points at the record, e.g.
-`Built  slice 3 — csv-streaming   (forged: 3 candidates → winner B; forge-report.md)`.
-
-**DO NOT continue to the next slice automatically** — even at `✅ ALL BUILT`, `/rite-prove` is the user's call.
+Use the full output contract in [`reference/output.md`](reference/output.md).
+It preserves the progress-footer-first response shape, uses the shared completion
+reply contract
+([`devrites-lib/reference/reply-contract.md`](../devrites-lib/reference/reply-contract.md)),
+and keeps the explicit stop after one slice.

package/pack/.claude/skills/rite-build/reference/afk-discipline.md

@@ -27,7 +27,7 @@ allow_gates: [advisory, validating]  # gate severities AFK may auto-handle
 
 `.devrites/AFK` is **read-only config** — never rewritten in place. `max_slices` is the
 initial budget; the mutable remaining count lives in `state.md` as `AFK slices remaining:
-<n>`, seeded from `max_slices` on the first AFK build and decremented by `tick-afk.sh`
+<n>`, seeded from `max_slices` on the first AFK build and decremented by `devrites-engine tick-afk`
 (see "Iteration cap").
 
 Defaults when keys are omitted:
@@ -42,9 +42,9 @@ into HITL.
 
 `/rite-build`'s **record step** (workflow step 6) decrements `state.md`'s `AFK slices
 remaining` by 1 each time a slice is marked `built`, by running
-`bash .claude/skills/devrites-lib/scripts/tick-afk.sh <state.md path>`. The script reads the
+`devrites-engine tick-afk <state.md path>`. The script reads the
 field, decrements, writes it back, prints the new value, and **exits `3` when it hits 0**.
-The cap is enforced by `tick-afk.sh`, not by prose — when it exits 3:
+The cap is enforced by `devrites-engine tick-afk`, not by prose — when it exits 3:
 
 - `/rite-build` treats exit 3 as a forced HITL stop:
   ```

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

@@ -6,7 +6,7 @@ calling `devrites-doubt`.
 
 Pack-wide rationalizations + red flags (incl. tests-later, defensive checks,
 generic AI naming, drive-by refactors): see
-[rules/anti-patterns.md](../../../rules/anti-patterns.md).
+[standards/anti-patterns.md](../../devrites-lib/reference/standards/anti-patterns.md).
 
 ## Phase-specific rationalizations
 

package/pack/.claude/skills/rite-build/reference/checkpoint-protocol.md

@@ -100,7 +100,7 @@ In one atomic write (one `state.md` rewrite + one `questions.md` append):
 
 Format: `q-YYYY-MM-DD-NNN`, where `NNN` is the next sequential integer for that date in
 `questions.md`. For the write side, call
-`bash .claude/skills/devrites-lib/scripts/resolve.sh next-qid <questions.md path>` — it
+`devrites-engine resolve next-qid <questions.md path>` — it
 counts existing `## q-YYYY-MM-DD-` headers for today, prints the next zero-padded id, and
 refuses to print an id whose header already exists. Use that id verbatim so each qid is
 unique within the date.

package/pack/.claude/skills/rite-build/reference/checkpoint.md

@@ -0,0 +1,44 @@
+# Checkpoint — crash-survivable WIP commits (opt-in)
+
+`.devrites/` markdown survives compaction, but a slice's *source* stays uncommitted until
+`/rite-ship`. A crash or killed session mid-build — the AFK / `/rite-autocomplete` case —
+loses that source **and** the reasoning behind it. Checkpoint mode commits each proven
+slice as a local `WIP`, so the work and its context outlive the session.
+
+## When it's on
+Opt-in via the `.devrites/CHECKPOINT` sentinel — the mirror of `.devrites/AFK`. Absent →
+no checkpoints; `/rite-build` behaves exactly as before. A long unattended run
+(`/rite-autocomplete`) is the case it earns its keep, so that path sets the sentinel for
+the run. **Local-only by rule:** a checkpoint is never pushed — scratch work must not
+trigger CI.
+
+## The checkpoint commit — orchestrator, at RECORD, after gates are green
+A checkpoint records a **proven** slice; it fires only after PROVE is green, never on a red
+gate. Stage only the slice's `touched-files.md`, then commit locally with a
+`[devrites-context]` body a cold reader can restore from:
+
+```bash
+[ -f .devrites/CHECKPOINT ] || exit 0   # sentinel absent → no-op, silent
+git commit -m "WIP(<slug>): <slice>" -m "$(cat <<'BODY'
+[devrites-context]
+decisions: <one-line delta this slice added to decisions.md>
+remaining: <pending slices — count or names>
+dead-ends: <approaches ruled out this slice, if any>
+BODY
+)"
+```
+
+## Restore
+The commit body is a durable record, not just a marker. After a crash, a fresh session —
+or `/rite-status` — reads the last `WIP(<slug>)` body to reconstruct the decisions,
+remaining slices, and dead-ends that in-session `.devrites/` state would have held. No
+special tooling: it's a git log entry any agent can read.
+
+## Collapse at ship
+WIP commits are scratch and never reach shared history. `/rite-ship` folds them into the
+one atomic feature commit before the Conventional-Commit ladder — see the collapse step in
+[git-ship.md](../../rite-ship/reference/git-ship.md). Result: one clean commit, bisect
+stays green.
+
+## Autocomplete clean-baseline use
+`/rite-autocomplete` may arm checkpoint mode after it verifies a clean or explicitly accepted baseline. Checkpoints are local-only crash recovery, not authorization to continue across red gates or to ship. `/rite-build` remains one-slice-at-a-time; autocomplete is the only opt-in loop that may invoke multiple builds.

package/pack/.claude/skills/rite-build/reference/evidence-standard.md

@@ -15,14 +15,14 @@ Evidence beats confidence. A slice isn't built until there's a record that prove
 - "No type errors" as proof that a *feature* works (it proves types, not behavior).
 - A screenshot path you didn't open.
 
-## Record format (`evidence.md`, append-only)
+## Record format (`evidence.md`)
 ```markdown
-## Slice <N> — <name>  (<date>)
-- cmd: <command>
-  result: <pass/fail + key output line>
-- observation: <what you saw at runtime>
-- browser: see browser-evidence.md (if UI)
-- gaps: <what remains unproven, if anything>
+# Evidence
+
+## Evidence log
+| Evidence ID | Command / action | Result | Timestamp | Related IDs | Limitation |
+| --- | --- | --- | --- | --- | --- |
+| EVID-001 | <command/action> | <pass/fail + key output line> | <iso if available> | AC-001, SLICE-001 | <what remains unproven, or none> |
 ```
 
 ## Honesty rules
@@ -30,3 +30,6 @@ Evidence beats confidence. A slice isn't built until there's a record that prove
 - If a step was skipped (no browser available, command not found), say so and record
   the manual verification steps instead.
 - Unproven acceptance criteria stay unchecked. The seal will catch them.
+- Every evidence row uses `EVID-###` and names the related `AC-###` and `SLICE-###`.
+- UI/browser proof goes in `browser-evidence.md`; `evidence.md` links to its `EVID-###`
+  instead of copying screenshot notes.

package/pack/.claude/skills/rite-build/reference/forge.md

@@ -55,7 +55,7 @@ Snapshot the working tree first (the winner's landing is reconciled against it l
 each candidate its own isolated tree. **Prefer parallel isolated worktrees** when the harness can
 dispatch a sub-agent with worktree isolation; the **always-available** path is one throwaway git
 branch per candidate, built sequentially (slower, universally works — the
-[`tooling.md`](../../../rules/tooling.md) "fallback is first-class" discipline):
+[`tooling.md`](../../devrites-lib/reference/standards/tooling.md) "fallback is first-class" discipline):
 
 ```bash
 SLUG="$(cat .devrites/ACTIVE 2>/dev/null)"
@@ -107,13 +107,23 @@ The durable record of the competition (template below). One per forged slice; ar
 feature.
 
 ### F7 — Clean up, then return to the cycle
-Remove the losing worktrees / delete the candidate branches:
+Remove only clean losing worktrees / delete their candidate branches. If a losing worktree is dirty,
+preserve it and record the path in `forge-report.md`; never `--force` away unlanded work.
 
 ```bash
 SLUG="$(cat .devrites/ACTIVE 2>/dev/null)"
 for C in A B; do
-  git worktree remove ".devrites/work/$SLUG/forge/cand-$C" --force 2>/dev/null || true
-  git branch -D "forge/$SLUG/cand-$C" 2>/dev/null || true
+  WT=".devrites/work/$SLUG/forge/cand-$C"
+  if [ -d "$WT/.git" ] || git -C "$WT" rev-parse --is-inside-work-tree >/dev/null 2>&1; then
+    if git -C "$WT" diff --quiet && git -C "$WT" diff --cached --quiet; then
+      git worktree remove "$WT" 2>/dev/null || true
+      git branch -D "forge/$SLUG/cand-$C" 2>/dev/null || true
+    else
+      echo "preserved dirty forge worktree: $WT"
+    fi
+  else
+    git branch -D "forge/$SLUG/cand-$C" 2>/dev/null || true
+  fi
 done
 ```
 
@@ -148,14 +158,14 @@ approach forge already rejected.
 ## AFK & budget
 
 - **Cost.** Forge multiplies the build by K. Under `.devrites/AFK`, each candidate counts against
-  the slice budget (`tick-afk.sh` once per candidate dispatched), so a forge slice can exhaust the
+  the slice budget (`devrites-engine tick-afk` once per candidate dispatched), so a forge slice can exhaust the
   cap faster — that is intended back-pressure, not a bug.
 - **Gates are unchanged.** Forge changes *how many candidates build*, never *what pauses*. An
   irreversible-risk item, a blocking/escalating gate, or a red-on-completion in **any** candidate
-  pauses per [`afk-hitl.md`](../../../rules/afk-hitl.md) exactly as single-path. AFK widens what is
+  pauses per [`afk-hitl.md`](../../devrites-lib/reference/standards/afk-hitl.md) exactly as single-path. AFK widens what is
   automatic, never what is irreversible — forge included.
 - **Stuck loop still applies.** Re-dispatching the same candidate without progress trips
-  `stuck.sh` the same as a single wright.
+  `devrites-engine stuck` the same as a single wright.
 
 ## When isolation is impossible