devrites 7.2.6 → 7.2.8

package/engine/internal/install/uninstall.go

@@ -35,18 +35,12 @@ func (r *runner) uninstall() error {
 		return err
 	}
 
-	// Per-path would-be content for a dry run; a nil value means the file
-	// would be removed.
-	dryTree := map[string][]byte{}
 	for _, rel := range entries {
 		merge, ok := hostpack.ManagedMergeForMarker(rel)
 		if !ok {
 			continue
 		}
 		if r.opts.DryRun {
-			if err := dryRunStripMarker(dryTree, r.target, merge); err != nil {
-				return err
-			}
 			fmt.Fprintf(r.opts.Stdout, "  [merge-remove] %s\n", merge.DryRun)
 			continue
 		}
@@ -142,11 +136,16 @@ func (r *runner) uninstall() error {
 // dryRunStripMarker runs the real marker strip against an in-memory view of
 // the target (tree), so a dry run follows the same sequence as the real
 // uninstall and reports the same errors without writing anything.
-func dryRunStripMarker(tree map[string][]byte, target string, merge hostpack.ManagedMerge) error {
-	if merge.MarkerRel == hostpack.LegacyCodexHooksMerge.MarkerRel || merge.TargetRel == hostpack.ClaudeSettingsMerge.TargetRel {
-		return nil
+func (r *runner) dryRunStripMarker(tree map[string][]byte, merge hostpack.ManagedMerge) error {
+	path := filepath.Join(r.target, filepath.FromSlash(merge.TargetRel))
+	write := func(data []byte) error { tree[path] = data; return nil }
+	remove := func() error { tree[path] = nil; return nil }
+	if merge.MarkerRel == hostpack.LegacyCodexHooksMerge.MarkerRel {
+		return stripHooksWith(path, write, remove)
+	}
+	if merge.TargetRel == hostpack.ClaudeSettingsMerge.TargetRel {
+		return r.stripClaudeSettingsWith(path, write, remove)
 	}
-	path := filepath.Join(target, filepath.FromSlash(merge.TargetRel))
 	data, seen := tree[path]
 	if !seen {
 		var err error

package/engine/internal/lib/apply_bundle.go

@@ -210,7 +210,12 @@ func collectBundleTargets(slug string, bundles []candidateBundle) ([]*bundleTarg
 		}
 		pins := map[string]string{}
 		for path, hash := range bundle.BaseHashes {
-			pins[strings.TrimPrefix(filepath.ToSlash(path), prefix)] = strings.ToLower(strings.TrimPrefix(strings.TrimSpace(hash), "sha256:"))
+			rel := filepath.ToSlash(filepath.Clean(strings.TrimPrefix(filepath.ToSlash(path), prefix)))
+			pin := strings.ToLower(strings.TrimPrefix(strings.TrimSpace(hash), "sha256:"))
+			if previous, ok := pins[rel]; ok && previous != pin {
+				problems = append(problems, fmt.Sprintf("bundle %d %s: conflicting base hashes for the same file", bi+1, path))
+			}
+			pins[rel] = pin
 		}
 		for _, file := range bundle.CandidateFiles {
 			rel := strings.TrimPrefix(filepath.ToSlash(file.Path), prefix)
@@ -219,6 +224,7 @@ func collectBundleTargets(slug string, bundles []candidateBundle) ([]*bundleTarg
 				problems = append(problems, where+": path must be a Markdown file inside the "+slug+" workspace")
 				continue
 			}
+			rel = filepath.ToSlash(filepath.Clean(rel))
 			op := strings.ToLower(strings.TrimSpace(file.Operation))
 			switch op {
 			case "create", "replace":

package/engine/internal/lib/closeout.go

@@ -62,11 +62,6 @@ func CloseOut(root string, args []string, stdout, stderr io.Writer) int {
 	archDisplay := filepath.ToSlash(filepath.Join("archive", slug))
 	active := filepath.Join(dv, "ACTIVE")
 
-	activeSlug, err := devritespaths.ActiveSlug(dv)
-	if err != nil {
-		fmt.Fprintf(stderr, "state close: invalid ACTIVE cursor: %v\n", err)
-		return 1
-	}
 	// A broken symlink at the destination still counts as "already there", so use
 	// Lstat rather than Stat to avoid silently overwriting it.
 	if _, err := os.Lstat(arch); err == nil {
@@ -84,7 +79,7 @@ func CloseOut(root string, args []string, stdout, stderr io.Writer) int {
 	// open file, so there the lock is released just before the rename.
 	code := 1
 	if err := state.WithFeatureLockRelease(dv, slug, func(release func()) error {
-		code = closeOutLocked(release, work, arch, archiveDir, archDisplay, active, activeSlug, slug, stdout, stderr)
+		code = closeOutLocked(release, work, arch, archiveDir, archDisplay, active, slug, stdout, stderr)
 		return nil
 	}); err != nil {
 		fmt.Fprintf(stderr, "state close: cannot lock feature %s: %v\n", slug, err)
@@ -96,7 +91,12 @@ func CloseOut(root string, args []string, stdout, stderr io.Writer) int {
 // closeOutLocked performs the rename and the conditional ACTIVE clear. It runs
 // under the feature lock held by CloseOut and reports an exit code rather than
 // an error, preserving CloseOut's documented exit codes.
-func closeOutLocked(release func(), work, arch, archiveDir, archDisplay, active, activeSlug, slug string, stdout, stderr io.Writer) int {
+func closeOutLocked(release func(), work, arch, archiveDir, archDisplay, active, slug string, stdout, stderr io.Writer) int {
+	activeSlug, err := devritespaths.PhysicalActiveSlug(filepath.Dir(active))
+	if err != nil {
+		fmt.Fprintf(stderr, "state close: invalid ACTIVE cursor: %v\n", err)
+		return 1
+	}
 	// Fail closed: if the move does not happen, leave the cursor alone and do not
 	// claim success: a lost audit trail must never look like a clean close-out.
 	if err := os.MkdirAll(archiveDir, 0o755); err != nil {

package/engine/internal/lib/context.go

@@ -57,7 +57,9 @@ every ID the block cites).
 Repeat --slice for a recheck that spans several slices. In phase build a
 --role bundle other than slice-wright requires --slice (exit 3). A root
 build or autocomplete bundle (no --role, no --slice) defaults to --slice
-<active_slice> when state.md names one present in tasks.md; --whole opts out.
+<active_slice> when state.md names one present in tasks.md, unless
+.devrites/AFK max_parallel is 2 or more or a parallel lease is running
+(the bundle stays whole so the other slices stay visible); --whole opts out.
 --recheck <inventory> (phase build, with --role and --slice) builds a
 bounded recheck bundle: the inventory file (relative to the workspace)
 and core.md are inlined; every other pack file becomes a by-reference
@@ -78,7 +80,7 @@ func RunContext(root string, args []string, stdout, stderr io.Writer) int {
 	}
 	// A Build reviewer judges one slice; an unscoped bundle inlines whole
 	// plan/tasks/architecture into every dispatch.
-	if opts.phase == "build" && opts.role != "" && opts.role != "slice-wright" && opts.slice == "" {
+	if opts.phase == "build" && opts.role != "" && roleBase(opts.role) != "slice-wright" && opts.slice == "" {
 		fmt.Fprintf(stderr, "context: BLOCKED: unscoped build reviewer bundle: --role %s in phase build needs --slice <SLICE-ID>\n", opts.role)
 		return 3
 	}
@@ -91,10 +93,11 @@ func RunContext(root string, args []string, stdout, stderr io.Writer) int {
 			return 2
 		}
 	}
-	// The root's own build/autocomplete bundle holds one slice at a time;
-	// whole tasks/plan/decisions ride every later turn otherwise.
+	// One active slice per bundle, except a parallel batch: the root has to
+	// see the other slices to start them. Whole tasks/plan/decisions ride
+	// that batch's turns; serial runs stay scoped.
 	autoScope := false
-	if featureDir != "" && opts.role == "" && opts.slice == "" && !opts.whole && (opts.phase == "build" || opts.phase == "autocomplete") {
+	if featureDir != "" && opts.role == "" && opts.slice == "" && !opts.whole && (opts.phase == "build" || opts.phase == "autocomplete") && !parallelPlanVisible(root, opts.slug) {
 		if id := activeSliceScope(featureDir); id != "" {
 			opts.slices, opts.slice, autoScope = []string{id}, id, true
 		}
@@ -452,7 +455,7 @@ func workspaceReadSet(manifest loadsManifest, role string) ([]string, bool) {
 	if role == "" {
 		return manifest.Workspace, false
 	}
-	if list, ok := manifest.WorkspaceByRole[role]; ok {
+	if list, ok := manifest.WorkspaceByRole[roleBase(role)]; ok {
 		return list, true
 	}
 	return manifest.Workspace, false
@@ -912,6 +915,7 @@ func parseLoadsManifest(text string) (loadsManifest, bool, error) {
 }
 
 func roleAgentPath(manifest loadsManifest, role string) string {
+	role = roleBase(role)
 	if manifest.Agents != nil {
 		if rel, ok := manifest.Agents[role]; ok {
 			return rel

package/engine/internal/lib/dispatch.go

@@ -50,6 +50,7 @@ For a reviewer role, return --result <file> stores the return verbatim as
 packets/<wave>-<role>.return.md (never overwritten), derives the outcome
 from its Outcome/Counts head (malformed records gap), refuses an --outcome
 that disagrees, and records its Finding: keys for metrics summary.
+Reviewer returns require --result or --outcome; omitting both leaves the role pending.
 
 A build wave with a wright role must name its slice(s) with --slice; a vet
 wave may (slice-bound recheck), and so may a reviewer-only wave (uncapped),
@@ -57,9 +58,11 @@ which keys its --result findings on that slice. A --result file may already
 be the packets/ path; it is then kept as the stored return. Every 5 rounds of one kind on one slice, the
 next open is blocked until --reslice-review names a drift.md
 "## <DRIFT-ID>" heading for that slice. Under .devrites/AFK max_parallel >= 2,
-a first-round build wright wave narrower than the parallel select --from-plan
-batch is blocked until evidence.md records "serial: <skipped ids> — <reason>";
-repair rounds and lease siblings are never blocked.
+a build wright wave that leaves parallel select --from-plan picks unstarted is
+blocked until evidence.md records "serial: <skipped ids> — <reason>". A repair
+round or a running lease slice does not waive those picks. A wave naming two
+or more slices needs one slice-wright.<SLICE-ID> role per slice; one shared
+role has one handle, so the other slices never start. HITL is never width-blocked.
 
 Root-edit tripwire (ADR-0038): the first open records tree-baseline.json
 (dirty product paths outside .devrites/ and .scratch/, accepted as user work);
@@ -453,6 +456,9 @@ func dispatchLocked(root, slug, sub, phase, wave, role, handle, reason string, r
 		if r.Returned {
 			return fail("role %q already returned", role)
 		}
+		if isReviewerRole(role) && result == "" && outcome == "" {
+			return fail("reviewer %q needs --result <file> or --outcome <findings|no-findings|gap>", role)
+		}
 		if outcome != "" && !slices.Contains([]string{"findings", "no-findings", "gap"}, outcome) {
 			return fail("--outcome %q is not findings, no-findings, or gap", outcome)
 		}
@@ -742,7 +748,6 @@ func admitWrightRounds(root, slug string, f *dispatchFile, w *dispatchWave, revi
 		}
 	}
 	var lines, overCap []string
-	firstRound := true
 	for _, id := range w.Slices {
 		prior, reviews := 0, 0
 		var unreturned []string
@@ -762,7 +767,6 @@ func admitWrightRounds(root, slug string, f *dispatchFile, w *dispatchWave, revi
 			}
 		}
 		round := prior + 1
-		firstRound = firstRound && prior == 0
 		if round > wrightRoundsPerReview*(1+reviews) {
 			overCap = append(overCap, id)
 		}
@@ -780,7 +784,11 @@ func admitWrightRounds(root, slug string, f *dispatchFile, w *dispatchWave, revi
 			fmt.Fprintf(stderr, "dispatch: --reslice-review given but no slice has reached its %d-round cap\n", wrightRoundsPerReview)
 			return nil, 2
 		}
-		if kind == "wright" && firstRound {
+		if kind == "wright" {
+			if refusal := wrightFanoutRefusal(w); refusal != "" {
+				fmt.Fprintln(stderr, refusal)
+				return nil, 3
+			}
 			if refusal := widerBatchRefusal(root, slug, w.Slices); refusal != "" {
 				fmt.Fprintln(stderr, refusal)
 				return nil, 3
@@ -816,36 +824,88 @@ func admitWrightRounds(root, slug string, f *dispatchFile, w *dispatchWave, revi
 }
 
 // serialRecordRe matches an evidence.md `serial: <ids> — <reason>` record
-// (the reason may open with a code span, never be empty); group 1 holds the ids.
-var serialRecordRe = regexp.MustCompile("(?mi)^[ \\t]*(?:[-*][ \\t]+)?`?serial:([^\\n]*?)(?:[ \\t]*[—–]|[ \\t]+--?[ \\t])[ \\t]*(?:[^\\s`]|`[^\\s`])")
+// (the reason may open with a code span, never be empty). Group 1 holds the
+// ids; group 2 holds the reason.
+var serialRecordRe = regexp.MustCompile("(?mi)^[ \\t]*(?:[-*][ \\t]+)?`?serial:([^\\n]*?)(?:[ \\t]*[—–]|[ \\t]+--?[ \\t])[ \\t]*([^\\s`][^\\n]*|`[^\\s`][^\\n]*)")
+
+// A repair, an open wave, or "already started" is not a shared surface.
+// Those reasons do not waive a pick unless they also name a path.
+var transientSerialReasonRe = regexp.MustCompile(`(?i)\b(?:repairs?|repairing|repaired|already started|in flight|open wave|sealed wave|running lease|in the lease)\b`)
+var serialSurfaceRe = regexp.MustCompile("`[^`\\n]*\\.[^`\\n]+`|(?i)\\b[\\w./-]+\\.[a-z0-9]+\\b")
+
+func serialReasonWaives(reason string) bool {
+	if transientSerialReasonRe.MatchString(reason) && !serialSurfaceRe.MatchString(reason) {
+		return false
+	}
+	return true
+}
 
 var sliceTokenRe = regexp.MustCompile(`(?i)\bSLICE-\d+\b`)
 
-// widerBatchRefusal refuses a first-round AFK build wright wave when
-// `parallel select --from-plan` picks more slices than the wave holds and
-// evidence.md has no `serial:` record naming each skipped pick. HITL runs,
-// lease siblings, slices the plan does not list as eligible, and selection
-// errors are never refused: the check widens batches, it never stops a build.
+// wrightFanoutRefusal refuses a build wright wave that names several slices
+// but not one slice-wright role per slice. One role has one host handle, so
+// the other slices would never start.
+func wrightFanoutRefusal(w *dispatchWave) string {
+	if len(w.Slices) < 2 {
+		return ""
+	}
+	lanes := map[string]bool{}
+	bare := 0
+	for role := range w.Roles {
+		if roleBase(role) != "slice-wright" {
+			continue
+		}
+		lane, ok := wrightLane(role)
+		if !ok {
+			bare++
+			continue
+		}
+		lanes[sliceNumber(lane)] = true
+	}
+	if bare > 0 || len(lanes) != len(w.Slices) {
+		return fmt.Sprintf("dispatch: BLOCKED: %d slices need one `--role slice-wright.<SLICE-ID>` each so every writer gets a handle; one shared slice-wright role starts only one agent", len(w.Slices))
+	}
+	for _, id := range w.Slices {
+		if !lanes[sliceNumber(id)] {
+			return fmt.Sprintf("dispatch: BLOCKED: %s has no `--role slice-wright.%s`", id, id)
+		}
+	}
+	return ""
+}
+
+// wrightLane is the SLICE-### suffix of a slice-wright.<SLICE-ID> role.
+func wrightLane(role string) (string, bool) {
+	base, lane, ok := strings.Cut(strings.TrimPrefix(role, "devrites-"), ".")
+	if !ok || base != "slice-wright" || !state.ValidSliceID(lane) {
+		return "", false
+	}
+	return lane, true
+}
+
+// widerBatchRefusal refuses an AFK build wright wave when
+// `parallel select --from-plan` still picks slices this wave does not start
+// and evidence.md has no `serial:` record for each. A repair round or a
+// running lease slice does not waive those picks. HITL runs and selection
+// errors are never refused: the check widens the batch, it never stops a
+// wave that already starts every remaining pick.
 func widerBatchRefusal(root, slug string, wave []string) string {
 	capN := min(afkMaxParallel(root), parallel.MaxParallelSlices)
 	if capN < 2 {
 		return ""
 	}
-	eligible, batch, err := planBatch(root, slug, capN)
-	if err != nil || len(batch) <= len(wave) {
+	_, batch, err := planBatch(root, slug, capN)
+	if err != nil || len(batch) == 0 {
 		return ""
 	}
-	for _, id := range wave {
-		if !containsSlice(eligible, id) {
-			return ""
-		}
-	}
 	var recorded []string
 	if raw, err := readWorkspaceArtifact(root, slug, "evidence.md"); err == nil {
 		if visible, err := markdowntext.Structural(raw); err == nil {
 			raw = visible
 		}
 		for _, m := range serialRecordRe.FindAllStringSubmatch(string(raw), -1) {
+			if len(m) < 3 || !serialReasonWaives(m[2]) {
+				continue
+			}
 			recorded = append(recorded, sliceTokenRe.FindAllString(m[1], -1)...)
 		}
 	}
@@ -858,7 +918,7 @@ func widerBatchRefusal(root, slug string, wave []string) string {
 	if len(missing) == 0 {
 		return ""
 	}
-	return fmt.Sprintf("dispatch: BLOCKED: AFK max_parallel %d: `%s` picks %s, wider than this wave (%s); run that batch per rite-build/reference/parallel-batch.md (`parallel create`, then one wave with a --slice per sibling), or record `serial: %s — <shared surface or reason>` in evidence.md",
+	return fmt.Sprintf("dispatch: BLOCKED: AFK max_parallel %d: `%s` picks %s, wider than this wave (%s); start those picks (`parallel create`, or `parallel add` while a lease runs) and dispatch them, or record `serial: %s — <shared surface or reason>` in evidence.md",
 		capN, planSelectCommand(filepath.Dir(root), slug, capN), strings.Join(batch, ","), strings.Join(wave, ","), strings.Join(missing, ","))
 }
 

package/engine/internal/lib/resolve.go

@@ -361,6 +361,10 @@ func clearAwaiting(sfile, qid string) error {
 		return fmt.Errorf("read state %s: %w", sfile, err)
 	}
 	lines := splitLinesNoTrailing(data)
+	visible, err := structuralLines(data)
+	if err != nil {
+		return fmt.Errorf("read state %s: %w", sfile, err)
+	}
 	resumePolicy, _ := state.PolicyFor(state.PhaseBuild)
 	if rawPhase, ok := state.CursorField(lines, state.CursorPhase); ok {
 		if fields := strings.Fields(strings.ToLower(rawPhase)); len(fields) > 0 {
@@ -373,7 +377,7 @@ func clearAwaiting(sfile, qid string) error {
 	// First check whether the awaiting block references this question at all.
 	inAw := false
 	var awaitingLines []string
-	for _, line := range lines {
+	for _, line := range visible {
 		switch {
 		case awaitingRe.MatchString(line):
 			inAw = true
@@ -400,7 +404,8 @@ func clearAwaiting(sfile, qid string) error {
 	ts := nowUTC()
 	var out []string
 	inAw, inLog, logAppended := false, false, false
-	for _, line := range lines {
+	for i, original := range lines {
+		line := visible[i]
 		if awaitingRe.MatchString(line) {
 			inAw = true
 			continue
@@ -413,7 +418,7 @@ func clearAwaiting(sfile, qid string) error {
 		}
 		switch {
 		case logHdrRe.MatchString(line):
-			out = append(out, line)
+			out = append(out, original)
 			inLog = true
 			continue
 		case inLog && hdrSpaceRe.MatchString(line):
@@ -422,10 +427,10 @@ func clearAwaiting(sfile, qid string) error {
 				logAppended = true
 			}
 			inLog = false
-			out = append(out, line)
+			out = append(out, original)
 			continue
 		}
-		out = append(out, line)
+		out = append(out, original)
 	}
 	if inLog && !logAppended {
 		out = append(out, fmt.Sprintf("- %s %s: resolved %s", ts, resumePolicy.Target, qid))

package/engine/internal/lib/state_edit.go

@@ -58,10 +58,17 @@ func RunStateSet(root string, args []string, stdout, stderr io.Writer) int {
 				return fail(stderr, stateSetUsage, 2)
 			}
 		}
-		if !cursorKeyPattern.MatchString(key) || seen[key] {
+		if !cursorKeyPattern.MatchString(key) {
 			return fail(stderr, fmt.Sprintf("state set: key %q is not a snake_case cursor key or repeats", key), 2)
 		}
-		seen[key] = true
+		if canonical, ok := state.CanonicalCursorKey(key); ok {
+			key = canonical
+		}
+		identity := strings.ReplaceAll(key, "_", "")
+		if seen[identity] {
+			return fail(stderr, fmt.Sprintf("state set: key %q is not a snake_case cursor key or repeats", key), 2)
+		}
+		seen[identity] = true
 		changes = append(changes, change{key, value})
 	}
 	sfile, code := stateEditWorkspace(root, slug, "state.md", stderr)

package/engine/internal/lib/taskgraph.go

@@ -1,6 +1,7 @@
 package lib
 
 import (
+	"errors"
 	"fmt"
 	"os"
 	"path"
@@ -195,10 +196,10 @@ func PrecheckSkips(root, slug, slice string, gateIDs []string) (map[string]strin
 	return skips, nil
 }
 
-// planReady lists, in plan order, the tasks.md slices state.md does not check
-// built whose dependencies it all checks built, each with its sliceWritePaths
-// plus its dependency manifest and lockfile when it declares external
-// dependencies. root is the .devrites directory.
+// planReady lists, in plan order, the tasks.md slices that are not built whose
+// dependencies are all built, each with its sliceWritePaths plus its dependency
+// manifest and lockfile when it declares external dependencies. root is the
+// .devrites directory.
 func planReady(root, slug string) ([]parallel.SlicePaths, error) {
 	raw, err := readWorkspaceArtifact(root, slug, "tasks.md")
 	if err != nil {
@@ -233,8 +234,11 @@ func planReady(root, slug string) ([]parallel.SlicePaths, error) {
 // builtWordRe marks a checked state.md item as a built checkpoint.
 var builtWordRe = regexp.MustCompile(`(?i)\bbuilt\b`)
 
-// builtSlices returns the slice numbers state.md checks built (`- [x] SLICE-004
-// built — <sha>`, or `- [x] Slice 4: <name> — built`), outside fenced examples.
+// builtSlices returns the slice numbers that are built, outside fenced examples.
+// A state.md checkbox (`- [x] SLICE-004 built — <sha>`, or `- [x] Slice 4:
+// <name> — built`) counts. So does an evidence.md heading that says that slice
+// was checkpointed and whose section has a `Checkpoint: <sha>` line — a missed
+// checkbox must not keep dependents out of the ready set.
 func builtSlices(root, slug string) (map[string]bool, error) {
 	raw, err := readWorkspaceArtifact(root, slug, "state.md")
 	if err != nil {
@@ -253,35 +257,86 @@ func builtSlices(root, slug string) (map[string]bool, error) {
 			built[strings.TrimLeft(m[1], "0")] = true
 		}
 	}
+	extra, err := evidenceBuilt(root, slug)
+	if err != nil {
+		return nil, err
+	}
+	for id := range extra {
+		built[id] = true
+	}
 	return built, nil
 }
 
-// manifestDenialRe is prose that says the slice adds no dependency.
-var manifestDenialRe = regexp.MustCompile(`(?i)\b(?:no new|no product|existing|already-admitted|already admitted|stdlib)\b`)
+var (
+	checkpointedHeadingRe = regexp.MustCompile(`(?i)\bcheckpointed\b`)
+	notCheckpointedRe     = regexp.MustCompile(`(?i)\bnot checkpointed\b|\bcheckpoint (?:refused|reverted|failed)\b`)
+	checkpointSHARe       = regexp.MustCompile(`(?m)^[ \t]*Checkpoint: [0-9a-fA-F]{7,40}\b`)
+)
+
+// evidenceBuilt reads evidence.md checkpoint sections. A missing file is none.
+func evidenceBuilt(root, slug string) (map[string]bool, error) {
+	raw, err := readWorkspaceArtifact(root, slug, "evidence.md")
+	if err != nil {
+		if errors.Is(err, os.ErrNotExist) {
+			return map[string]bool{}, nil
+		}
+		return nil, err
+	}
+	masked, err := markdowntext.Structural(raw)
+	if err != nil {
+		return nil, fmt.Errorf("evidence.md: %w", err)
+	}
+	text := string(masked)
+	if strings.HasPrefix(text, "## ") {
+		text = "\n" + text
+	}
+	built := map[string]bool{}
+	for part := range strings.SplitSeq(text, "\n## ") {
+		heading, body, _ := strings.Cut(part, "\n")
+		var ids []string
+		for _, id := range sliceTokenRe.FindAllString(heading, -1) {
+			ids = append(ids, sliceNumber(id))
+		}
+		if len(ids) == 0 {
+			continue
+		}
+		if notCheckpointedRe.MatchString(heading) {
+			for _, id := range ids {
+				delete(built, id)
+			}
+			continue
+		}
+		if checkpointedHeadingRe.MatchString(heading) && checkpointSHARe.MatchString(body) {
+			for _, id := range ids {
+				built[id] = true
+			}
+		}
+	}
+	return built, nil
+}
 
 // A backtick name, module path, npm scope, or x.y.z pin. go.mod/go.sum is not a module path.
+// A toolchain version (Go 1.22.0) is not a package add.
 var (
-	backtickPkgRe  = regexp.MustCompile("`([^`]+)`")
-	modulePathRe   = regexp.MustCompile(`(?i)(?:[a-z0-9-]+\.)+[a-z]{2,}/[a-z0-9._@~+-]+`)
-	npmScopeRe     = regexp.MustCompile(`(?i)@[a-z0-9._-]+/[a-z0-9._-]+`)
-	versionPinRe   = regexp.MustCompile(`(?i)\bv?\d+\.\d+\.\d+\b`)
-	manifestHostRe = regexp.MustCompile(`(?i)\.(?:mod|sum|json|toml|yaml|yml|lock|lockb)$`)
+	backtickPkgRe      = regexp.MustCompile("`([^`]+)`")
+	modulePathRe       = regexp.MustCompile(`(?i)(?:[a-z0-9-]+\.)+[a-z]{2,}/[a-z0-9._@~+-]+`)
+	npmScopeRe         = regexp.MustCompile(`(?i)@[a-z0-9._-]+/[a-z0-9._-]+`)
+	versionPinRe       = regexp.MustCompile(`(?i)\bv?\d+\.\d+\.\d+\b`)
+	toolchainVersionRe = regexp.MustCompile(`(?i)\b(?:go|golang|node|bun|npm|pnpm|yarn|rustc|python|ruby|java)\s+v?\d+\.\d+\.\d+\b`)
+	manifestHostRe     = regexp.MustCompile(`(?i)\.(?:mod|sum|json|toml|yaml|yml|lock|lockb)$`)
 )
 
 // externalClaimsManifest reports whether External dependencies names a package
 // add, so parallel select reserves the nearest manifest. A none prefix does
-// not. shortcut: existing/no-new prose with no package coordinate does not
-// either; name the module, version, scope, or `package` when the slice edits one.
+// not. Prose with no module path, npm scope, `package`, or non-toolchain
+// version pin does not either. shortcut: name the package when the slice
+// edits a manifest; "Go 1.22.0" or "standard library" is not a package add.
 func externalClaimsManifest(external string) bool {
 	ext := strings.ToLower(strings.Trim(strings.TrimSpace(external), "`"))
 	if ext == "" || ext == "-" || ext == "n/a" || strings.HasPrefix(ext, "none") {
 		return false
 	}
-	raw := strings.TrimSpace(external)
-	if manifestDenialRe.MatchString(raw) && !namesPackage(raw) {
-		return false
-	}
-	return true
+	return namesPackage(strings.TrimSpace(external))
 }
 
 // namesPackage reports a module path, version pin, npm scope, or `package`
@@ -293,7 +348,7 @@ func namesPackage(raw string) bool {
 			return true
 		}
 	}
-	if npmScopeRe.MatchString(raw) || versionPinRe.MatchString(raw) {
+	if npmScopeRe.MatchString(raw) || versionPinRe.MatchString(toolchainVersionRe.ReplaceAllString(raw, " ")) {
 		return true
 	}
 	for _, loc := range modulePathRe.FindAllStringIndex(raw, -1) {
@@ -396,6 +451,24 @@ func afkMaxParallel(root string) int {
 	return n
 }
 
+// parallelPlanVisible reports that the root must see every slice. An
+// unattended cap above 1, or a running parallel lease, is a batch: scoping
+// the bundle to active_slice hides the siblings that batch is supposed to start.
+func parallelPlanVisible(devritesRoot, slug string) bool {
+	if afkMaxParallel(devritesRoot) >= 2 {
+		return true
+	}
+	if slug == "" {
+		return false
+	}
+	path, err := parallel.LeasePath(filepath.Dir(devritesRoot), slug)
+	if err != nil {
+		return false
+	}
+	lease, err := parallel.ReadLease(path)
+	return err == nil && lease.Status == parallel.StatusRunning
+}
+
 func allDone(ids []string, done map[string]bool) bool {
 	for _, id := range ids {
 		if !done[id] {

package/engine/internal/lib/triggers.go

@@ -52,7 +52,7 @@ var (
 // corpus (minus the template's AI-SPEC annex) names a model, agent, RAG, or
 // tool surface.
 func keepModelSurface(role string, facts triggerFacts) bool {
-	return role == "security-auditor" || facts.aiSpec || strings.TrimSpace(facts.corpus) == "" ||
+	return roleBase(role) == "security-auditor" || facts.aiSpec || strings.TrimSpace(facts.corpus) == "" ||
 		aiSignalRe.MatchString(aiAnnexRe.ReplaceAllString(facts.corpus, "$1"))
 }
 
@@ -102,7 +102,7 @@ func suggestTriggers(manifest loadsManifest, root, featureDir string, opts conte
 }
 
 func gatherTriggerFacts(root, featureDir, role string) triggerFacts {
-	facts := triggerFacts{role: role}
+	facts := triggerFacts{role: roleBase(role)}
 	if root != "" {
 		afkPath := filepath.Join(root, "AFK")
 		if info, err := os.Stat(afkPath); err == nil && info.Mode().IsRegular() {

package/engine/internal/state/cursor.go

@@ -265,7 +265,7 @@ func ConvertCursorToTable(lines []string) ([]string, bool) {
 		if strings.Contains(value, "|") {
 			continue
 		}
-		spelling, ok := canonicalCursorSpelling(key)
+		spelling, ok := CanonicalCursorKey(key)
 		if !ok {
 			continue
 		}
@@ -278,14 +278,14 @@ func ConvertCursorToTable(lines []string) ([]string, bool) {
 }
 
 func isMigratableCursorKey(key string) bool {
-	_, ok := canonicalCursorSpelling(key)
+	_, ok := CanonicalCursorKey(key)
 	return ok
 }
 
-// canonicalCursorSpelling maps a cursor key (including aliases) to the
+// CanonicalCursorKey maps a cursor key (including aliases) to the
 // canonical table-row spelling. Matching is normalization-based, so
-// "Next step" resolves to the "next_action" spelling.
-func canonicalCursorSpelling(key string) (string, bool) {
+// "Next step" resolves to the "next_action" spelling. Unknown extensions return false.
+func CanonicalCursorKey(key string) (string, bool) {
 	normalized := normalizeCursorKey(key)
 	canonicals := []string{CursorPhase, CursorStatus, CursorNextAction, CursorQuestionID,
 		CursorActiveSlice, CursorAFKSlicesRemaining, CursorSequenceParent,

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

@@ -169,9 +169,9 @@ named in the re-dispatch contract; changes outside task paths stop for the human
 
 ## Scale limits
 
-The role table bounds rosters. Use roughly four concurrent read-only reviewers,
-counting children any leaf spawned; eight only with disjoint paths/resources.
-Refuse unbounded swarms and role substitution: sharpen scope or use a bounded second pass when coverage is missing.
+The role table bounds rosters. Use up to ten concurrent read-only reviewers,
+the same cap as a writer batch, counting children any leaf spawned.
+Refuse a larger swarm and role substitution: sharpen scope or use a bounded second pass when coverage is missing.
 Overlapping reviewers increase duplicate findings and reconciliation work.
 
 ## Children are tools, not peers