devrites 5.7.1 → 5.8.0

package/CHANGELOG.md

@@ -2,6 +2,22 @@
 
 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
+
+* **skills:** drop absolute AFK sentinel expiry so unattended runs finish ([#72](https://github.com/ViktorsBaikers/DevRites/issues/72)) ([3f880cb](https://github.com/ViktorsBaikers/DevRites/commit/3f880cb0c0e3072a1512c87229c9c1c38ef12417))
+
 ## [5.7.1](https://github.com/ViktorsBaikers/DevRites/compare/v5.7.0...v5.7.1) (2026-09-13)
 
 ### 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.1`](https://github.com/ViktorsBaikers/DevRites/releases/tag/v5.7.1): 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.
 
@@ -239,7 +239,6 @@ max_slices: 10
 max_agents: 32
 max_minutes: 120
 max_review_queue: 8
-expires_at: "<ISO-8601 UTC timestamp>"
 allow_gates: [advisory]
 ```
 
@@ -247,8 +246,9 @@ The workflow treats this file as configuration and never rewrites it.
 `max_slices` seeds the remaining budget in the active feature's `state.md`; the
 root charges that state exactly once after each green built slice and stops
 before another dispatch at zero. Unattended slice work additionally requires a
-valid `max_agents`, `max_minutes`, `max_review_queue`, and `expires_at`;
-sentinels that miss or malform these fail closed. Delete `.devrites/AFK` to
+valid `max_agents`, `max_minutes`, and `max_review_queue`;
+sentinels that miss or malform these fail closed. Leftover `expires_at` is
+ignored and never rewritten. Delete `.devrites/AFK` to
 return to HITL.
 
 AFK still pauses for product, scope, or policy choices, irreversible risk,

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

@@ -54,7 +54,6 @@ max_slices: 10                       # whole-workspace writer budget; seeds stat
 max_agents: 32                       # native agent dispatches in one host activation
 max_minutes: 120                     # wall-clock minutes in one host activation
 max_review_queue: 8                  # unresolved review/gate items admitted before fan-out stops
-expires_at: "<ISO-8601 UTC timestamp>" # absolute unattended-authority expiry
 # max_tokens: 200000                 # optional stricter host-observed token cap
 # max_cost_usd: 10                   # optional stricter host-observed cost cap
 notify: "ntfy.sh/my-topic"           # shell command; examples: rite-build/reference/afk-discipline.md
@@ -108,7 +107,7 @@ candidate manifest to cover the whole recorded chain — run
 
 - Only continuations recorded in the parent's `decisions.md` sequence
   ([slicing.md § Continuation workspaces](../../../rite-plan/reference/slicing.md#continuation-workspaces))
-  qualify; no recorded next entry, or the cap/expiry/review-queue bound reached, stops
+  qualify; no recorded next entry, or the cap/review-queue bound reached, stops
   with the winning reason.
 - Milestones are **not** shipped: they stay sealed and unarchived in `.devrites/work/`
   with `Next step: /rite-ship` preserved. Per-slice `WIP(<slug>)` checkpoints still
@@ -121,34 +120,34 @@ 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.
 
 ## Unattended resource envelope
 
 AFK writer admission needs a bounded input queue, effective slice cap, and valid
-`max_agents`, `max_minutes`, `max_review_queue`, and `expires_at`. Existing sentinels
+`max_agents`, `max_minutes`, and `max_review_queue`. Existing sentinels
 that declare writer admission but miss/malform these fail closed; cold resume keeps the
-state-owned slice counter.
+state-owned slice counter. A leftover `expires_at` is ignored and never rewritten.
 Read-only watchers use equivalent native caps from [`loop-operations.md`](loop-operations.md).
 
 `max_agents` counts every leaf in the native activation, including failures and
 parallel branches; do not add dispatch telemetry to `.devrites/`. `max_review_queue`
 counts open validating questions plus unresolved admitted Critical/Important findings.
-Above it stop; at it run only reconciliation that reduces the queue. `expires_at` is
-absolute ISO-8601 authority. Optional `max_tokens`/`max_cost_usd` lower enforceable
-native caps; if declared but unobservable, stop.
+Above it stop; at it run only reconciliation that reduces the queue. Optional
+`max_tokens`/`max_cost_usd` lower enforceable native caps; if declared but unobservable, stop.
 
 Numeric limits are nonnegative decimals. Before costly checks, fan-out, or writing,
 run cheap readiness, reject overlap, count queue, and confirm agent/time/token/cost
 headroom; re-check after every result. Never start one call that can exceed remaining
 headroom. Agent/time/token/cost counters are per native activation and start fresh only
-for a genuinely new activation. Slices, recovery attempts, absolute expiry, and current
+for a genuinely new activation. Slices, recovery attempts, and current
 review queue remain durable/recomputed across wakes. Persist each activation stop and
 checkpoint before notification.
 
-New sentinels default `expires_at` to arming + 4h with no notification/token/cost cap.
+New sentinels write no `expires_at` and no notification/token/cost cap.
 Post-Vet pending count may lower slices. Existing files
 never receive missing defaults implicitly.
 

package/pack/.claude/skills/devrites-lib/reference/standards/loop-operations.md

@@ -38,13 +38,13 @@ Every unattended loop must name:
 4. **Evaluator:** the skill's existing readiness, proof, review, or watcher verdict.
 5. **Budget:** every applicable `.devrites/AFK` resource cap.
 6. **Checkpoint:** durable workspace/evidence update before the turn ends.
-7. **Stop:** success, human/safety/access gate, expiry, budget exhaustion, unchanged
+7. **Stop:** success, human/safety/access gate, budget exhaustion, unchanged
    no-progress fingerprint, host failure, or terminal external state.
 8. **Notification:** optional native-host notification after state is durable; never a
    substitute for recording the stop.
 
 A read-only scheduled/event loop that has no active AFK workspace must still configure
-native maximum activations/iterations, wall time, and absolute expiry. Add token/cost
+native maximum activations/iterations and wall time. Add token/cost
 caps when the host exposes them. One observation cycle per wake is the work unit; the
 skill never starts its own timer or background poller.
 
@@ -76,7 +76,7 @@ armed AFK workspace whose exact scope, gates, and budgets permit it.
   is `gap`/`cannot_verify`, never success.
 - Do not retry unchanged work merely because a timer fired. Apply the exact
   causal-fingerprint recovery cap ([`afk-hitl.md`](afk-hitl.md)).
-- A cold resume continues durable slice/recovery state and absolute expiry. Fresh
+- A cold resume continues durable slice/recovery state. Fresh
   native activation counters follow `afk-hitl.md`; no durable bound is reinitialized.
 - Native notifications fire only after evidence and stop state are written.
 

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

@@ -48,7 +48,7 @@ executable controller/harness/bundle bytes or a missing writer, read
 - Every exact causal fingerprint gets at most three no-progress corrections.
   Closing one is progress; a distinct Critical/Important invariant has its own
   budget. Lower severity cannot prolong recovery.
-- Enforce `--max-slices`, the AFK sentinel, expiry, review queue, and native
+- Enforce `--max-slices`, the AFK sentinel, review queue, and native
   agent/token/cost/time limits before every phase or dispatch. Count failed,
   malformed, and unavailable leaf calls. At the review cap, permit only work
   that reduces the queue.
@@ -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

@@ -18,7 +18,6 @@ max_slices: 10
 max_agents: 32
 max_minutes: 120
 max_review_queue: 8
-expires_at: "<now + 4 hours>"
 # continue_sequence: true          # opt-in: chain recorded continuations after Seal GO
 # max_workspaces: 5                # sequence budget when chaining
 # max_parallel: 10                 # Build batch cap; 1 = serial (default: eligible, cap 10)
@@ -28,11 +27,11 @@ expires_at: "<now + 4 hours>"
 ```
 
 Read an existing sentinel first. Preserve it byte-for-byte when valid; stop if
-its gate ceiling exceeds advisory, required envelope is malformed/expired, or
+its gate ceiling exceeds advisory, required envelope is malformed, or
 `max_slices` conflicts with the invocation. If absent, write it once after
-clarity, replacing the safe slice default only for explicit `--max-slices N`
-and resolving one absolute UTC expiry. It is read-only: never rewrite it after
-Vet or reset it on resume.
+clarity, replacing the safe slice default only for explicit `--max-slices N`.
+It is read-only: never rewrite it after Vet or reset it on resume. Leftover
+`expires_at` is ignored and never rewritten.
 
 ### Derive the mutable post-vet budget
 
@@ -45,12 +44,12 @@ or reinitialize it. AFK configuration itself stays unchanged.
 
 Before every phase, review fan-out, recovery, or writer dispatch, apply
 [`afk-hitl.md`](../../devrites-lib/reference/standards/afk-hitl.md#unattended-resource-envelope): cheapest current-state/readiness
-check first; reject overlap; count unresolved review; check expiry and native
+check first; reject overlap; count unresolved review; check native
 agent/token/cost/time headroom. Count every leaf result. At the review cap, only
 reconciliation that reduces the queue may run. Any reached or unobservable
 bound stops before more work and persists the winning reason. A new activation
-gets fresh activation-local counters but retains durable slice/recovery state,
-expiry, and recomputed queue.
+gets fresh activation-local counters but retains durable slice/recovery state
+and recomputed queue.
 
 `allow_gates: [advisory]` means validating gates pause now rather than becoming
 Seal NO-GO. Only explicit human configuration outside Autocomplete may widen it.
@@ -66,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 |
@@ -100,7 +99,7 @@ fields are missing is re-seeded from its `brief.md` parent/position and the
 parent's counter (same values, never a second charge); a child with no recorded
 parent/position is not a sequence member and the chain stops.
 
-Stop instead when: no recorded next entry; the cap, expiry, or review-queue bound is
+Stop instead when: no recorded next entry; the cap or review-queue bound is
 reached; a human-owned, safety, access, or exhaustion condition fires; or Seal returns
 `NO-GO`. On stop, report the sequence position, the sealed-but-unshipped workspaces, and
 the single release command (`/rite-autocomplete <release milestone> --ship`, or

package/pack/.claude/skills/rite-autocomplete/reference/stop-conditions.md

@@ -71,11 +71,10 @@ exhausted.
   when slices remain; malformed state also stops. Report whether the winning
   bound was the pre-existing remaining value, explicit flag, sentinel cap, or post-vet pending count.
   Zero with no pending slices is normal completion and proceeds to Prove.
-- **Resource envelope:** missing/malformed/expired AFK, overlapping run,
+- **Resource envelope:** missing/malformed AFK, overlapping run,
   exhausted/unobservable declared agent/token/cost/time headroom, or review queue
   above cap. At cap, only queue-reducing reconciliation may run. Persist winning
-  bound and observed usage; a new activation does not reset durable budgets or
-  expiry.
+  bound and observed usage; a new activation does not reset durable budgets.
 - **Confidence:** intent still cannot become testable acceptance after interview.
 - **Repeated failure:** the exact fingerprint's bounded recovery is exhausted.
 

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 *)",