devrites 7.0.17 → 7.1.1

package/pack/generated/omp/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/omp/skills/rite-build/reference/parallel-batch.md

@@ -37,13 +37,15 @@ Select **greedily in plan order** with
 reads the ready set (tasks.md dependencies checked `built` in `state.md`, minus
 running-lease slices) and each slice's Writer allowlist (else `Files likely
 touched`), plus its manifest/lockfile when `External dependencies:` is not none;
-in Build, `next` prints the same `eligible_now:`/`batch:`. `N_eff ≥ 2` → parallel batch;
-`N_eff = 1` → one serial round; nothing pending → Prove. A cap that cannot be filled
-is normal: take fewer. Serial is this round's size, not the rest of the run.
+`next` prints `eligible_now:`/`batch:`. `n_eff` counts new picks only.
+With a running lease, a single new pick still uses `parallel add`;
+`n_eff=0` with a running lease waits for siblings, not Prove. Without one:
+≥2 → parallel batch, 1 → serial, none pending → Prove.
+Serial is this round only; a cap need not be filled.
 
 **Refill per landing; never wait for the batch.** Each sibling lands alone when
-green ([Lifecycle](#lifecycle) step 6). Then re-read `state.md`, pending slices, and
-the tree and run `parallel select --slug <slug> --cap N --from-plan`: unlanded siblings hold
+green ([Lifecycle](#lifecycle) step 6). Re-read state, pending slices, and the
+tree; reselect: unlanded siblings hold
 their slots and paths, landed ones count as built, and only new picks print;
 `parallel add` starts each from the control tip and its wright dispatches at once.
 No lease → plain `select` + `create`. AFK/autocomplete is one run; HITL stops after
@@ -116,6 +118,10 @@ Lease: `batch_id`, `created_at`, `base_sha`, `n`,
    full inventory, then bounded owning-role rechecks after repairs. Run approved
    proof in the same window as that review. Gap or Critical/Important → `gap`;
    else proof → `green|red|gap`.
+
+   A recheck round is one dispatch per changed surface, not one per checklist: the
+   recheck agent carries every open checklist (code, test, doubt) for that diff and
+   answers each by name. Merging cuts dispatches; dropping a checklist does not.
    Reviewer fan-out for a batch is itself batched under
    [`parallel-dispatch.md`](skill://devrites-lib/reference/parallel-dispatch.md#scale-limits)
    (≈4 concurrent read-only reviewers, 8 only with disjoint paths), and `max_agents`
@@ -137,11 +143,11 @@ Lease: `batch_id`, `created_at`, `base_sha`, `n`,
 7. Each landing: FF control (the branch that held `HEAD` when the batch started —
    often `main`/`master`, otherwise whatever the user was on) by one local commit,
    never pushed; union that sibling's paths into `touched-files.md`; update
-   state/evidence; AFK +1 for that sibling; optional `check candidate`. Then
-   refill ([Dynamic selection](#dynamic-selection-and-re-batching)) and start the
-   feature gates on control
-   ([Proof tiers](phase-contract.md#proof-tiers)); the next landing waits for them
-   to pass, the refilled wrights do not.
+   state/evidence; AFK +1; optional `check candidate`. Land every green sibling,
+   refill ([Dynamic selection](#dynamic-selection-and-re-batching)), then run the
+   feature gates once for the train
+   ([Proof tiers](phase-contract.md#proof-tiers)); the next train waits, the
+   refilled wrights do not.
 8. Cleanup runs only after the last landing marks the lease `complete` — work
    landed in control, so `parallel cleanup` removes worktrees/branches.
    Blocked/human-stopped batches keep lease, worktrees, branches — nothing is
@@ -223,13 +229,13 @@ devrites-engine parallel lease-write|lease-read|lease-clear --root <repo> --slug
 #   parallel cleanup --root <repo> --slug <slug> --force   (salvages, prints retained refs)
 ```
 
-`integrate` without `--apply-to-control` stages the per-sibling commits, leaves
-the lease `running` and control at `B`; cleanup still refuses — the commits
-cannot be lost. `record-green` and `integrate` also accept an `integrate-failed`
-lease, so a failed integrate retries after repair. `--apply-to-control`
-refuses when control moved past `B` or holds uncommitted changes on slice
-paths — stop for the human (never stash or commit their work); the batch is
-untouched. Go is SSOT; never ad-hoc git/bash orchestration.
+`integrate` without `--apply-to-control` stages commits; lease stays `running`,
+control stays at its expected tip, cleanup refuses. `record-green` and `integrate`
+accept `integrate-failed` for retry. Applied landings advance `control_tip`
+(initially `B`), permitting landings/refill. External control movement or
+uncommitted slice-path edits with `--apply-to-control` cause refusal:
+stop for the human (never stash or commit their work); the batch is untouched.
+Go is SSOT; never ad-hoc git/bash orchestration.
 
 ## Runtime isolation
 

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

@@ -73,13 +73,25 @@ One contract builds one slice: preserve TDD, exact paths and independent judgmen
 ## Proof tiers
 
 With a `test-plan.md` `## Feature gates` section, step 6 runs `Tests/proof` and every
-other row; feature gates run once per parallel landing, on control, while worktree
-wrights continue. The next landing and Prove wait for them; red is a fingerprint
-against slices landed since the last green run. Serial same-worktree mode, and plans
+other row; feature gates run once per landing train, on control, while worktree
+wrights continue: land every green sibling together, run the suite once, and bisect only
+on red. The next train and Prove wait for them; red is a fingerprint against slices
+landed since the last green run. Serial same-worktree mode, and plans
 without the section, run every row each round. Run gate, benchmark and proof commands
 through the host's shell tool, never a code-evaluation subprocess, whose environment
 can lack the owner's exported variables.
 
+Wrights run only the tests their changed paths reach, resolved from the merge base
+against the plan's baseline rather than the last commit; Prove and Seal always run the
+full suite. Resolve that narrow set with
+`devrites-engine check affected <changed path...>`, which expands a changed package to its
+dependent packages and widens on its own when a path is a module manifest, a generated
+artifact, CI config, shared testdata, or one it cannot classify. Widen to the full suite
+inside Build the moment a slice touches `go.mod` or a
+lockfile, generated artifacts, CI config, a shared test harness, or whenever no test can
+be named for a changed path. When selection is uncertain, run the full suite: the narrow
+set is an optimisation, never a substitute.
+
 ## Independent Build review
 
 After inspection, freeze full slice scope and cumulative baseline diff with

package/pack/generated/omp/skills/rite-define/SKILL.md

@@ -175,9 +175,11 @@ Pull these via `Read` when shaping the plan:
    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
-   `devrites-engine check task-graph <slug>`; a malformed dependency graph blocks
+   `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
-   `ADVISORY size:`/`hub:` line now (split or seam slice, or a rationale); never blocking.
+   `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

package/pack/generated/omp/skills/rite-plan/reference/slicing.md

@@ -172,8 +172,12 @@ cannot name what crosses, drop the edge; a shallow, wide graph runs in parallel.
 
 Slices sharing a file never build side by side: put a hub file's shared edit
 (registry, command table, test harness) in one seam slice the others depend on.
-`check task-graph` prints the `schedule:` and `ADVISORY hub:` lines; inseparable
-writes get `Serial rationale: <why>`. Never merge slices or drop acceptance to widen it.
+`check task-graph` prints the `schedule:`, `ADVISORY hub:` and `ADVISORY chain:` lines.
+A `chain` line means only one slice was ever ready, so the DAG rather than the cap
+serializes: cut a slice that stands alone, or record `Serial rationale: <why>`.
+`check task-graph <slug> --strict` refuses a plan whose shared path carries `ADVISORY hub:`
+writers, so a contended plan must split disjointly instead of widening the cap.
+Never merge slices or drop acceptance to widen it.
 
 ## Deferred slice
 A slice with `Satisfies: none` is an optional follow-up: plan-invented hardening or

package/pack/generated/pi/agents/devrites-upgrade-planner.md

@@ -23,7 +23,8 @@ Read named paths only. Accept released v1/v2 bullet or v3 table `state.md` under
 `.devrites/work/<slug>/`. Reject aliases, release scripts/markers, and conversion.
 
 Cite current rule plus workspace evidence for each applicable axis: cursor/topology,
-phase artifacts, decisions, planning/traceability/proof, built-code/intent, protected
+phase artifacts, decisions, planning/traceability/proof (including a `check task-graph`
+`ADVISORY chain:` schedule that no parallel cap can widen), built-code/intent, protected
 history, artifact budgets/feature ceiling (the supplied `devrites-engine orient`
 `artifact_budgets`/`bulk_files` and `task_graph.slice_count` against
 [`workspace-artifact-schema.md`](../skills/devrites-lib/reference/workspace-artifact-schema.md) and [`slicing.md`](../skills/rite-plan/reference/slicing.md) § Feature ceiling),

package/pack/generated/pi/skills/rite-autocomplete/SKILL.md

@@ -118,13 +118,13 @@ next sequence continuation through Vet in a second session, then stop.
    `/rite-build` batch loop → `/rite-prove` → `/rite-polish` →
    `/rite-review` → `/rite-seal`. Read and execute each skill; durable files, not
    chat, carry state. Apply the mutable post-vet budget before first Build.
-   Build runs the path-disjoint batch `parallel select --from-plan` picks (cap: this invocation's
-   `--parallel N`, else sentinel `max_parallel`, else 10) and refills a slot
-   per landing until no pending slice remains; a one-slice round is serial for that round only, then
-   selection runs again (host isolation still forces serial when concurrent writers
-   cannot be separated). When `--parallel N`
-   is present, pass it into `/rite-build` and do not consult leftover sentinel
-   `max_parallel`.
+   Build uses `parallel select --from-plan` (cap: explicit `--parallel N`, else
+   sentinel `max_parallel`, else 10), refilling per landing until none pending;
+   a one-slice round is serial for that round only; reselect afterward. Host
+   isolation may force serial. If `--parallel N` is explicit,
+   pass it into `/rite-build` and ignore leftover sentinel `max_parallel`.
+   Otherwise pass the resolved sentinel/default cap into `/rite-build` as
+   `--parallel N`, never bare `/rite-build`.
    **Completion:** loop reaches Seal GO or persists a valid stop before any later phase.
 5. **Apply stops.** At every gate use
    [stop-conditions.md](reference/stop-conditions.md). A `blocked` label alone is not a stop condition:

package/pack/generated/pi/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/pi/skills/rite-build/SKILL.md

@@ -11,10 +11,10 @@ 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.
-**Opt-in:** `/rite-build --parallel N` (2≤N≤10; N=1≡serial) follows
+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)).
 
@@ -45,8 +45,8 @@ Wright applies anti-slop; root verifies returns and never patches source. Refuse
 
 ## Invariants
 
-- Default: one slice; writers serial on control (core.md #5). Parallel only via
-  `--parallel N` under [`reference/parallel-batch.md`](reference/parallel-batch.md).
+- Standalone HITL default: serial on control (core.md #5). AFK/`--parallel N`
+  uses [`parallel-batch.md`](reference/parallel-batch.md).
   Same-worktree multi-writer / root-emulated concurrency forbidden.
   Native-worktree pilot = single-slice isolation when `wright-dispatch.md`
   preflight + reconcile hold.
@@ -80,7 +80,8 @@ Wright applies anti-slop; root verifies returns and never patches source. Refuse
 <!-- workflow-artifact-adapter: {"module":"devrites-lib/reference/standards/workflow-artifacts.md","entry":"Vet-ready admitted bytes require root authorship outside product wright","action":"ROOT_TRANSACTION; root writes only admitted .devrites/** targets","return":"saved Build slice cursor; wright product allowlist unchanged"} -->
 ## `--parallel N` (opt-in)
 
-Omitted/`1` ≡ serial; `2`–`10` is a **cap** — the root runs the largest eligible
+HITL default/explicit `1` ≡ serial; AFK inherits cap.
+`2`–`10` is a **cap** — the root runs an eligible
 path-disjoint set it can start now (`N_eff`, from `parallel select --from-plan`), takes fewer when the cap cannot be
 filled, and refills a slot per landing (serial slice or one sibling) until
 no pending slice remains
@@ -108,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/pi/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/pi/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/pi/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/pi/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/pi/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/pi/skills/rite-build/reference/parallel-batch.md

@@ -37,13 +37,15 @@ Select **greedily in plan order** with
 reads the ready set (tasks.md dependencies checked `built` in `state.md`, minus
 running-lease slices) and each slice's Writer allowlist (else `Files likely
 touched`), plus its manifest/lockfile when `External dependencies:` is not none;
-in Build, `next` prints the same `eligible_now:`/`batch:`. `N_eff ≥ 2` → parallel batch;
-`N_eff = 1` → one serial round; nothing pending → Prove. A cap that cannot be filled
-is normal: take fewer. Serial is this round's size, not the rest of the run.
+`next` prints `eligible_now:`/`batch:`. `n_eff` counts new picks only.
+With a running lease, a single new pick still uses `parallel add`;
+`n_eff=0` with a running lease waits for siblings, not Prove. Without one:
+≥2 → parallel batch, 1 → serial, none pending → Prove.
+Serial is this round only; a cap need not be filled.
 
 **Refill per landing; never wait for the batch.** Each sibling lands alone when
-green ([Lifecycle](#lifecycle) step 6). Then re-read `state.md`, pending slices, and
-the tree and run `parallel select --slug <slug> --cap N --from-plan`: unlanded siblings hold
+green ([Lifecycle](#lifecycle) step 6). Re-read state, pending slices, and the
+tree; reselect: unlanded siblings hold
 their slots and paths, landed ones count as built, and only new picks print;
 `parallel add` starts each from the control tip and its wright dispatches at once.
 No lease → plain `select` + `create`. AFK/autocomplete is one run; HITL stops after
@@ -116,6 +118,10 @@ Lease: `batch_id`, `created_at`, `base_sha`, `n`,
    full inventory, then bounded owning-role rechecks after repairs. Run approved
    proof in the same window as that review. Gap or Critical/Important → `gap`;
    else proof → `green|red|gap`.
+
+   A recheck round is one dispatch per changed surface, not one per checklist: the
+   recheck agent carries every open checklist (code, test, doubt) for that diff and
+   answers each by name. Merging cuts dispatches; dropping a checklist does not.
    Reviewer fan-out for a batch is itself batched under
    [`parallel-dispatch.md`](../../devrites-lib/reference/parallel-dispatch.md#scale-limits)
    (≈4 concurrent read-only reviewers, 8 only with disjoint paths), and `max_agents`
@@ -137,11 +143,11 @@ Lease: `batch_id`, `created_at`, `base_sha`, `n`,
 7. Each landing: FF control (the branch that held `HEAD` when the batch started —
    often `main`/`master`, otherwise whatever the user was on) by one local commit,
    never pushed; union that sibling's paths into `touched-files.md`; update
-   state/evidence; AFK +1 for that sibling; optional `check candidate`. Then
-   refill ([Dynamic selection](#dynamic-selection-and-re-batching)) and start the
-   feature gates on control
-   ([Proof tiers](phase-contract.md#proof-tiers)); the next landing waits for them
-   to pass, the refilled wrights do not.
+   state/evidence; AFK +1; optional `check candidate`. Land every green sibling,
+   refill ([Dynamic selection](#dynamic-selection-and-re-batching)), then run the
+   feature gates once for the train
+   ([Proof tiers](phase-contract.md#proof-tiers)); the next train waits, the
+   refilled wrights do not.
 8. Cleanup runs only after the last landing marks the lease `complete` — work
    landed in control, so `parallel cleanup` removes worktrees/branches.
    Blocked/human-stopped batches keep lease, worktrees, branches — nothing is
@@ -223,13 +229,13 @@ devrites-engine parallel lease-write|lease-read|lease-clear --root <repo> --slug
 #   parallel cleanup --root <repo> --slug <slug> --force   (salvages, prints retained refs)
 ```
 
-`integrate` without `--apply-to-control` stages the per-sibling commits, leaves
-the lease `running` and control at `B`; cleanup still refuses — the commits
-cannot be lost. `record-green` and `integrate` also accept an `integrate-failed`
-lease, so a failed integrate retries after repair. `--apply-to-control`
-refuses when control moved past `B` or holds uncommitted changes on slice
-paths — stop for the human (never stash or commit their work); the batch is
-untouched. Go is SSOT; never ad-hoc git/bash orchestration.
+`integrate` without `--apply-to-control` stages commits; lease stays `running`,
+control stays at its expected tip, cleanup refuses. `record-green` and `integrate`
+accept `integrate-failed` for retry. Applied landings advance `control_tip`
+(initially `B`), permitting landings/refill. External control movement or
+uncommitted slice-path edits with `--apply-to-control` cause refusal:
+stop for the human (never stash or commit their work); the batch is untouched.
+Go is SSOT; never ad-hoc git/bash orchestration.
 
 ## Runtime isolation
 

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

@@ -73,13 +73,25 @@ One contract builds one slice: preserve TDD, exact paths and independent judgmen
 ## Proof tiers
 
 With a `test-plan.md` `## Feature gates` section, step 6 runs `Tests/proof` and every
-other row; feature gates run once per parallel landing, on control, while worktree
-wrights continue. The next landing and Prove wait for them; red is a fingerprint
-against slices landed since the last green run. Serial same-worktree mode, and plans
+other row; feature gates run once per landing train, on control, while worktree
+wrights continue: land every green sibling together, run the suite once, and bisect only
+on red. The next train and Prove wait for them; red is a fingerprint against slices
+landed since the last green run. Serial same-worktree mode, and plans
 without the section, run every row each round. Run gate, benchmark and proof commands
 through the host's shell tool, never a code-evaluation subprocess, whose environment
 can lack the owner's exported variables.
 
+Wrights run only the tests their changed paths reach, resolved from the merge base
+against the plan's baseline rather than the last commit; Prove and Seal always run the
+full suite. Resolve that narrow set with
+`devrites-engine check affected <changed path...>`, which expands a changed package to its
+dependent packages and widens on its own when a path is a module manifest, a generated
+artifact, CI config, shared testdata, or one it cannot classify. Widen to the full suite
+inside Build the moment a slice touches `go.mod` or a
+lockfile, generated artifacts, CI config, a shared test harness, or whenever no test can
+be named for a changed path. When selection is uncertain, run the full suite: the narrow
+set is an optimisation, never a substitute.
+
 ## Independent Build review
 
 After inspection, freeze full slice scope and cumulative baseline diff with

package/pack/generated/pi/skills/rite-define/SKILL.md

@@ -175,9 +175,11 @@ Pull these via `Read` when shaping the plan:
    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
-   `devrites-engine check task-graph <slug>`; a malformed dependency graph blocks
+   `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
-   `ADVISORY size:`/`hub:` line now (split or seam slice, or a rationale); never blocking.
+   `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

package/pack/generated/pi/skills/rite-plan/reference/slicing.md

@@ -172,8 +172,12 @@ cannot name what crosses, drop the edge; a shallow, wide graph runs in parallel.
 
 Slices sharing a file never build side by side: put a hub file's shared edit
 (registry, command table, test harness) in one seam slice the others depend on.
-`check task-graph` prints the `schedule:` and `ADVISORY hub:` lines; inseparable
-writes get `Serial rationale: <why>`. Never merge slices or drop acceptance to widen it.
+`check task-graph` prints the `schedule:`, `ADVISORY hub:` and `ADVISORY chain:` lines.
+A `chain` line means only one slice was ever ready, so the DAG rather than the cap
+serializes: cut a slice that stands alone, or record `Serial rationale: <why>`.
+`check task-graph <slug> --strict` refuses a plan whose shared path carries `ADVISORY hub:`
+writers, so a contended plan must split disjointly instead of widening the cap.
+Never merge slices or drop acceptance to widen it.
 
 ## Deferred slice
 A slice with `Satisfies: none` is an optional follow-up: plan-invented hardening or

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "devrites",
-  "version": "7.0.17",
+  "version": "7.1.1",
   "description": "DevRites: a disciplined senior-engineer workflow pack for Claude Code, Codex, omp, pi, and Devin CLI",
   "license": "SEE LICENSE IN LICENSE",
   "homepage": "https://github.com/ViktorsBaikers/DevRites#readme",