devrites 5.7.2 → 5.8.0

package/CHANGELOG.md

@@ -2,6 +2,16 @@
 
 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.8.0](https://github.com/ViktorsBaikers/DevRites/compare/v5.7.2...v5.8.0) (2026-09-14)
+
+### Added
+
+* **agents:** allowlist lean-ctx and lens tools on pi agents ([#74](https://github.com/ViktorsBaikers/DevRites/issues/74)) ([08390d3](https://github.com/ViktorsBaikers/DevRites/commit/08390d3bf3ccffec0353803e910ee7a7227ff6ba))
+
+### Fixed
+
+* **rite:** re-select parallel width after a serial round ([#73](https://github.com/ViktorsBaikers/DevRites/issues/73)) ([ac8f073](https://github.com/ViktorsBaikers/DevRites/commit/ac8f073c0640ab0350b92a87a86193de39dedd57))
+
 ## [5.7.2](https://github.com/ViktorsBaikers/DevRites/compare/v5.7.1...v5.7.2) (2026-09-14)
 
 ### Fixed

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.7.2`](https://github.com/ViktorsBaikers/DevRites/releases/tag/v5.7.2): see [`CHANGELOG.md`](CHANGELOG.md) for release notes.
+**Status:** [`v5.8.0`](https://github.com/ViktorsBaikers/DevRites/releases/tag/v5.8.0): see [`CHANGELOG.md`](CHANGELOG.md) for release notes.
 
 This is the latest published release; `main` may contain unreleased work.
 

package/docs/command-map.md

@@ -40,7 +40,7 @@ The Go surface is intentionally closed and deterministic:
 
 | Lane | Commands | Owner |
 |---|---|---|
-| Candidate and deterministic checks | `check candidate`, `check readiness [--emit-binding]`, `check seal`, `check task-graph`, `check path-disjoint`, `check skill-trust`, `check indexes` | Candidate validates/hashes the strict project manifest; readiness checks phase files, the required `tasks.md` slice graph, or emits the vetted Build-input binding; seal checks final files/open gates, that graph and binding, then exact candidate bindings. `check indexes` reports install manifest and optional code-index directory presence as JSON. |
+| Candidate and deterministic checks | `check candidate`, `check readiness [--emit-binding]`, `check seal`, `check task-graph`, `check path-disjoint`, `parallel select`, `check skill-trust`, `check indexes` | Candidate validates/hashes the strict project manifest; readiness checks phase files, the required `tasks.md` slice graph, or emits the vetted Build-input binding; seal checks final files/open gates, that graph and binding, then exact candidate bindings. `check indexes` reports install manifest and optional code-index directory presence as JSON. `parallel select` returns the greedy path-disjoint subset ≤ cap from the supplied ready slices. |
 | Workspace observation | `observe summary`, `orient`, `observe slice <slug> <SLICE-ID>` | JSON workspace snapshot for agents (cursor, task graph, `artifact_budgets`, `bulk_files`); `orient` is an alias for `observe summary`. `observe slice` prints one `SLICE-###` section of `tasks.md` so Build reads a slice, not the file. |
 | Atomic workspace state | `state resolve`, `state merge-manifest`, `state close`, `migrate [--dry-run] [--answer id=choice]` | Go owns answer/drop/batch resolution, the recorded predecessor-chain manifest union for a release milestone, transactional close, and fail-closed v5 schema normalization. |
 | Security | `secret-scan` | `/rite-ship`, safe hooks, or an operator scans staged blobs, stdin, or touched files. |

package/docs/engine/commands.md

@@ -16,6 +16,7 @@ workflow strategy.
 | `check readiness --emit-binding <slug>` | Render the exact stable Build-input binding for Vet to record after review. |
 | `check seal <slug>` | Check files required by target Phase `seal`, open human gates, the `tasks.md` slice graph, canonical `AC-###` presence when `tasks.md`/`test-plan.md` are required, the stable Build-input binding, and exact candidate bindings. |
 | `check path-disjoint [--root <dir>] [<json-file> | -]` | Verify slice path sets are pairwise disjoint. |
+| `parallel select --cap <1-10> [--root <dir>] [<json-file> | -]` | Choose the greedy path-disjoint subset ≤ cap from supplied ready slices. |
 | `check task-graph <slug>` | Validate `tasks.md` slice dependency graph for cycles, unknown deps, malformed tokens, duplicate IDs, missing `Dependencies`, and `depends_on` mismatch. |
 | `check skill-trust <path>` | Scan one skill/agent Markdown file for structural trust violations. |
 | `observe summary <slug>` | Emit sanitized JSON workspace summary from one retained observation. `task_graph.ok` is true iff `task_graph.problems` is empty; `problems` lists cycle, unknown-dep, malformed-token, duplicate-id, and missing-`Dependencies` blockers. |

package/docs/orchestration.md

@@ -130,8 +130,8 @@ Isolation does not authorize same-worktree throughput. Parallel writers are allo
 **only** under the `/rite-build` batch path when path-disjoint eligibility, abort-batch,
 and a control `parallel-lease.md` apply. `--parallel N` (or the AFK sentinel
 `max_parallel`, default cap 10 under `/rite-autocomplete`) is a **cap**: each round runs
-the largest eligible set, recomputes after every integrate, and repeats until no pending
-slice remains; fewer than two eligible slices fall back to the serial cycle (see
+the largest eligible set, recomputes after every completed round, and repeats until no
+pending slice remains; a one-slice round is serial for that round only (see
 [`parallel-batch.md`](../pack/.claude/skills/rite-build/reference/parallel-batch.md)).
 Same-worktree multi-writer and root-emulated worktrees remain forbidden; default
 `/rite-build` stays one writer across linked worktrees.

package/engine/internal/parallel/cli.go

@@ -5,6 +5,7 @@ import (
 	"fmt"
 	"io"
 	"os"
+	"strconv"
 	"strings"
 )
 
@@ -71,6 +72,71 @@ func runPathDisjoint(args []string, stdin io.Reader, stdout, stderr io.Writer) i
 	return ExitOK
 }
 
+func cmdSelect(args []string, stdin io.Reader, stdout, stderr io.Writer) int {
+	const usage = "usage: parallel select --cap <1-10> [--root <dir>] [<json-file>|-]"
+	root := ""
+	jsonPath := "-"
+	capN := 0
+	sawCap := false
+	for i := 0; i < len(args); i++ {
+		switch args[i] {
+		case "--root":
+			if i+1 >= len(args) {
+				fmt.Fprintln(stderr, usage)
+				return ExitUsage
+			}
+			i++
+			root = args[i]
+		case "--cap":
+			if i+1 >= len(args) {
+				fmt.Fprintln(stderr, usage)
+				return ExitUsage
+			}
+			i++
+			n, err := strconv.Atoi(args[i])
+			if err != nil {
+				fmt.Fprintf(stderr, "parallel select: --cap must be an integer\n")
+				return ExitUsage
+			}
+			capN = n
+			sawCap = true
+		case "-h", "--help":
+			fmt.Fprintln(stdout, usage)
+			return ExitOK
+		default:
+			if args[i] != "-" && strings.HasPrefix(args[i], "-") {
+				fmt.Fprintf(stderr, "parallel select: unknown flag %s\n", args[i])
+				return ExitUsage
+			}
+			jsonPath = args[i]
+		}
+	}
+	if !sawCap {
+		fmt.Fprintln(stderr, usage)
+		return ExitUsage
+	}
+	data, err := readJSONInput(jsonPath, stdin)
+	if err != nil {
+		fmt.Fprintf(stderr, "parallel select: %v\n", err)
+		return ExitBlocked
+	}
+	slices, err := ParseSlicesJSON(data)
+	if err != nil {
+		fmt.Fprintf(stderr, "parallel select: %v\n", err)
+		return ExitBlocked
+	}
+	selected, err := SelectGreedy(capN, slices, root)
+	if err != nil {
+		fmt.Fprintf(stderr, "parallel select: %v\n", err)
+		if strings.Contains(err.Error(), "cap must be") {
+			return ExitUsage
+		}
+		return ExitBlocked
+	}
+	fmt.Fprintln(stdout, formatSelect(selected))
+	return ExitOK
+}
+
 func runParallel(args []string, stdin io.Reader, stdout, stderr io.Writer) int {
 	if len(args) == 0 {
 		fmt.Fprintln(stderr, parallelUsage())
@@ -98,6 +164,8 @@ func runParallel(args []string, stdin io.Reader, stdout, stderr io.Writer) int {
 		return cmdLeaseClear(rest, stdout, stderr)
 	case "check-disjoint", "path-disjoint":
 		return runPathDisjoint(rest, stdin, stdout, stderr)
+	case "select":
+		return cmdSelect(rest, stdin, stdout, stderr)
 	case "-h", "--help", "help":
 		fmt.Fprintln(stdout, parallelUsage())
 		return ExitOK
@@ -121,6 +189,7 @@ Subcommands:
   lease-read      --root --slug [--field name]
   lease-clear     --root --slug
   check-disjoint  [--root] [<json-file>|-]
+  select          --cap <1-10> [--root] [<json-file>|-]
 
 Exit codes: 0 ok, 2 usage, 3 blocked`)
 }

package/engine/internal/parallel/select.go

@@ -0,0 +1,76 @@
+package parallel
+
+import (
+	"fmt"
+	"strings"
+)
+
+// SelectGreedy returns the largest plan-order pairwise-disjoint subset of ready
+// whose size is ≤ cap. ready must already be dependency-satisfied and in plan
+// order. cap is 1–MaxParallelSlices; 1 is a legal one-slice round, not a latch.
+func SelectGreedy(cap int, ready []SlicePaths, root string) ([]SlicePaths, error) {
+	if cap < 1 || cap > MaxParallelSlices {
+		return nil, fmt.Errorf("cap must be 1-%d (got %d)", MaxParallelSlices, cap)
+	}
+	normalized := make([]SlicePaths, 0, len(ready))
+	seen := make(map[string]struct{}, len(ready))
+	for i, item := range ready {
+		label := fmt.Sprintf("slice %d", i)
+		if item.ID != "" {
+			if err := validateSliceID(item.ID); err != nil {
+				return nil, fmt.Errorf("%s: %w", label, err)
+			}
+			label = fmt.Sprintf("slice %q", item.ID)
+		} else {
+			return nil, fmt.Errorf("%s: missing id", label)
+		}
+		if _, ok := seen[item.ID]; ok {
+			return nil, fmt.Errorf("duplicate slice id %q", item.ID)
+		}
+		seen[item.ID] = struct{}{}
+		paths, err := validateSlicePaths(item.Paths, label, root)
+		if err != nil {
+			return nil, err
+		}
+		normalized = append(normalized, SlicePaths{ID: item.ID, Paths: paths})
+	}
+
+	selected := make([]SlicePaths, 0, min(cap, len(normalized)))
+	for _, cand := range normalized {
+		if len(selected) >= cap {
+			break
+		}
+		if len(selected) == 0 {
+			selected = append(selected, cand)
+			continue
+		}
+		trial := append(append([]SlicePaths{}, selected...), cand)
+		if _, err := CheckPathDisjoint(trial, root); err != nil {
+			if strings.Contains(err.Error(), "overlap") {
+				continue
+			}
+			return nil, err
+		}
+		selected = trial
+	}
+	return selected, nil
+}
+
+func selectMode(n int) string {
+	switch {
+	case n <= 0:
+		return "none"
+	case n == 1:
+		return "serial"
+	default:
+		return "parallel"
+	}
+}
+
+func formatSelect(selected []SlicePaths) string {
+	ids := make([]string, len(selected))
+	for i, item := range selected {
+		ids[i] = item.ID
+	}
+	return fmt.Sprintf("select: n_eff=%d mode=%s slices=%s", len(selected), selectMode(len(selected)), strings.Join(ids, ","))
+}

package/engine/internal/parallel/select_test.go

@@ -0,0 +1,95 @@
+package parallel
+
+import (
+	"bytes"
+	"strings"
+	"testing"
+)
+
+func TestSelectGreedyOneThenMany(t *testing.T) {
+	t.Parallel()
+	round1, err := SelectGreedy(5, []SlicePaths{
+		{ID: "SLICE-001", Paths: []string{"src/a.go"}},
+	}, "")
+	if err != nil {
+		t.Fatal(err)
+	}
+	if len(round1) != 1 || round1[0].ID != "SLICE-001" {
+		t.Fatalf("round1=%#v", round1)
+	}
+
+	round2, err := SelectGreedy(5, []SlicePaths{
+		{ID: "SLICE-002", Paths: []string{"src/b.go"}},
+		{ID: "SLICE-003", Paths: []string{"src/c.go"}},
+		{ID: "SLICE-004", Paths: []string{"src/d.go"}},
+		{ID: "SLICE-005", Paths: []string{"src/e.go"}},
+	}, "")
+	if err != nil {
+		t.Fatal(err)
+	}
+	if len(round2) != 4 {
+		t.Fatalf("after a one-slice round, cap 5 with 4 ready must select 4, got %d (%#v)", len(round2), round2)
+	}
+}
+
+func TestSelectGreedySkipsOverlapKeepsCap(t *testing.T) {
+	t.Parallel()
+	got, err := SelectGreedy(5, []SlicePaths{
+		{ID: "SLICE-001", Paths: []string{"src/shared.go"}},
+		{ID: "SLICE-002", Paths: []string{"src/shared.go", "src/b.go"}},
+		{ID: "SLICE-003", Paths: []string{"src/c.go"}},
+	}, "")
+	if err != nil {
+		t.Fatal(err)
+	}
+	if len(got) != 2 || got[0].ID != "SLICE-001" || got[1].ID != "SLICE-003" {
+		t.Fatalf("got %#v", got)
+	}
+}
+
+func TestSelectGreedyRejectsBadCap(t *testing.T) {
+	t.Parallel()
+	if _, err := SelectGreedy(0, nil, ""); err == nil {
+		t.Fatal("cap 0 should fail")
+	}
+	if _, err := SelectGreedy(11, nil, ""); err == nil {
+		t.Fatal("cap 11 should fail")
+	}
+}
+
+func TestSelectCLIOneThenMany(t *testing.T) {
+	t.Parallel()
+	var stdout, stderr bytes.Buffer
+	in := strings.NewReader(`{"slices":[{"id":"SLICE-001","paths":["src/a.go"]}]}`)
+	code := Run("parallel", []string{"select", "--cap", "5", "-"}, in, &stdout, &stderr)
+	if code != ExitOK {
+		t.Fatalf("code=%d stderr=%s", code, stderr.String())
+	}
+	if got := stdout.String(); got != "select: n_eff=1 mode=serial slices=SLICE-001\n" {
+		t.Fatalf("round1 got %q", got)
+	}
+
+	stdout.Reset()
+	stderr.Reset()
+	in = strings.NewReader(`{"slices":[
+		{"id":"SLICE-002","paths":["src/b.go"]},
+		{"id":"SLICE-003","paths":["src/c.go"]},
+		{"id":"SLICE-004","paths":["src/d.go"]}
+	]}`)
+	code = Run("parallel", []string{"select", "--cap", "5", "-"}, in, &stdout, &stderr)
+	if code != ExitOK {
+		t.Fatalf("code=%d stderr=%s", code, stderr.String())
+	}
+	if got := stdout.String(); got != "select: n_eff=3 mode=parallel slices=SLICE-002,SLICE-003,SLICE-004\n" {
+		t.Fatalf("round2 got %q; must not stay n_eff=1", got)
+	}
+}
+
+func TestSelectCLIRequiresCap(t *testing.T) {
+	t.Parallel()
+	var stdout, stderr bytes.Buffer
+	code := Run("parallel", []string{"select", "-"}, strings.NewReader(`{"slices":[]}`), &stdout, &stderr)
+	if code != ExitUsage {
+		t.Fatalf("code=%d want %d stderr=%s", code, ExitUsage, stderr.String())
+	}
+}

package/pack/.claude/settings.json

@@ -13,6 +13,7 @@
       "Bash(devrites-engine orient *)",
       "Bash(devrites-engine observe *)",
       "Bash(devrites-engine parallel status *)",
+      "Bash(devrites-engine parallel select *)",
       "Bash(devrites-engine parallel create *)",
       "Bash(devrites-engine parallel record-green *)",
       "Bash(devrites-engine parallel integrate *)",

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

@@ -120,7 +120,8 @@ candidate manifest to cover the whole recorded chain — run
   run exactly as without this field.
 
 `max_parallel` caps a Build batch for unattended runs; `1` forces the serial cycle.
-Unattended runs take the largest eligible set ≤ cap and recompute after every integrate
+Unattended runs take the largest eligible set ≤ cap and recompute after every completed
+round (serial slice or parallel integrate)
 ([parallel-batch.md § Dynamic selection and re-batching](../../../rite-build/reference/parallel-batch.md#dynamic-selection-and-re-batching));
 an explicit `/rite-build --parallel N` cap wins for that invocation.
 

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

@@ -94,9 +94,10 @@ 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: `--parallel N`, else
-   sentinel `max_parallel`, else 10) and recomputes after every integrate until no
-   pending slice remains; serial only when fewer than two slices are eligible or the
-   host cannot isolate concurrent worktree writers.
+   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
+   selection runs again (host isolation still forces serial when concurrent writers
+   cannot be separated).
    **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/.claude/skills/rite-autocomplete/reference/loop.md

@@ -65,7 +65,7 @@ Workspace files carry state; chat does not. Read and execute each phase skill:
 | 3 | `/rite-temper` | harden or reduce; expansion and irreversible risk pause |
 | 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 10; serial when <2 eligible); recompute after each integrate; charge once per green built slice |
+| 6 | `/rite-build` batch loop | largest eligible path-disjoint set (cap 10; one-slice round when <2 eligible); recompute after each round; charge once per green built 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/.claude/skills/rite-build/SKILL.md

@@ -60,7 +60,8 @@ Wright applies anti-slop; root verifies returns and never patches source.
 
 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 integrate until no pending slice remains
+filled, and recomputes after every completed round (serial slice or parallel
+integrate) 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. Non-integer/`N≤0`/`N>10` hard refuse.

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

@@ -16,7 +16,9 @@ control; irreversible work (destructive/auth/public API) always pauses.
 The controlling root owns the cap:
 
 1. **Before every dispatch**, re-read `.devrites/AFK`, `state.md`, and the
-   selected slice. A configured `max_slices` and any existing
+   selected slice. When `--parallel N` or sentinel `max_parallel` is greater than
+   1, recompute `N_eff` via `parallel select` before the next dispatch — a prior
+   one-slice round does not keep the run serial. A configured `max_slices` and any existing
    `afk_slices_remaining` value, including its released bullet form, must each
    be a decimal nonnegative integer. A missing
    `state.md` or malformed configured value fails closed; an omitted cap is the

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

@@ -26,7 +26,7 @@ RECORD    → orchestrator: after green verification, update state.md/evidence.m
             upsert the authoritative candidate manifest from the actual scoped diff
 (CHECKPOINT) → orchestrator: commit the proven slice local-only as WIP(<slug>)
             with a [devrites-context] body → clean tree, survives a crash (checkpoint.md)
-NEXT      → HITL root reports and stops; AFK root may repeat only under afk-discipline.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
 ```
 
 ## Why the boundary matters

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

@@ -28,18 +28,20 @@ N_eff = min(
 )
 ```
 
-Select **greedily in plan order**: walk pending slices whose `depends_on` are built and
-add each one while it stays pairwise disjoint with the selected set and the cap is not
-reached. Then `N_eff ≥ 2` → parallel batch; `N_eff = 1` → the serial one-slice cycle;
-nothing pending → Prove. A cap that cannot be filled is normal: take fewer.
-
-**Re-batch automatically.** After integrate + cleanup are green, re-read `state.md`,
-the pending slices (`observe slice`), and the updated tree, then recompute: integrated
-siblings leave the pending set and free their paths, and satisfied dependencies unlock
-new slices. Repeat until no pending slice remains. Under `.devrites/AFK` and
-`/rite-autocomplete` the repeat is part of the same run — a new batch is another
-`/rite-build --parallel` round inside it, not a new user invocation; HITL stops after
-each batch. A batch of three followed by one of four and then two is the expected shape.
+Select **greedily in plan order**: pass every currently dependency-ready pending slice
+(plan order, `Files likely touched`) to
+`devrites-engine parallel select --cap N [--root <dir>]`. `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.
+
+**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.
 
 ## Path-disjoint
 
@@ -71,7 +73,8 @@ Lease: `batch_id`, `created_at`, `base_sha`, `n`,
 1. Orient/gate; parse the cap; compute `N_eff` and select the eligible set
    ([Dynamic selection and re-batching](#dynamic-selection-and-re-batching)) —
    candidates from `orient` `task_graph.slices` + built list, each candidate's
-   `Files likely touched` via `observe slice`, disjointness via `check path-disjoint`.
+   `Files likely touched` via `observe slice`, then
+   `parallel select --cap N` (pairwise disjointness is inside that verb).
 2. Write lease; freeze `B=HEAD`; `parallel create` worktrees.
 3. Dispatch ≤10 wrights in parallel (cwd=worktree; allowlist; prove `HEAD==B`).
 4. Inspect each returned path list, cumulative diff from `B`, transfer identity,
@@ -163,6 +166,7 @@ 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 create --root <repo> --slug <slug> --batch <id> --base <B> --json <file>|-
 devrites-engine parallel record-green --root <repo> --slug <slug> --slice <id> --commit <sha>
 devrites-engine parallel integrate --root <repo> --slug <slug> --apply-to-control

package/pack/generated/claude/settings.json

@@ -13,6 +13,7 @@
       "Bash(devrites-engine orient *)",
       "Bash(devrites-engine observe *)",
       "Bash(devrites-engine parallel status *)",
+      "Bash(devrites-engine parallel select *)",
       "Bash(devrites-engine parallel create *)",
       "Bash(devrites-engine parallel record-green *)",
       "Bash(devrites-engine parallel integrate *)",

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

@@ -120,7 +120,8 @@ candidate manifest to cover the whole recorded chain — run
   run exactly as without this field.
 
 `max_parallel` caps a Build batch for unattended runs; `1` forces the serial cycle.
-Unattended runs take the largest eligible set ≤ cap and recompute after every integrate
+Unattended runs take the largest eligible set ≤ cap and recompute after every completed
+round (serial slice or parallel integrate)
 ([parallel-batch.md § Dynamic selection and re-batching](../../../rite-build/reference/parallel-batch.md#dynamic-selection-and-re-batching));
 an explicit `/rite-build --parallel N` cap wins for that invocation.
 

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

@@ -94,9 +94,10 @@ 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: `--parallel N`, else
-   sentinel `max_parallel`, else 10) and recomputes after every integrate until no
-   pending slice remains; serial only when fewer than two slices are eligible or the
-   host cannot isolate concurrent worktree writers.
+   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
+   selection runs again (host isolation still forces serial when concurrent writers
+   cannot be separated).
    **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/claude/skills/rite-autocomplete/reference/loop.md

@@ -65,7 +65,7 @@ Workspace files carry state; chat does not. Read and execute each phase skill:
 | 3 | `/rite-temper` | harden or reduce; expansion and irreversible risk pause |
 | 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 10; serial when <2 eligible); recompute after each integrate; charge once per green built slice |
+| 6 | `/rite-build` batch loop | largest eligible path-disjoint set (cap 10; one-slice round when <2 eligible); recompute after each round; charge once per green built 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/claude/skills/rite-build/SKILL.md

@@ -60,7 +60,8 @@ Wright applies anti-slop; root verifies returns and never patches source.
 
 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 integrate until no pending slice remains
+filled, and recomputes after every completed round (serial slice or parallel
+integrate) 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. Non-integer/`N≤0`/`N>10` hard refuse.

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

@@ -16,7 +16,9 @@ control; irreversible work (destructive/auth/public API) always pauses.
 The controlling root owns the cap:
 
 1. **Before every dispatch**, re-read `.devrites/AFK`, `state.md`, and the
-   selected slice. A configured `max_slices` and any existing
+   selected slice. When `--parallel N` or sentinel `max_parallel` is greater than
+   1, recompute `N_eff` via `parallel select` before the next dispatch — a prior
+   one-slice round does not keep the run serial. A configured `max_slices` and any existing
    `afk_slices_remaining` value, including its released bullet form, must each
    be a decimal nonnegative integer. A missing
    `state.md` or malformed configured value fails closed; an omitted cap is the

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

@@ -26,7 +26,7 @@ RECORD    → orchestrator: after green verification, update state.md/evidence.m
             upsert the authoritative candidate manifest from the actual scoped diff
 (CHECKPOINT) → orchestrator: commit the proven slice local-only as WIP(<slug>)
             with a [devrites-context] body → clean tree, survives a crash (checkpoint.md)
-NEXT      → HITL root reports and stops; AFK root may repeat only under afk-discipline.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
 ```
 
 ## Why the boundary matters

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

@@ -28,18 +28,20 @@ N_eff = min(
 )
 ```
 
-Select **greedily in plan order**: walk pending slices whose `depends_on` are built and
-add each one while it stays pairwise disjoint with the selected set and the cap is not
-reached. Then `N_eff ≥ 2` → parallel batch; `N_eff = 1` → the serial one-slice cycle;
-nothing pending → Prove. A cap that cannot be filled is normal: take fewer.
-
-**Re-batch automatically.** After integrate + cleanup are green, re-read `state.md`,
-the pending slices (`observe slice`), and the updated tree, then recompute: integrated
-siblings leave the pending set and free their paths, and satisfied dependencies unlock
-new slices. Repeat until no pending slice remains. Under `.devrites/AFK` and
-`/rite-autocomplete` the repeat is part of the same run — a new batch is another
-`/rite-build --parallel` round inside it, not a new user invocation; HITL stops after
-each batch. A batch of three followed by one of four and then two is the expected shape.
+Select **greedily in plan order**: pass every currently dependency-ready pending slice
+(plan order, `Files likely touched`) to
+`devrites-engine parallel select --cap N [--root <dir>]`. `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.
+
+**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.
 
 ## Path-disjoint
 
@@ -71,7 +73,8 @@ Lease: `batch_id`, `created_at`, `base_sha`, `n`,
 1. Orient/gate; parse the cap; compute `N_eff` and select the eligible set
    ([Dynamic selection and re-batching](#dynamic-selection-and-re-batching)) —
    candidates from `orient` `task_graph.slices` + built list, each candidate's
-   `Files likely touched` via `observe slice`, disjointness via `check path-disjoint`.
+   `Files likely touched` via `observe slice`, then
+   `parallel select --cap N` (pairwise disjointness is inside that verb).
 2. Write lease; freeze `B=HEAD`; `parallel create` worktrees.
 3. Dispatch ≤10 wrights in parallel (cwd=worktree; allowlist; prove `HEAD==B`).
 4. Inspect each returned path list, cumulative diff from `B`, transfer identity,
@@ -163,6 +166,7 @@ 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 create --root <repo> --slug <slug> --batch <id> --base <B> --json <file>|-
 devrites-engine parallel record-green --root <repo> --slug <slug> --slice <id> --commit <sha>
 devrites-engine parallel integrate --root <repo> --slug <slug> --apply-to-control

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

@@ -120,7 +120,8 @@ candidate manifest to cover the whole recorded chain — run
   run exactly as without this field.
 
 `max_parallel` caps a Build batch for unattended runs; `1` forces the serial cycle.
-Unattended runs take the largest eligible set ≤ cap and recompute after every integrate
+Unattended runs take the largest eligible set ≤ cap and recompute after every completed
+round (serial slice or parallel integrate)
 ([parallel-batch.md § Dynamic selection and re-batching](../../../rite-build/reference/parallel-batch.md#dynamic-selection-and-re-batching));
 an explicit `$rite-build --parallel N` cap wins for that invocation.
 

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

@@ -94,9 +94,10 @@ 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: `--parallel N`, else
-   sentinel `max_parallel`, else 10) and recomputes after every integrate until no
-   pending slice remains; serial only when fewer than two slices are eligible or the
-   host cannot isolate concurrent worktree writers.
+   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
+   selection runs again (host isolation still forces serial when concurrent writers
+   cannot be separated).
    **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: