devrites 6.0.2 → 6.0.4

package/engine/internal/lib/context_next_test.go

@@ -672,3 +672,241 @@ func TestContextWorkspaceIncludeMarkerStaysLiteral(t *testing.T) {
 		t.Fatalf("workspace include marker not kept literal:\n%s", text)
 	}
 }
+
+func TestContextSliceScopesWorkspaceAndRole(t *testing.T) {
+	root, featureDir := newWorkspace(t, "build")
+	skills := newSkillsRoot(t)
+	writeFile(t, filepath.Join(skills, "rite-build", "reference", "root-procedure.md"), "# root procedure body\n")
+	writeFile(t, filepath.Join(skills, "rite-build", "SKILL.md"), "---\nname: rite-build\n---\n<!-- loads: {\"always\":[\"devrites-lib/reference/standards/core.md\",\"rite-build/reference/root-procedure.md\"],\"rootOnly\":[\"rite-build/reference/root-procedure.md\"],\"workspace\":[\"tasks.md\",\"decisions.md\",\"spec.md\"]} -->\n# build\n")
+	writeFile(t, filepath.Join(featureDir, "tasks.md"), "# Tasks\n\n## SLICE-001 First\nGoal: first body\n\n## SLICE-002 Second\nGoal: second body\nSatisfies: AC-001\nDecisions: DEC-010\ndepends_on: [SLICE-001]\n")
+	var decisions strings.Builder
+	decisions.WriteString("# Decisions\n")
+	for i := 0; i < 250; i++ {
+		decisions.WriteString("filler decision row\n")
+	}
+	decisions.WriteString("## DEC-010 Use the store\nDEC-0100 is a different id\n")
+	writeFile(t, filepath.Join(featureDir, "decisions.md"), decisions.String())
+	writeFile(t, filepath.Join(featureDir, "spec.md"), "# spec\nAC-001 small spec body\n")
+
+	stdout, stderr := &bytes.Buffer{}, &bytes.Buffer{}
+	args := []string{"feat", "--phase", "build", "--role", "slice-wright", "--slice", "SLICE-002", "--skills-root", skills}
+	if code := RunContext(root, args, stdout, stderr); code != 0 {
+		t.Fatalf("code=%d\n%s%s", code, stdout, stderr)
+	}
+	if !strings.Contains(stdout.String(), "scope: slice SLICE-002 (1 whole, 2 by-reference)") {
+		t.Fatalf("scope line missing:\n%s", stdout)
+	}
+	raw, err := os.ReadFile(filepath.Join(featureDir, "ctx", "build-slice-wright.SLICE-002.bundle.md"))
+	if err != nil {
+		t.Fatalf("bundle: %v", err)
+	}
+	text := string(raw)
+	for _, want := range []string{
+		"Goal: second body",
+		"workspace/decisions.md (by reference)",
+		"/work/feat/decisions.md sha256: ",
+		"- L252 ## DEC-010 Use the store",
+		"- DEC-010: L252\n",
+		"- SLICE-001: L3 L10\n",
+		"- AC-001: L8\n",
+		"small spec body",
+		"===== root-only (not inlined for role slice-wright) =====\nrite-build/reference/root-procedure.md",
+	} {
+		if !strings.Contains(text, want) {
+			t.Fatalf("bundle missing %q:\n%s", want, text)
+		}
+	}
+	for _, absent := range []string{"Goal: first body", "filler decision row", "root procedure body"} {
+		if strings.Contains(text, absent) {
+			t.Fatalf("bundle inlined %q:\n%s", absent, text)
+		}
+	}
+	if strings.Index(text, "# wright") > strings.Index(text, "# core") {
+		t.Fatalf("role contract must lead the bundle:\n%s", text)
+	}
+
+	// Without --role the root still gets its procedure inline.
+	stdout.Reset()
+	if code := RunContext(root, []string{"feat", "--phase", "build", "--skills-root", skills}, stdout, stderr); code != 0 {
+		t.Fatalf("phase bundle code=%d\n%s", code, stderr)
+	}
+	phase, err := os.ReadFile(filepath.Join(featureDir, "ctx", "build.bundle.md"))
+	if err != nil || !strings.Contains(string(phase), "root procedure body") || !strings.Contains(string(phase), "Goal: first body") {
+		t.Fatalf("phase bundle must stay whole: err=%v\n%s", err, phase)
+	}
+}
+
+func TestContextSliceRejectsBadOrUnknownID(t *testing.T) {
+	root, featureDir := newWorkspace(t, "build")
+	skills := newSkillsRoot(t)
+	writeFile(t, filepath.Join(featureDir, "tasks.md"), "# Tasks\n\n## SLICE-001 First\nGoal: x\n")
+	stdout, stderr := &bytes.Buffer{}, &bytes.Buffer{}
+	if code := RunContext(root, []string{"feat", "--phase", "build", "--slice", "slice-1", "--skills-root", skills}, stdout, stderr); code != 2 {
+		t.Fatalf("malformed id: code=%d want 2\n%s", code, stderr)
+	}
+	if code := RunContext(root, []string{"--skill", "rite-build", "--slice", "SLICE-001", "--out", "x.md", "--skills-root", skills}, stdout, stderr); code != 2 {
+		t.Fatalf("slice without slug: code=%d want 2\n%s", code, stderr)
+	}
+	stdout.Reset()
+	if code := RunContext(root, []string{"feat", "--phase", "build", "--slice", "SLICE-009", "--skills-root", skills}, stdout, stderr); code != 3 || !strings.Contains(stdout.String(), "BLOCKED: SLICE-009 not found") {
+		t.Fatalf("unknown slice: code=%d\n%s", code, stdout)
+	}
+}
+
+func TestDispatchWrightRoundCap(t *testing.T) {
+	root, featureDir := newWorkspace(t, "build")
+	run := func(args ...string) (int, string) {
+		stdout, stderr := &bytes.Buffer{}, &bytes.Buffer{}
+		code := RunDispatch(root, append([]string{"feat"}, args...), stdout, stderr)
+		return code, stdout.String() + stderr.String()
+	}
+	open := func(wave string, extra ...string) (int, string) {
+		return run(append([]string{"open", "--phase", "build", "--wave", wave, "--role", "slice-wright", "--slice", "SLICE-001"}, extra...)...)
+	}
+	if code, out := run("open", "--phase", "build", "--wave", "w0", "--role", "slice-wright"); code != 2 || !strings.Contains(out, "needs --slice") {
+		t.Fatalf("missing --slice: code=%d\n%s", code, out)
+	}
+	if code, out := run("open", "--phase", "vet", "--wave", "v1", "--role", "plan-reviewer"); code != 0 {
+		t.Fatalf("non-build wave must not need --slice: code=%d\n%s", code, out)
+	}
+	for i := 1; i <= wrightRoundsPerReview; i++ {
+		code, out := open("r" + string(rune('0'+i)))
+		if code != 0 || !strings.Contains(out, "SLICE-001 wright round "+string(rune('0'+i))) {
+			t.Fatalf("round %d: code=%d\n%s", i, code, out)
+		}
+	}
+	if code, out := run("abandon", "--wave", "r5", "--reason", "orphaned"); !strings.Contains(out, "wave r5 abandoned") {
+		t.Fatalf("abandon: code=%d\n%s", code, out)
+	}
+	if code, out := open("r5b"); code != 0 || !strings.Contains(out, "wright round 5") {
+		t.Fatalf("abandoned wave must not count: code=%d\n%s", code, out)
+	}
+	if code, out := open("r6"); code != 3 || !strings.Contains(out, "BLOCKED: SLICE-001 reached 5 wright rounds") {
+		t.Fatalf("round 6 must block: code=%d\n%s", code, out)
+	}
+	writeFile(t, filepath.Join(featureDir, "drift.md"), "# Drift\n\n## D-010 — SLICE-002 unrelated\n\n## D-011 — SLICE-001 reslice review: no smaller AC-preserving split\n")
+	if code, out := open("r6", "--reslice-review", "D-099"); code != 3 {
+		t.Fatalf("unknown drift id: code=%d\n%s", code, out)
+	}
+	if code, out := open("r6", "--reslice-review", "D-010"); code != 3 || !strings.Contains(out, "naming SLICE-001") {
+		t.Fatalf("drift heading for another slice: code=%d\n%s", code, out)
+	}
+	if code, out := open("r6", "--reslice-review", "D-011"); code != 0 || !strings.Contains(out, "wright round 6") {
+		t.Fatalf("valid review must admit: code=%d\n%s", code, out)
+	}
+	for i := 7; i <= 2*wrightRoundsPerReview; i++ {
+		if code, out := open("r" + string(rune('a'+i))); code != 0 {
+			t.Fatalf("round %d inside the reviewed window: code=%d\n%s", i, code, out)
+		}
+	}
+	if code, out := open("r11", "--reslice-review", "D-011"); code != 3 || !strings.Contains(out, "already admitted") {
+		t.Fatalf("reused review: code=%d\n%s", code, out)
+	}
+	if code, out := run("open", "--phase", "build", "--wave", "s2", "--role", "slice-wright", "--slice", "SLICE-002", "--reslice-review", "D-010"); code != 2 {
+		t.Fatalf("review before the cap must be refused: code=%d\n%s", code, out)
+	}
+}
+
+func TestDispatchVetRoundsCountSeparately(t *testing.T) {
+	root, featureDir := newWorkspace(t, "build")
+	run := func(args ...string) (int, string) {
+		stdout, stderr := &bytes.Buffer{}, &bytes.Buffer{}
+		code := RunDispatch(root, append([]string{"feat"}, args...), stdout, stderr)
+		return code, stdout.String() + stderr.String()
+	}
+	for i := 0; i < 7; i++ {
+		if code, out := run("open", "--phase", "vet", "--wave", "full"+string(rune('a'+i)), "--role", "plan-reviewer"); code != 0 {
+			t.Fatalf("full Vet without --slice stays uncapped: code=%d\n%s", code, out)
+		}
+	}
+	if code, out := run("open", "--phase", "build", "--wave", "w1", "--role", "slice-wright", "--slice", "SLICE-001"); code != 0 || !strings.Contains(out, "wright round 1") {
+		t.Fatalf("wright round must not see vet waves: code=%d\n%s", code, out)
+	}
+	for i := 1; i <= wrightRoundsPerReview; i++ {
+		if code, out := run("open", "--phase", "vet", "--wave", "v"+string(rune('0'+i)), "--role", "plan-reviewer", "--slice", "SLICE-001"); code != 0 || !strings.Contains(out, "vet round "+string(rune('0'+i))) {
+			t.Fatalf("vet round %d: code=%d\n%s", i, code, out)
+		}
+	}
+	if code, out := run("open", "--phase", "vet", "--wave", "v6", "--role", "plan-reviewer", "--slice", "SLICE-001"); code != 3 || !strings.Contains(out, "reached 5 vet rounds") {
+		t.Fatalf("vet round 6 must block: code=%d\n%s", code, out)
+	}
+	writeFile(t, filepath.Join(featureDir, "drift.md"), "## D-001 — SLICE-001 reslice review: proof seam already minimal\n")
+	if code, out := run("open", "--phase", "vet", "--wave", "v6", "--role", "plan-reviewer", "--slice", "SLICE-001", "--reslice-review", "D-001"); code != 0 {
+		t.Fatalf("reviewed vet round 6: code=%d\n%s", code, out)
+	}
+	if code, out := run("open", "--phase", "plan", "--wave", "p1", "--role", "plan-drafter", "--slice", "SLICE-001"); code != 2 {
+		t.Fatalf("--slice on a plan wave: code=%d\n%s", code, out)
+	}
+}
+
+func TestContextRepeatedSliceUnion(t *testing.T) {
+	root, featureDir := newWorkspace(t, "build")
+	skills := newSkillsRoot(t)
+	writeFile(t, filepath.Join(skills, "rite-build", "SKILL.md"), "---\nname: rite-build\n---\n<!-- loads: {\"always\":[\"devrites-lib/reference/standards/core.md\"],\"workspace\":[\"tasks.md\"]} -->\n# build\n")
+	writeFile(t, filepath.Join(featureDir, "tasks.md"), "# Tasks\n\n## SLICE-001 A\nGoal: alpha body\n\n## SLICE-002 B\nGoal: beta body\n\n## SLICE-003 C\nGoal: gamma body\n")
+	stdout, stderr := &bytes.Buffer{}, &bytes.Buffer{}
+	args := []string{"feat", "--phase", "build", "--slice", "SLICE-001", "--slice", "SLICE-003", "--skills-root", skills}
+	if code := RunContext(root, args, stdout, stderr); code != 0 {
+		t.Fatalf("code=%d\n%s%s", code, stdout, stderr)
+	}
+	raw, err := os.ReadFile(filepath.Join(featureDir, "ctx", "build.SLICE-001+SLICE-003.bundle.md"))
+	if err != nil {
+		t.Fatal(err)
+	}
+	text := string(raw)
+	if !strings.Contains(text, "alpha body") || !strings.Contains(text, "gamma body") || strings.Contains(text, "beta body") {
+		t.Fatalf("union of slice blocks wrong:\n%s", text)
+	}
+}
+
+func TestContextRootBundleAnchorsOverBudgetArtifacts(t *testing.T) {
+	root, featureDir := newWorkspace(t, "build")
+	skills := newSkillsRoot(t)
+	writeFile(t, filepath.Join(skills, "rite-build", "SKILL.md"), "---\nname: rite-build\n---\n<!-- loads: {\"always\":[\"devrites-lib/reference/standards/core.md\"],\"workspace\":[\"decisions.md\",\"spec.md\"]} -->\n# build\n")
+	writeFile(t, filepath.Join(featureDir, "decisions.md"), "# Decisions\n"+strings.Repeat("filler decision row\n", 250)+"## DEC-010 Use the store\n")
+	writeFile(t, filepath.Join(featureDir, "spec.md"), "# spec\nsmall spec body\n")
+	run := func(args ...string) string {
+		stdout, stderr := &bytes.Buffer{}, &bytes.Buffer{}
+		if code := RunContext(root, append([]string{"feat", "--phase", "build", "--skills-root", skills}, args...), stdout, stderr); code != 0 {
+			t.Fatalf("code=%d\n%s%s", code, stdout, stderr)
+		}
+		return stdout.String()
+	}
+	out := run()
+	if !strings.Contains(out, "scope: root (1 whole, 1 by-reference over budget)") {
+		t.Fatalf("root scope line missing:\n%s", out)
+	}
+	rootBundle, _ := os.ReadFile(filepath.Join(featureDir, "ctx", "build.bundle.md"))
+	if text := string(rootBundle); !strings.Contains(text, "workspace/decisions.md (by reference)") || strings.Contains(text, "filler decision row") || !strings.Contains(text, "small spec body") {
+		t.Fatalf("root bundle must anchor only the over-budget artifact:\n%s", text)
+	}
+	run("--role", "code-reviewer")
+	roleBundle, _ := os.ReadFile(filepath.Join(featureDir, "ctx", "build-code-reviewer.bundle.md"))
+	if !strings.Contains(string(roleBundle), "filler decision row") {
+		t.Fatalf("a role bundle without --slice must stay whole:\n%s", roleBundle)
+	}
+}
+
+func TestMetricsSummaryBySlice(t *testing.T) {
+	root, featureDir := newWorkspace(t, "build")
+	writeFile(t, filepath.Join(featureDir, "dispatch.json"), `{"waves":{
+ "w1":{"phase":"build","state":"complete","slices":["SLICE-001"],"roles":{"slice-wright":{"handle":"a","started":"2026-10-15T10:00:00Z","returned":true,"returned_at":"2026-10-15T10:30:00Z"}}},
+ "w2":{"phase":"build","state":"complete","slices":["SLICE-001","SLICE-002"],"roles":{"slice-wright":{"handle":"b","started":"2026-10-15T11:00:00Z","returned":true,"returned_at":"2026-10-15T11:20:00Z"}}},
+ "w3":{"phase":"build","state":"abandoned","slices":["SLICE-001"],"roles":{"slice-wright":{"handle":"c"}}},
+ "v1":{"phase":"vet","state":"complete","slices":["SLICE-002"],"roles":{"plan-reviewer":{"handle":"d","started":"2026-10-15T12:00:00Z","returned":true}}},
+ "f1":{"phase":"vet","state":"complete","roles":{"plan-reviewer":{"handle":"e"}}}
+}}`)
+	stdout, stderr := &bytes.Buffer{}, &bytes.Buffer{}
+	if code := RunMetrics(root, []string{"summary", "feat", "--by-slice"}, stdout, stderr); code != 0 {
+		t.Fatalf("code=%d\n%s", code, stderr)
+	}
+	out := stdout.String()
+	for _, want := range []string{
+		"metrics: SLICE-001 wright_rounds=2 vet_rechecks=0 agent_minutes=40\n",
+		"metrics: SLICE-002 wright_rounds=1 vet_rechecks=1 agent_minutes=10\n",
+	} {
+		if !strings.Contains(out, want) {
+			t.Fatalf("missing %q:\n%s", want, out)
+		}
+	}
+}

package/engine/internal/lib/dispatch.go

@@ -6,6 +6,8 @@ import (
 	"io"
 	"os"
 	"path/filepath"
+	"regexp"
+	"slices"
 	"sort"
 	"strings"
 	"time"
@@ -19,30 +21,45 @@ import (
 // fan-out cannot silently degrade to serial (open -> every role started ->
 // seal -> returns -> complete). start/return also auto-record metrics events.
 //
-//	devrites-engine dispatch <slug> <sub> [--phase p] [--wave w] [--role r] [--handle h] [--reason s]
+//	devrites-engine dispatch <slug> <sub> [--phase p] [--wave w] [--role r] [--handle h] [--reason s] [--slice SLICE-###] [--reslice-review <DRIFT-ID>]
 
-const dispatchUsage = `usage: devrites-engine dispatch <slug> <open|start|seal|return|status|abandon> [--phase p] [--wave w] [--role r] [--handle h] [--reason s]
+const dispatchUsage = `usage: devrites-engine dispatch <slug> <open|start|seal|return|status|abandon> [--phase p] [--wave w] [--role r] [--handle h] [--reason s] [--slice SLICE-###] [--reslice-review <DRIFT-ID>]
 
 Wave barrier for parallel agent dispatch: seal fails until every declared
 role has a distinct handle; return fails before seal; status exits nonzero
 while a wave is open, sealed, or abandoned.
+
+A build wave with a wright role must name its slice(s) with --slice; a vet
+wave may (slice-bound recheck). 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.
 `
 
+// wrightRoundsPerReview is how many build wright rounds (or slice-bound Vet
+// rechecks) one slice may take before (and after each) reslice review.
+// Recovery itself stays unbounded; the cap only forces the split question
+// onto the record.
+const wrightRoundsPerReview = 5
+
 type dispatchFile struct {
 	Waves map[string]*dispatchWave `json:"waves"`
 }
 
 type dispatchWave struct {
-	Phase  string                   `json:"phase"`
-	State  string                   `json:"state"` // open, sealed, abandoned, complete
-	Reason string                   `json:"reason,omitempty"`
-	Roles  map[string]*dispatchRole `json:"roles"`
+	Phase           string                   `json:"phase"`
+	State           string                   `json:"state"` // open, sealed, abandoned, complete
+	Reason          string                   `json:"reason,omitempty"`
+	Roles           map[string]*dispatchRole `json:"roles"`
+	Slices          []string                 `json:"slices,omitempty"`
+	ResliceReview   string                   `json:"reslice_review,omitempty"`
+	ResliceReviewed []string                 `json:"reslice_reviewed,omitempty"`
 }
 
 type dispatchRole struct {
-	Handle    string `json:"handle,omitempty"`
-	StartedAt string `json:"started,omitempty"`
-	Returned  bool   `json:"returned,omitempty"`
+	Handle     string `json:"handle,omitempty"`
+	StartedAt  string `json:"started,omitempty"`
+	Returned   bool   `json:"returned,omitempty"`
+	ReturnedAt string `json:"returned_at,omitempty"`
 }
 
 func dispatchPath(root, slug string) string {
@@ -89,8 +106,8 @@ func nowStamp() string { return time.Now().UTC().Format(time.RFC3339) }
 
 // RunDispatch implements the dispatch wave state machine.
 func RunDispatch(root string, args []string, stdout, stderr io.Writer) int {
-	var slug, sub, phase, wave, role, handle, reason string
-	var roles []string
+	var slug, sub, phase, wave, role, handle, reason, review string
+	var roles, sliceIDs []string
 	var positional []string
 	for i := 0; i < len(args); i++ {
 		value := argAt(args, i+1)
@@ -106,6 +123,10 @@ func RunDispatch(root string, args []string, stdout, stderr io.Writer) int {
 			handle = value
 		case "--reason":
 			reason = value
+		case "--slice":
+			sliceIDs = append(sliceIDs, value)
+		case "--reslice-review":
+			review = value
 		default:
 			if strings.HasPrefix(args[i], "-") {
 				fmt.Fprintf(stderr, "dispatch: unknown flag %q\n", args[i])
@@ -129,7 +150,7 @@ func RunDispatch(root string, args []string, stdout, stderr io.Writer) int {
 	// an update and strand the wave short of complete.
 	code := 0
 	if err := state.WithFeatureLock(root, slug, func() error {
-		code = dispatchLocked(root, slug, sub, phase, wave, role, handle, reason, roles, stdout, stderr)
+		code = dispatchLocked(root, slug, sub, phase, wave, role, handle, reason, roles, sliceIDs, review, stdout, stderr)
 		return nil
 	}); err != nil {
 		fmt.Fprintf(stderr, "dispatch: %v\n", err)
@@ -138,7 +159,7 @@ func RunDispatch(root string, args []string, stdout, stderr io.Writer) int {
 	return code
 }
 
-func dispatchLocked(root, slug, sub, phase, wave, role, handle, reason string, roles []string, stdout, stderr io.Writer) int {
+func dispatchLocked(root, slug, sub, phase, wave, role, handle, reason string, roles, sliceIDs []string, review string, stdout, stderr io.Writer) int {
 	f, path, err := loadDispatch(root, slug)
 	if err != nil {
 		fmt.Fprintf(stderr, "dispatch: %v\n", err)
@@ -166,18 +187,25 @@ func dispatchLocked(root, slug, sub, phase, wave, role, handle, reason string, r
 		if w := getWave(); w != nil && w.State != "abandoned" {
 			return fail("wave %q already exists (state %s)", wave, w.State)
 		}
-		w := &dispatchWave{Phase: phase, State: "open", Roles: map[string]*dispatchRole{}}
+		w := &dispatchWave{Phase: phase, State: "open", Roles: map[string]*dispatchRole{}, Slices: sliceIDs}
 		for _, r := range roles {
 			if w.Roles[r] != nil {
 				return fail("duplicate role %q in wave", r)
 			}
 			w.Roles[r] = &dispatchRole{}
 		}
+		rounds, code := admitWrightRounds(root, slug, f, w, review, stderr)
+		if code != 0 {
+			return code
+		}
 		f.Waves[wave] = w
 		if err := saveDispatch(path, f); err != nil {
 			return fail("%v", err)
 		}
 		fmt.Fprintf(stdout, "dispatch: wave %s open, %d roles declared\n", wave, len(roles))
+		for _, line := range rounds {
+			fmt.Fprintln(stdout, line)
+		}
 		return 0
 
 	case "start":
@@ -243,7 +271,7 @@ func dispatchLocked(root, slug, sub, phase, wave, role, handle, reason string, r
 		if r.Returned {
 			return fail("role %q already returned", role)
 		}
-		r.Returned = true
+		r.Returned, r.ReturnedAt = true, nowStamp()
 		all := true
 		for _, o := range w.Roles {
 			if !o.Returned {
@@ -322,6 +350,152 @@ func dispatchLocked(root, slug, sub, phase, wave, role, handle, reason string, r
 	return 2
 }
 
+// roundKind names the capped loop a wave belongs to: build wright rounds or
+// slice-bound Vet rechecks. Other waves are uncapped.
+func roundKind(w *dispatchWave) string {
+	switch {
+	case isBuildWrightWave(w):
+		return "wright"
+	case strings.EqualFold(w.Phase, "vet") && len(w.Slices) > 0:
+		return "vet"
+	}
+	return ""
+}
+
+func isBuildWrightWave(w *dispatchWave) bool {
+	if w.Phase != "build" {
+		return false
+	}
+	for r := range w.Roles {
+		if strings.Contains(r, "wright") {
+			return true
+		}
+	}
+	return false
+}
+
+// admitWrightRounds enforces the per-slice round cap for a new build wright
+// or slice-bound Vet wave and returns the round lines to print. A slice may
+// take wrightRoundsPerReview rounds of each kind per reslice review (the first
+// window is free); beyond that the open needs --reslice-review naming an
+// unused drift.md heading for every slice over the cap.
+func admitWrightRounds(root, slug string, f *dispatchFile, w *dispatchWave, review string, stderr io.Writer) ([]string, int) {
+	kind := roundKind(w)
+	if kind == "" {
+		if review != "" || (len(w.Slices) > 0 && !strings.EqualFold(w.Phase, "vet")) {
+			fmt.Fprintln(stderr, "dispatch: --slice/--reslice-review apply only to build wright waves and slice-bound vet waves")
+			return nil, 2
+		}
+		return nil, 0
+	}
+	if len(w.Slices) == 0 {
+		fmt.Fprintln(stderr, "dispatch: a build wright wave needs --slice SLICE-### for each slice it builds")
+		return nil, 2
+	}
+	for _, id := range w.Slices {
+		if !state.ValidSliceID(id) {
+			fmt.Fprintf(stderr, "dispatch: %q is not a SLICE-### id\n", id)
+			return nil, 2
+		}
+	}
+	var lines, overCap []string
+	for _, id := range w.Slices {
+		prior, reviews := 0, 0
+		var unreturned []string
+		for name, other := range f.Waves {
+			if other.State == "abandoned" || roundKind(other) != kind {
+				continue
+			}
+			if slices.Contains(other.Slices, id) {
+				prior++
+				if other.State == "open" || other.State == "sealed" {
+					unreturned = append(unreturned, name)
+				}
+			}
+			if slices.Contains(other.ResliceReviewed, id) {
+				reviews++
+			}
+		}
+		round := prior + 1
+		if round > wrightRoundsPerReview*(1+reviews) {
+			overCap = append(overCap, id)
+		}
+		lines = append(lines, fmt.Sprintf("dispatch: %s %s round %d (reslice review every %d)", id, kind, round, wrightRoundsPerReview))
+		if len(unreturned) > 0 {
+			sort.Strings(unreturned)
+			lines = append(lines, fmt.Sprintf("dispatch: WARNING: %s earlier wave(s) %s never returned; record `dispatch return` or `dispatch abandon --reason`", id, strings.Join(unreturned, ",")))
+		}
+	}
+	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
+		}
+		return lines, 0
+	}
+	if review == "" {
+		fmt.Fprintf(stderr, "dispatch: BLOCKED: %s reached %d %s rounds; run a reslice review (acceptance-preserving split or simpler proof seam, or a drift.md entry recording why neither applies) and reopen with --reslice-review <DRIFT-ID>\n",
+			strings.Join(overCap, ","), wrightRoundsPerReview, kind)
+		return nil, 3
+	}
+	for _, other := range f.Waves {
+		if other.State != "abandoned" && other.ResliceReview == review && roundKind(other) == kind {
+			fmt.Fprintf(stderr, "dispatch: BLOCKED: reslice review %s already admitted another round window\n", review)
+			return nil, 3
+		}
+	}
+	drift, err := readWorkspaceArtifact(root, slug, "drift.md")
+	if err != nil {
+		fmt.Fprintf(stderr, "dispatch: BLOCKED: reslice review %s: %v\n", review, err)
+		return nil, 3
+	}
+	heading := driftHeading(string(drift), review)
+	for _, id := range overCap {
+		if !regexp.MustCompile(`\b` + regexp.QuoteMeta(id) + `\b`).MatchString(heading) {
+			fmt.Fprintf(stderr, "dispatch: BLOCKED: drift.md has no \"## %s\" heading naming %s\n", review, id)
+			return nil, 3
+		}
+	}
+	w.ResliceReview, w.ResliceReviewed = review, overCap
+	return lines, 0
+}
+
+// driftHeading returns the drift.md level-2 heading line for id, or "".
+func driftHeading(drift, id string) string {
+	re := regexp.MustCompile(`(?m)^## ` + regexp.QuoteMeta(id) + `\b.*$`)
+	return re.FindString(drift)
+}
+
+// InflightWave is a dispatch wave whose agents have not all returned.
+type InflightWave struct {
+	Wave    string   `json:"wave"`
+	Phase   string   `json:"phase"`
+	State   string   `json:"state"`
+	Pending []string `json:"pending"`
+	Slices  []string `json:"slices,omitempty"`
+}
+
+// inflightWaves lists open or sealed waves with the roles still awaiting a
+// return, sorted by wave name.
+func inflightWaves(f *dispatchFile) []InflightWave {
+	var out []InflightWave
+	for name, w := range f.Waves {
+		if w.State != "open" && w.State != "sealed" {
+			continue
+		}
+		var pending []string
+		for role, r := range w.Roles {
+			if !r.Returned {
+				pending = append(pending, role)
+			}
+		}
+		sort.Strings(pending)
+		out = append(out, InflightWave{Wave: name, Phase: w.Phase, State: w.State, Pending: pending, Slices: w.Slices})
+	}
+	sort.Slice(out, func(i, j int) bool { return out[i].Wave < out[j].Wave })
+	return out
+}
+
 func waveState(w *dispatchWave) string {
 	if w == nil {
 		return "absent"

package/engine/internal/lib/drift.go

@@ -48,7 +48,7 @@ type driftBaseline struct {
 // driftDiff is one input whose state differs from the baseline.
 type driftDiff struct {
 	Path string `json:"path"`
-	Kind string `json:"kind"` // changed | missing | added
+	Kind string `json:"kind"` // changed | missing | added | reviewed-identity-only
 }
 
 // RunCheckDrift implements `devrites-engine check drift`.
@@ -130,6 +130,10 @@ func compareDrift(workspace, baselinePath string, digests []gate.ReadinessInputD
 	if baseline.Binding != binding && len(diffs) == 0 {
 		fmt.Fprintln(stdout, "DRIFT: aggregate binding changed without a recorded input diff; re-record the baseline")
 	}
+	if len(diffs) == 1 && diffs[0].Kind == "reviewed-identity-only" {
+		fmt.Fprintln(stdout, "check drift: reviewed-identity-only — only the Workflow Artifact reviewed identity moved; /rite-vet may use its bytes-only recheck")
+		return 0
+	}
 	fmt.Fprintf(stdout, "check drift: %d input(s) differ — a change is legal only as a dated delta through the owning rite; otherwise restore the input or rerun /rite-vet and --record\n", len(diffs))
 	return 0
 }
@@ -189,7 +193,11 @@ func diffInputs(base, current []gate.ReadinessInputDigest) []driftDiff {
 			}
 			diffs = append(diffs, driftDiff{Path: b.Path, Kind: kind})
 		case b.Present && b.SHA256 != c.SHA256:
-			diffs = append(diffs, driftDiff{Path: b.Path, Kind: "changed"})
+			kind := "changed"
+			if b.Normalized != "" && b.Normalized == c.Normalized {
+				kind = "reviewed-identity-only"
+			}
+			diffs = append(diffs, driftDiff{Path: b.Path, Kind: kind})
 		}
 	}
 	sort.Slice(diffs, func(i, j int) bool { return diffs[i].Path < diffs[j].Path })

package/engine/internal/lib/drift_test.go

@@ -104,3 +104,32 @@ func TestDriftCorruptBaselineBlocks(t *testing.T) {
 		t.Fatalf("code=%d out=%s", code, out)
 	}
 }
+
+func TestDriftClassifiesReviewedIdentityOnlyChange(t *testing.T) {
+	root, featureDir := driftWorkspace(t)
+	if code, out := checkDrift(t, root, "feat", "--record"); code != 0 {
+		t.Fatalf("record code=%d out=%s", code, out)
+	}
+	plan := filepath.Join(featureDir, "test-plan.md")
+	line := "Workflow Artifact reviewed identity: " + strings.Repeat("ab", 32) + "\n"
+	writeFile(t, plan, "# test-plan.md\n\ncontent\n"+line)
+	code, out := checkDrift(t, root, "feat")
+	if code != 0 || !strings.Contains(out, "test-plan.md reviewed-identity-only") || !strings.Contains(out, "bytes-only recheck") {
+		t.Fatalf("identity-only change not classified: code=%d\n%s", code, out)
+	}
+	// Any other edit, including a malformed identity line, is ordinary drift.
+	for _, body := range []string{
+		"# test-plan.md\n\nchanged\n" + line,
+		"# test-plan.md\n\ncontent\nWorkflow Artifact reviewed identity: not-a-digest\n",
+	} {
+		writeFile(t, plan, body)
+		if _, out := checkDrift(t, root, "feat"); !strings.Contains(out, "test-plan.md changed") || strings.Contains(out, "bytes-only") {
+			t.Fatalf("non-identity edit hidden:\n%s", out)
+		}
+	}
+	writeFile(t, plan, "# test-plan.md\n\ncontent\n"+line)
+	writeFile(t, filepath.Join(featureDir, "plan.md"), "# plan.md\n\nrewritten\n")
+	if _, out := checkDrift(t, root, "feat"); strings.Contains(out, "bytes-only") {
+		t.Fatalf("a second changed input must void the bytes-only route:\n%s", out)
+	}
+}