devrites 7.1.0 → 7.1.2

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

@@ -138,30 +138,28 @@ next sequence continuation through Vet in a second session, then stop.
    product scope is never auto-resolved by a recommended option; it stops for a human.
    A spent strategy escalates; parked recovery records
    `Next step: /rite-autocomplete`, never a routine phase command. **Completion:** no stop is active, or its cursor and reason are durable.
-6. **Seal boundary.** Without a ship flag, leave the sealed workspace unshipped and
-   open the next recorded continuation
+6. **Seal boundary.** With or without a ship flag, leave intermediate sealed
+   workspaces unshipped and open the next recorded continuation
    ([loop.md § Sequence continuation](reference/loop.md#sequence-continuation))
    unless `continue_sequence: false`, the sequence budget is spent, or no entry
-   remains; then stop at Seal GO with `/rite-ship`. Report the sequence position on
-   every stop.
-   With a ship flag, perform Ship preflight, disclose the exact Git plan, and stop for
-   fresh literal `GO` plus native approval. **Completion:** performed no Git action before fresh literal `GO` plus native approval.
+   remains. At that boundary without a ship flag, stop at Seal GO with `/rite-ship`.
+   Report sequence position at every stop. Only at that boundary, with a ship flag, perform Ship preflight,
+   disclose the exact Git plan, and stop for fresh literal `GO` plus native approval. **Completion:** performed no Git action before fresh literal `GO` plus native approval.
 
 ## Reply and resume
 
-HITL Build returns after one slice; Autocomplete ignores `--max-slices` and
-keeps chaining pending slices. One Autocomplete invocation owns all internal
-backtracking. Context pressure, compaction, or a nested completion footer does
+HITL Build returns after one slice; Autocomplete ignores `--max-slices`, chaining
+pending slices. Each Autocomplete invocation owns internal backtracking. Context pressure, compaction, or a nested completion footer does
 not create a stop; persist and resume the cursor.
 
-Reply only at a final state, never as mid-run progress: a text-only turn ends
-the run, so after a compaction or phase change keep calling tools. Use one terse line:
+Reply only at final state: text-only turns end the run. Keep
+calling tools after compaction or phase changes. Use one line:
 
 ```text
 Autocomplete: <slug>
 spec <done|stopped> · clarify <clear|stopped> · temper <done|stopped> · define <done|stopped> · vet <ready|stopped> · build <n/N|stopped> · prove <done|stopped> · polish <done|stopped> · review <done|stopped> · seal <GO|NO-GO|stopped>
 ```
 
-Final state is `Shipped`, `Stopped`, `Awaiting human`, `NO-GO`, or `GO`; do not
-write a narrative recap. Require a clean or accepted baseline, land a local
-unpushed checkpoint after each green check, and never auto-pass a red gate.
+Final state: `Shipped`, `Stopped`, `Awaiting human`, `NO-GO`, or `GO`; no narrative
+recap. Require clean or accepted baseline; land local unpushed checkpoints after
+each green check; never auto-pass red gates.

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

@@ -1,7 +1,6 @@
 # The autocomplete loop: arm AFK, drive every phase
 
-Autocomplete sequences existing `/rite-*` workflows without pausing between
-routine phases. Acceptance-preserving Reslice authority is
+Autocomplete chains existing `/rite-*` workflows without routine-phase pauses. Acceptance-preserving Reslice authority is
 `.claude/skills/devrites-lib/reference/standards/acceptance-preserving-reslice.md`.
 
 <!-- BEGIN RESLICE ROUTE-TO-ACTION -->
@@ -21,7 +20,7 @@ allow_gates: [advisory, validating]
 # notify: "<cmd>"
 ```
 
-Read an existing sentinel first. Preserve it byte-for-byte when valid, except
+Read existing sentinel first. Preserve valid bytes, except
 when this invocation contains `--parallel N`: then write or replace only
 `max_parallel: N` and leave every other key unchanged. Stop if the sentinel is
 malformed. Do not stop because it names `max_slices` / `max_agents` /
@@ -39,24 +38,22 @@ remaining. AFK configuration itself stays unchanged.
 
 ### Admit each unattended cycle
 
-Before every phase, review fan-out, recovery, or writer dispatch: cheapest
+Before each phase, review fan-out, recovery, or writer dispatch: cheapest
 readiness check first; reject overlap. Do not stop on `max_agents`,
-`max_minutes`, or `max_review_queue`. Count every leaf result. A new activation
-gets fresh activation-local counters but retains durable slice/recovery state.
-
-When driving `/rite-build`, ignore afk-discipline remaining-0, `--max-slices`,
-and parallel AFK headroom as stop conditions. Pass this invocation's
-`--parallel N` into `/rite-build` when present; leftover sentinel
-`max_parallel` is then not the cap. Close validating questions and blocking questions
-that already name a ranked recommended option (recommended pick via
-`devrites-engine state resolve`) instead of queuing them or handing
-`/rite-resolve` to the user. Escalating, irreversible-risk, access, and
-blocking with no recommended option still pause, as does Seal's judgment-only
-validating question (`slice: seal`).
+`max_minutes`, or `max_review_queue`. Count every leaf result. New activations reset activation-local counters, retaining durable slice/recovery state.
+
+[Build return](../../rite-build/reference/output.md#caller-owned-continuation).
+Pass `--parallel N`; ignore leftover cap/headroom, remaining-0,
+and `--max-slices` stops. Agent-invented dispatch, wait, tool-call, or turn budgets are not stop conditions.
+An explicit human request to pause or run only a bounded subset still wins.
+Path collisions serialize work; they do not end the run.
+Resolve ranked validating/blocking picks via `devrites-engine state resolve`;
+never hand `/rite-resolve` to the user. Escalating, irreversible-risk, access, blocking
+without recommendations, and Seal judgment (`slice: seal`) still pause.
 
 ## Phase arc
 
-Workspace files carry state; chat does not. Read and execute each phase skill:
+Workspace files, not chat, carry state. Read/execute each phase skill:
 
 | Step | Phase | Completion / edge |
 | --- | --- | --- |
@@ -65,16 +62,15 @@ Workspace files carry state; chat does not. Read and execute each phase skill:
 | 3 | `/rite-temper` | harden or reduce; `expand` and extra acceptance stop for a human; irreversible risk still pauses |
 | 4 | `/rite-define` | approved plan/tasks/traceability |
 | 5 | `/rite-vet` | every plan; derive mutable budget after READY |
-| 6 | `/rite-build` batch loop | largest eligible path-disjoint set (cap: this invocation's `--parallel N`, else sentinel `max_parallel`, else 10; one-slice round when <2 eligible); refill per landing; charge once per landed slice |
+| 6 | `/rite-build` batch loop | largest eligible path-disjoint set (cap: this invocation's `--parallel N`, else sentinel `max_parallel`, else 10; serial if <2 eligible); refill per landing; charge once per landed slice |
 | 7 | `/rite-prove` | all slices built except deferred (`Satisfies: none`); approved proof; recovery on red |
 | 8 | `/rite-polish` | re-prove after code edits |
 | 9 | `/rite-review` | in-scope correction then fresh proof |
 | 10 | `/rite-seal` | GO/NO-GO; no Git |
 | 11 | `/rite-ship` | only after GO; `--ship` never authorizes Git; stop at literal-GO/native approval |
 
-Before advancing, check
-[stop-conditions.md](stop-conditions.md). After source edits, discard stale pass
-evidence. Re-read the active workspace before each phase. On a cold resume or
+Check [stop-conditions.md](stop-conditions.md) before advancing. Discard stale
+pass evidence after source edits. Re-read active workspace before each phase. On a cold resume or
 new activation, run `devrites-engine check regression <slug>`: `BLOCKED` names a
 durable fact lost since the last checkpoint — restore or route it through its
 owning phase before continuing; `unproven` does not block. After each phase's
@@ -91,37 +87,35 @@ step 10 does not end the run: leave the sealed workspace unshipped with its
 (`/rite-spec <parent>-<n> "<objective>"` from the parent's `decisions.md` sequence)
 and re-enter step 1. Spend one workspace per opened continuation.
 
-When that workspace already exists because a [lookahead](lookahead.md) session
-planned it, do not specify it again. Wait while `devrites-engine claim check
---workspace <child>` exits 3 (a live lookahead holds it), then set
-`.devrites/ACTIVE` to the child and resume from its cursor at step 1. A
-predecessor replan since its Vet blocks the child's readiness with
-`DRV-GATE-READINESS-STALE`; route that to `/rite-vet` before Build.
-
-Spend accounting is durable in `state.md` cursors, not chat. Before invoking the
-continuation, ensure the current workspace's `sequence_workspaces_remaining` is
-set — absent, write `max_workspaces - 1` and `sequence_position: 1` first — and
-`> 0`. `/rite-spec` seeds the child's sequence cursor at creation per the
+For a child already planned by [lookahead](lookahead.md), do not re-specify.
+Wait while `devrites-engine claim check --workspace <child>` exits 3 (live
+lookahead), then set `.devrites/ACTIVE` to the child and resume its cursor at
+step 1. A predecessor replan since its Vet blocks child readiness with
+`DRV-GATE-READINESS-STALE`; route to `/rite-vet` before Build.
+
+Before invoking a continuation, require durable `state.md`
+`sequence_workspaces_remaining > 0`; if absent, first write
+`max_workspaces - 1` and `sequence_position: 1`. `/rite-spec` seeds the child's sequence cursor at creation per the
 [continuation contract](../../rite-plan/reference/slicing.md#continuation-workspaces);
-after the child's `state.md` exists, verify it — `sequence_parent` = the current
-slug, `sequence_position` = parent position + 1,
+verify the created child's `state.md`: `sequence_parent` = current slug,
+`sequence_position` = parent position + 1,
 `sequence_workspaces_remaining` = parent remaining − 1, and — when the recorded
 entry is the sequence's release milestone — `sequence_role: release` (gates then
-require the union manifest). On resume, a child whose
-fields are missing is re-seeded from its `brief.md` parent/position and the
-parent's counter (same values, never a second charge); a child with no recorded
-parent/position is not a sequence member and the chain stops.
-
-Stop instead when: no recorded next entry; the cap or review-queue bound is
-reached; a human-owned, safety, access, or parked-recovery stop fires; or Seal returns
-`NO-GO`. On stop, report the sequence position, the sealed-but-unshipped workspaces, and
-the single release command (`/rite-autocomplete <release milestone> --ship`, or
+require the union manifest). On resume, re-seed missing child fields from its `brief.md` parent/position and
+parent counter (same values, no second charge). No recorded parent/position
+means no sequence membership: stop the chain.
+
+Stop sequence continuation when: `continue_sequence: false`; no recorded next
+entry (the final milestone); the `max_workspaces` cap is reached; or a genuine
+human-owned, safety, access, or parked-recovery stop fires. `max_review_queue`
+never stops Autocomplete; agent-owned Seal `NO-GO` enters recovery, not a handoff.
+Intermediate sealed milestones continue without `--ship` and without Git mutation. On stop, report sequence position, sealed/unshipped workspaces, and
+one release command (`/rite-autocomplete <release milestone> --ship`, or
 `/rite-ship` for the current sealed workspace when the sequence is complete).
 
 ## Backtrack without handing off
 
-The active Autocomplete root remains caller whenever a later phase exposes an
-agent-owned earlier-phase gap:
+Autocomplete remains caller for agent-owned earlier-phase gaps:
 
 1. Save the originating phase/action unless a valid native return cursor exists.
 2. On cold resume, reconcile the terminal cursor against durable fingerprint
@@ -151,6 +145,8 @@ and park it after three escalations while independent work continues.
 
 ## Continuous caller obligation
 
+Green slice/phase checkpoints consume their recorded `next_action` internally;
+only the caller replies finally at completion or a genuine stop.
 No user-facing reply is permitted while durable state contains agent-owned
 `NEEDS_REPLAN`, an intermediate Plan/Vet action, a distinct retained
 Critical/Important fingerprint below its cap or with an escalation left, runnable
@@ -161,7 +157,6 @@ already names a ranked recommended option. Invoke the next internal repair or
 `state resolve` exits 1 on every call and the loop re-invokes it without end. A narrow reviewer closing one finding and exposing another
 Critical/Important invariant is progress, not exhaustion.
 
-The number of completed repair/Vet cycles is not a stop condition. Context
-pressure, compaction, session duration, and nested completion do not convert an
-internal checkpoint into a handoff. Persist it and resume until the requested
-rest point or a shared human/safety/access/parked-recovery condition.
+The number of completed repair/Vet cycles, context pressure, compaction, session
+duration, and nested completion never turn checkpoints into handoffs. Persist and
+resume to the requested rest point or shared human/safety/access/parked-recovery stop.

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

@@ -1,9 +1,8 @@
 # Stop conditions: when autocomplete pauses
 
-On a real stop, write `state.md` as `awaiting_human` or `blocked`, persist the
-reason, and include one resume command. Agent-owned recovery never ends the run:
-a spent strategy escalates and a fully escalated fingerprint parks while other
-work continues ([retry contract](../../devrites-lib/reference/standards/afk-hitl.md#retry-cap-no-progress-loops-and-self-resolve)).
+On real stops, persist `state.md` `awaiting_human` or `blocked`, reason, and one
+resume command. Agent-owned recovery never ends the run: spent strategies
+escalate; fully escalated fingerprints park while other work continues ([retry contract](../../devrites-lib/reference/standards/afk-hitl.md#retry-cap-no-progress-loops-and-self-resolve)).
 `--ship` never bypasses a stop.
 
 Authority: `.claude/skills/devrites-lib/reference/standards/acceptance-preserving-reslice.md`.
@@ -14,7 +13,7 @@ Authority: `.claude/skills/devrites-lib/reference/standards/acceptance-preservin
 
 ## Always stop
 
-Regardless of flags or AFK ceiling:
+Flags/AFK ceiling never override:
 
 - destructive data migration;
 - auth/authz boundary change;
@@ -22,8 +21,8 @@ Regardless of flags or AFK ceiling:
 - external-service contract change; or
 - filesystem destruction outside the workspace.
 
-Red proof cannot advance. Run bounded Debug Recovery and escalate spent
-strategies; a fully escalated fingerprint parks unless the remaining owner is human.
+Red proof cannot advance. Run bounded Debug Recovery; escalate spent strategies.
+Fully escalated fingerprints park unless remaining owner is human.
 
 ## Not stops: internal technical routing
 
@@ -32,13 +31,12 @@ forward work, persists the return cursor, and invokes Plan repair plus Recovery
 Vet inline. The same applies to nested `STOP`/`Next step` when its decision is
 agent-owned.
 
-Agent-owned backtracking is not a stop condition while the exact causal
-fingerprint has budget. Invoke the earlier phase, affected Vet, remediation, and
-proof; then resume the origin. Three no-progress corrections of that exact
-fingerprint spend only its current strategy: escalate to the next correction
-class inline (shared root cause, diagnostic amplification, boundary redesign)
-with a fresh budget, never asking permission. After three escalations in this
-activation the fingerprint parks; finish all independent work, then stop once.
+Agent-owned backtracking is not a stop condition while its exact causal
+fingerprint has budget: invoke earlier phase, affected Vet, remediation, proof;
+resume origin. Three no-progress corrections spend only that fingerprint's current
+strategy: escalate inline to the next class (shared root cause, diagnostic
+amplification, boundary redesign) with fresh budget, without permission. After
+three escalations per activation it parks; finish independent work, then stop once.
 Preserve reproduction, attempts, and dead ends; never offer `/rite-plan unblock`
 or another routine phase command. A new user-issued `/rite-autocomplete`
 reopens parked fingerprints with fresh escalation; wakes and compaction do not.
@@ -50,11 +48,10 @@ It blocks another execution; retained new Critical/Important evidence still
 enters offline recovery. After affected Vet is READY, pause for fresh action
 authorization and never reuse old GO.
 
-Past evidence being irretrievable is not by itself terminal. If an in-scope
-trusted seam can uniquely discriminate the next failure, run diagnostic-
-amplification Plan repair and narrow Vet inline, then pause for fresh GO before
-one evidence-acquisition attempt. Without a safe seam, escalate to the next
-class or park; only a real human/risk/scope gate stops for a human.
+Past evidence being irretrievable is not by itself terminal. If an in-scope trusted seam
+uniquely discriminates the next failure, run diagnostic-amplification Plan repair
+and narrow Vet inline; pause for fresh GO before one evidence-acquisition attempt.
+Without a safe seam, escalate or park; only a real human/risk/scope gate stops for a human.
 
 <!-- workflow-artifact-adapter: {"module":"devrites-lib/reference/standards/workflow-artifacts.md","entry":"classifier returns owner-busy, exhausted, or existing hard gate","action":"escalate BLOCKED_EXHAUSTED; on WAIT_ACTIVE_OWNER run independent work and recheck; stop on exact BLOCKED_GATE result","return":"unchanged cursor plus fixed route-owned output"} -->
 ## Other stop classes
@@ -74,10 +71,9 @@ class or park; only a real human/risk/scope gate stops for a human.
 - **Clarify:** material `open`/unowned decision coverage or a
   low-confidence high-consequence assumption. Continue the initial interview;
   never arm AFK early.
-- **Seal:** remaining NO-GO after recommended-option questions are closed, with
-  every remaining blocker and fix direction. Never round up to GO. An open
-  recommended-option blocking question is not a Seal stop: resolve it, recover
-  agent-owned findings, then re-enter Seal. A first NO-GO is not a stop either:
+- **Seal:** report remaining NO-GO with every blocker/fix direction; never round
+  up to GO. Resolve recommended-option blocking questions internally; recover
+  agent-owned findings and re-enter Seal. A first NO-GO is not a stop:
   recover every agent-owned blocker (missing or unbound proof, a reviewer gap root
   can close, a finding with a fix direction, a missing `review.md` verdict), then
   re-enter Seal. The unattended `N` to accepting Important risks means repair, not
@@ -95,23 +91,26 @@ class or park; only a real human/risk/scope gate stops for a human.
 - **Resource envelope:** overlapping run or missing AFK after arm still stops.
   Do not stop on `--max-slices`, `max_agents`, `max_minutes`, or `max_review_queue`.
 - **Confidence:** intent still cannot become testable acceptance after interview.
-- **Repeated failure:** not a stop. Escalate; a fully escalated fingerprint parks,
-  and the run stops only once no independent work remains.
-- **Resolver failure:** `devrites-engine state resolve` not found, or nonzero exit.
-  Never hand-edit `questions.md`/`state.md` in its place. Not found stops at once;
-  nonzero allows one identical re-run (the fingerprint is command + exit code +
-  decisive stderr line; an unchanged re-run is not a correction, so no further
-  attempts). Then stop `blocked` with the exact command, exit code, and stderr line,
-  and resume action `/rite-doctor`.
+- **Repeated failure:** not a stop. Escalate; fully escalated fingerprints park.
+  Stop only when no independent work remains.
+- **Resolver failure:** `devrites-engine state resolve` missing or nonzero.
+  Never hand-edit `questions.md`/`state.md` instead. Missing stops immediately;
+  nonzero permits one identical re-run (fingerprint: command + exit code + decisive
+  stderr line; unchanged re-run is no correction, no further attempts). Then stop
+  `blocked`: exact command, exit code, stderr line; resume via `/rite-doctor`.
 
 ## Final GO and durable stop
 
-`--ship`/`--yolo` never authorizes Git. With a flag, complete Ship preflight,
-disclose the exact plan, and stop for literal `GO` plus native approval. Without
-one, stop at Seal GO with `/rite-ship`. Seal GO, AFK, prior approval, and flags
-never satisfy Ship approval.
+With a recorded continuation, no opt-out, and workspace budget, Seal GO stays
+internal: continue without `--ship`, leaving milestones sealed/unshipped. Only the
+final milestone, explicit `continue_sequence: false`, or exhausted sequence cap
+ends green sequence continuation.
 
-A cold-resumable stop records `state.md` status, exact reason, and one resume
-action: the human-owned action, or `/rite-autocomplete` to reopen parked
-fingerprints; the owning question/drift/seal entry explains it. The user-facing line says what stopped
-and, only when applicable, what human action resumes it.
+There, `--ship`/`--yolo` requires [Ship preflight](../../rite-ship/reference/git-ship.md#before-type-go):
+disclose exact plan; stop for fresh literal `GO` plus native approval.
+Without flags, stop at Seal GO with `/rite-ship`. Seal GO never authorizes Git
+or satisfies Ship approval; neither do AFK, prior approval, or flags.
+
+Record cold-resumable `state.md` stops: status, exact reason, one resume action
+(human-owned or `/rite-autocomplete` to reopen parked fingerprints). Explain in
+owning question/drift/seal entry. Tell user what stopped and any required human action.

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

@@ -11,9 +11,9 @@ user-invocable: true
 
 # /rite-build: one verified slice
 
-HITL stops; a later user invocation starts the next slice.
-Explicit `.devrites/AFK` alone lets the controlling root chain under green proof,
-caps and pause rules. Every wright returns after one slice.
+Active caller takes precedence per [output.md](reference/output.md#caller-owned-continuation).
+Standalone HITL stops; standalone AFK chains under green proof, caps and pause
+rules. Every wright returns after one slice.
 **HITL:** `/rite-build --parallel N` (2≤N≤10; N=1≡serial) follows
 [`reference/parallel-batch.md`](reference/parallel-batch.md)
 ([`one-slice-cycle.md`](reference/one-slice-cycle.md)).
@@ -109,10 +109,9 @@ AFK charges per landed sibling only. Running lease blocks another
 
 Run every step in `reference/phase-contract.md`: readiness, one target, dispatch
 or canonical transaction, return inspection, independent code/doubt/test analysis,
-approved fail-on-red proof, record, AFK accounting, and stop. Use
+approved fail-on-red proof, record, and applicable accounting. Continue/reply via
 [`reference/output.md`](reference/output.md) plus the shared
-[`reply contract`](../devrites-lib/reference/reply-contract.md). HITL never starts
-the next slice automatically; AFK obeys remaining budget; Prove requires every slice built except a
+[`reply contract`](../devrites-lib/reference/reply-contract.md). Standalone AFK obeys remaining budget; Prove requires every slice built except a
 [deferred slice](../rite-plan/reference/slicing.md#deferred-slice).
 
 ## Phase exit

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

@@ -2,22 +2,20 @@
 
 > Root-only: not inlined in --role bundles.
 
-AFK mode is active when `.devrites/AFK` exists. It lets `/rite-build` chain slices
-without per-slice user input. The rules below limit that unattended work.
-
-Load the shared
+`.devrites/AFK` enables unattended slice chaining. Load the shared
 [`afk-hitl.md`](../../devrites-lib/reference/standards/afk-hitl.md#the-sentinel-devritesafk)
-contract for the sentinel schema, defaults, gate ceiling, and mutable-counter
-ownership. This file owns only Build's dispatch, charging, and red-path behavior.
+for sentinel schema, defaults, gate ceiling, and mutable-counter ownership.
+This file owns Build dispatch, charging, and red paths.
 
-Rules: green before `built`; hard `max_slices` cap; gates before the action they
-control; irreversible work (destructive/auth/public API) always pauses; a tick
-never ends with an open or sealed wave — wait for its returns or
-`dispatch abandon --reason`.
+Rules: green before `built`; gates before their action; irreversible work
+(destructive/auth/public API) pauses; no tick ends with an open/sealed wave —
+wait for returns or `dispatch abandon --reason`.
 
 ## Iteration cap
 
-The controlling root owns the cap:
+Under active `/rite-autocomplete`, skip the slice-cap checks, charges, and cap-stop message below;
+use its [admission rules](../../rite-autocomplete/reference/loop.md#admit-each-unattended-cycle).
+Otherwise root owns cap:
 
 1. **Before every dispatch**, re-read `.devrites/AFK`, `state.md`, and the
    selected slice. This invocation's `--parallel N` is the cap when present;

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

@@ -10,12 +10,12 @@ Pack-wide rationalizations and red flags live in
 
 | Excuse | Rebuttal |
 |---|---|
-| "Slices 1 and 2 are related; let me do both." | HITL needs a later user invocation. Explicit `.devrites/AFK` may let the root chain only after green proof and cap/pause gates; each wright still returns after one. |
+| "Slices 1 and 2 are related; let me do both." | Caller first: [output.md](output.md#caller-owned-continuation). Standalone HITL stops; standalone AFK chains after green proof and cap/pause gates; each wright returns after one. |
 | "It's faster to skip `devrites-doubt` for this small change." | Doubt is cheapest *before* the decision is standing. After is debugging. |
 
 ## Red Flags
 
-- About to start slice N+1 outside explicit AFK or before its green-proof/cap/pause gates.
+- Next slice violates caller/standalone routing or proof/cap/pause gates.
 - Skipping `devrites-doubt` on a branching, boundary, data-model, auth, public-API, or migration decision.
 - Adding a dependency or a second design system without recording rationale in `decisions.md`.
 - Writing a `try/catch` block wider than what you handle.

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

@@ -54,11 +54,16 @@ BODY
 
 **Local-only:** never push or let scratch work trigger CI.
 
-After the commit lands, run `devrites-engine check regression <slug> --update`
-to ratchet the workspace progress baseline — the landed slice, newly checked
-acceptance criteria, and resolved questions become the new floor that later
-checks compare against. A `BLOCKED` compare before that ratchet means durable
-facts were lost this cycle; restore or route them before landing the commit.
+After green landing (parallel: successful integrate), check `state.md`
+outside fences before reselecting:
+
+```text
+- [x] SLICE-004 built — <proof/checkpoint reference>
+```
+
+A cursor `built_slices` value or a tasks.md `Status: built` field is not a substitute.
+After landing: `devrites-engine check regression <slug> --update`. Before landing,
+restore or route `BLOCKED` lost facts.
 
 ## Restore
 After a crash, a fresh session may read the last `WIP(<slug>)` body as crash context.

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

@@ -1,8 +1,8 @@
 # One-slice cycle
 
-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.
+Each wright returns after one proven slice. Root follows
+[`output.md`](output.md#caller-owned-continuation); standalone AFK uses
+`afk-discipline.md`.
 This serial cycle is the default `/rite-build`. Opt-in fan-out: [`parallel-batch.md`](parallel-batch.md) (`--parallel N`).
 
 ## The cycle
@@ -31,7 +31,9 @@ RECORD    → orchestrator: after green verification, update state.md/evidence.m
             upsert the authoritative candidate manifest from the actual scoped diff
 (CHECKPOINT) → only now, with review+proof green: local WIP(<slug>): <imperative summary>
             on the control branch (no slice id) → checkpoint.md
-NEXT      → HITL root reports and stops. AFK with parallel cap>1: return to parallel-batch selection to refill; otherwise repeat under afk-discipline.md
+NEXT → controlling caller first: return internally via output.md; no user-facing reply.
+       HITL stops. Standalone AFK with parallel cap>1:
+       return to parallel-batch selection to refill; otherwise repeat under afk-discipline.md
 ```
 
 ## Why the boundary matters

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

@@ -2,34 +2,28 @@
 
 > Root-only: not inlined in --role bundles.
 
-**Slices remain:**
+## Caller-owned continuation
 
-```text
-Done: built slice <n> — <name>.
-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 (none in `orient` `inflight_waves`); /rite-handoff if away > a few hours
-```
+Before standalone replies, return internally to active `/rite-autocomplete` or
+another controlling rite after green proof, checkpoint, and accounting:
+- Slices remain: re-read durable state and reselect/refill; no user-facing reply.
+- All built: return internally to the caller to invoke `/rite-prove` under its own contract.
+
+Human/safety/access/Git stops still use the shared reply contract.
+
+## Standalone response
 
-**All built:**
+HITL returns after one green slice; AFK chains per `afk-discipline.md`.
+Every wright returns after one slice. Build alone never invokes Prove.
 
 ```text
-Done: built slice <n> — <name>; all slices built.
+Done: built slice <n> — <name>[; all slices built].
 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
+Next: /rite-build [all built: /rite-prove]
 Record: .devrites/work/<slug>/evidence.md
-↻ Hygiene: /clear before /rite-prove; /rite-handoff if away > a few hours
+↻ Hygiene: /clear between slices (none in `orient` `inflight_waves`); /rite-handoff if away > a few hours
 ```
 
-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.
-
-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.
+Awaiting-human or stopped states use the shared reply contract.

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

@@ -147,21 +147,18 @@ Pull these via `Read` when shaping the plan:
    cross-slice boundary names producer, consumer, invariant, integration step, and proof.
    Map each applicable topology/data/integration risk to a slice, failure/recovery path,
    and discriminating proof; a risk cannot live only in the architecture narrative.
-4a. **Persist traceability natively.** The drafter proposes and root writes
+4a. **Persist traceability natively.** Drafter proposes; root writes
    `traceability.md` (`AC/REQ ID → slice → proof → evidence ID → files → status`).
-   Re-read spec, tasks, and proof fields: every ID must exist and every mapping
-   preserve meaning, not just labels. Reject orphans, inventions, and false mappings;
-   `/rite-prove` and `/rite-seal` read this file directly. Reference the plan's
-   `Shared contract proof` rows from existing slice/proof mappings; do not create a second
-   traceability system.
-5. **Complexity and deviations gate:** justify anything outside DevRites defaults (new dep,
-   extra abstraction, second design system) in the plan; if you can't justify it, simplify.
-   **Principles conformance:** read `.devrites/principles.md` (if present) and confirm the
-   approach honors every declared invariant. A plan that conflicts with one is not "a deviation
-   to justify away": either reshape the approach to conform, or, when the conflict is genuine and
-   intended, route it through the Spec Drift Guard plus a recorded decision and a scoped principle
-   exception a human approves. Never ready a plan that silently violates an invariant. (Re-scored
-   as a blocking gate at `/rite-vet`; no file → none declared → nothing to check.)
+   Re-read spec/tasks/proof: require real IDs, meaning-preserving mappings, not
+   just labels. Reject orphans/inventions/false mappings. `/rite-prove` and
+   `/rite-seal` read it directly. Reference plan `Shared contract proof` rows from
+   existing slice/proof mappings; never create a second traceability system.
+5. **Complexity and deviations gate:** justify deviations from DevRites defaults
+   (new dep, extra abstraction, second design system) in plan; else simplify.
+   **Principles conformance:** honor all `.devrites/principles.md` invariants
+   (absent → none). Reshape conflicts; intended genuine conflicts need Spec Drift
+   Guard, a recorded decision, and a human-approved scoped principle exception.
+   Never ready silent violations; `/rite-vet` re-scores this blocking gate.
 6. **Write** `architecture.md`, `plan.md`, `tasks.md`, and `traceability.md` — save the
    accepted bundle under `packets/` and apply it with `devrites-engine state
    apply-bundle <slug> <bundle.json>` before root reconciliation edits; update
@@ -169,27 +166,31 @@ Pull these via `Read` when shaping the plan:
    `flows.md` (**Mermaid-first**). If a richer reviewable visual earns it, emit
    `visual/<flow>.html` + `visual/<flow>.outline.md` after loading matching playbooks from
    [`../devrites-lib/reference/visual-playbooks/index.md`](../devrites-lib/reference/visual-playbooks/index.md)
-   (progressive; never preload all seven), link the pair from `flows.md`, treat outline as
-   SSOT (outline wins), and never require Lavish or a new phase.
-6a. **Cross-artifact gate.** Read spec, tasks, and traceability together: every
-   buildable AC/REQ maps to an existing slice/proof, every slice maps to real
-   acceptance, and names/prose agree. Missing, duplicate, contradictory, or
-   meaning-changing mappings block. Then run
+   (progressive; never preload all seven), link both from `flows.md`; outline is
+   SSOT (wins). No Lavish or new phase required.
+6a. **Cross-artifact gate.** Read spec/tasks/traceability together: each buildable
+   AC/REQ maps to existing slice/proof; each slice maps to real acceptance;
+   names/prose agree. Missing, duplicate, contradictory, or meaning-changing
+   mappings block. Run
    `devrites-engine check task-graph <slug> --strict`; a malformed dependency graph, or a
    shared path written by `hubAdvisoryMin`+ slices with no `Serial rationale:`, blocks
-   before Vet rather than spending a reviewer context on invalid tasks. Resolve each
+   before Vet; no reviewer context for invalid tasks. Resolve each
    `ADVISORY size:`/`hub:`/`chain:` line now (split or seam slice, or a rationale);
    `--strict` refuses the contended plan, the default run only advises.
 7. **Readiness gate** (`plan-template.md`): require CLEAR coverage; complete acceptance,
    wiring, shared-contract proof, applicable outputs, and rollback; risk-first acyclic order;
    justified deviations; and every horizon item present, with blockers resolved, planning
    items resolved/validly spiked, and local/action entries bounded and owned.
-   **Stop and confirm** before code. Render the review-before-code
-   digest first: `Intent` (one sentence from the spec), `Done means` (acceptance coverage x/y),
-   `Plan sanity` (slice count + riskiest boundary/gate), `Expected build interruptions`
-   (`none` or only justified action-time gates), and `Build exactly this?` (yes → approve;
-   no → `/rite-plan revise`). When the human confirms the plan, write `Plan approved: <iso>` to
-   `state.md` (see [state-workspace](../rite-spec/reference/state-workspace.md)).
+   **Standalone: stop and confirm** before code. Render digest: `Intent` (one
+   spec sentence), `Done means` (AC coverage x/y), `Plan sanity` (slice count +
+   riskiest boundary/gate), `Expected build interruptions` (`none` or justified
+   action-time gates), `Build exactly this?` (yes → approve; no → `/rite-plan revise`).
+   Human confirmation writes `Plan approved: <iso>` to `state.md`
+   ([state-workspace](../rite-spec/reference/state-workspace.md)).
+   Under active `/rite-autocomplete`, once this readiness gate is green and no
+   unresolved human-owned decision, irreversible-risk, scope, or access gate remains,
+   root writes autonomous approval to existing `Plan approved: <iso>` cursor and records Autocomplete provenance and rationale in `decisions.md`;
+   never claim human approval. Return internally for `/rite-vet`. Plan approval grants no protected-path, Git, or safety authority.
 
 ## tasks.md slice format
 

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

@@ -170,8 +170,13 @@ Before classifying any Reslice, read `.claude/skills/devrites-lib/reference/stan
    the previous vet verdict: set `Phase: plan`, `Next step: /rite-vet`, and, when
    `eng-review.md` exists, set `Implementation readiness: NEEDS REPLAN`. Never retain READY
    across changed planning inputs. Preserve `Plan approved` only for behavior/acceptance-neutral
-   technical repair; clear it for a contract-changing or newly blocking horizon item and
-   reconfirm only after Clarify and Vet close it. If you stopped for drift,
+   technical repair; clear it for a contract-changing or newly blocking horizon item.
+   Settle human decisions and restore current `CLEAR` coverage through Clarify,
+   then obtain renewed Plan approval BEFORE Vet using only
+   [`rite-define`'s readiness/approval rule](../rite-define/SKILL.md), not its initial
+   decomposition. Under active Autocomplete, retain that rule's explicit autonomous
+   provenance in `decisions.md` — never claim human approval. Approval grants no
+   protected-path, Git, or safety authority. If you stopped for drift,
    mark the `drift.md` entry resolved. Never remove or overwrite a valid caller
    return cursor while writing the Plan checkpoint.
 6. After editing `brief.md`, `spec.md`, `decisions.md`, `assumptions.md`, or `questions.md`,