devrites 7.0.17 → 7.1.0

package/CHANGELOG.md

@@ -2,6 +2,17 @@
 
 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`.
 
+## [7.1.0](https://github.com/ViktorsBaikers/DevRites/compare/v7.0.17...v7.1.0) (2026-10-28)
+
+### Added
+
+* **devrites:** measure slice parallelism and ship the plan-width guard ([#179](https://github.com/ViktorsBaikers/DevRites/issues/179)) ([1b8defe](https://github.com/ViktorsBaikers/DevRites/commit/1b8defe92ecd3bc5feb4757f3ecf5e9d611467cc))
+
+### Fixed
+
+* **ci:** mirror the new undici exceptions in osv-scanner.toml ([9a916a1](https://github.com/ViktorsBaikers/DevRites/commit/9a916a1cb2215e0d8382655c88e93f5adbea04fd))
+* **no-release:** preserve autocomplete rolling parallelism ([#178](https://github.com/ViktorsBaikers/DevRites/issues/178)) ([604c705](https://github.com/ViktorsBaikers/DevRites/commit/604c705d4a470ca992bd9050651bfc64145ced97))
+
 ## [7.0.17](https://github.com/ViktorsBaikers/DevRites/compare/v7.0.16...v7.0.17) (2026-10-27)
 
 ### Fixed

package/README.md

@@ -31,7 +31,7 @@ history can't lose it. After you clear the conversation, switch hosts, or hand
 the feature to another engineer, the next session reads the same plan,
 decisions, and evidence before it continues.
 
-**Status:** [`v7.0.17`](https://github.com/ViktorsBaikers/DevRites/releases/tag/v7.0.17): see [`CHANGELOG.md`](CHANGELOG.md) for release notes.
+**Status:** [`v7.1.0`](https://github.com/ViktorsBaikers/DevRites/releases/tag/v7.1.0): see [`CHANGELOG.md`](CHANGELOG.md) for release notes.
 
 This is the latest published release; `main` may contain unreleased work.
 

package/engine/help.go

@@ -12,7 +12,7 @@ import (
 )
 
 const (
-	checkUsage = `usage: devrites-engine check <candidate|readiness|preconditions|seal|path-disjoint|task-graph|slice|diff-scope|skill-trust|indexes|regression|drift|windows|dup|anchors|perturb> ...
+	checkUsage = `usage: devrites-engine check <candidate|readiness|preconditions|seal|path-disjoint|task-graph|affected|slice|diff-scope|skill-trust|indexes|regression|drift|windows|dup|anchors|perturb> ...
 
   check candidate <slug>
   check readiness <slug>
@@ -20,7 +20,8 @@ const (
   check preconditions <slug> [--slice SLICE-###] [--timeout N]
   check seal <slug>
   check path-disjoint [--root <dir>] [<json-file>|-]
-  check task-graph <slug>
+  check task-graph <slug> [--strict]
+  check affected <path...>
   check slice <slug> <SLICE-ID>
   check diff-scope <slug> --allow <csv> | --allow-file <path> [--worktree|--staged|--base <ref>] [--allow-empty] [--baseline] [--verbose] [--cwd <dir>]
   check diff-scope <slug> --snapshot [--worktree|--staged|--base <ref>] [--cwd <dir>]
@@ -84,7 +85,7 @@ const (
 	readinessUsage      = "usage: devrites-engine check readiness <slug>\n       devrites-engine check readiness --emit-binding <slug>"
 	preconditionsUsage  = "usage: devrites-engine check preconditions <slug> [--slice SLICE-###] [--timeout N]"
 	sealUsage           = "usage: devrites-engine check seal <slug>"
-	taskGraphUsage      = "usage: devrites-engine check task-graph <slug>"
+	taskGraphUsage      = "usage: devrites-engine check task-graph <slug> [--strict]"
 	sliceCheckUsage     = "usage: devrites-engine check slice <slug> <SLICE-ID>"
 	skillTrustUsage     = "usage: devrites-engine check skill-trust <path>"
 	indexesUsage        = "usage: devrites-engine check indexes [--root <dir>]"

package/engine/internal/lib/affected.go

@@ -0,0 +1,233 @@
+package lib
+
+import (
+	"bufio"
+	"fmt"
+	"io"
+	"os"
+	"os/exec"
+	"path"
+	"path/filepath"
+	"sort"
+	"strings"
+)
+
+// AffectedSelection is the validation a changed-path set requires during Build.
+type AffectedSelection struct {
+	Packages []string // Go packages whose tests must run
+	Widen    bool     // full suite required
+	Reason   string   // why the selection widened
+}
+
+// widenPrefixes force the full suite: each can change behaviour in packages
+// that no changed path names.
+var widenPrefixes = []string{
+	".github/workflows/",
+	".github/actions/",
+	"pack/generated/",
+	"engine/internal/lib/testdata/",
+}
+
+// widenBasenames are module manifests at any depth: engine/go.mod is not the
+// only one, and a manifest change re-resolves the whole module.
+var widenBasenames = map[string]bool{"go.mod": true, "go.sum": true, "go.work": true}
+
+// SelectAffected maps changed repository paths to the narrowest safe validation.
+// It fails safe: a path it cannot classify widens to the full suite instead of
+// silently narrowing.
+func SelectAffected(changed []string) AffectedSelection {
+	seen := map[string]bool{}
+	var pkgs []string
+	for _, raw := range changed {
+		p := strings.TrimSpace(raw)
+		if p == "" {
+			continue
+		}
+		p = path.Clean(strings.TrimPrefix(p, "./"))
+		if reason, widen := widenReason(p); widen {
+			return AffectedSelection{Widen: true, Reason: reason}
+		}
+		dir := path.Dir(p)
+		if seen[dir] {
+			continue
+		}
+		seen[dir] = true
+		pkgs = append(pkgs, dir)
+	}
+	sort.Strings(pkgs)
+	if len(pkgs) == 0 {
+		return AffectedSelection{Widen: true, Reason: "no Go package affected"}
+	}
+	return AffectedSelection{Packages: pkgs}
+}
+
+func widenReason(p string) (string, bool) {
+	if widenBasenames[path.Base(p)] {
+		return p + " is a module manifest", true
+	}
+	for _, w := range widenPrefixes {
+		if strings.HasPrefix(p, w) {
+			return p + " can change packages no changed path names", true
+		}
+	}
+	// An unclassified path can carry behaviour this selection cannot see, so it
+	// must not be dropped just because a sibling path named a package.
+	if !strings.HasSuffix(p, ".go") {
+		return p + " is not a Go source path", true
+	}
+	return "", false
+}
+
+// pkgDeps is one `go list` row: a package's directory, import path, and every
+// import it reaches, test-only imports included.
+type pkgDeps struct {
+	Dir    string
+	Import string
+	Deps   []string
+}
+
+// goListDeps is a variable so tests can inject a module graph without a toolchain.
+var goListDeps = runGoListDeps
+
+func runGoListDeps(moduleRoot string) ([]pkgDeps, error) {
+	const format = "{{.Dir}}\t{{.ImportPath}}\t{{join .Deps \",\"}}\t{{join .TestImports \",\"}}\t{{join .XTestImports \",\"}}"
+	cmd := exec.Command("go", "list", "-f", format, "./...") // #nosec G204 -- fixed args, no caller input
+	cmd.Dir = moduleRoot
+	out, err := cmd.Output()
+	if err != nil {
+		return nil, err
+	}
+	rows := make([]pkgDeps, 0, 64)
+	sc := bufio.NewScanner(strings.NewReader(string(out)))
+	sc.Buffer(make([]byte, 0, 1<<16), 1<<22)
+	for sc.Scan() {
+		parts := strings.Split(sc.Text(), "\t")
+		if len(parts) != 5 {
+			continue
+		}
+		row := pkgDeps{Dir: parts[0], Import: parts[1]}
+		for _, field := range parts[2:] {
+			for _, imp := range strings.Split(field, ",") {
+				if imp = strings.TrimSpace(imp); imp != "" {
+					row.Deps = append(row.Deps, imp)
+				}
+			}
+		}
+		rows = append(rows, row)
+	}
+	return rows, sc.Err()
+}
+
+// moduleRootFor returns the deepest ancestor of dir holding a go.mod.
+func moduleRootFor(dir string) (string, bool) {
+	for {
+		if _, err := os.Stat(filepath.Join(dir, "go.mod")); err == nil {
+			return dir, true
+		}
+		parent := filepath.Dir(dir)
+		if parent == dir {
+			return "", false
+		}
+		dir = parent
+	}
+}
+
+// expandDependents adds every package whose imports reach a selected package: a
+// change breaks its dependents' tests too, so those packages must run as well.
+func expandDependents(selected []string, rows []pkgDeps) []string {
+	importers := map[string][]string{}
+	for _, r := range rows {
+		for _, dep := range r.Deps {
+			importers[dep] = append(importers[dep], r.Import)
+		}
+	}
+	seen := map[string]bool{}
+	queue := append([]string(nil), selected...)
+	for _, s := range selected {
+		seen[s] = true
+	}
+	for len(queue) > 0 {
+		cur := queue[0]
+		queue = queue[1:]
+		for _, imp := range importers[cur] {
+			if !seen[imp] {
+				seen[imp] = true
+				queue = append(queue, imp)
+			}
+		}
+	}
+	out := make([]string, 0, len(seen))
+	for imp := range seen {
+		out = append(out, imp)
+	}
+	sort.Strings(out)
+	return out
+}
+
+// locateSelection resolves selected repository-relative dirs to one module root
+// plus absolute dirs. A selection spanning modules or missing a go.mod widens.
+func locateSelection(root string, dirs []string) (string, []string, bool) {
+	absRoot, err := filepath.Abs(root)
+	if err != nil {
+		return "", nil, false
+	}
+	var moduleRoot string
+	abs := make([]string, 0, len(dirs))
+	for _, d := range dirs {
+		a := filepath.Join(absRoot, filepath.FromSlash(d))
+		mr, ok := moduleRootFor(a)
+		if !ok {
+			return "", nil, false
+		}
+		if moduleRoot == "" {
+			moduleRoot = mr
+		} else if moduleRoot != mr {
+			return "", nil, false
+		}
+		abs = append(abs, a)
+	}
+	return moduleRoot, abs, moduleRoot != ""
+}
+
+// RunCheckAffected prints the affected-only validation plan for changed paths.
+func RunCheckAffected(root string, args []string, stdout, stderr io.Writer) int {
+	if len(args) == 0 {
+		fmt.Fprintln(stderr, "usage: devrites-engine check affected <path...>")
+		return 2
+	}
+	sel := SelectAffected(args)
+	if sel.Widen {
+		fmt.Fprintf(stdout, "affected: full suite (%s)\n", sel.Reason)
+		return 0
+	}
+	moduleRoot, absDirs, ok := locateSelection(root, sel.Packages)
+	if !ok {
+		fmt.Fprintln(stdout, "affected: full suite (selection does not resolve to one Go module)")
+		return 0
+	}
+	rows, err := goListDeps(moduleRoot)
+	if err != nil {
+		fmt.Fprintf(stdout, "affected: full suite (dependency graph unavailable: %v)\n", err)
+		return 0
+	}
+	byDir := make(map[string]string, len(rows))
+	for _, r := range rows {
+		byDir[filepath.Clean(r.Dir)] = r.Import
+	}
+	selected := make([]string, 0, len(absDirs))
+	for _, d := range absDirs {
+		imp, found := byDir[filepath.Clean(d)]
+		if !found {
+			fmt.Fprintf(stdout, "affected: full suite (%s is not a listed Go package)\n", d)
+			return 0
+		}
+		selected = append(selected, imp)
+	}
+	all := expandDependents(selected, rows)
+	suffix := ""
+	if len(all) > len(selected) {
+		suffix = " (includes dependents)"
+	}
+	fmt.Fprintf(stdout, "affected: %d package(s): %s%s\n", len(all), strings.Join(all, " "), suffix)
+	return 0
+}

package/engine/internal/lib/cli_observe.go

@@ -9,8 +9,20 @@ import (
 	"github.com/devrites/devrites/internal/state"
 )
 
-// RunTaskGraphCheck validates tasks.md for one slug.
+// RunTaskGraphCheck validates tasks.md for one slug. Shared-path findings are
+// advisory: they never change the exit code.
 func RunTaskGraphCheck(root, slug string, stdout, stderr io.Writer) int {
+	return runTaskGraphCheck(root, slug, false, stdout, stderr)
+}
+
+// RunTaskGraphCheckStrict is RunTaskGraphCheck, except a plan whose shared-path
+// writer count breaches the hub limit is refused instead of only advised. That is
+// the plan-shape repair point: split disjointly rather than widen the cap.
+func RunTaskGraphCheckStrict(root, slug string, stdout, stderr io.Writer) int {
+	return runTaskGraphCheck(root, slug, true, stdout, stderr)
+}
+
+func runTaskGraphCheck(root, slug string, strict bool, stdout, stderr io.Writer) int {
 	graph, err := CheckTaskGraph(root, slug)
 	if err != nil {
 		fmt.Fprintf(stderr, "task-graph: %v\n", err)
@@ -38,8 +50,14 @@ func RunTaskGraphCheck(root, slug string, stdout, stderr io.Writer) int {
 			recordMetric(root, slug, "define", "size-advisory", "", int64(over))
 		}
 		paths, serial := sliceWritePaths(raw, graph)
-		if rounds := scheduleRounds(graph, paths, root); rounds > 0 {
-			fmt.Fprintf(stdout, "task-graph: schedule: %d slices in %d build rounds at cap %d\n", len(graph.Slices), rounds, parallel.MaxParallelSlices)
+		if plan, idle, maxReady := schedulePlan(graph, paths, root); len(plan) > 0 {
+			fmt.Fprintf(stdout, "task-graph: schedule: %d slices in %d build rounds at cap %d, width %d, idle-eligible %d\n", len(graph.Slices), len(plan), parallel.MaxParallelSlices, scheduleWidth(plan), idle)
+			if chain := chainAdvisories(graph, serial, len(plan), maxReady); len(chain) > 0 {
+				for _, line := range chain {
+					fmt.Fprintf(stdout, "task-graph: %s\n", line)
+				}
+				recordMetric(root, slug, "define", "chain-advisory", "", int64(len(chain)))
+			}
 		}
 		if hubs := hubAdvisories(graph, paths, serial); len(hubs) > 0 {
 			for _, line := range hubs[:min(len(hubs), hubAdvisoryShown)] {
@@ -49,6 +67,10 @@ func RunTaskGraphCheck(root, slug string, stdout, stderr io.Writer) int {
 				fmt.Fprintf(stdout, "task-graph: ADVISORY hub: %d more shared paths; fix the ones above first\n", extra)
 			}
 			recordMetric(root, slug, "define", "hub-advisory", "", int64(len(hubs)))
+			if strict {
+				fmt.Fprintf(stdout, "task-graph: BLOCKED: %d shared path(s) with %d+ writers; split disjointly (acceptance-preserving) or record `Serial rationale:`\n", len(hubs), hubAdvisoryMin)
+				return 3
+			}
 		}
 	}
 	if edges := edgeAdvisories(graph); len(edges) > 0 {

package/engine/internal/lib/taskgraph.go

@@ -78,12 +78,18 @@ func pathTokens(raw string) []string {
 	return out
 }
 
-// scheduleRounds replays /rite-build batch selection at the maximum cap: each
+// schedulePlan replays /rite-build batch selection at the maximum cap: each
 // round runs the plan-order path-disjoint subset of dependency-ready slices.
-// It returns 0 when a slice has no write paths or parallel select rejects them.
-func scheduleRounds(graph TaskGraphResult, paths map[string][]string, root string) int {
+// It returns the picked slice ids per round, the number of dependency-ready
+// slices each round left idle (parallelism the cap could not use), and the
+// largest dependency-ready set any round saw. That last value separates a
+// dependency chain (never more than one slice ready) from write contention
+// (many ready, one picked). It returns nil when a slice has no write paths or
+// parallel select rejects.
+func schedulePlan(graph TaskGraphResult, paths map[string][]string, root string) ([][]string, int, int) {
 	done := make(map[string]bool, len(graph.Slices))
-	rounds := 0
+	var rounds [][]string
+	idle, maxReady := 0, 0
 	for len(done) < len(graph.Slices) {
 		var ready []parallel.SlicePaths
 		for _, s := range graph.Slices {
@@ -91,23 +97,42 @@ func scheduleRounds(graph TaskGraphResult, paths map[string][]string, root strin
 				continue
 			}
 			if len(paths[s.ID]) == 0 {
-				return 0
+				return nil, 0, 0
 			}
 			ready = append(ready, parallel.SlicePaths{ID: s.ID, Paths: paths[s.ID]})
 		}
 		if len(ready) == 0 {
-			return 0
+			return nil, 0, 0
 		}
 		picked, err := parallel.SelectGreedy(parallel.MaxParallelSlices, ready, root)
 		if err != nil || len(picked) == 0 {
-			return 0
+			return nil, 0, 0
 		}
+		ids := make([]string, 0, len(picked))
 		for _, p := range picked {
 			done[p.ID] = true
+			ids = append(ids, p.ID)
 		}
-		rounds++
+		idle += len(ready) - len(picked)
+		maxReady = max(maxReady, len(ready))
+		rounds = append(rounds, ids)
+	}
+	return rounds, idle, maxReady
+}
+
+// scheduleRounds returns the round count alone; see schedulePlan for the shape.
+func scheduleRounds(graph TaskGraphResult, paths map[string][]string, root string) int {
+	rounds, _, _ := schedulePlan(graph, paths, root)
+	return len(rounds)
+}
+
+// scheduleWidth is the busiest round: the plan's achieved DAG width.
+func scheduleWidth(rounds [][]string) int {
+	width := 0
+	for _, picked := range rounds {
+		width = max(width, len(picked))
 	}
-	return rounds
+	return width
 }
 
 // PlanReady is the ready set for `parallel select --from-plan`; repoRoot is
@@ -319,8 +344,8 @@ func allDone(ids []string, done map[string]bool) bool {
 // hubAdvisories names each path written by hubAdvisoryMin+ slices that carry
 // no `Serial rationale:`, most-shared first.
 func hubAdvisories(graph TaskGraphResult, paths map[string][]string, serial map[string]bool) []string {
-	writers := map[string][]string{}
-	shown := map[string]string{} // first spelling seen, for display
+	claimed := map[string][]string{} // key -> slices claiming exactly it
+	shown := map[string]string{}     // first spelling seen, for display
 	for _, s := range graph.Slices {
 		if serial[s.ID] {
 			continue
@@ -330,13 +355,39 @@ func hubAdvisories(graph TaskGraphResult, paths map[string][]string, serial map[
 			key := strings.ToLower(path.Clean(strings.ReplaceAll(p, `\`, "/")))
 			if !seen[key] {
 				seen[key] = true
-				writers[key] = append(writers[key], s.ID)
+				claimed[key] = append(claimed[key], s.ID)
 				if _, ok := shown[key]; !ok {
 					shown[key] = p
 				}
 			}
 		}
 	}
+	// A directory claim contains every path beneath it, so writers of a path
+	// include slices claiming its ancestors and its descendants; counting exact
+	// spellings alone would report one writer for a hub every slice touches.
+	writers := map[string][]string{}
+	for key := range claimed {
+		set := map[string]bool{}
+		for _, id := range claimed[key] {
+			set[id] = true
+		}
+		for other, ids := range claimed {
+			if other == key {
+				continue
+			}
+			if strings.HasPrefix(other, key+"/") || strings.HasPrefix(key, other+"/") {
+				for _, id := range ids {
+					set[id] = true
+				}
+			}
+		}
+		ids := make([]string, 0, len(set))
+		for id := range set {
+			ids = append(ids, id)
+		}
+		sort.Strings(ids)
+		writers[key] = ids
+	}
 	hubs := make([]string, 0, len(writers))
 	for p, ids := range writers {
 		if len(ids) >= hubAdvisoryMin {
@@ -356,6 +407,22 @@ func hubAdvisories(graph TaskGraphResult, paths map[string][]string, serial map[
 	return lines
 }
 
+// chainAdvisories names a plan whose schedule never overlaps because only one
+// slice was ever dependency-ready per round, so no parallel cap can help. A plan
+// serialized by write contention instead is a hub problem, not a chain, and a
+// plan whose slices all record `Serial rationale:` is deliberate; both stay quiet.
+func chainAdvisories(graph TaskGraphResult, serial map[string]bool, rounds, maxReady int) []string {
+	if len(graph.Slices) < 2 || rounds != len(graph.Slices) || maxReady != 1 {
+		return nil
+	}
+	for _, s := range graph.Slices {
+		if !serial[s.ID] {
+			return []string{fmt.Sprintf("ADVISORY chain: %d slices run in %d build rounds, so no two slices overlap and a parallel cap cannot help; cut a slice that stands alone, or record `Serial rationale:`", len(graph.Slices), rounds)}
+		}
+	}
+	return nil
+}
+
 // edgeAdvisories names each dependency edge that does not say what crosses it:
 // no `(via <interface>)`, or a via the dependency's Consumes / Produces lacks.
 // An edge the dependent reads nothing across only serializes work.

package/engine/main.go

@@ -229,6 +229,8 @@ func cmdCheck(root string, args []string, stdin io.Reader, stdout, stderr io.Wri
 		return parallel.Run("path-disjoint", rest, stdin, stdout, stderr)
 	case "task-graph":
 		return cmdTaskGraph(root, rest, stdout, stderr)
+	case "affected":
+		return lib.RunCheckAffected(root, rest, stdout, stderr)
 	case "slice":
 		return lib.RunCheckSlice(root, rest, stdout, stderr)
 	case "diff-scope":
@@ -378,11 +380,26 @@ func cmdGate(root string, kind gate.Kind, args []string, stdout, stderr io.Write
 }
 
 func cmdTaskGraph(root string, args []string, stdout, stderr io.Writer) int {
-	if len(args) != 1 {
+	strict, slug, seen := false, "", false
+	for _, a := range args {
+		if a == "--strict" {
+			strict = true
+			continue
+		}
+		if a == "" || seen {
+			fmt.Fprintln(stderr, taskGraphUsage)
+			return exitUsage
+		}
+		slug, seen = a, true
+	}
+	if !seen {
 		fmt.Fprintln(stderr, taskGraphUsage)
 		return exitUsage
 	}
-	return lib.RunTaskGraphCheck(root, args[0], stdout, stderr)
+	if strict {
+		return lib.RunTaskGraphCheckStrict(root, slug, stdout, stderr)
+	}
+	return lib.RunTaskGraphCheck(root, slug, stdout, stderr)
 }
 
 func cmdSkillTrust(args []string, stdout, stderr io.Writer) int {

package/pack/.claude/agents/devrites-upgrade-planner.md

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

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

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

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

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

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

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