devrites 6.0.1 → 6.0.3

package/engine/internal/lib/context.go

@@ -14,6 +14,8 @@ import (
 	"strings"
 
 	"github.com/devrites/devrites/internal/devritespaths"
+	"github.com/devrites/devrites/internal/markdowntext"
+	"github.com/devrites/devrites/internal/state"
 )
 
 // loadsManifest is the machine-readable read-set a skill declares in an HTML
@@ -24,29 +26,35 @@ import (
 // role key is present its list replaces "workspace" entirely (an empty list
 // means the role needs no workspace artifacts). "agents" maps a --role name to
 // an agents-root-relative path when it deviates from the devrites-<role>
-// convention.
+// convention. "rootOnly" lists always/trigger paths that only the controlling
+// root executes; a --role bundle names them instead of inlining them.
 type loadsManifest struct {
 	Always          []string            `json:"always"`
 	Triggers        map[string][]string `json:"triggers"`
 	Workspace       []string            `json:"workspace"`
 	WorkspaceByRole map[string][]string `json:"workspaceByRole"`
 	Agents          map[string]string   `json:"agents"`
+	RootOnly        []string            `json:"rootOnly"`
 }
 
 const loadsMarker = "<!-- loads:"
 
-const contextUsage = `usage: devrites-engine context [slug] (--phase <p> | --skill <name>) [--role <r>] [--trigger a,b] [--skills-root <dir>] [--out <path>]
+const contextUsage = `usage: devrites-engine context [slug] (--phase <p> | --skill <name>) [--role <r>] [--slice <SLICE-###>] [--trigger a,b] [--skills-root <dir>] [--out <path>]
 
 Emits one deduplicated context bundle for a phase or standalone skill
 (+ optional dispatch role) into .devrites/work/<slug>/ctx/ so an agent
 reads a single file. With --skill, slug may be omitted; then --out is
-required and no workspace section is included.
+required and no workspace section is included. --slice scopes the
+workspace section to one slice: tasks.md contributes that slice's block,
+and an artifact over its line/byte budget becomes a by-reference index
+(path, SHA-256, headings, and line hits for every ID the block cites).
+Repeat --slice for a recheck that spans several slices.
 `
 
 // RunContext emits one deduplicated context bundle for a phase (+ optional
 // dispatch role) so an agent reads a single file instead of selecting files.
 //
-//	context <slug> --phase <p> [--role <r>] [--trigger a,b] [--skills-root <dir>] [--out <path>]
+//	context <slug> --phase <p> [--role <r>] [--slice <SLICE-###>] [--trigger a,b] [--skills-root <dir>] [--out <path>]
 func RunContext(root string, args []string, stdout, stderr io.Writer) int {
 	opts, code := parseContextArgs(args, stderr)
 	if code != 0 {
@@ -82,6 +90,27 @@ func RunContext(root string, args []string, stdout, stderr io.Writer) int {
 		return 2
 	}
 
+	var sliceBlock string
+	var sliceIDs []citedID
+	if opts.slice != "" {
+		raw, err := os.ReadFile(filepath.Join(featureDir, "tasks.md")) // #nosec G304 -- featureDir is the validated feature workspace
+		if err != nil {
+			fmt.Fprintf(stderr, "context: %v\n", err)
+			return 2
+		}
+		var blocks []string
+		for _, id := range opts.slices {
+			block, ok := state.ExtractTaskSlice(raw, id)
+			if !ok {
+				fmt.Fprintf(stdout, "context: BLOCKED: %s not found in tasks.md\n", id)
+				return 3
+			}
+			blocks = append(blocks, block)
+		}
+		sliceBlock = strings.Join(blocks, "\n")
+		sliceIDs = citedIDs(sliceBlock)
+	}
+
 	var files []string
 	var missingRequired []string
 	var autoTriggers []string
@@ -124,12 +153,31 @@ func RunContext(root string, args []string, stdout, stderr io.Writer) int {
 
 	seen := map[string]bool{}
 	loaded := 0
+	// The role contract leads the bundle so the agent reads its rules before
+	// reference text.
+	if opts.role != "" {
+		rel := roleAgentPath(manifest, opts.role)
+		if writeContextEntry(&bundle, filepath.Join(skillsRoot, "..", "agents", filepath.FromSlash(rel)),
+			"agents/"+rel, seen, true) {
+			loaded++
+		} else {
+			// The agent contract is a pack file, not a workspace artifact: a
+			// miss means a typo'd role or a pack bug, and a dispatch without
+			// its contract must fail loudly.
+			missingRequired = append(missingRequired, "agents/"+rel)
+		}
+	}
+	var rootOnly []string
 	for _, rel := range files {
 		abs := filepath.Join(skillsRoot, filepath.FromSlash(rel))
 		if seen[abs] {
 			continue
 		}
 		seen[abs] = true
+		if opts.role != "" && slices.Contains(manifest.RootOnly, rel) {
+			rootOnly = append(rootOnly, rel)
+			continue
+		}
 		data, err := os.ReadFile(abs) // #nosec G304 -- abs is resolved from the validated skills root
 		fmt.Fprintf(&bundle, "===== %s =====\n", rel)
 		if err != nil {
@@ -144,34 +192,37 @@ func RunContext(root string, args []string, stdout, stderr io.Writer) int {
 		bundle.WriteByte('\n')
 		loaded++
 	}
+	if len(rootOnly) > 0 {
+		fmt.Fprintf(&bundle, "===== root-only (not inlined for role %s) =====\n%s\n\n", opts.role, strings.Join(rootOnly, "\n"))
+	}
 
+	whole, byReference := 0, 0
 	workspaceList, workspaceScoped := workspaceReadSet(manifest, opts.role)
 	if hasManifest && featureDir != "" {
 		if workspaceScoped && len(workspaceList) == 0 {
 			bundle.WriteString("===== workspace =====\nskipped: role-scoped read-set declares no workspace artifacts\n\n")
 		}
 		for _, rel := range workspaceList {
-			if writeContextEntry(&bundle, filepath.Join(featureDir, filepath.FromSlash(rel)),
-				"workspace/"+rel, seen, false) {
+			abs := filepath.Join(featureDir, filepath.FromSlash(rel))
+			if opts.slice == "" {
+				if writeContextEntry(&bundle, abs, "workspace/"+rel, seen, false) {
+					loaded++
+				}
+				continue
+			}
+			ok, byRef := writeSliceEntry(&bundle, filepath.Dir(root), abs, "workspace/"+rel, opts.slice, sliceBlock, sliceIDs, seen)
+			if ok {
 				loaded++
 			}
+			if byRef {
+				byReference++
+			} else if ok {
+				whole++
+			}
 		}
 	} else if hasManifest && len(workspaceList) > 0 {
 		bundle.WriteString("===== workspace =====\nskipped: no feature workspace (slug omitted)\n\n")
 	}
-	if opts.role != "" {
-		rel := roleAgentPath(manifest, opts.role)
-		if writeContextEntry(&bundle, filepath.Join(skillsRoot, "..", "agents", filepath.FromSlash(rel)),
-			"agents/"+rel, seen, true) {
-			loaded++
-		} else {
-			// The agent contract is a pack file, not a workspace artifact: a
-			// miss means a typo'd role or a pack bug, and a dispatch without
-			// its contract must fail loudly.
-			missingRequired = append(missingRequired, "agents/"+rel)
-		}
-	}
-
 	out := opts.out
 	if out == "" {
 		out = filepath.Join(featureDir, "ctx", bundleName(opts))
@@ -216,6 +267,9 @@ func RunContext(root string, args []string, stdout, stderr io.Writer) int {
 		fmt.Fprintf(stdout, ", MISSING: %s", strings.Join(missingRequired, ","))
 	}
 	fmt.Fprintln(stdout, ")")
+	if opts.slice != "" {
+		fmt.Fprintf(stdout, "scope: slice %s (%d whole, %d by-reference)\n", opts.slice, whole, byReference)
+	}
 	if workspaceScoped {
 		fmt.Fprintf(stdout, "workspace: role-scoped for %s (%d of %d declared artifacts)\n",
 			opts.role, len(workspaceList), len(manifest.Workspace))
@@ -280,6 +334,110 @@ func expandIncludes(abs string, data []byte) []byte {
 	})
 }
 
+// writeSliceEntry writes one workspace artifact of a --slice bundle: tasks.md
+// as the slice block plus a by-reference index, any other canonical artifact
+// over its line/byte budget as a by-reference index, everything else whole.
+func writeSliceEntry(bundle *strings.Builder, project, abs, label, slice, block string, ids []citedID, seen map[string]bool) (loaded, byRef bool) {
+	if seen[abs] {
+		return false, false
+	}
+	data, err := os.ReadFile(abs) // #nosec G304 -- abs is resolved from the validated feature workspace
+	name := filepath.Base(abs)
+	if err == nil && name == "tasks.md" {
+		seen[abs] = true
+		fmt.Fprintf(bundle, "===== %s (%s block) =====\n%s\n", label, slice, block)
+	} else if status, ok := state.ArtifactBudget(name, data); err != nil || !ok || !status.Over {
+		return writeContextEntry(bundle, abs, label, seen, false), false
+	} else {
+		seen[abs] = true
+	}
+	writeAnchorIndex(bundle, project, abs, label, data, ids)
+	return true, true
+}
+
+var (
+	citedIDRE       = regexp.MustCompile(`\b[A-Z]{1,6}-\d{2,}(?:-[A-Z][A-Z0-9]*)*\b`)
+	anchorHeadingRE = regexp.MustCompile(`^#{1,3}\s`)
+)
+
+// maxIDHits bounds the line anchors listed per ID; the live file holds the rest.
+const maxIDHits = 20
+
+// citedID is one ID the slice block cites with its word-bounded matcher.
+type citedID struct {
+	id string
+	re *regexp.Regexp
+}
+
+// citedIDs returns each distinct ID the slice block cites (AC-###, DEC-###,
+// T-###, PF-##, SLICE-###, ...).
+func citedIDs(block string) []citedID {
+	var out []citedID
+	seen := map[string]bool{}
+	for _, id := range citedIDRE.FindAllString(block, -1) {
+		if !seen[id] {
+			seen[id] = true
+			out = append(out, citedID{id, regexp.MustCompile(`\b` + regexp.QuoteMeta(id) + `\b`)})
+		}
+	}
+	return out
+}
+
+// writeAnchorIndex emits a by-reference entry: identity, heading anchors, and
+// line hits for each cited ID, so the agent reads owning sections from the
+// live file instead of the whole artifact.
+func writeAnchorIndex(bundle *strings.Builder, project, abs, label string, data []byte, ids []citedID) {
+	rel, err := filepath.Rel(project, abs)
+	if err != nil {
+		rel = abs
+	}
+	lines := strings.Split(strings.ReplaceAll(string(data), "\r\n", "\n"), "\n")
+	structural := lines
+	if masked, err := markdowntext.Structural(data); err == nil {
+		structural = strings.Split(strings.ReplaceAll(string(masked), "\r\n", "\n"), "\n")
+	}
+	fmt.Fprintf(bundle, "===== %s (by reference) =====\n", label)
+	fmt.Fprintf(bundle, "path: %s sha256: %x bytes: %d lines: %d\n", filepath.ToSlash(rel), sha256.Sum256(data), len(data), len(lines))
+	bundle.WriteString("Not inlined. Read owning sections from the live file by line anchor; nothing is omitted there.\n")
+	bundle.WriteString("headings:\n")
+	for i, line := range structural {
+		if anchorHeadingRE.MatchString(line) {
+			fmt.Fprintf(bundle, "- L%d %s\n", i+1, clipRunes(lines[i], 120))
+		}
+	}
+	if len(ids) > 0 {
+		bundle.WriteString("id hits (IDs cited by the slice block):\n")
+	}
+	for _, cited := range ids {
+		var at []string
+		total := 0
+		for i, line := range lines {
+			if cited.re.MatchString(line) {
+				total++
+				if len(at) < maxIDHits {
+					at = append(at, fmt.Sprintf("L%d", i+1))
+				}
+			}
+		}
+		hits := "none"
+		if total > 0 {
+			hits = strings.Join(at, " ")
+			if total > len(at) {
+				hits += fmt.Sprintf(" (+%d more)", total-len(at))
+			}
+		}
+		fmt.Fprintf(bundle, "- %s: %s\n", cited.id, hits)
+	}
+	bundle.WriteByte('\n')
+}
+
+func clipRunes(s string, n int) string {
+	if r := []rune(s); len(r) > n {
+		return string(r[:n]) + "…"
+	}
+	return s
+}
+
 func writeContextEntry(bundle *strings.Builder, abs, label string, seen map[string]bool, expand bool) bool {
 	if seen[abs] {
 		return false
@@ -308,6 +466,8 @@ type contextOpts struct {
 	phase      string
 	skill      string
 	role       string
+	slice      string // display label: slices joined with "+"
+	slices     []string
 	triggers   []string
 	skillsRoot string
 	out        string
@@ -325,6 +485,8 @@ func parseContextArgs(args []string, stderr io.Writer) (contextOpts, int) {
 			opts.skill = value
 		case "--role":
 			opts.role = value
+		case "--slice":
+			opts.slices = append(opts.slices, value)
 		case "--trigger", "--triggers":
 			for _, name := range strings.Split(value, ",") {
 				if name = strings.TrimSpace(name); name != "" {
@@ -353,6 +515,13 @@ func parseContextArgs(args []string, stderr io.Writer) (contextOpts, int) {
 		fmt.Fprintf(stderr, "context: --skill must be a directory name, not a path\n")
 		return opts, 2
 	}
+	for _, id := range opts.slices {
+		if !state.ValidSliceID(id) || len(positional) == 0 {
+			fmt.Fprintf(stderr, "context: --slice needs a slug and a SLICE-### id, got %q\n", id)
+			return opts, 2
+		}
+	}
+	opts.slice = strings.Join(opts.slices, "+")
 	if len(positional) == 1 {
 		opts.slug = positional[0]
 	} else if opts.out == "" {
@@ -429,6 +598,9 @@ func bundleName(opts contextOpts) string {
 	if opts.role != "" {
 		name += "-" + opts.role
 	}
+	if opts.slice != "" {
+		name += "." + opts.slice
+	}
 	return name + ".bundle.md"
 }
 

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)
+	}
+}