devrites 6.0.2 → 6.0.3

package/engine/internal/lib/context_next_test.go

@@ -672,3 +672,189 @@ 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)
+	}
+}

package/engine/internal/lib/dispatch.go

@@ -6,6 +6,8 @@ import (
 	"io"
 	"os"
 	"path/filepath"
+	"regexp"
+	"slices"
 	"sort"
 	"strings"
 	"time"
@@ -19,24 +21,38 @@ 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 {
@@ -89,8 +105,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 +122,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 +149,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 +158,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 +186,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":
@@ -322,6 +349,114 @@ 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
+		for _, other := range f.Waves {
+			if other.State == "abandoned" || roundKind(other) != kind {
+				continue
+			}
+			if slices.Contains(other.Slices, id) {
+				prior++
+			}
+			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(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)
+}
+
 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)
+	}
+}

package/engine/internal/lib/slicecheck.go

@@ -29,6 +29,22 @@ var (
 	windowsDrivePath = regexp.MustCompile(`^[A-Za-z]:[\\/]`)
 )
 
+// sliceFileAdvisory is the Writer allowlist size at which a slice is flagged
+// for an acceptance-preserving split. Advisory only: it never changes an exit
+// code. Measured on real plans, slices at or above it averaged ~10 wright
+// rounds versus ~3.5 below it.
+const sliceFileAdvisory = 12
+
+// sliceSizeAdvisory returns the Writer allowlist size and whether the slice is
+// oversized without a recorded `Size rationale:`.
+func sliceSizeAdvisory(block string) (int, bool) {
+	fields := sliceFields(block)
+	raw, _ := fieldValue(fields, "writer allowlist")
+	n := len(parsePathList(raw))
+	rationale, _ := fieldValue(fields, "size rationale")
+	return n, n >= sliceFileAdvisory && rationale == ""
+}
+
 // sliceFields extracts the single-line `Field: value` pairs of a slice block.
 func sliceFields(block string) map[string]string {
 	fields := map[string]string{}
@@ -169,6 +185,9 @@ func RunCheckSlice(root string, args []string, stdout, stderr io.Writer) int {
 		problems = append(problems, "Tests/proof field missing or empty — no evidence plan for the slice")
 	}
 
+	if n, over := sliceSizeAdvisory(block); over {
+		fmt.Fprintf(stdout, "check slice: ADVISORY size: %s has %d Writer allowlist files (>= %d); consider an acceptance-preserving split\n", sliceID, n, sliceFileAdvisory)
+	}
 	if len(problems) > 0 {
 		fmt.Fprintf(stdout, "check slice: %s BLOCKED\n", sliceID)
 		for _, p := range problems {

package/engine/internal/lib/slicecheck_test.go

@@ -127,3 +127,44 @@ func TestCheckSliceTouchedComparesNormalizedPaths(t *testing.T) {
 		t.Fatalf("code=%d want 0\n%s%s", code, stdout, stderr)
 	}
 }
+
+func bigSliceTasks(rationale string) string {
+	var paths []string
+	for i := 1; i <= sliceFileAdvisory; i++ {
+		paths = append(paths, "`src/f"+strings.Repeat("x", i)+".go`")
+	}
+	return "# Tasks\n\n## SLICE-001 Big\nGoal: do it.\nSatisfies: AC-001\ndepends_on: []\nWriter allowlist: " +
+		strings.Join(paths, ", ") + "\nTests/proof: go test ./...\n" + rationale +
+		"\n## SLICE-002 Small\nGoal: tiny.\nSatisfies: AC-001\ndepends_on: [SLICE-001]\nWriter allowlist: `src/a.go`\nTests/proof: go test ./...\n"
+}
+
+func TestSliceSizeAdvisoryNeverBlocks(t *testing.T) {
+	root := sliceWorkspace(t, bigSliceTasks(""), "## Acceptance criteria\n- AC-001 works\n")
+	stdout, stderr := &bytes.Buffer{}, &bytes.Buffer{}
+	if code := RunCheckSlice(root, []string{"feat", "SLICE-001"}, stdout, stderr); code != 0 {
+		t.Fatalf("advisory must not block: code=%d\n%s%s", code, stdout, stderr)
+	}
+	if !strings.Contains(stdout.String(), "ADVISORY size: SLICE-001 has 12 Writer allowlist files") {
+		t.Fatalf("advisory missing:\n%s", stdout)
+	}
+	stdout.Reset()
+	if code := RunTaskGraphCheck(root, "feat", stdout, stderr); code != 0 {
+		t.Fatalf("task-graph code=%d\n%s%s", code, stdout, stderr)
+	}
+	out := stdout.String()
+	if !strings.Contains(out, "task-graph: ADVISORY size: SLICE-001 has 12") || strings.Contains(out, "SLICE-002 has") {
+		t.Fatalf("task-graph advisory wrong:\n%s", out)
+	}
+	stdout.Reset()
+	if code := RunMetrics(root, []string{"summary", "feat"}, stdout, stderr); code != 0 || !strings.Contains(stdout.String(), "size-advisory=1") {
+		t.Fatalf("size-advisory metric not recorded: code=%d\n%s", code, stdout)
+	}
+}
+
+func TestSliceSizeRationaleSilencesAdvisory(t *testing.T) {
+	root := sliceWorkspace(t, bigSliceTasks("Size rationale: one generated golden set moves together\n"), "## Acceptance criteria\n- AC-001 works\n")
+	stdout, stderr := &bytes.Buffer{}, &bytes.Buffer{}
+	if code := RunTaskGraphCheck(root, "feat", stdout, stderr); code != 0 || strings.Contains(stdout.String(), "ADVISORY") {
+		t.Fatalf("rationale must silence advisory: code=%d\n%s", code, stdout)
+	}
+}