devrites 7.1.0 → 7.1.1

package/CHANGELOG.md

@@ -2,6 +2,12 @@
 
 All notable changes to DevRites are documented here. The format follows [Keep a Changelog](https://keepachangelog.com/en/1.1.0/) and DevRites adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html). Releases are generated automatically by [semantic-release](https://semantic-release.gitbook.io/) from Conventional Commits on `main`.
 
+## [7.1.1](https://github.com/ViktorsBaikers/DevRites/compare/v7.1.0...v7.1.1) (2026-10-28)
+
+### Fixed
+
+* **skills:** preserve autocomplete continuation ([#180](https://github.com/ViktorsBaikers/DevRites/issues/180)) ([5d685e8](https://github.com/ViktorsBaikers/DevRites/commit/5d685e85e21c59acee2ac8903f5cc584772ad937))
+
 ## [7.1.0](https://github.com/ViktorsBaikers/DevRites/compare/v7.0.17...v7.1.0) (2026-10-28)
 
 ### Added

package/README.md

@@ -31,7 +31,7 @@ history can't lose it. After you clear the conversation, switch hosts, or hand
 the feature to another engineer, the next session reads the same plan,
 decisions, and evidence before it continues.
 
-**Status:** [`v7.1.0`](https://github.com/ViktorsBaikers/DevRites/releases/tag/v7.1.0): see [`CHANGELOG.md`](CHANGELOG.md) for release notes.
+**Status:** [`v7.1.1`](https://github.com/ViktorsBaikers/DevRites/releases/tag/v7.1.1): see [`CHANGELOG.md`](CHANGELOG.md) for release notes.
 
 This is the latest published release; `main` may contain unreleased work.
 

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

@@ -44,15 +44,14 @@ 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`).
+[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
 
@@ -65,7 +64,7 @@ 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 |

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/generated/claude/skills/rite-autocomplete/reference/loop.md

@@ -46,15 +46,14 @@ 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`).
+[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
 
@@ -67,7 +66,7 @@ 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 |

package/pack/generated/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/generated/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/generated/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/generated/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/generated/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/generated/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/generated/codex/skills/rite-autocomplete/reference/loop.md

@@ -46,15 +46,14 @@ 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`).
+[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
 
@@ -67,7 +66,7 @@ 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 |

package/pack/generated/codex/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/generated/codex/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/generated/codex/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/generated/codex/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/generated/codex/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