devrites 3.2.28 → 4.0.0

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

@@ -1,21 +1,19 @@
 # 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.
+`.devrites/` markdown survives compaction, but a slice's source normally stays
+uncommitted until `/rite-ship`. A crash during unattended Build can lose that source.
+Checkpoint mode commits each proven slice as a local `WIP`, so it survives 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.
+Opt in with `.devrites/CHECKPOINT`, the mirror of `.devrites/AFK`. When absent,
+`/rite-build` makes no checkpoint. Autocomplete sets it for long unattended runs.
+**Local-only:** never push a checkpoint or let scratch work 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:
+A checkpoint records a **proven** slice only after its gates are green. Stage the exact
+slice-owned candidate paths from the manifest, passing each literal path separately.
+Never stage `touched-files.md`, a directory, glob, unrelated path, or user change.
+Verify the staged set, then commit locally with a `[devrites-context]` body:
 
 ```bash
 [ -f .devrites/CHECKPOINT ] || exit 0   # sentinel absent → no-op, silent
@@ -29,10 +27,9 @@ 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.
+After a crash, a fresh session may read the last `WIP(<slug>)` body as crash context.
+Authoritative state remains in `.devrites/`: validate the body against that workspace;
+never reconstruct, overwrite, or advance state from the commit body alone.
 
 ## Collapse at ship
 WIP commits are scratch and never reach shared history. `/rite-ship` folds them into the
@@ -41,4 +38,7 @@ one atomic feature commit before the Conventional-Commit ladder: see the collaps
 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.
+`/rite-autocomplete` may arm checkpoints after verifying a clean or accepted baseline.
+They authorize neither red-gate continuation nor Ship. Each wright returns after one
+slice; HITL stops, while explicit `.devrites/AFK` lets the controlling Build root chain
+another green slice only under its cap and pause rules.

package/pack/generated/claude/skills/rite-build/reference/frontend-trigger.md

@@ -14,9 +14,9 @@ A slice is **frontend/UI** if it touches or plans to touch any of:
 - `/rite-spec` applies **`devrites-ux-shape`** (spec step 3a) to write the feature-level
   **`design-brief.md`** before any code: design direction, key states, interaction model,
   optional Figma/image visual-direction probe.
-- `/rite-build` applies **`devrites-frontend-craft`**, building **to** that `design-brief.md`
-  (register detection, refine the brief per slice, existing design system, all states,
-  anti-AI-slop) before/while implementing.
+- `/rite-build` applies **`devrites-frontend-craft`** to the vetted `design-brief.md`
+  (register, system, states, anti-AI-slop). If missing or materially changed, shape it
+  and return through `/rite-vet` before code.
 - `/rite-prove` applies **`devrites-browser-proof`** (proof ladder + evidence schema).
 - `/rite-polish` runs the full **normalize + polish** workflow.
 - `/rite-review` and `/rite-seal` include frontend UX / a11y / responsive / design-

package/pack/generated/claude/skills/rite-build/reference/one-slice-cycle.md

@@ -1,35 +1,32 @@
 # One-slice cycle
 
-The discipline that makes large features manageable: build one thin slice, leave it
-working and proven, stop. Never implement the whole feature in one pass.
+One wright dispatch builds one thin, proven slice. HITL stops; only explicit
+`.devrites/AFK` lets the controlling root chain another pending slice under the
+green-proof, cap, and pause rules. Each wright returns after exactly one slice.
 
 ## The cycle
 The orchestrator (`/rite-build`) gates and records; the **wright** writes. See
 [`wright-dispatch.md`](wright-dispatch.md).
 ```
 SELECT    → orchestrator: restate slice goal + acceptance + scope boundary; HITL gate (pause pre-code)
-(SHAPE)   → orchestrator: if UI and no design-brief.md, shape it (devrites-ux-shape) before dispatch
-(FORGE)   → orchestrator: if slice is Forge: yes, engine plan → snapshot → bound isolated
-            candidates → extract → judge → record + merge one winner, then continue at DOUBT (forge.md)
+(SHAPE)   → orchestrator: missing UI design-brief.md → shape it, then /rite-vet before dispatch
 DISPATCH  → hand the slice contract to devrites-slice-wright (fresh context). Inside the wright:
    ORIENT    → load only the files this slice touches; learn the project's idiom; reuse-first
    (RED)     → if behavior change: write the failing test first
    IMPLEMENT → smallest complete version; match conventions; devrites-frontend-craft for UI
    VERIFY    → writer-safe tests/types/lint; return code + tests
 (DOUBT)   → orchestrator, on return: devrites-doubt each non-trivial decision the wright stood up
-PROVE     → root: exact required production build/browser/E2E, then final reconcile; fail-on-red
-RECORD    → orchestrator: after green verification, Forge cleanup/report if used; then
-            state.md, evidence.md, touched-files.md (the canonical writer)
+PROVE     → root: required build/browser/E2E, then returned-diff/path review; fail-on-red
+RECORD    → orchestrator: after green verification, update state.md/evidence.md and
+            upsert the authoritative candidate manifest from the actual scoped diff
 (CHECKPOINT) → orchestrator: if .devrites/CHECKPOINT is set, commit the proven slice
             local-only as WIP(<slug>) with a [devrites-context] body → survives a crash (checkpoint.md)
-STOP      → report + recommend next; do not start slice N+1
+NEXT      → HITL root reports and stops; AFK root may repeat only under afk-discipline.md
 ```
 
-## Why stop after one slice
-- Keeps the diff reviewable (~one capability, roughly ≤100 lines of meaningful change).
-- Surfaces integration/drift problems while they're cheap.
-- Gives the user a decision point. They may reprioritize, reslice, or polish now.
-- Prevents the "90% done" pile-up where nothing is proven.
+## Why the boundary matters
+- Keeps diffs reviewable and reveals integration or drift early.
+- Preserves a HITL decision point and prevents unproven pile-ups.
 
 ## Restate the scope boundary
 Before coding, write what this slice will and will **not** touch. This is the contract

package/pack/generated/claude/skills/rite-build/reference/output.md

@@ -1,41 +1,31 @@
 # rite-build output
 
-This is the normative output contract for `/rite-build`. `../SKILL.md` points
-here so the root skill can stay focused without weakening response shape.
-
-Run `devrites-engine progress` first. It prints the deterministic header, slice
-meter, and flow ribbon. Put the compact fact lines below it using the shared
-completion reply contract
-([`devrites-lib/reference/reply-contract.md`](../../devrites-lib/reference/reply-contract.md)).
-
-**Slice built; slices remain:**
+**Slices remain:**
 ```text
 Done: built slice <n> — <name>.
-Changed: <files touched>; state.md, touched-files.md, evidence.md
-Evidence: acceptance met; tests <cmd -> pass>; browser <summary | n/a>; drift <none|handled>
-Open: <none | blockers | questions>
+Changed: <files>; state.md, touched-files.md, evidence.md
+Evidence: acceptance met; tests <cmd->pass>; browser <summary|n/a>; drift <none|handled>
+Open: <none|blockers|questions>
 Next: /rite-build
 Record: .devrites/work/<slug>/evidence.md
 ↻ Hygiene: /clear between slices; /rite-handoff if away > a few hours
 ```
 
-**Slice built; all slices built:**
+**All built:**
 ```text
 Done: built slice <n> — <name>; all slices built.
-Changed: <files touched>; state.md, touched-files.md, evidence.md
-Evidence: acceptance met; tests <cmd -> pass>; browser <summary | n/a>; drift <none|handled>
-Open: <none | blockers | questions>
+Changed: <files>; state.md, touched-files.md, evidence.md
+Evidence: acceptance met; tests <cmd->pass>; browser <summary|n/a>; drift <none|handled>
+Open: <none|blockers|questions>
 Next: /rite-prove
 Record: .devrites/work/<slug>/evidence.md
 ↻ Hygiene: /clear before /rite-prove; /rite-handoff if away > a few hours
 ```
 
-For awaiting-human or stopped states, use the typed templates from the reply contract.
-Keep fact lines terse. The meter and ribbon carry progress; don't duplicate them in
-prose.
-
-For a **forged slice**, the `Built` line names the competition and points at the record, e.g.
-`Done: built slice 3 — csv-streaming (forged: 3 candidates, winner B).` and
-`Record: .devrites/work/<slug>/forge-report.md`.
+HITL returns after one green slice. Only explicit `.devrites/AFK` lets the
+controlling root chain another pending slice after green-proof, cap, and pause
+gates. Every `devrites-slice-wright` returns after exactly one slice.
 
-**DO NOT continue to the next slice automatically**: even at `✅ ALL BUILT`, `/rite-prove` is the user's call.
+At all built, Build never enters `/rite-prove` automatically; a higher-level
+orchestrator may invoke it only under its own contract. Awaiting-human or
+stopped states use the shared reply contract.

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

@@ -1,193 +1,54 @@
 # rite-build phase contract
 
-See also [`one-slice-cycle.md`](one-slice-cycle.md).
+See [`one-slice-cycle.md`](one-slice-cycle.md); candidate lifecycle is
+[`candidate-integrity.md`](../../devrites-lib/reference/candidate-integrity.md).
 
-0. **Rules + AFK + readiness check.** Read
-   `.claude/skills/devrites-lib/reference/standards/core.md`, then orient and run the
-   deterministic readiness gate:
-   ```bash
-   devrites-engine preamble
-   devrites-engine snapshot
-   ```
-   Treat the snapshot as canonical machine-readable status and use its host-specific
-   `nextCommands` value:
-   ```bash
-   devrites-engine build-readiness; echo "readiness rc=$?"
-   ```
-   Any non-zero result is a hard STOP at the gate's reported route; `6` → `/rite-clarify`,
-   `7` → `/rite-vet`, and `8` → `/rite-upgrade`. Under AFK, also
-   enforce the mutable `state.md` budget from
-   [`afk-discipline.md`](afk-discipline.md); zero remaining slices forces a HITL stop.
-1. Read `spec.md`, `decision-coverage.md`, `plan.md`, `tasks.md`, `assumptions.md`,
-   `drift.md`, `eng-review.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.
-   Require `Decision coverage: CLEAR` and `Implementation readiness: READY`. If a
-   **blocking `[NEEDS CLARIFICATION]`** or uncovered decision remains, stop →
-   `/rite-clarify`; if plan readiness does not pass, stop → `/rite-plan` or `/rite-vet`
-   as classified by the gate. Don't build on an unresolved spec or unvetted plan.
-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, including the non-HITL path; `/rite-resolve` clears or updates
-   it on resume.
-2a. **HITL gate (pre-action pause).** Resolve any `HITL` slice checkpoint before code,
-    exactly as [`checkpoint-protocol.md`](checkpoint-protocol.md) defines. An interactive
-    human answers inline and the build continues in place. AFK may auto-pick only allowed
-    gates; otherwise persist the question and awaiting-human cursor, notify, and STOP for
-    `/rite-resolve`. Blocking, escalating, and irreversible-risk gates always take that stop path.
-3. **Authorize exact paths, snapshot, then fresh-context dispatch the build core to
-   `devrites-slice-wright`.** First write the root-owned exact project-relative file list to
-   `.devrites/work/<slug>/.wright-allowlist`; mirror it in the packet's
-   `scope.allowed_repo_writes`. The wright's later `Files changed` report cannot widen it.
-   **Forge branch: only for a fully typed `Forge: yes` slice.** Follow
-   [`forge.md`](forge.md) sections 1 through 3: require the scorecard, strategies, and
-   real `manifest-env-v1` host binding; run `forge plan` before reconciliation; snapshot after a
-   planned result; bind, dispatch, record, and extract every candidate; judge the
-   immutable deltas; record one winner; and merge it. A typed serial degradation has
-   no Forge side effects and uses the default branch below. A later error preserves
-   the manifest-owned run for technical recovery; never degrade silently. After merge,
-   validate the winner envelope and enter the common return check at the end of this
-   step. Do not also dispatch a serial wright.
+1. **Orient and gate.** Read core, `.devrites/ACTIVE`, `state.md`, and required
+   slice artifacts. Require `Implementation readiness: READY`, its current
+   `Readiness inputs SHA-256`, all applicable exact reviewer accounts,
+   ID-and-meaning traceability, and green proof preflight; run
+   `devrites-engine check readiness <slug>`. Any miss/nonzero stops.
+2. **Select one slice.** Restate goal, acceptance criteria, exclusions, and exact
+   source/test paths. Before dispatch, validate relevant `assumptions.md` rows
+   against live evidence. If one is disproved and changes acceptance, architecture,
+   scope, or proof, use the Spec Drift Guard/plan recovery; a human-owned unknown
+   stops. Resolve HITL before source work. AFK answers only permitted gates;
+   human-owned or irreversible risk persists a question and stops for `/rite-resolve`.
+3. **Dispatch the sole writer.** Apply [`wright-dispatch.md`](wright-dispatch.md).
+   Put the smallest exact project-relative source/test path list directly in the task;
+   dispatch the exact `devrites-slice-wright` fresh. Root never writes, wright never
+   widens, and a missing profile stops.
+4. **Inspect the return.** Wait; compare its file list and `git diff --name-only`
+   with the contract. Reject stale, partial, malformed, or out-of-scope work.
+   Preserve user work; source restoration uses the same bounded wright.
+5. **Challenge stood decisions.** For each stood decision, run exact
+   `devrites-doubt-reviewer` fresh/read-only and record accepted or resolved-rejected
+   in `decisions.md`. A missing verdict, principle breach, scope change, or
+   irreversible risk blocks.
+6. **Prove without guessing.** Against the frozen pre-slice candidate, inspect
+   test hunks for deletion, skipping/focus, tautology, or weaker expectations. Dispatch exact
+   `devrites-test-analyst` on that immutable diff; missing account or adverse criterion
+   verdict is Critical. Run only `test-plan.md` repository/CI commands, capture output,
+   and recheck `git diff --name-only`. Missing, weakened, red, or source-mutating proof
+   is not success.
 
-   **Default serial branch.** Follow
-   [`wright-dispatch.md`](wright-dispatch.md) end to end; it owns snapshot timing, stuck
-   logging, the exact packet, conditional skill loading, and return checks. Dispatch through
-   named wright → safely enforced generic fresh worker. If neither is available, stop for
-   HITL; root never writes source. Validate the result before `.devrites`
-   writes; run `reconcile check`. Exit `5` rejects: run standalone
-   `devrites-engine reconcile abort`, then verify its receipt and frozen hashes.
-4. **Doubt every stood decision before accepting the slice.** The writer never grades its
-   own decisions: invoke `devrites-doubt` and its fresh reviewer for each entry. Do not enter
-   step 5 until every entry has a recorded `accept` or resolved `reject` verdict. Log each dispatch:
-   ```bash
-   devrites-engine footprint log <slug> doubt "<decision id>"
-   ```
-   Apply Doubt's AFK exception. Irreversible-risk or blocking escalations pause; scope-changing
-   answers route through the Spec Drift Guard. An irreversible-risk item misfiled under
-   `Decisions stood` is a blocking protocol violation: re-dispatch it as out of bounds,
-   never doubt-and-accept it.
-   **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. **Run retained-baseline integrity and every root-owned proof gate, then recover
-   any objective red.**
-   ```bash
-   devrites-engine test-integrity; echo "test-integrity rc=$?"
-   ```
-   Run only root-owned gates already authorized byte-for-byte by the vetted
-   `test-plan.md` and unchanged `agent-packet/v1`, including exact command, cwd,
-   prerequisites, and expected artifact boundary. A wright result may report one
-   of those commands as `not-run`; it cannot invent, rewrite, widen, or authorize a
-   command. Reject any reported command that does not exactly match the frozen
-   plan/packet. Opaque wrapper, build, Playwright, and browser commands are root-owned
-   only when pre-authorized there; this transfers no source/test write authority.
-   A missing approved command is unverifiable proof.
-   After they pass, run `devrites-engine reconcile check` again after the root-owned gates
-   and before close, proving their child processes did not change tracked source:
-   ```bash
-   devrites-engine reconcile check; echo "reconcile rc=$?"
-   ```
-   If a root-owned gate changes source after the clean pre-gate check, run the exact
-   engine-owned rollback and verify the retained tree before recovery:
-   ```bash
-   devrites-engine reconcile restore-check
-   devrites-engine reconcile check; echo "reconcile rc=$?"
-   ```
-   Never manually restore, truncate, resnapshot, or widen an allowlist to hide
-   post-check drift.
+   Technical failure uses bounded `devrites-debug-recovery`: reapply the host gate
+   before an accepted in-slice correction, keep one root cause/three total attempts,
+   and never rerun an unchanged check. Ask humans only for product decisions,
+   irreversible risk, or genuinely human-only access.
+7. **Record.** After green proof, upsert `touched-files.md`'s authoritative candidate
+   manifest from the actual scoped diff with explicit `present`/`deleted` rows;
+   update `state.md`, `evidence.md`, and applicable UI/browser evidence. The manifest
+   stays mutable until Polish closes it.
+   Record stood decisions/dead ends in `decisions.md`; update checked assumptions'
+   status/evidence, never leaving a disproved row live. If code reveals a durable
+   project rule, propose a reviewed `AGENTS.md`/nearest-doc update, not a scored ledger.
+8. **AFK and reply.** Under `afk-discipline.md`, root charges
+   exactly once after each green built slice, never below zero; stop before another dispatch at zero, and fail closed
+   on malformed budget. Use the reply contract; name the next pending slice or, only
+   when all slices are built, `/rite-prove`. Emit no decorative progress renderer or
+   dispatch telemetry.
 
-   If the wright's `Gates` were red (targeted tests / types / lint), `test-integrity`
-   failed, a root-owned gate failed, the final reconcile failed, or proof could not be
-   verified: do **not** mark the slice `built`, and **do not fix the code yourself**.
-   Classify each causal fingerprint through
-   [`cleanup-and-classify.md`](../../devrites-debug-recovery/reference/cleanup-and-classify.md),
-   run `devrites-engine recovery route <class>`, and follow the `recovery-route/v1`
-   owner/action. Only `humanPause: true` or an exact human-only predicate opens a question;
-   technical repair, environment stabilization, and proof reruns remain agent-owned.
-   For an agent-owned defect route, continue the same wright under
-   `devrites-debug-recovery`, carrying command/output, attempt count, and dead ends. Wright
-   plus recovery share **three total attempts per root cause** and never
-   rerun an unchanged check. Persist the initial and retry failures with
-   `devrites-engine recovery record --class <class> "<root cause>" "<exact failure>" <slug>`,
-   run `recovery check` before each retry, and
-   `recovery clear --class <class> "<root cause>" <slug>` only after green. Before every
-   re-dispatch, update the root-owned allowlist only for an accepted in-slice path and run
-   `reconcile snapshot`: after a clean check this refreshes canonical-state scope while
-   retaining the original source baseline. Repeat reconcile and the integrity gate on every
-   return. This owns red gates, missing coverage, browser/runtime failures, and
-   workflow-tool defects.
-   After recovery:
-   - green → continue to record;
-   - product-contract/acceptance ambiguity or irreversible risk → open the genuine human gate
-     (and use `/rite-plan repair` only when the durable plan or contract changes);
-   - human-only access/action → gate with the exact needed input;
-   - exhausted objective failure → preserve reproduction/dead ends, set `Status: blocked` and
-     `Next step: /rite-plan unblock`, then STOP without a question or `/rite-resolve`.
-6. **Close the retained baseline, then record. You are the canonical writer.**
-   Reconciliation ran immediately on return; step 5 ran integrity, root-owned proof,
-   and a final clean reconciliation.
-   **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`.
-
-   Once every gate and doubt verdict is accepted, a forged slice records successful
-   verification and runs manifest-only cleanup per [`forge.md`](forge.md). Then close the
-   private window:
-   ```bash
-   devrites-engine reconcile close
-   ```
-   Keep it open across a genuine human wait that resumes the same slice; close it before a
-   scope/plan transition.
-
-   Then, from the wright's artifact, update `state.md`,
-   `evidence.md`, `touched-files.md` (and `browser-evidence.md` for UI). For a forged
-   slice, write `forge-report.md` after reconciliation, verification, and cleanup;
-   it records the run but owns nothing. Add a `## Review trail`
-   to `touched-files.md`: group the slice's important `path:line` stops by concern (design intent,
-   not file order), 1-5 concerns, each stop under 15 words. This is for a later human walkthrough;
-   keep it factual and skip invented rationale. **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
-   devrites-engine conventions contradict --key <key> --slug <slug> \
-     --evidence "<what the live code does>" --drift-file .devrites/work/<slug>/drift.md
-   ```
-   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.md`](evidence-standard.md). Append a footprint record for this
-   slice's wright dispatch (deterministic run-weight bookkeeping the seal reports):
-   ```bash
-   devrites-engine footprint log <slug> wright "<slice id>"
-   ```
-   If `.devrites/AFK` is present, decrement
-   the budget by running `devrites-engine tick-afk <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
-   devrites-engine progress
-   ```
-   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.
-
-> **Mid-flight discipline.** The wright 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.md`](anti-patterns.md). Load it the moment you reach for the excuse.
+> **Mid-flight discipline.** One writer contract builds one slice. Do not skip
+> TDD, widen paths, fold in a second slice, or accept the writer's judgment as
+> independent review.

package/pack/generated/claude/skills/rite-build/reference/spec-drift-guard.md

@@ -28,7 +28,7 @@ other phases reference it here.
        re-vet, then resume.
      NO, product/policy/irreversible-risk decision → ask the user (format below).
 5. Never continue on a known-wrong durable plan. A repaired active-slice implementation
-   may continue only after the normal recovery, reconciliation, and integrity gates pass.
+   may continue only after bounded recovery, returned-diff review, and proof gates pass.
 ```
 
 ## User question format