devrites 6.1.1 → 6.1.2

package/pack/generated/codex/skills/rite-build/reference/parallel-batch.md

@@ -36,14 +36,14 @@ Select **greedily in plan order**: pass every currently dependency-ready pending
 `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.
 
-**Re-batch automatically after every completed round** (parallel integrate+cleanup or
-a serial slice). Re-read `state.md`, pending slices, and the tree, then run
-`parallel select` again: finished work leaves the pending set, and satisfied
-dependencies unlock new slices. Under `.devrites/AFK` and `$rite-autocomplete` the
-repeat is the same run — HITL stops after each batch. `--parallel 5` with one eligible
-slice runs that one; when two to five then become eligible, the next round takes that
-many. **Failing case:** the run stays one-by-one after a serial round even though more
-slices are now eligible under the same cap.
+**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 --cap N --slug <slug>`: 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
+each landing. **Failing case:** three siblings are green, one is repairing, and no
+new slice starts.
 
 ## Path-disjoint
 
@@ -109,22 +109,27 @@ Lease: `batch_id`, `created_at`, `base_sha`, `n`,
    headroom bounds the batch size — one batch never assumes unbounded reviewers.
 5. Non-green siblings → **repair round** (below) in the same worktrees; lease
    stays `running` — no abort while repair budget remains. A green sibling →
-   `parallel record-green`. No partial integrate. All green → integrate.
+   `parallel record-green`, then step 6 for it alone.
    A recoverable RED blocks integration but does not cancel independent safe running siblings.
    Expected test-first RED is not a terminal gate failure. Cancel only for a shared
    invalid foundation, safety/access failure, resource boundary, or explicit stop;
    preserve completed and in-progress recoverable work and classify each result.
-6. `parallel integrate --apply-to-control` **only after steps 4–5 are green**:
-   each `transfer_commit` descends from `B` and diffs path-exact vs
-   `B`; apply each in plan order as its own local `WIP(<slug>):` commit
-   (imperative summary, never a slice id). Staging branch, then FF. Conflict →
-   reset to `B`, `integrate-failed`; classify under repair rounds (siblings stay
-   in place). Never integrate because a wright returned.
-7. Success: FF control (the branch that held `HEAD` when the batch started —
-   often `main`/`master`, otherwise whatever the user was on) to the integrate
-   tip: N local commits, never pushed; union `touched-files.md`; update
-   state/evidence; AFK +1 per integrated sibling; optional `check candidate`.
-8. Cleanup runs only after `integrate` marks the lease `complete` — work
+6. `parallel integrate --slice <id> --apply-to-control` **only after its steps
+   4–5 are green**: `transfer_commit` descends from the sibling's base and diffs
+   path-exact vs it; apply as its own local `WIP(<slug>):` commit
+   (imperative summary, never a slice id). Staging branch, then FF; the engine
+   refuses (never rewinds) if anything but this lease moved control. Conflict →
+   `integrate-failed`; classify under repair rounds (siblings stay in place).
+   Never integrate because a wright returned.
+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.
+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
    removed while the batch may resume. `parallel abort` + `cleanup --force`
@@ -191,9 +196,11 @@ Repair rejected work in place; never discard/rebuild while budget remains.
 ## Engine verbs
 
 ```text
-devrites-engine parallel select --cap <1-10> [--root <dir>] [<json-file>|-]
+devrites-engine parallel select --cap <1-10> [--root <dir>] [--slug <slug>] [<json-file>|-]
 devrites-engine parallel create --root <repo> --slug <slug> --batch <id> --base <B> --json <file>|-
+devrites-engine parallel add --root <repo> --slug <slug> --json <file>|-
 devrites-engine parallel record-green --root <repo> --slug <slug> --slice <id> --commit <sha>
+devrites-engine parallel integrate --root <repo> --slug <slug> --slice <id> --apply-to-control
 devrites-engine parallel integrate --root <repo> --slug <slug> --apply-to-control
 devrites-engine parallel status --root <repo> --slug <slug>
 devrites-engine parallel lease-write|lease-read|lease-clear --root <repo> --slug <slug>

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

@@ -42,7 +42,8 @@ Spec Drift Guard still applies.
 6. **Prove.** Against the frozen pre-slice candidate inspect
    test hunks for deletion, skipping/focus, tautology, or weaker expectations.
    Wait for step 5's exact test-analyst account; missing/adverse criterion verdict is
-   Critical. Run only `test-plan.md` repository/CI commands, record output, recheck
+   Critical. Run only `test-plan.md` repository/CI commands ([tier](#proof-tiers)),
+   record output, recheck
    `git diff --name-only`. Missing/weakened/red/source-mutating proof cannot pass.
    Pre-existing/environment-specific claims need a predating same-command,
    same-environment baseline; otherwise unresolved.
@@ -67,6 +68,14 @@ Spec Drift Guard still applies.
 
 One contract builds one slice: preserve TDD, exact paths and independent judgment.
 
+## 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
+without the section, run every row each round.
+
 ## Independent Build review
 
 After inspection, freeze full slice scope and cumulative baseline diff. Initial

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

@@ -82,5 +82,6 @@ The detecting phase owns backtracking and the batch sweep. Save
 `return_phase`/`return_next_action`; consume nested Plan/Vet `STOP` internally, complete
 vetted acceptance-preserving remediation, then restore the cursor and failed step.
 Never hand the human an intermediate command. The shared three-attempt causal-fingerprint
-cap still applies: exhaustion produces one technical blocker, while a genuinely
-human-owned decision uses the question format below.
+cap still applies: a spent strategy escalates and a fully escalated fingerprint parks
+under the [retry contract](../../devrites-lib/reference/standards/afk-hitl.md#retry-cap-no-progress-loops-and-self-resolve),
+while a genuinely human-owned decision uses the question format below.

package/pack/generated/codex/skills/rite-build/reference/wright-dispatch.md

@@ -144,8 +144,8 @@ TTL is crash recovery, not normal cleanup.
    **Do not land on control until review and proof are both green.** Isolated
    `transfer_commit` stays on the worker branch; same-worktree diffs stay
    uncommitted. Serial: [`checkpoint.md`](checkpoint.md), then host may remove the
-   worktree. Parallel: `record-green` only; land with `parallel integrate
-   --apply-to-control` after the batch; `parallel cleanup` removes worktrees.
+   worktree. Parallel: `record-green`, then `parallel integrate
+   --slice <id> --apply-to-control`; `parallel cleanup` removes worktrees.
 5. Reconcile returned reuse, conventions, principles, sources, assumptions,
    decisions, dead ends, follow-ups, gates, and touched files. Persist the
    relevant facts in canonical artifacts, not the wholesale report. A plan-gap

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

@@ -161,7 +161,7 @@ Pull these via `Read` when shaping the plan:
    meaning-changing mappings block. Then run
    `devrites-engine check task-graph <slug>`; a malformed dependency graph blocks
    before Vet rather than spending a reviewer context on invalid tasks. Resolve each
-   `ADVISORY size:` line now (split, or `Size rationale:`); it never blocks.
+   `ADVISORY size:`/`hub:` line now (split or seam slice, or a rationale); never blocking.
 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/codex/skills/rite-handoff/SKILL.md

@@ -74,7 +74,7 @@ themselves. The workspace is the canonical store; the handoff is the chat-only d
 6. **In-flight work.** Every dispatch wave opened or sealed without a return (`devrites-engine
    dispatch <slug> status`), running writer handle, held claim id plus paths (`devrites-engine
    claim list --all`), and consumptive action started, each `terminal: yes|unknown` (`yes` only with
-   an admitted return, release, or proof of stop). The live handle exists only in chat. Any
+   an admitted return, release, `dead` claim, or proof of stop). The live handle exists only in chat. Any
    `unknown` row makes item 1 a reconcile step (`dispatch <slug> status`, `parallel status`,
    `claim list --all`), never a writer command: otherwise the next session dispatches a second writer.
 7. **How to resume:** fixed boilerplate (see template below).

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

@@ -168,3 +168,8 @@ Order by dependency, but minimize coupling. A slice that needs three other slice
 is a smell: look for a thinner cut that stands alone. An edge exists only when this slice
 reads something the other produces: write it as `SLICE-001 (via <interface>)`. If you
 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.

package/pack/generated/codex/skills/rite-vet/reference/artifacts.md

@@ -103,6 +103,14 @@ From $rite-vet on <iso>. Runner + conventions: <detected framework + command>.
 Link any disposable parser fixture. Preflight values are planning evidence, not post-build proof;
 Prove recaptures the observed command, candidate identity, and result.
 
+## Feature gates
+| Gate | Command | Cwd | Expected |
+|---|---|---|---|
+| <full suite / workspace lint / audit> | <exact command> | <path> | <exit/output> |
+
+Whole-repository rows only: Build runs them per landing
+([tiers](../../rite-build/reference/phase-contract.md#proof-tiers)), Prove on the final candidate.
+
 Commands in this durable artifact are portable repository commands: no RTK or local shell
 aliases, user-specific absolute paths, or temporary proof trees. Evidence records
 the command actually executed.

package/pack/generated/codex/skills/rite-vet/reference/review-axes.md

@@ -30,7 +30,7 @@ Before implementation review, check for work beyond the settled spec.
    (over-budget `tasks.md`/`plan.md` from slice or AC count) is a scope finding, not a
    `Budget override`: route to `$rite-plan course-correct` (`MVP cut`) with the
    continuation sequence named; do not vet the whole epic. An `ADVISORY size:`
-   slice without `Size rationale:` is a non-blocking Suggestion to split it.
+   or `hub:` line without its rationale is a non-blocking Suggestion to split or seam it.
 4. **Built-in check.** For each new pattern/infra/concurrency approach, invoke
    `devrites-source-driven` inline to verify current framework/runtime support and cite it. Custom
    work where a built-in suffices is a scope-reduction finding.

package/pack/generated/devin/agents/devrites-plan-drafter.md

@@ -24,7 +24,8 @@ seams supplied by the orchestrator.
   planning artifacts while preserving settled intent.
 
 Reuse existing seams and dependencies before proposing new ones. Build vertical
-slices in dependency order. Map every REQ and AC to a slice and executable proof,
+slices in dependency order; put a hub file's shared edit in one seam slice
+([slicing.md](../skills/rite-plan/reference/slicing.md#slice-independence)). Map every REQ and AC to a slice and executable proof,
 name rollback and failure paths; keep acceptance-changing proposals separate. Durable
 proof commands must be portable repository commands, never host-local wrappers,
 user-specific absolute paths, or temporary proof trees.

package/pack/generated/devin/agents/devrites-slice-wright.md

@@ -108,7 +108,8 @@ unclear boundary is underspecified: return `Escalation` without proceeding.
      that source in the result. Never invent an API.
    - **No process residue.** Do not put `SLICE-###`, slice numbers, or "this slice"
      in product source, tests, comments, or filenames.
-4. **VERIFY (fail-on-red).** Run writer-safe tests/types/lint. Report required
+4. **VERIFY (fail-on-red).** Run writer-safe tests/types/lint: `Tests/proof` plus
+   tests of changed code; `## Feature gates` rows are root-owned. Report required
    build/browser/E2E as `not-run` (root-owned, artifact-producing gates), and only
    when the exact command, cwd, and prerequisites already appear in the unchanged
    vetted `test-plan.md`; never synthesize or rewrite a root command. Root runs

package/pack/generated/devin/skills/devrites-lib/reference/parallel-dispatch.md

@@ -127,7 +127,8 @@ child's handle, path/resource ownership and capacity reservation until the
 native host confirms a terminal state and returned work has been reconciled.
 Query or wait on that handle; do not replace the child, release its slot, or
 reuse its resources while it may still run. If terminal state cannot be
-established, record a gap and retain ownership. A result classification alone
+established, record a gap and retain ownership; for a child launched by an earlier
+session, the claim proof below settles it. A result classification alone
 does not prove host termination.
 
 On resume (compaction or a new session), run `devrites-engine dispatch <slug>
@@ -135,7 +136,11 @@ status`, `parallel status`, and `claim list --all` before any dispatch. A read-o
 wave whose handles this session cannot query: `abandon` it, record each unreturned
 role `gap`, and re-dispatch fresh on the current digest; its late returns are
 `stale`. A writer keeps its claim and lease — no relaunch on those paths until the
-claim is released or its holder is proven terminal. A wright that never returned an
+claim is released or its holder is proven terminal. For an unqueryable writer,
+`claim list --all` showing its claim `released` or `dead` (the engine proved the
+holding session exited on this host) is that proof: `abandon` the wave, record the
+role `gap`, claim the paths, and re-dispatch without waiting on the launching
+session. `live` or `expired` stays held. A wright that never returned an
 admitted result leaves unadmitted bytes: task-path changes since its pre-dispatch
 `git diff --name-only` baseline are never cited as built nor discarded, and are
 named in the re-dispatch contract; changes outside task paths stop for the human

package/pack/generated/devin/skills/devrites-lib/reference/standards/afk-hitl.md

@@ -223,8 +223,9 @@ project/decision docs, and authoritative dependency sources; make and record rev
 implementation/test choices. Ask only about product, scope, acceptance, architecture policy,
 irreversible risk, or human-only access/action.
 
-Objective test/build/tool failure runs bounded `devrites-debug-recovery`; fix it or record a
-technical blocker. Never ask permission for another attempt, test, parser repair, or probe.
+Objective test/build/tool failure runs bounded `devrites-debug-recovery`; fix it, or escalate and
+park it under the [retry contract](#retry-cap-no-progress-loops-and-self-resolve). Never ask
+permission for another attempt, test, parser repair, or probe.
 Close decisions at the earliest informed phase: product in spec, coverage in clarify,
 scope/risk in temper, architecture/dependencies in define, and proof/toolchain in vet. Build
 keeps only unavailable-pre-code or mandatory action-time checkpoints.

package/pack/generated/devin/skills/devrites-lib/reference/standards/agents.md

@@ -62,7 +62,9 @@ a human plus an agent) can share one working tree. Before a same-tree writer
 starts, it records an advisory claim — `devrites-engine claim add --session
 <id> <paths>` — retains the returned `<claim-id>`, then checks the same paths
 with `devrites-engine claim check --session <id> <paths>`; a held claim from a
-live foreign session is a stop-and-report, not a merge-later problem. On every
+live foreign session is never merged later or overridden. Unattended, skip only
+work that needs those paths, run independent work, and re-check `claim list --all`
+before stopping; stop and report the holder only when nothing independent remains. On every
 host-confirmed terminal path after `add` ([unknown outcomes keep it](../parallel-dispatch.md#cancellation-and-terminal-reconciliation)) — return,
 rejected result, stop, or a launch refused with no handle — run
 `devrites-engine claim release --session <id> --id <claim-id>`. Claims expire
@@ -73,7 +75,9 @@ Claims cover product paths only; root-authored `.devrites/**` files use
 Expiry is not proof the holder stopped: size `claim add --ttl <minutes>` to the
 expected write (engine max 240) and re-add before it lapses; before writing, also
 read `claim list --all` — a foreign `expired` claim on overlapping paths whose
-session is not proven terminal counts as held (stop and report). **Failing case:**
+session is not proven terminal counts as held (stop and report). `dead` (engine-proven
+exited holder) or `released` is terminal: reconcile per
+[§ Cancellation](../parallel-dispatch.md#cancellation-and-terminal-reconciliation). **Failing case:**
 session B's `claim check` passes at minute 35 over session A's still-running wright.
 
 ## Independence

package/pack/generated/devin/skills/devrites-lib/reference/standards/workflow-artifacts.md

@@ -326,12 +326,16 @@ Epoch starts 1. `FAILED` records preimages/cleanup/epoch/fingerprint/reason/
 boundary/route/no-progress count. Resolved fingerprints close; a different
 invariant gets a distinct fingerprint. Handoff death resumes its retry epoch with
 prior rows immutable. `WA-OP-011/012` enforce independent fingerprint/epoch caps
-and terminal source cleanup. Exhaustion records:
+and terminal source cleanup. Exhaustion closes this admission, not the work:
+the controlling caller escalates it under the
+[retry contract](afk-hitl.md#retry-cap-no-progress-loops-and-self-resolve)
+through `PLAN_VET_REPAIR`, and a re-vetted changed design re-admits under a new
+identity with fresh epochs. A fully escalated fingerprint parks. Exhaustion records:
 
 ```text
-status=blocked
+status=running
 exhaustion_cause=<same-fingerprint-count|total-epoch-limit>
-next_action=none — technical recovery exhausted; requires new evidence or changed failure conditions
+next_action=/rite-plan repair <slug> — escalate exhausted workflow attempt
 ```
 
 The journal, evidence section, and observer retain that cause; epoch exhaustion
@@ -343,7 +347,7 @@ Precedence: busy owner; safety/access/approval gate; completed historical; activ
 journal; `CLEANED`; missing/stale authority; stale writer evidence; current
 admission. `PROVED|CLEANING` resumes cleanup; install-through-`PROVING`, rollback,
 or failure cleanup routes offline; retryable `FAILED` routes correction/retry;
-`EXHAUSTED` blocks; `PREPARING|PREPARED` resumes only with current authority.
+`EXHAUSTED` escalates; `PREPARING|PREPARED` resumes only with current authority.
 There is no actor-history migration or backfill.
 
 |Route|Owner|Exact action|Durable state/status/next action|Cursor/output|
@@ -356,7 +360,7 @@ There is no actor-history migration or backfill.
 | `VERIFY_EXISTING`|controlling root|verify `CLEANED`, targets, proof, and product separation; do not reinstall|restore saved return phase/action|no retry/slice/action budget|
 | `NO_BACKFILL`|controlling root|no action|completed state unchanged|no new output|
 | `WAIT_ACTIVE_OWNER`|non-owner|no write; stop invocation|shared state unchanged|fixed owner-busy diagnostic|
-| `BLOCKED_EXHAUSTED`|controlling root|no attempt 4|blocked with exact exhausted next action|fixed exhausted diagnostic|
+| `BLOCKED_EXHAUSTED`|controlling root|no attempt 4 on this admission; escalate through `PLAN_VET_REPAIR` or park per retry contract|`status=running`, exact exhausted `next_action`; parked keeps the parked-recovery action|fixed exhausted diagnostic; no intermediate reply|
 | `BLOCKED_GATE`|controlling root|follow existing safety/access/approval gate|gate-owned state|gate output; never reinterpret as retry|
 
 |Scenario ID|Trigger|Exact route / action|Durable consequence|Forbidden behavior|
@@ -422,7 +426,7 @@ pairs remain injective for actionable seams.
 | `devrites-debug-recovery/SKILL.md`|durable active failure or ambiguous admitted state|`OFFLINE_RECOVERY`; correct offline, re-preflight, narrow Vet, retry only under cap|saved caller or exact Plan/Vet route|
 | `rite-autocomplete/SKILL.md`|lifecycle cursor encounters admitted set or resumable journal|invoke classifier; execute returned route internally|saved phase/action; zero intermediate reply|
 | `rite-autocomplete/reference/loop.md`|loop tick sees Workflow Artifact trigger/state|invoke classifier once under owner lock; no actor-history migration|same loop cursor; no budget charge for verify/rerun|
-| `rite-autocomplete/reference/stop-conditions.md`|classifier returns owner-busy, exhausted, or existing hard gate|stop on exact `WAIT_ACTIVE_OWNER`, `BLOCKED_EXHAUSTED`, or `BLOCKED_GATE` result|unchanged cursor plus fixed route-owned output|
+| `rite-autocomplete/reference/stop-conditions.md`|classifier returns owner-busy, exhausted, or existing hard gate|escalate `BLOCKED_EXHAUSTED`; on `WAIT_ACTIVE_OWNER` run independent work and recheck; stop on exact `BLOCKED_GATE` result|unchanged cursor plus fixed route-owned output|
 | `rite-build/SKILL.md`|Vet-ready admitted bytes require root authorship outside product wright|`ROOT_TRANSACTION`; root writes only admitted `.devrites/**` targets|saved Build slice cursor; wright product allowlist unchanged|
 | `rite-build/reference/phase-contract.md`|Build gate enters or resumes transaction|invoke canonical operation table; reconcile exact result|same slice/checkpoint cursor or Plan/Vet route|
 | `rite-prove/SKILL.md`|Prove consumes installed Workflow Artifact or `CLEANED` rerun|`VERIFY_EXISTING` or admitted proof path ending `PROVE_AND_RETURN`|saved Prove cursor; stop before real action|

package/pack/generated/devin/skills/devrites-lib/reference/workspace-artifact-schema.md

@@ -237,7 +237,7 @@ slices; use `none` when they do not apply. Complexity above 3 triggers reslicing
 unless the stated reason makes the boundary irreducible. A Writer allowlist of 12+
 files prints an engine `ADVISORY size:` line (`check task-graph`, `check slice`;
 never blocking): split it acceptance-preserving, or add `Size rationale:` naming
-the inseparable capability.
+the inseparable capability; `ADVISORY hub:` takes a seam slice or `Serial rationale:`.
 
 ## Read next by phase
 

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

@@ -107,8 +107,8 @@ executable controller/harness/bundle bytes or a missing writer, read
    `/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 largest eligible path-disjoint batch (cap: this invocation's
-   `--parallel N`, else sentinel `max_parallel`, else 10) and recomputes after
-   every completed round until no pending slice remains; a one-slice round is serial for that round only, then
+   `--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

package/pack/generated/devin/skills/rite-autocomplete/reference/loop.md

@@ -67,7 +67,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); recompute after each round; charge once per green built slice |
+| 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 |
 | 7 | `/rite-prove` | all slices built; 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/devin/skills/rite-autocomplete/reference/stop-conditions.md

@@ -58,7 +58,7 @@ 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.
 
-<!-- workflow-artifact-adapter: {"module":"devrites-lib/reference/standards/workflow-artifacts.md","entry":"classifier returns owner-busy, exhausted, or existing hard gate","action":"stop on exact WAIT_ACTIVE_OWNER, BLOCKED_EXHAUSTED, or BLOCKED_GATE result","return":"unchanged cursor plus fixed route-owned output"} -->
+<!-- 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
 
 - **Gate severity:** escalating always stops. Blocking with a ranked recommended
@@ -85,6 +85,10 @@ class or park; only a real human/risk/scope gate stops for a human.
   pre-existing remaining value, explicit flag, sentinel cap, or post-vet pending count
   does not stop. Zero with no pending slices is normal completion.
   Malformed flag stops before any write.
+- **Foreign writer:** a `live`/`expired` claim or `WAIT_ACTIVE_OWNER` held by
+  another session blocks only work on those paths; run independent work, re-check,
+  and stop only when nothing independent remains. `released`/`dead` claims are
+  reconciled per [§ Cancellation](../../devrites-lib/reference/parallel-dispatch.md#cancellation-and-terminal-reconciliation).
 - **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.

package/pack/generated/devin/skills/rite-build/SKILL.md

@@ -74,15 +74,15 @@ Wright applies anti-slop; root verifies returns and never patches source. Refuse
 
 Omitted/`1` ≡ serial; `2`–`10` is a **cap** — the root runs the largest eligible
 path-disjoint set it can start now (`N_eff`), takes fewer when the cap cannot be
-filled, and recomputes after every completed round (serial slice or parallel
-integrate) until no pending slice remains
+filled, and refills a slot per landing (serial slice or one sibling) until
+no pending slice remains
 ([`parallel-batch.md` § Dynamic selection](reference/parallel-batch.md#dynamic-selection-and-re-batching)).
-Unattended runs (`/rite-autocomplete`, `.devrites/AFK` `max_parallel`) repeat batches
-inside the same run; HITL stops after each batch. This invocation's `--parallel N`
+Unattended runs (`/rite-autocomplete`, `.devrites/AFK` `max_parallel`) refill
+inside the same run; HITL stops after each landing. This invocation's `--parallel N`
 is the cap: leftover sentinel `max_parallel` is not consulted. Autocomplete with
 that flag also writes or replaces only `max_parallel: N`. Non-integer/`N≤0`/`N>10` hard refuse.
-All-green (independent review + proof) then integrate as one local `WIP(<slug>):`
-commit per sibling onto the current control branch (never pushed). Do not
+Each sibling lands alone when its review + proof are green (`integrate --slice`):
+one local `WIP(<slug>):` commit onto the control branch (never pushed). Do not
 integrate a sibling because the wright returned. A red/gap sibling gets a bounded repair
 round in its own worktree — never rebuilt from scratch while budget remains.
 Post-writer inventory and affected rechecks follow `phase-contract.md` § Independent
@@ -93,7 +93,7 @@ a human `Fix`. Exhausted repair blocks and preserves everything;
 `cleanup --force` salvages slice branches before removing worktrees —
 human-gated to abandon a batch, orchestrator-emitted only as the salvage
 step of an automatic frozen-lease re-batch.
-AFK charges after integrate only. Running lease blocks another
+AFK charges per landed sibling only. Running lease blocks another
 `/rite-build`. Details: `parallel-batch.md`.
 
 ## Execute and reply

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

@@ -44,8 +44,8 @@ The controlling root owns the cap:
    before the next dispatch.
    - **Serial:** charge when fail-on-red is green and the built record is written
      (same rewrite as step 2).
-   - **Parallel `--parallel`:** charge only after **successful serial integrate**
-     — once per integrated green sibling. Abort / integrate-failed → charge **0**.
+   - **Parallel `--parallel`:** charge only after **successful integrate**
+     — once per landed green sibling. Abort / integrate-failed → charge **0**.
      Do not charge on worktree-green before integrate. See
      [`parallel-batch.md`](parallel-batch.md).
 

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

@@ -18,7 +18,7 @@ the orchestrator pauses for approval before landing it.
   and fail-on-red proof are green, with no open Critical/Important and no repair
   wright still in flight. Serial: git recipe below (skip empty index) or isolated
   FF of a matching `transfer_commit`. Parallel: `devrites-engine parallel
-  integrate --apply-to-control` (no second control `git commit`).
+  integrate --slice <id> --apply-to-control` (no second control `git commit`).
 - **Do not:** when a wright returns; before review/proof; with red/gap findings;
   fast-forward an isolated transfer onto control before those checks.
 

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

@@ -28,7 +28,7 @@ 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 and run the new N_eff; otherwise repeat under afk-discipline.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
 ```
 
 ## Why the boundary matters

package/pack/generated/devin/skills/rite-build/reference/parallel-batch.md

@@ -36,14 +36,14 @@ Select **greedily in plan order**: pass every currently dependency-ready pending
 `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.
 
-**Re-batch automatically after every completed round** (parallel integrate+cleanup or
-a serial slice). Re-read `state.md`, pending slices, and the tree, then run
-`parallel select` again: finished work leaves the pending set, and satisfied
-dependencies unlock new slices. Under `.devrites/AFK` and `/rite-autocomplete` the
-repeat is the same run — HITL stops after each batch. `--parallel 5` with one eligible
-slice runs that one; when two to five then become eligible, the next round takes that
-many. **Failing case:** the run stays one-by-one after a serial round even though more
-slices are now eligible under the same cap.
+**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 --cap N --slug <slug>`: 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
+each landing. **Failing case:** three siblings are green, one is repairing, and no
+new slice starts.
 
 ## Path-disjoint
 
@@ -109,22 +109,27 @@ Lease: `batch_id`, `created_at`, `base_sha`, `n`,
    headroom bounds the batch size — one batch never assumes unbounded reviewers.
 5. Non-green siblings → **repair round** (below) in the same worktrees; lease
    stays `running` — no abort while repair budget remains. A green sibling →
-   `parallel record-green`. No partial integrate. All green → integrate.
+   `parallel record-green`, then step 6 for it alone.
    A recoverable RED blocks integration but does not cancel independent safe running siblings.
    Expected test-first RED is not a terminal gate failure. Cancel only for a shared
    invalid foundation, safety/access failure, resource boundary, or explicit stop;
    preserve completed and in-progress recoverable work and classify each result.
-6. `parallel integrate --apply-to-control` **only after steps 4–5 are green**:
-   each `transfer_commit` descends from `B` and diffs path-exact vs
-   `B`; apply each in plan order as its own local `WIP(<slug>):` commit
-   (imperative summary, never a slice id). Staging branch, then FF. Conflict →
-   reset to `B`, `integrate-failed`; classify under repair rounds (siblings stay
-   in place). Never integrate because a wright returned.
-7. Success: FF control (the branch that held `HEAD` when the batch started —
-   often `main`/`master`, otherwise whatever the user was on) to the integrate
-   tip: N local commits, never pushed; union `touched-files.md`; update
-   state/evidence; AFK +1 per integrated sibling; optional `check candidate`.
-8. Cleanup runs only after `integrate` marks the lease `complete` — work
+6. `parallel integrate --slice <id> --apply-to-control` **only after its steps
+   4–5 are green**: `transfer_commit` descends from the sibling's base and diffs
+   path-exact vs it; apply as its own local `WIP(<slug>):` commit
+   (imperative summary, never a slice id). Staging branch, then FF; the engine
+   refuses (never rewinds) if anything but this lease moved control. Conflict →
+   `integrate-failed`; classify under repair rounds (siblings stay in place).
+   Never integrate because a wright returned.
+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.
+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
    removed while the batch may resume. `parallel abort` + `cleanup --force`
@@ -191,9 +196,11 @@ Repair rejected work in place; never discard/rebuild while budget remains.
 ## Engine verbs
 
 ```text
-devrites-engine parallel select --cap <1-10> [--root <dir>] [<json-file>|-]
+devrites-engine parallel select --cap <1-10> [--root <dir>] [--slug <slug>] [<json-file>|-]
 devrites-engine parallel create --root <repo> --slug <slug> --batch <id> --base <B> --json <file>|-
+devrites-engine parallel add --root <repo> --slug <slug> --json <file>|-
 devrites-engine parallel record-green --root <repo> --slug <slug> --slice <id> --commit <sha>
+devrites-engine parallel integrate --root <repo> --slug <slug> --slice <id> --apply-to-control
 devrites-engine parallel integrate --root <repo> --slug <slug> --apply-to-control
 devrites-engine parallel status --root <repo> --slug <slug>
 devrites-engine parallel lease-write|lease-read|lease-clear --root <repo> --slug <slug>

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

@@ -42,7 +42,8 @@ Spec Drift Guard still applies.
 6. **Prove.** Against the frozen pre-slice candidate inspect
    test hunks for deletion, skipping/focus, tautology, or weaker expectations.
    Wait for step 5's exact test-analyst account; missing/adverse criterion verdict is
-   Critical. Run only `test-plan.md` repository/CI commands, record output, recheck
+   Critical. Run only `test-plan.md` repository/CI commands ([tier](#proof-tiers)),
+   record output, recheck
    `git diff --name-only`. Missing/weakened/red/source-mutating proof cannot pass.
    Pre-existing/environment-specific claims need a predating same-command,
    same-environment baseline; otherwise unresolved.
@@ -67,6 +68,14 @@ Spec Drift Guard still applies.
 
 One contract builds one slice: preserve TDD, exact paths and independent judgment.
 
+## 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
+without the section, run every row each round.
+
 ## Independent Build review
 
 After inspection, freeze full slice scope and cumulative baseline diff. Initial

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

@@ -82,5 +82,6 @@ The detecting phase owns backtracking and the batch sweep. Save
 `return_phase`/`return_next_action`; consume nested Plan/Vet `STOP` internally, complete
 vetted acceptance-preserving remediation, then restore the cursor and failed step.
 Never hand the human an intermediate command. The shared three-attempt causal-fingerprint
-cap still applies: exhaustion produces one technical blocker, while a genuinely
-human-owned decision uses the question format below.
+cap still applies: a spent strategy escalates and a fully escalated fingerprint parks
+under the [retry contract](../../devrites-lib/reference/standards/afk-hitl.md#retry-cap-no-progress-loops-and-self-resolve),
+while a genuinely human-owned decision uses the question format below.

package/pack/generated/devin/skills/rite-build/reference/wright-dispatch.md

@@ -144,8 +144,8 @@ TTL is crash recovery, not normal cleanup.
    **Do not land on control until review and proof are both green.** Isolated
    `transfer_commit` stays on the worker branch; same-worktree diffs stay
    uncommitted. Serial: [`checkpoint.md`](checkpoint.md), then host may remove the
-   worktree. Parallel: `record-green` only; land with `parallel integrate
-   --apply-to-control` after the batch; `parallel cleanup` removes worktrees.
+   worktree. Parallel: `record-green`, then `parallel integrate
+   --slice <id> --apply-to-control`; `parallel cleanup` removes worktrees.
 5. Reconcile returned reuse, conventions, principles, sources, assumptions,
    decisions, dead ends, follow-ups, gates, and touched files. Persist the
    relevant facts in canonical artifacts, not the wholesale report. A plan-gap

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

@@ -160,7 +160,7 @@ Pull these via `Read` when shaping the plan:
    meaning-changing mappings block. Then run
    `devrites-engine check task-graph <slug>`; a malformed dependency graph blocks
    before Vet rather than spending a reviewer context on invalid tasks. Resolve each
-   `ADVISORY size:` line now (split, or `Size rationale:`); it never blocks.
+   `ADVISORY size:`/`hub:` line now (split or seam slice, or a rationale); never blocking.
 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/devin/skills/rite-handoff/SKILL.md

@@ -74,7 +74,7 @@ themselves. The workspace is the canonical store; the handoff is the chat-only d
 6. **In-flight work.** Every dispatch wave opened or sealed without a return (`devrites-engine
    dispatch <slug> status`), running writer handle, held claim id plus paths (`devrites-engine
    claim list --all`), and consumptive action started, each `terminal: yes|unknown` (`yes` only with
-   an admitted return, release, or proof of stop). The live handle exists only in chat. Any
+   an admitted return, release, `dead` claim, or proof of stop). The live handle exists only in chat. Any
    `unknown` row makes item 1 a reconcile step (`dispatch <slug> status`, `parallel status`,
    `claim list --all`), never a writer command: otherwise the next session dispatches a second writer.
 7. **How to resume:** fixed boilerplate (see template below).