devrites 7.3.3 → 7.3.5

package/engine/internal/lib/claims.go

@@ -239,21 +239,39 @@ func validSession(s string) bool {
 	return true
 }
 
-// claimConflicts returns live claims by other sessions overlapping any path: a
-// claimed directory covers every path beneath it, and vice versa.
-func claimConflicts(live []*claimRecord, session string, paths []string) []*claimRecord {
+// claimConflicts checks logical and physical overlap for other live sessions:
+// a claimed directory covers every path beneath it, and vice versa.
+func claimConflicts(root string, live []*claimRecord, session string, paths []string) ([]*claimRecord, error) {
 	var out []*claimRecord
+	var physical []string
 	for _, rec := range live {
 		if rec.Session == session {
 			continue
 		}
-		if slices.ContainsFunc(rec.Paths, func(held string) bool {
+		overlaps := slices.ContainsFunc(rec.Paths, func(held string) bool {
 			return slices.ContainsFunc(paths, func(p string) bool { return claimPathsOverlap(held, p) })
-		}) {
+		})
+		if !overlaps {
+			if physical == nil {
+				var err error
+				physical, err = physicalClaimPaths(root, paths)
+				if err != nil {
+					return nil, err
+				}
+			}
+			held, err := physicalClaimPaths(root, rec.Paths)
+			if err != nil {
+				return nil, fmt.Errorf("claim %s: %w", rec.ID, err)
+			}
+			overlaps = slices.ContainsFunc(held, func(h string) bool {
+				return slices.ContainsFunc(physical, func(p string) bool { return claimPathsOverlap(h, p) })
+			})
+		}
+		if overlaps {
 			out = append(out, rec)
 		}
 	}
-	return out
+	return out, nil
 }
 
 // claimPathsOverlap folds case always: on a case-sensitive filesystem a false
@@ -482,6 +500,37 @@ func addClaimTargets(root, session, reason string, ttl int, raw, workspaces []st
 	return id, code
 }
 
+// Caller holds the repository claims lock through new-wave publication.
+func checkWriterClaimsLocked(root, session string, paths []string) error {
+	if len(paths) == 0 {
+		return nil
+	}
+	latest, order, bad, err := readClaims(claimsPath(root))
+	if err != nil {
+		return err
+	}
+	if bad > 0 {
+		return fmt.Errorf("%d unparsed ledger line(s); cannot rule out a writer claim", bad)
+	}
+	probe := newHolderProbe()
+	retained, err := retainedWriterConflicts(root, latest, paths, probe)
+	if err != nil {
+		return err
+	}
+	if len(retained) > 0 {
+		return fmt.Errorf("abandoned writer still holds claim %s on %s; confirm host termination and use dispatch abandon --release before retrying", retained[0].ID, strings.Join(retained[0].Paths, ","))
+	}
+	conflicts, err := claimConflicts(root, probe.withoutGone(liveClaims(latest, order, time.Now().UTC())), session, paths)
+	if err != nil {
+		return err
+	}
+	if len(conflicts) > 0 {
+		rec := conflicts[0]
+		return fmt.Errorf("live writer claim %s on %s held by session %q until %s", rec.ID, strings.Join(rec.Paths, ","), rec.Session, rec.ExpiresAt)
+	}
+	return nil
+}
+
 func claimAddLocked(path, session, reason string, ttl int, paths, admissionPaths []string, stdout, stderr io.Writer) (string, int) {
 	latest, order, bad, err := readClaims(path)
 	if err != nil {
@@ -503,7 +552,11 @@ func claimAddLocked(path, session, reason string, ttl int, paths, admissionPaths
 		printConflicts(stderr, retained)
 		return "", 3
 	}
-	conflicts := claimConflicts(probe.withoutGone(liveClaims(latest, order, now)), session, paths)
+	conflicts, err := claimConflicts(filepath.Dir(path), probe.withoutGone(liveClaims(latest, order, now)), session, admissionPaths)
+	if err != nil {
+		fmt.Fprintf(stderr, "claim: %v\n", err)
+		return "", 3
+	}
 	if len(conflicts) > 0 {
 		printConflicts(stderr, conflicts)
 		return "", 3
@@ -698,7 +751,11 @@ func claimCheckLocked(root, session string, paths []string, stdout, stderr io.Wr
 		printConflicts(stdout, retained)
 		return 3
 	}
-	conflicts := claimConflicts(probe.withoutGone(liveClaims(latest, order, time.Now().UTC())), session, paths)
+	conflicts, err := claimConflicts(root, probe.withoutGone(liveClaims(latest, order, time.Now().UTC())), session, paths)
+	if err != nil {
+		fmt.Fprintf(stderr, "claim: %v\n", err)
+		return 2
+	}
 	if len(conflicts) > 0 {
 		printConflicts(stdout, conflicts)
 		return 3

package/engine/internal/lib/continuation.go

@@ -10,6 +10,7 @@ import (
 
 	"github.com/devrites/devrites/internal/devritespaths"
 	"github.com/devrites/devrites/internal/gate"
+	"github.com/devrites/devrites/internal/markdowntext"
 	"github.com/devrites/devrites/internal/state"
 	"github.com/devrites/devrites/internal/workflow"
 )
@@ -39,12 +40,31 @@ func RunCheckContinuation(root string, args []string, stdout, stderr io.Writer)
 		}
 		return code
 	}
+	mode, err := autocompleteMode(root)
+	if err != nil {
+		fmt.Fprintf(stderr, "check continuation: %v\n", err)
+		return 2
+	}
 	verdict, err := classifyContinuation(root, slug)
 	if err != nil {
 		fmt.Fprintf(stderr, "check continuation: %v\n", err)
 		return 2
 	}
+	var frontier []string
+	if afkPresent(root) {
+		frontier, err = FrontierLines(root, slug)
+		if err != nil {
+			fmt.Fprintf(stderr, "check continuation: frontier: %v\n", err)
+			return 2
+		}
+		if mode && frontierGlobalPriority(slug, frontier) || !mode && !verdict.Required && len(frontier) > 0 && frontier[0] == "frontier: actionable" {
+			verdict = continuationVerdict{Required: true, Invoke: "/rite-autocomplete", Source: slug, Reason: "global frontier requires native preparation, authority review, or selection; no Ship approval"}
+		}
+	}
 	writeContinuation(stdout, verdict)
+	for _, line := range frontier {
+		fmt.Fprintln(stdout, line)
+	}
 	return 0
 }
 
@@ -59,12 +79,16 @@ func classifyContinuation(root, slug string) (continuationVerdict, error) {
 	}
 	invoke, internal, err := internalPhaseEdge(report.NextAction, slug)
 	if err != nil {
-		return continuationVerdict{}, err
+		if !frontierBoundSpec(root, slug, report.NextAction) {
+			return continuationVerdict{}, err
+		}
+		// A successor Spec belongs to the global controller, never this source's phase invocation.
+		invoke, internal = "", false
 	}
 	if !afkPresent(root) {
 		return continuationVerdict{Reason: "no AFK sentinel"}, nil
 	}
-	if report.Status != "running" {
+	if report.Status != "running" && !(report.Phase == state.PhaseVet && report.Status == "ready") {
 		if report.Status == "" {
 			return continuationVerdict{Reason: "status unset"}, nil
 		}
@@ -75,7 +99,17 @@ func classifyContinuation(root, slug string) (continuationVerdict, error) {
 	if err != nil {
 		return continuationVerdict{}, err
 	}
-	if qid, ok := state.CursorField(strings.Split(string(data), "\n"), state.CursorQuestionID); ok && strings.TrimSpace(qid) != "" {
+	structural, err := markdowntext.Structural(data)
+	if err != nil {
+		return continuationVerdict{Reason: "malformed source cursor; native normalization required"}, nil
+	}
+	cursorLines := strings.Split(string(structural), "\n")
+	for _, key := range []string{state.CursorPhase, state.CursorStatus, state.CursorNextAction, state.CursorQuestionID} {
+		if _, _, err := frontierField(cursorLines, key); err != nil {
+			return continuationVerdict{Reason: err.Error() + "; native normalization required"}, nil
+		}
+	}
+	if qid, ok := state.CursorField(cursorLines, state.CursorQuestionID); ok && strings.TrimSpace(qid) != "" {
 		return continuationVerdict{Reason: "question cursor set"}, nil
 	}
 	// #nosec G304 -- questions.md inside the checked feature workspace
@@ -93,7 +127,7 @@ func classifyContinuation(root, slug string) (continuationVerdict, error) {
 	if !internal {
 		return continuationVerdict{Reason: "next_action is not an internal phase edge"}, nil
 	}
-	return continuationVerdict{Required: true, Invoke: invoke, Source: slug, Reason: "AFK status=running internal phase edge"}, nil
+	return continuationVerdict{Required: true, Invoke: invoke, Source: slug, Reason: "AFK status=" + report.Status + " internal phase edge"}, nil
 }
 
 func afkPresent(root string) bool {

package/engine/internal/lib/dispatch.go

@@ -52,6 +52,8 @@ An abandoned writer's unreleased claim blocks overlapping writers across every
 live or archived feature in this repository, even in the same session or after
 TTL expiry, until explicit release or proven host termination.
 return --handle, when supplied, must match the role's recorded host handle.
+Completed return replay requires the exact recorded role and --handle and only
+reconciles claim release; failed release exits nonzero without undoing the return.
 status --wave exits
 nonzero until that wave is complete; bare status lists every open, sealed,
 or abandoned wave, folds complete waves into one count line (--all lists
@@ -114,7 +116,9 @@ type dispatchWave struct {
 	ResliceReviewed []string                 `json:"reslice_reviewed,omitempty"`
 	Claim           string                   `json:"claim,omitempty"`
 	ClaimSession    string                   `json:"claim_session,omitempty"`
-	Tree            string                   `json:"tree,omitempty"` // work tree at a build wright open, for check windows --since-dispatch
+	Tree            string                   `json:"tree,omitempty"`             // work tree at a build wright open, for check windows --since-dispatch
+	ControllerBatch string                   `json:"controller_batch,omitempty"` // cohort admission identity, not evidence of actor checkout
+	AdmittedPaths   map[string][]string      `json:"admitted_paths,omitempty"`   // immutable normalized write sets, keyed by source-local slice
 }
 
 // dispatchClaim carries the wave-claim flags; ttl 0 means unset.
@@ -150,32 +154,36 @@ func loadDispatch(root, slug string) (*dispatchFile, string, error) {
 }
 
 func loadDispatchFile(path string) (*dispatchFile, string, error) {
-	f := &dispatchFile{Waves: map[string]*dispatchWave{}}
 	data, err := os.ReadFile(path) // #nosec G304 -- path is a validated feature workspace artifact
 	if os.IsNotExist(err) {
-		return f, path, nil
+		return &dispatchFile{Waves: map[string]*dispatchWave{}}, path, nil
 	}
 	if err != nil {
 		return nil, path, err
 	}
-	f = &dispatchFile{}
+	f, err := decodeDispatch(data)
+	return f, path, err
+}
+
+func decodeDispatch(data []byte) (*dispatchFile, error) {
+	f := &dispatchFile{}
 	if err := json.Unmarshal(data, f); err != nil {
-		return nil, path, fmt.Errorf("dispatch.json is not valid JSON: %w", err)
+		return nil, fmt.Errorf("dispatch.json is not valid JSON: %w", err)
 	}
 	if f.Waves == nil {
-		return nil, path, fmt.Errorf("dispatch.json is malformed (missing waves)")
+		return nil, fmt.Errorf("dispatch.json is malformed (missing waves)")
 	}
 	// Validate every account before any caller can use or mutate the ledger.
 	for name, w := range f.Waves {
 		if w == nil || strings.TrimSpace(name) == "" || strings.TrimSpace(w.Phase) == "" || len(w.Roles) == 0 ||
 			!slices.Contains([]string{"open", "sealed", "complete", "abandoned"}, w.State) {
-			return nil, path, fmt.Errorf("wave %q is malformed (invalid phase, state or roles)", name)
+			return nil, fmt.Errorf("wave %q is malformed (invalid phase, state or roles)", name)
 		}
 		handles := map[string]bool{}
 		allStarted, allReturned := true, true
 		for role, r := range w.Roles {
 			if r == nil || strings.TrimSpace(role) == "" {
-				return nil, path, fmt.Errorf("wave %q role %q is malformed (missing account)", name, role)
+				return nil, fmt.Errorf("wave %q role %q is malformed (missing account)", name, role)
 			}
 			started := r.Handle != ""
 			if started != (r.StartedAt != "") || r.Returned != (r.ReturnedAt != "") ||
@@ -183,19 +191,19 @@ func loadDispatchFile(path string) (*dispatchFile, string, error) {
 				(w.State == "open" && r.Returned) ||
 				((w.State == "sealed" || w.State == "complete") && !started) ||
 				(w.State == "complete" && !r.Returned) {
-				return nil, path, fmt.Errorf("wave %q role %q is malformed (inconsistent start or return)", name, role)
+				return nil, fmt.Errorf("wave %q role %q is malformed (inconsistent start or return)", name, role)
 			}
 			allStarted = allStarted && started
 			allReturned = allReturned && r.Returned
 			if started {
 				start, startErr := time.Parse(time.RFC3339Nano, r.StartedAt)
 				if startErr != nil {
-					return nil, path, fmt.Errorf("wave %q role %q is malformed (invalid start timestamp)", name, role)
+					return nil, fmt.Errorf("wave %q role %q is malformed (invalid start timestamp)", name, role)
 				}
 				if r.Returned {
 					end, endErr := time.Parse(time.RFC3339Nano, r.ReturnedAt)
 					if endErr != nil || end.Before(start) {
-						return nil, path, fmt.Errorf("wave %q role %q is malformed (invalid return timestamp)", name, role)
+						return nil, fmt.Errorf("wave %q role %q is malformed (invalid return timestamp)", name, role)
 					}
 				}
 			}
@@ -204,32 +212,32 @@ func loadDispatchFile(path string) (*dispatchFile, string, error) {
 			}
 		}
 		if (w.State == "open" && allStarted) || (w.State == "sealed" && allReturned) {
-			return nil, path, fmt.Errorf("wave %q is malformed (inconsistent barrier state)", name)
+			return nil, fmt.Errorf("wave %q is malformed (inconsistent barrier state)", name)
 		}
 		if w.AbandonedAt != "" {
 			if _, err := time.Parse(time.RFC3339Nano, w.AbandonedAt); err != nil || w.State != "abandoned" {
-				return nil, path, fmt.Errorf("wave %q is malformed (invalid abandonment timestamp)", name)
+				return nil, fmt.Errorf("wave %q is malformed (invalid abandonment timestamp)", name)
 			}
 		}
 		if w.TerminalAt != "" {
 			terminal, err := time.Parse(time.RFC3339Nano, w.TerminalAt)
 			abandoned, abandonErr := time.Parse(time.RFC3339Nano, w.AbandonedAt)
 			if err != nil || abandonErr != nil || w.State != "abandoned" || terminal.Before(abandoned) {
-				return nil, path, fmt.Errorf("wave %q is malformed (invalid terminal timestamp)", name)
+				return nil, fmt.Errorf("wave %q is malformed (invalid terminal timestamp)", name)
 			}
 			for _, account := range w.Roles {
 				for _, stamp := range []string{account.StartedAt, account.ReturnedAt} {
 					if stamp != "" {
 						at, _ := time.Parse(time.RFC3339Nano, stamp)
 						if terminal.Before(at) {
-							return nil, path, fmt.Errorf("wave %q is malformed (terminal timestamp precedes account)", name)
+							return nil, fmt.Errorf("wave %q is malformed (terminal timestamp precedes account)", name)
 						}
 					}
 				}
 			}
 		}
 	}
-	return f, path, nil
+	return f, nil
 }
 
 func saveDispatch(path string, f *dispatchFile) error {
@@ -335,20 +343,61 @@ func RunDispatch(root string, args []string, stdout, stderr io.Writer) int {
 	// Serialize load-modify-save so concurrent start/return calls never lose
 	// an update and strand the wave short of complete.
 	code := 0
-	if err := state.WithFeatureLock(root, slug, func() error {
-		// Feature → claims is the lock order; never acquire another feature.
-		return state.WithLock(claimsPath(root)+".lock", func() error {
-			code = dispatchLocked(root, slug, sub, phase, wave, role, handle, reason, roles, sliceIDs, review, contract, packet, outcome, result, all, claim, stdout, stderr)
-			return nil
+	recordedReturn := false
+	mutate := func() error {
+		return state.WithFeatureLock(root, slug, func() error {
+			// Controller → feature → claims; never acquire another feature.
+			return state.WithLock(claimsPath(root)+".lock", func() error {
+				code = dispatchLocked(root, slug, sub, phase, wave, role, handle, reason, roles, sliceIDs, review, contract, packet, outcome, result, all, claim, stdout, stderr, &recordedReturn)
+				return nil
+			})
 		})
-	}); err != nil {
+	}
+	controllerOpen := false
+	if sub == "open" && strings.EqualFold(phase, "build") {
+		for _, candidate := range roles {
+			controllerOpen = controllerOpen || strings.Contains(candidate, "wright")
+		}
+	}
+	if controllerOpen {
+		mode, err := autocompleteMode(root)
+		if err != nil {
+			fmt.Fprintf(stderr, "dispatch: BLOCKED: %v\n", err)
+			return 3
+		}
+		controllerOpen = mode
+	}
+	var lockErr error
+	if controllerOpen {
+		lockErr = parallel.WithControlLock(root, mutate)
+	} else {
+		lockErr = mutate()
+	}
+	if err := lockErr; err != nil {
 		fmt.Fprintf(stderr, "dispatch: %v\n", err)
 		return 3
 	}
+	if recordedReturn {
+		mode, err := autocompleteMode(root)
+		if err != nil {
+			fmt.Fprintf(stderr, "dispatch: return recorded; global scheduling: %v\n", err)
+			return 3
+		}
+		if mode {
+			lines, err := FrontierLines(root, slug)
+			if err != nil {
+				fmt.Fprintf(stderr, "dispatch: return recorded; global scheduling: %v\n", err)
+				return 3
+			}
+			for _, line := range lines {
+				fmt.Fprintln(stdout, line)
+			}
+		}
+	}
 	return code
 }
 
-func dispatchLocked(root, slug, sub, phase, wave, role, handle, reason string, roles, sliceIDs []string, review, contract, packet, outcome, result string, all bool, claim dispatchClaim, stdout, stderr io.Writer) int {
+func dispatchLocked(root, slug, sub, phase, wave, role, handle, reason string, roles, sliceIDs []string, review, contract, packet, outcome, result string, all bool, claim dispatchClaim, stdout, stderr io.Writer, recordedReturn *bool) int {
 	f, path, err := loadDispatch(root, slug)
 	if err != nil {
 		fmt.Fprintf(stderr, "dispatch: %v\n", err)
@@ -386,6 +435,16 @@ func dispatchLocked(root, slug, sub, phase, wave, role, handle, reason string, r
 		if err := lintKnownRoles(root, phase, roles); err != nil {
 			return fail("BLOCKED: %v", err)
 		}
+		if isBuildWrightWave(w) {
+			binding, notices, err := autocompleteWriterAdmission(root, slug, w, f)
+			if err != nil {
+				return fail("BLOCKED: %v", err)
+			}
+			w.ControllerBatch = binding
+			for _, notice := range notices {
+				fmt.Fprintln(stdout, notice)
+			}
+		}
 		rounds, code := admitWrightRounds(root, slug, f, w, review, stderr)
 		if code != 0 {
 			return code
@@ -422,10 +481,16 @@ func dispatchLocked(root, slug, sub, phase, wave, role, handle, reason string, r
 		}
 		admissionPaths := slices.Clone(claimPaths)
 		if isWrightWave(w) {
-			admissionPaths = append(admissionPaths, sliceWriteSet(root, slug, w.Slices)...)
+			if len(w.AdmittedPaths) > 0 {
+				for _, id := range w.Slices {
+					admissionPaths = append(admissionPaths, w.AdmittedPaths[id]...)
+				}
+			} else {
+				admissionPaths = append(admissionPaths, sliceWriteSet(root, slug, w.Slices)...)
+			}
 		}
 		if len(claimPaths) == 0 {
-			if err := checkAbandonedWriterClaims(root, admissionPaths); err != nil {
+			if err := checkWriterClaimsLocked(root, claim.session, admissionPaths); err != nil {
 				return fail("BLOCKED: %v", err)
 			}
 		}
@@ -543,7 +608,7 @@ func dispatchLocked(root, slug, sub, phase, wave, role, handle, reason string, r
 
 	case "return":
 		w := getWave()
-		if w == nil || w.State != "sealed" {
+		if w == nil || (w.State != "sealed" && w.State != "complete") {
 			return fail("wave %q is not sealed (state %s)", wave, waveState(w))
 		}
 		r := w.Roles[role]
@@ -553,6 +618,16 @@ func dispatchLocked(root, slug, sub, phase, wave, role, handle, reason string, r
 		if handle != "" && handle != r.Handle {
 			return fail("handle %q does not match role %q's recorded handle %q", handle, role, r.Handle)
 		}
+		if w.State == "complete" {
+			if !r.Returned || handle == "" || r.Handle == "" || w.Claim == "" {
+				return fail("completed wave %q needs a returned role, its recorded --handle, and an owned claim to reconcile", wave)
+			}
+			if !releaseWaveClaim(root, wave, w, stdout, stderr) {
+				return 3
+			}
+			*recordedReturn = true
+			return 0
+		}
 		if r.Returned {
 			return fail("role %q already returned", role)
 		}
@@ -589,13 +664,14 @@ func dispatchLocked(root, slug, sub, phase, wave, role, handle, reason string, r
 			}
 			return fail("%v", err)
 		}
+		*recordedReturn = true
 		recordMetricNote(root, slug, w.Phase, "return", role, note)
 		fmt.Fprintf(stdout, "dispatch: %s returned (wave %s %s)\n", role, wave, w.State)
 		if all {
 			absorbWave(root, slug, w, stderr)
 		}
-		if all && w.Claim != "" {
-			releaseWaveClaim(root, wave, w, stdout, stderr)
+		if all && w.Claim != "" && !releaseWaveClaim(root, wave, w, stdout, stderr) {
+			return 3
 		}
 		if stored != "" {
 			head, _, _ := strings.Cut(note, " slice=")
@@ -699,33 +775,11 @@ func dispatchLocked(root, slug, sub, phase, wave, role, handle, reason string, r
 	return 2
 }
 
-// Caller holds the repository claims lock through new-wave publication.
-func checkAbandonedWriterClaims(root string, paths []string) error {
-	if len(paths) == 0 {
-		return nil
-	}
-	latest, _, bad, err := readClaims(claimsPath(root))
-	if err != nil {
-		return err
-	}
-	if bad > 0 {
-		return fmt.Errorf("%d unparsed ledger line(s); cannot rule out an abandoned writer claim", bad)
-	}
-	conflicts, err := retainedWriterConflicts(root, latest, paths, newHolderProbe())
-	if err != nil {
-		return err
-	}
-	if len(conflicts) > 0 {
-		return fmt.Errorf("abandoned writer still holds claim %s on %s; confirm host termination and use dispatch abandon --release before retrying", conflicts[0].ID, strings.Join(conflicts[0].Paths, ","))
-	}
-	return nil
-}
-
-// releaseWaveClaim releases w's claim; explicit terminal abandonment also
-// reconciles a verified prior release. A failure only warns.
+// releaseWaveClaim releases w's claim or reconciles a verified prior release.
+// Callers surface failure without undoing the recorded return or abandonment.
 func releaseWaveClaim(root, wave string, w *dispatchWave, stdout, stderr io.Writer) bool {
 	n, err := releaseClaim(root, w.ClaimSession, w.Claim)
-	if w.State == "abandoned" && errors.Is(err, errClaimAlreadyReleased) {
+	if errors.Is(err, errClaimAlreadyReleased) {
 		fmt.Fprintf(stdout, "dispatch: wave %s claim %s already released\n", wave, w.Claim)
 		return true
 	}
@@ -914,21 +968,21 @@ func admitWrightRounds(root, slug string, f *dispatchFile, w *dispatchWave, revi
 	if kind == "wright" {
 		lines = append(lines, "dispatch: ADVISORY: wright contract reminder: name the writer-safe checks the wright runs (syntax/type/lint, unit and self-check suites, a narrow local smoke) and never forbid them; only artifact-producing, consumptive, or full canonical gates stay root-owned")
 	}
+	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
+		}
+	}
 	if len(overCap) == 0 {
 		if review != "" {
 			fmt.Fprintf(stderr, "dispatch: --reslice-review given but no slice has reached its %d-round cap\n", wrightRoundsPerReview)
 			return nil, 2
 		}
-		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
-			}
-		}
 		return lines, 0
 	}
 	if review == "" {
@@ -1024,6 +1078,13 @@ func wrightLane(role string) (string, bool) {
 // 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 {
+	mode, modeErr := autocompleteMode(root)
+	if modeErr != nil {
+		return fmt.Sprintf("dispatch: BLOCKED: %v", modeErr)
+	}
+	if mode {
+		return ""
+	}
 	capN := min(afkMaxParallel(root), parallel.MaxParallelSlices)
 	if capN < 2 {
 		return ""