devrites 5.0.0 → 5.2.0

package/CHANGELOG.md

@@ -2,6 +2,18 @@
 
 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`.
 
+## [5.2.0](https://github.com/ViktorsBaikers/DevRites/compare/v5.1.0...v5.2.0) (2026-09-11)
+
+### Added
+
+* **skills:** batch build-time gap repair and auto-chain plan/vet ([#61](https://github.com/ViktorsBaikers/DevRites/issues/61)) ([a668270](https://github.com/ViktorsBaikers/DevRites/commit/a668270b4a278ffb81a1b73bf962d13da2097e5a))
+
+## [5.1.0](https://github.com/ViktorsBaikers/DevRites/compare/v5.0.0...v5.1.0) (2026-09-10)
+
+### Added
+
+* **skills:** raise /rite-build --parallel cap from 3 to 10 ([#60](https://github.com/ViktorsBaikers/DevRites/issues/60)) ([d88afa0](https://github.com/ViktorsBaikers/DevRites/commit/d88afa0af31eed421a1a5fdbff8eaf3f61b02bff))
+
 ## [5.0.0](https://github.com/ViktorsBaikers/DevRites/compare/v4.7.0...v5.0.0) (2026-09-06)
 
 ### ⚠ BREAKING CHANGES

package/README.md

@@ -33,7 +33,7 @@ project-conventional push, tag, or PR action, and archive the workspace.
 Unattended runs may create local WIP checkpoint commits along the way, but they
 remain local unless Ship's disclosed plan includes an approved remote action.
 
-**Status:** [`v5.0.0`](https://github.com/ViktorsBaikers/DevRites/releases/tag/v5.0.0): see [`CHANGELOG.md`](CHANGELOG.md) for release notes.
+**Status:** [`v5.2.0`](https://github.com/ViktorsBaikers/DevRites/releases/tag/v5.2.0): see [`CHANGELOG.md`](CHANGELOG.md) for release notes.
 
 This is the latest published release; `main` may contain unreleased work.
 

package/engine/internal/parallel/lease.go

@@ -20,6 +20,9 @@ const (
 	WrightGreen   = "green"
 	WrightRed     = "red"
 	WrightGap     = "gap"
+
+	MinParallelSlices = 2
+	MaxParallelSlices = 10
 )
 
 var (
@@ -95,6 +98,13 @@ func validateSliceID(id string) error {
 	return nil
 }
 
+func checkParallelSliceCount(n int) error {
+	if n < MinParallelSlices || n > MaxParallelSlices {
+		return fmt.Errorf("parallel requires %d-%d slices (got %d)", MinParallelSlices, MaxParallelSlices, n)
+	}
+	return nil
+}
+
 func ValidateLease(lease *Lease) error {
 	if lease == nil {
 		return fmt.Errorf("lease is nil")
@@ -113,8 +123,8 @@ func ValidateLease(lease *Lease) error {
 	default:
 		return fmt.Errorf("invalid lease status %q", lease.Status)
 	}
-	if len(lease.Slices) < 2 || len(lease.Slices) > 3 {
-		return fmt.Errorf("lease must have 2 or 3 slices (got %d)", len(lease.Slices))
+	if err := checkParallelSliceCount(len(lease.Slices)); err != nil {
+		return err
 	}
 	if lease.N != len(lease.Slices) {
 		return fmt.Errorf("lease n=%d does not match slices=%d", lease.N, len(lease.Slices))

package/engine/internal/parallel/ops.go

@@ -29,7 +29,7 @@ type CreateOpts struct {
 	Slices  []SlicePaths
 }
 
-// Create path-disjoint-gates, creates <=3 worktrees from base, and writes a running lease.
+// Create path-disjoint-gates, creates 2-10 worktrees from base, and writes a running lease.
 func Create(opts CreateOpts) (*Lease, error) {
 	if err := validateSlug(opts.Slug); err != nil {
 		return nil, err
@@ -37,8 +37,8 @@ func Create(opts CreateOpts) (*Lease, error) {
 	if err := validateBatchID(opts.BatchID); err != nil {
 		return nil, err
 	}
-	if len(opts.Slices) < 2 || len(opts.Slices) > 3 {
-		return nil, fmt.Errorf("create requires 2 or 3 slices (got %d)", len(opts.Slices))
+	if err := checkParallelSliceCount(len(opts.Slices)); err != nil {
+		return nil, err
 	}
 	if _, err := CheckPathDisjoint(opts.Slices, opts.Root); err != nil {
 		return nil, err

package/engine/internal/parallel/parallel_test.go

@@ -1,6 +1,7 @@
 package parallel
 
 import (
+	"fmt"
 	"os"
 	"os/exec"
 	"path/filepath"
@@ -146,6 +147,109 @@ func TestCreateAbortCleanup(t *testing.T) {
 	}
 }
 
+func TestCreateAcceptsFourSlices(t *testing.T) {
+	t.Parallel()
+	repo, _ := setupRepo(t)
+	for _, name := range []string{"c.go", "d.go"} {
+		if err := os.WriteFile(filepath.Join(repo, "src", name), []byte("package main\n"), 0o644); err != nil {
+			t.Fatal(err)
+		}
+	}
+	gitOk(t, repo, "add", ".")
+	gitOk(t, repo, "commit", "-m", "more files")
+	base := gitOk(t, repo, "rev-parse", "HEAD")
+	lease, err := Create(CreateOpts{
+		Root:    repo,
+		Slug:    "demo-four",
+		BatchID: "batch4",
+		BaseSHA: base,
+		Slices: []SlicePaths{
+			{ID: "slice-a", Paths: []string{"src/a.go"}},
+			{ID: "slice-b", Paths: []string{"src/b.go"}},
+			{ID: "slice-c", Paths: []string{"src/c.go"}},
+			{ID: "slice-d", Paths: []string{"src/d.go"}},
+		},
+	})
+	if err != nil {
+		t.Fatal(err)
+	}
+	if lease.N != 4 || len(lease.Slices) != 4 {
+		t.Fatalf("want 4 slices, got n=%d slices=%d", lease.N, len(lease.Slices))
+	}
+}
+
+func TestCreateRefusesCountOutsideBounds(t *testing.T) {
+	t.Parallel()
+	repo, base := setupRepo(t)
+	_, err := Create(CreateOpts{
+		Root:    repo,
+		Slug:    "demo-one",
+		BatchID: "batch1",
+		BaseSHA: base,
+		Slices:  []SlicePaths{{ID: "slice-a", Paths: []string{"src/a.go"}}},
+	})
+	if err == nil || !strings.Contains(err.Error(), "2-10 slices") {
+		t.Fatalf("expected 2-10 bound for N=1, got %v", err)
+	}
+
+	slices := make([]SlicePaths, MaxParallelSlices+1)
+	for i := range slices {
+		name := fmt.Sprintf("src/x%d.go", i)
+		if err := os.WriteFile(filepath.Join(repo, name), []byte("package main\n"), 0o644); err != nil {
+			t.Fatal(err)
+		}
+		slices[i] = SlicePaths{ID: fmt.Sprintf("s%d", i), Paths: []string{name}}
+	}
+	gitOk(t, repo, "add", ".")
+	gitOk(t, repo, "commit", "-m", "eleven")
+	base = gitOk(t, repo, "rev-parse", "HEAD")
+	_, err = Create(CreateOpts{
+		Root:    repo,
+		Slug:    "demo-eleven",
+		BatchID: "batch11",
+		BaseSHA: base,
+		Slices:  slices,
+	})
+	if err == nil || !strings.Contains(err.Error(), "2-10 slices") {
+		t.Fatalf("expected 2-10 bound for N=11, got %v", err)
+	}
+}
+
+func TestValidateLeaseBounds(t *testing.T) {
+	t.Parallel()
+	ok := validTestLease(MaxParallelSlices)
+	if err := ValidateLease(ok); err != nil {
+		t.Fatalf("N=%d should validate: %v", MaxParallelSlices, err)
+	}
+	tooMany := validTestLease(MaxParallelSlices + 1)
+	if err := ValidateLease(tooMany); err == nil || !strings.Contains(err.Error(), "2-10 slices") {
+		t.Fatalf("N=%d should refuse, got %v", MaxParallelSlices+1, err)
+	}
+}
+
+func validTestLease(n int) *Lease {
+	slices := make([]LeaseSlice, n)
+	for i := range slices {
+		id := fmt.Sprintf("s%d", i)
+		slices[i] = LeaseSlice{
+			ID:           id,
+			Paths:        []string{fmt.Sprintf("src/%s.go", id)},
+			WorktreePath: "/tmp/" + id,
+			Branch:       "devrites/parallel/x/batch/" + id,
+			WrightStatus: WrightPending,
+		}
+	}
+	return &Lease{
+		BatchID:             "batch1",
+		CreatedAt:           "2026-08-23T00:00:00Z",
+		BaseSHA:             "abcdef1",
+		N:                   n,
+		Status:              StatusRunning,
+		ControlPIDOrSession: "test",
+		Slices:              slices,
+	}
+}
+
 func TestCreateRefusesOverlap(t *testing.T) {
 	repo, base := setupRepo(t)
 	_, err := Create(CreateOpts{

package/pack/.claude/agents/devrites-slice-wright.md

@@ -140,6 +140,10 @@ return an `Escalation`** when:
   scoped exception or the approach must change. Report the principle and conflict
   in `Escalation`.
 
+A plan-gap or underspecification escalation populates `assumptions` with every
+contract assumption already checked (verified|falsified); the orchestrator's
+batch sweep covers only the unchecked remainder. Never a bare "plan is wrong".
+
 If an answer would change scope or acceptance, do **not** fold it into the slice.
 Return it in `Escalation` so the orchestrator can route it through the Spec Drift
 Guard (`/rite-plan repair`). Respect any AFK budget in the contract.
@@ -174,7 +178,7 @@ reuse: []
 conventions: []
 principles: []
 sources: []
-assumptions: []
+assumptions: [] # plan-gap escalation: every checked contract assumption, verified|falsified
 decisions_stood: [] # irreversible-risk items go to escalation
 dead_ends: []
 escalation: <none | gate + crisp question + proposed answer>

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

@@ -1,6 +1,6 @@
 ---
 name: rite-build
-description: Build the next approved vertical slice with evidence. HITL one-slice default; AFK may chain serially; opt-in `--parallel N` (2≤N≤3) for path-disjoint worktrees.
+description: Build the next approved vertical slice with evidence. HITL one-slice default; AFK may chain serially; opt-in `--parallel N` (2≤N≤10) for path-disjoint worktrees.
 argument-hint: "[--parallel N] [slice number or name]"
 user-invocable: true
 ---
@@ -10,7 +10,7 @@ user-invocable: true
 Build and prove one slice. HITL stops; a later user invocation starts the next.
 Explicit `.devrites/AFK` alone lets the controlling root chain pending slices
 serially under green proof, caps, and pause rules. Every wright returns after one slice.
-**Opt-in:** `/rite-build --parallel N` (2≤N≤3; N=1≡serial) follows
+**Opt-in:** `/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)).
 
@@ -38,8 +38,10 @@ Wright applies anti-slop; root verifies returns and never patches source.
   single-slice isolation when `wright-dispatch.md` preflight + reconcile hold.
 - Exact feature scope only; reject out-of-allowlist diffs; record adjacent issues.
 - Never rerun an unchanged check; re-prove after edits.
-- Unplanned dependency/design-system/gap/repair → Vet/Spec Drift Guard. Ask only
-  for licensing/cost/security/product or explicit architecture-policy decisions.
+- Unplanned dependency/design-system/gap/repair → Vet/Spec Drift Guard batch
+  sweep: every contract-assumption violation recorded before one folded
+  repair+vet. Ask only for licensing/cost/security/product or explicit
+  architecture-policy decisions.
 - Root never edits product source/tests (`.devrites/` + Workflow Artifact only).
   Wright is sole product writer; extras in returned paths/`git diff --name-only` hard-stop.
 - Principles bind; irreversible conflict needs human exception or stop.
@@ -55,9 +57,11 @@ Wright applies anti-slop; root verifies returns and never patches source.
 <!-- 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`/`3` → path-disjoint fan-out when eligible; else hard refuse.
-All-green serial integrate; one red/gap aborts. AFK charges after integrate only.
-Running lease blocks another `/rite-build`. Details: `parallel-batch.md`.
+Omitted/`1` ≡ serial; `2`–`10` → path-disjoint fan-out when eligible; else hard refuse.
+All-green serial integrate; one red/gap aborts. Abort with agent-owned plan
+gaps continues via Spec Drift Guard (batch sweep, one folded plan repair + one
+vet recheck inline); do not emit a human `Fix`. AFK charges after integrate only. Running lease blocks another
+`/rite-build`. Details: `parallel-batch.md`.
 
 ## Execute and reply
 

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

@@ -3,7 +3,7 @@
 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.
-Opt-in fan-out: [`parallel-batch.md`](parallel-batch.md) (`--parallel N`); this is default.
+This serial cycle is the default `/rite-build`. Opt-in fan-out: [`parallel-batch.md`](parallel-batch.md) (`--parallel N`).
 
 ## The cycle
 
@@ -38,8 +38,11 @@ you check yourself against: anything outside it is scope creep or a drift event.
 
 ## When the slice can't be completed cleanly
 
-- Discovered the plan is wrong → **Spec Drift Guard** (stop, record, classify, maybe
-  ask, `/rite-plan` repair).
-- Slice is bigger than one cycle → stop and `/rite-plan reslice`.
-- Blocked on a failing dependency → record in `state.md`, `/rite-plan unblock`.
+- Discovered the plan is wrong → **Spec Drift Guard** (record, classify;
+  sweep every remaining contract assumption, then one folded repair+vet inline;
+  ask only for product/policy/irreversible-risk).
+- Slice is bigger than one cycle → `/rite-plan reslice` inline when AC is
+  preserved; do not emit a human Fix.
+- Blocked on a failing dependency → record in `state.md`, `/rite-plan unblock`
+  inline when the reroute is technical.
 Never power through by guessing.

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

@@ -7,12 +7,13 @@ Opt-in only. Default `/rite-build` stays [`one-slice-cycle.md`](one-slice-cycle.
 | Input | Behavior |
 | --- | --- |
 | omitted / `--parallel 1` | Serial one-slice |
-| `--parallel N` (**2≤N≤3**) | Parallel when eligible + host pass |
-| non-integer / `N≤0` / `N>3` | Hard refuse (no silent clamp) |
+| `--parallel N` (**2≤N≤10**) | Parallel when eligible + host pass |
+| non-integer / `N≤0` / `N>10` | Hard refuse (no silent clamp) |
 
 AFK caps `N` by remaining budget. Charge **only after successful integrate**
-(once per integrated green sibling). Abort / integrate-failed → **0**. Running
-lease blocks another `/rite-build`.
+(once per integrated green sibling). Abort / integrate-failed → **0**. A
+`running` lease blocks another `/rite-build`. Any present lease blocks
+`parallel create` until cleanup.
 
 ## Path-disjoint
 
@@ -40,14 +41,20 @@ Lease: `batch_id`, `created_at`, `base_sha`, `n`,
 
 1. Orient/gate; parse N; select ≤N path-disjoint pending slices.
 2. Write lease; freeze `B=HEAD`; `parallel create` worktrees.
-3. Dispatch ≤3 wrights in parallel (cwd=worktree; allowlist; prove `HEAD==B`).
-4. Inspect + fail-on-red → `green|red|gap`.
+3. Dispatch ≤10 wrights in parallel (cwd=worktree; allowlist; prove `HEAD==B`).
+4. Inspect + fail-on-red → `green|red|gap`. Independent-review Critical is `gap`
+   even when targeted tests are green.
 5. Any red/gap → **abort** (no partial integrate). All green → serial integrate.
 6. Integrate: `transfer_commit` descends from `B`; `` `<base>..<transfer>` ``
    path-exact; apply in plan order. Conflict → reset to `B`, `integrate-failed`.
 7. Success: FF control; union `touched-files.md`; update state/evidence; AFK +1
    per integrated sibling; optional `check candidate`.
-8. Cleanup: success removes worktrees/branches; abort keeps until acknowledged.
+8. Cleanup: success removes worktrees/branches. Abort keeps them as repair
+   inputs until the root consumes them: agent-owned plan gaps (AC unchanged)
+   follow [`spec-drift-guard.md`](spec-drift-guard.md) — batch-sweep all
+   siblings' contract assumptions, one folded `/rite-plan repair` + one
+   `/rite-vet` recheck inline, then cleanup and resume Build. Do not emit
+   `Fix: /rite-plan repair`. Product/policy/irreversible-risk still stops.
 
 ## Engine verbs
 

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

@@ -3,6 +3,7 @@
 See [`one-slice-cycle.md`](one-slice-cycle.md); candidate lifecycle is
 [`candidate-integrity.md`](../../devrites-lib/reference/candidate-integrity.md).
 Opt-in `--parallel N` uses [`parallel-batch.md`](parallel-batch.md) instead of steps 2–8.
+Spec Drift Guard still applies on abort or plan-gap.
 
 1. **Orient and gate.** Read core, `.devrites/ACTIVE`, `state.md`, and required
    slice artifacts. Require `Implementation readiness: READY`, its current

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

@@ -24,13 +24,31 @@ other phases reference it here.
      YES, active-slice technical/tool failure → log it and use Build's bounded debug
        recovery. Do not ask for retry authorization and do not re-plan unless the
        durable remaining-work instructions are wrong.
-     YES, durable plan is wrong → log it, save the caller's return cursor, then
-       invoke `/rite-plan repair` and `/rite-vet` inline without a question and resume.
+     YES, durable plan is wrong → run the batch sweep below, log every
+       violation, save the caller's return cursor, then invoke `/rite-plan repair` and `/rite-vet` inline
+       without a question — ONE folded repair for all open entries, ONE
+       recheck for every open fingerprint — and resume.
      NO, product/policy/irreversible-risk decision → ask the user (format below).
 5. Never continue on a known-wrong durable plan. A repaired active-slice implementation
    may continue only after bounded recovery, returned-diff review, and proof gates pass.
 ```
 
+## Batch sweep (before repair)
+
+A durable-plan drift abort never repairs the first gap alone:
+
+1. Verify every remaining statically-checkable contract assumption against the
+   live repo — named paths, symbols/APIs/signatures, routes, commands, dependency
+   versions, contract artifacts. The wright's return names what it falsified;
+   check the rest yourself — existence checks are deterministic, no dispatch.
+2. Record each violation as its own `drift.md` entry/fingerprint; one folded
+   repair + one batched recheck resolves the set.
+3. A recheck-surfaced gap is a new fingerprint with its own budget — loop
+   internally, never hand an intermediate command to the human.
+4. Nothing skips or defers silently: every entry ends resolved, human-escalated,
+   or fingerprint-exhausted. Execution-only gaps (tests, UX, evidence) get the
+   identical path when they surface.
+
 ## User question format
 ```
 I hit spec drift:
@@ -50,7 +68,8 @@ human permission question. Re-plan only when the durable plan changed.
 
 ## Inline return contract
 
-The phase that detected agent-owned drift owns the whole backtrack. Preserve it
+The phase that detected agent-owned drift owns the whole backtrack, batch sweep
+included. Preserve it
 as `return_phase`/`return_next_action`; consume Plan and Vet's nested `STOP`
 boundaries internally; follow any vetted remediation required by the settled
 acceptance; then restore the cursor and resume the failed step. Do not hand an

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

@@ -36,7 +36,7 @@ Conflict, extra/missing commit, moved base, or cleanup failure is `gap`/STOP:
 preserve the worktree and commit. Without explicit reconciliation, use same-worktree serial.
 Parallel isolated-writer worktrees remain forbidden until this serial pilot measures
 transfer, conflict, proof, and review outcomes on both hosts; opt-in `/rite-build --parallel N`
-(2≤N≤3) path-disjoint fan-out is the only sanctioned parallel mode. Same-worktree multi-writer / root-emulated
+(2≤N≤10) path-disjoint fan-out is the only sanctioned parallel mode. Same-worktree multi-writer / root-emulated
 worktrees stay forbidden.
 
 ## Prepare
@@ -83,4 +83,7 @@ Opt-in `/rite-build --parallel N` fans out only under [`parallel-batch.md`](para
    attempts is the limit; persist each and never dispatch a fourth related try.
 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.
+   relevant facts in canonical artifacts, not the wholesale report. A plan-gap
+   escalation without the checked-assumption list (verified|falsified) is
+   malformed; root sweeps the unchecked remainder per
+   [`spec-drift-guard.md`](spec-drift-guard.md) before repair.

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

@@ -79,6 +79,9 @@ Before classifying any Reslice, read `.claude/skills/devrites-lib/reference/stan
    require the drafter to apply `one-shot-actions.md` and return the bounded
    diagnostic-amplification design, injective boundary map, per-seam fixtures, and
    collision mutant. Past evidence loss is not terminal. The drafter supplies no bodies.
+   A repair candidate carries a delta self-check: touched invariants re-verified
+   (acyclic deps, bidirectional traceability, shared contract proof, sizing), no
+   correction-created regression.
    Bind exact active `.devrites/work/<slug>/` targets and executable contract; after Vet READY, root
    materializes the exact vetted workflow-artifact paths under
    [`workflow-artifacts.md`](../devrites-lib/reference/standards/workflow-artifacts.md)
@@ -115,8 +118,9 @@ Before classifying any Reslice, read `.claude/skills/devrites-lib/reference/stan
    material assumption, or open blocking/escalating question routes `/rite-clarify`/HITL.
    Restore `CLEAR` only from current evidence.
 7. **Done when:** every slice is sized (builds + proves in one cycle; no slice scoring >3
-   left unjustified), the dependency order is acyclic, every `drift.md` entry you stopped for
-   is marked resolved, revised artifacts agree with each other, no source files changed in
+   left unjustified), the dependency order is acyclic, every open `drift.md` entry
+   was folded in one pass and marked resolved, the delta self-check is recorded,
+   revised artifacts agree with each other, no source files changed in
    `revise` mode, the marked action is complete, and every changed
    plan ends at `/rite-vet` rather than returning directly to build; horizon IDs stay stable,
    reclassifications cite evidence, and no unresolved item vanished. The `Shared contract proof`
@@ -128,5 +132,13 @@ to that caller so it can invoke Vet immediately. The phase boundary is not a
 user-facing stop unless a genuine HITL, safety/access, or exhausted-recovery
 condition was recorded.
 
+When invoked directly with no controlling caller and a planning artifact
+changed, become the caller for the mandated next step: record the return
+cursor, invoke `/rite-vet` inline, and consume its results — `NEEDS REPLAN`
+re-enters repair internally under the fingerprint caps; `NEEDS CLARIFICATION`
+and human-owned gates still reach the user. Stop only at Vet's boundary (READY
+readback; next step `/rite-build`). An unchanged plan keeps its recorded next
+step.
+
 > **Mid-flight discipline.** Do not change product behavior without confirmation or
 > absorb drift silently. See [`anti-patterns`](reference/anti-patterns.md).

package/pack/.claude/skills/rite-plan/reference/replan-and-repair.md

@@ -26,12 +26,19 @@ dependency edges.
 
 A drift event stopped the build. Steps:
 
-1. Read the `drift.md` entry and its classification.
+1. Read the `drift.md` entries and their classifications. Fold EVERY open entry
+   and accepted finding for the affected artifacts in ONE pass, never serially.
 2. If the user answered a drift question, encode that decision in `decisions.md`.
 3. Update `spec.md` (only the affected sections) and `plan.md`/`tasks.md` to match
    reality. Adjust acceptance criteria if they were wrong.
-4. Mark the `drift.md` entry **resolved** with the resolution + date.
-5. Resume at the corrected slice.
+4. Mark each `drift.md` entry **resolved** with the resolution + date.
+5. **Self-check the repaired candidate on the delta before handoff** — re-verify
+   every invariant the correction touched (acyclic dependency graph,
+   bidirectional traceability, Shared contract proof vs boundary set, sizing,
+   no correction-created regression) and record the evidence in the Plan
+   checkpoint; Vet's recheck verifies it rather than rediscovering the defect a
+   loop later.
+6. Resume at the corrected slice.
 Never quietly delete a requirement; use the marked action before contract edits.
 
 ## reorder

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

@@ -52,10 +52,14 @@ plan declares a root-authored executable workflow file, read
 - Use the lowest axis band; never average or round thin to ready. Search before
   asking and resolve reversible technical choices. Ask only human-owned choices.
 - Preserve a valid technical return cursor. Agent-owned `NEEDS REPLAN` returns
-  internally to its caller, not to the human.
-- **Recovery recheck is bounded.** A valid cursor plus open fingerprint enters
-  Recovery recheck; it does not start another Full Vet or repeat unaffected
-  axes/reviewers.
+  internally to its caller, not to the human; on a direct invocation there is
+  no caller, so Vet becomes it — record the cursor and invoke `/rite-plan`
+  repair inline under the same fingerprint caps.
+- **Recovery recheck is bounded and batched.** A valid cursor plus open
+  fingerprints enters Recovery recheck; it does not start another Full Vet or
+  repeat unaffected axes/reviewers. One dispatch covers every open fingerprint
+  of the fold — each checked individually — with a mandatory correction-created
+  regression audit.
 <!-- workflow-artifact-adapter: {"module":"devrites-lib/reference/standards/workflow-artifacts.md","entry":"plan declares root-authored executable workflow file","action":"emit exact admission; stale/missing authority uses PLAN_VET_REPAIR","return":"Vet READY cursor or exact technical replan"} -->
 ## Workflow
 
@@ -73,10 +77,13 @@ plan declares a root-authored executable workflow file, read
    required account blocks.
 1b. **Recovery recheck.** Require valid return cursor, accepted prior finding,
    exact fingerprint/reproduction, repaired candidate identity, changed
-   paths/criteria, and affected drift/evidence. Freeze that packet and dispatch
-   each exact owning reviewer once, fresh/read-only, limited to it. Do not rerun
-   broad inventory or unaffected reviewers. Close the prior fingerprint only
-   with discriminating evidence. Otherwise record one no-progress outcome. A
+   paths/criteria, affected drift/evidence, and the recorded delta self-check.
+   Freeze that packet and dispatch each exact owning reviewer once,
+   fresh/read-only, limited to it — all its open fingerprints in that dispatch.
+   Do not rerun broad inventory or unaffected reviewers. Close the prior
+   fingerprint only with discriminating evidence plus an explicit
+   correction-created regression verdict on the touched invariants (acyclic
+   deps, traceability, contract proof, sizing). Otherwise record one no-progress outcome. A
    different Critical/Important invariant needs exact evidence and a new
    fingerprint; a Suggestion, Nit, or FYI cannot keep recovery open. Reconcile
    shared artifact/readiness gates and return to caller or next repair.
@@ -119,11 +126,13 @@ plan declares a root-authored executable workflow file, read
    criterion needs positive, discriminating proof; every slice must be one-pass
    implementable; developer plans need a predicted scorecard. Durable commands
    are portable repository commands, not host wrappers.
-7. **Narrow recheck after edits.** Dispatch exact plan reviewer once per
-   correction/fingerprint (`per correction/fingerprint`) with accepted findings,
-   changed paths/criteria, and new
-   identity. Within one correction, no broad third loop. If it changes plan,
-   fold again. A closed input plus a distinct Critical/Important invariant returns
+7. **Narrow recheck after edits.** Dispatch the exact plan reviewer once per
+   fold — one dispatch covering every open fingerprint, preserving
+   per correction/fingerprint accounting (each checked individually with its
+   accepted findings, changed paths/criteria, new identity, and recorded delta
+   self-check); it must return an explicit correction-created regression
+   verdict, not only fingerprint closure. Within one correction, no broad
+   third loop. If it changes plan, fold again. A closed input plus a distinct Critical/Important invariant returns
    that new fingerprint as progress. Then close matrix and rerun ID/meaning audit.
 8. **Build readback and readiness.** Add a cited five-line readback to
    `eng-review.md` (artifacts.md §7 rows 1–5): outcome/ACs; IN/OUT/must-NOT; UI direction and architecture/

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

@@ -140,6 +140,10 @@ return an `Escalation`** when:
   scoped exception or the approach must change. Report the principle and conflict
   in `Escalation`.
 
+A plan-gap or underspecification escalation populates `assumptions` with every
+contract assumption already checked (verified|falsified); the orchestrator's
+batch sweep covers only the unchecked remainder. Never a bare "plan is wrong".
+
 If an answer would change scope or acceptance, do **not** fold it into the slice.
 Return it in `Escalation` so the orchestrator can route it through the Spec Drift
 Guard (`/rite-plan repair`). Respect any AFK budget in the contract.
@@ -174,7 +178,7 @@ reuse: []
 conventions: []
 principles: []
 sources: []
-assumptions: []
+assumptions: [] # plan-gap escalation: every checked contract assumption, verified|falsified
 decisions_stood: [] # irreversible-risk items go to escalation
 dead_ends: []
 escalation: <none | gate + crisp question + proposed answer>

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

@@ -1,6 +1,6 @@
 ---
 name: rite-build
-description: Build the next approved vertical slice with evidence. HITL one-slice default; AFK may chain serially; opt-in `--parallel N` (2≤N≤3) for path-disjoint worktrees.
+description: Build the next approved vertical slice with evidence. HITL one-slice default; AFK may chain serially; opt-in `--parallel N` (2≤N≤10) for path-disjoint worktrees.
 argument-hint: "[--parallel N] [slice number or name]"
 user-invocable: true
 ---
@@ -10,7 +10,7 @@ user-invocable: true
 Build and prove one slice. HITL stops; a later user invocation starts the next.
 Explicit `.devrites/AFK` alone lets the controlling root chain pending slices
 serially under green proof, caps, and pause rules. Every wright returns after one slice.
-**Opt-in:** `/rite-build --parallel N` (2≤N≤3; N=1≡serial) follows
+**Opt-in:** `/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)).
 
@@ -38,8 +38,10 @@ Wright applies anti-slop; root verifies returns and never patches source.
   single-slice isolation when `wright-dispatch.md` preflight + reconcile hold.
 - Exact feature scope only; reject out-of-allowlist diffs; record adjacent issues.
 - Never rerun an unchanged check; re-prove after edits.
-- Unplanned dependency/design-system/gap/repair → Vet/Spec Drift Guard. Ask only
-  for licensing/cost/security/product or explicit architecture-policy decisions.
+- Unplanned dependency/design-system/gap/repair → Vet/Spec Drift Guard batch
+  sweep: every contract-assumption violation recorded before one folded
+  repair+vet. Ask only for licensing/cost/security/product or explicit
+  architecture-policy decisions.
 - Root never edits product source/tests (`.devrites/` + Workflow Artifact only).
   Wright is sole product writer; extras in returned paths/`git diff --name-only` hard-stop.
 - Principles bind; irreversible conflict needs human exception or stop.
@@ -55,9 +57,11 @@ Wright applies anti-slop; root verifies returns and never patches source.
 <!-- 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`/`3` → path-disjoint fan-out when eligible; else hard refuse.
-All-green serial integrate; one red/gap aborts. AFK charges after integrate only.
-Running lease blocks another `/rite-build`. Details: `parallel-batch.md`.
+Omitted/`1` ≡ serial; `2`–`10` → path-disjoint fan-out when eligible; else hard refuse.
+All-green serial integrate; one red/gap aborts. Abort with agent-owned plan
+gaps continues via Spec Drift Guard (batch sweep, one folded plan repair + one
+vet recheck inline); do not emit a human `Fix`. AFK charges after integrate only. Running lease blocks another
+`/rite-build`. Details: `parallel-batch.md`.
 
 ## Execute and reply
 

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

@@ -3,7 +3,7 @@
 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.
-Opt-in fan-out: [`parallel-batch.md`](parallel-batch.md) (`--parallel N`); this is default.
+This serial cycle is the default `/rite-build`. Opt-in fan-out: [`parallel-batch.md`](parallel-batch.md) (`--parallel N`).
 
 ## The cycle
 
@@ -38,8 +38,11 @@ you check yourself against: anything outside it is scope creep or a drift event.
 
 ## When the slice can't be completed cleanly
 
-- Discovered the plan is wrong → **Spec Drift Guard** (stop, record, classify, maybe
-  ask, `/rite-plan` repair).
-- Slice is bigger than one cycle → stop and `/rite-plan reslice`.
-- Blocked on a failing dependency → record in `state.md`, `/rite-plan unblock`.
+- Discovered the plan is wrong → **Spec Drift Guard** (record, classify;
+  sweep every remaining contract assumption, then one folded repair+vet inline;
+  ask only for product/policy/irreversible-risk).
+- Slice is bigger than one cycle → `/rite-plan reslice` inline when AC is
+  preserved; do not emit a human Fix.
+- Blocked on a failing dependency → record in `state.md`, `/rite-plan unblock`
+  inline when the reroute is technical.
 Never power through by guessing.