devrites 6.0.4 → 6.1.1

package/engine/internal/lib/context_next_test.go

@@ -1,912 +0,0 @@
-package lib
-
-import (
-	"bytes"
-	"os"
-	"path/filepath"
-	"runtime"
-	"strings"
-	"sync"
-	"testing"
-)
-
-func newWorkspace(t *testing.T, phase string) (root, featureDir string) {
-	t.Helper()
-	root = t.TempDir()
-	featureDir = filepath.Join(root, "work", "feat")
-	state := "# State\n\n## Cursor\n| Key | Value |\n| --- | --- |\n| phase | " + phase + " |\n| status | running |\n"
-	writeFile(t, filepath.Join(featureDir, "state.md"), state)
-	return root, featureDir
-}
-
-func TestMetricsRecordAndSummary(t *testing.T) {
-	root, _ := newWorkspace(t, "build")
-	stdout, stderr := &bytes.Buffer{}, &bytes.Buffer{}
-	code := RunMetrics(root, []string{"record", "feat", "--phase", "build", "--event", "context", "--role", "wright", "--bytes", "1234"}, stdout, stderr)
-	if code != 0 {
-		t.Fatalf("record code=%d out=%s", code, stderr.String())
-	}
-	stdout.Reset()
-	code = RunMetrics(root, []string{"summary", "feat"}, stdout, stderr)
-	if code != 0 {
-		t.Fatalf("summary code=%d out=%s", code, stderr.String())
-	}
-	out := stdout.String()
-	if !strings.Contains(out, "build") || !strings.Contains(out, "context=1") || !strings.Contains(out, "bytes=1234") {
-		t.Fatalf("summary missing aggregates:\n%s", out)
-	}
-}
-
-func newSkillsRoot(t *testing.T) string {
-	t.Helper()
-	skills := t.TempDir()
-	writeFile(t, filepath.Join(skills, "devrites-lib", "reference", "standards", "core.md"), "# core\nrules\n")
-	writeFile(t, filepath.Join(skills, "devrites-lib", "reference", "standards", "testing.md"), "# testing\n")
-	writeFile(t, filepath.Join(skills, "rite-build", "SKILL.md"), "---\nname: rite-build\n---\n<!-- loads: {\"always\":[\"devrites-lib/reference/standards/core.md\"],\"triggers\":{\"tdd\":[\"devrites-lib/reference/standards/testing.md\"]},\"workspace\":[\"spec.md\",\"missing.md\"]} -->\n# build\n")
-	writeFile(t, filepath.Join(skills, "..", "agents", "devrites-slice-wright.md"), "# wright\n")
-	writeFile(t, filepath.Join(skills, "..", "agents", "devrites-code-reviewer.md"), "# reviewer\n")
-	writeFile(t, filepath.Join(skills, "..", "agents", "devrites-proof-runner.md"), "# runner\n")
-	return skills
-}
-
-func TestContextEmitsDedupedBundle(t *testing.T) {
-	root, featureDir := newWorkspace(t, "build")
-	writeFile(t, filepath.Join(featureDir, "spec.md"), "# spec\n")
-	skills := newSkillsRoot(t)
-	stdout, stderr := &bytes.Buffer{}, &bytes.Buffer{}
-	args := []string{"feat", "--phase", "build", "--role", "slice-wright", "--trigger", "tdd", "--skills-root", skills}
-	code := RunContext(root, args, stdout, stderr)
-	out := stdout.String() + stderr.String()
-	if code != 0 {
-		t.Fatalf("code=%d want 0\n%s", code, out)
-	}
-	bundle, err := os.ReadFile(filepath.Join(featureDir, "ctx", "build-slice-wright.bundle.md"))
-	if err != nil {
-		t.Fatalf("bundle: %v", err)
-	}
-	text := string(bundle)
-	if !strings.Contains(text, "MISSING: workspace/missing.md") {
-		t.Fatalf("missing marker absent from bundle:\n%s", text)
-	}
-	for _, want := range []string{"===== devrites-lib/reference/standards/core.md =====", "# core", "# testing", "# wright", "# spec"} {
-		if !strings.Contains(text, want) {
-			t.Fatalf("bundle missing %q:\n%s", want, text)
-		}
-	}
-	if strings.Count(text, "core.md") < 1 {
-		t.Fatal("core not bundled")
-	}
-	// metrics auto-recorded
-	stdout.Reset()
-	if code := RunMetrics(root, []string{"summary", "feat"}, stdout, stderr); code != 0 || !strings.Contains(stdout.String(), "context=1") {
-		t.Fatalf("context metric not recorded: code=%d\n%s", code, stdout.String())
-	}
-}
-
-func TestContextRejectsUnknownTrigger(t *testing.T) {
-	root, _ := newWorkspace(t, "build")
-	skills := newSkillsRoot(t)
-	stdout, stderr := &bytes.Buffer{}, &bytes.Buffer{}
-	code := RunContext(root, []string{"feat", "--phase", "build", "--trigger", "nope", "--skills-root", skills}, stdout, stderr)
-	if code != 2 || !strings.Contains(stderr.String(), "unknown trigger") {
-		t.Fatalf("code=%d stderr=%s", code, stderr.String())
-	}
-}
-
-func TestContextSkillModeAndTriggerVisibility(t *testing.T) {
-	root, featureDir := newWorkspace(t, "build")
-	skills := newSkillsRoot(t)
-	writeFile(t, filepath.Join(skills, "devrites-audit", "SKILL.md"),
-		"---\nname: devrites-audit\n---\n<!-- loads: {\"always\":[\"devrites-lib/reference/standards/core.md\"],\"triggers\":{\"sec\":[\"devrites-lib/reference/standards/testing.md\"]}} -->\n# audit\n")
-	stdout, stderr := &bytes.Buffer{}, &bytes.Buffer{}
-	code := RunContext(root, []string{"feat", "--skill", "devrites-audit", "--skills-root", skills}, stdout, stderr)
-	if code != 0 {
-		t.Fatalf("code=%d\n%s%s", code, stdout, stderr)
-	}
-	if !strings.Contains(stdout.String(), "unselected=[sec]") {
-		t.Fatalf("unselected triggers not reported:\n%s", stdout)
-	}
-	if _, err := os.Stat(filepath.Join(featureDir, "ctx", "devrites-audit.bundle.md")); err != nil {
-		t.Fatalf("skill bundle not written: %v", err)
-	}
-}
-
-func TestContextSkillWithoutSlugNeedsOut(t *testing.T) {
-	root, _ := newWorkspace(t, "build")
-	skills := newSkillsRoot(t)
-	writeFile(t, filepath.Join(skills, "devrites-audit", "SKILL.md"),
-		"---\nname: devrites-audit\n---\n<!-- loads: {\"always\":[\"devrites-lib/reference/standards/core.md\"],\"workspace\":[\"spec.md\"]} -->\n# audit\n")
-	stdout, stderr := &bytes.Buffer{}, &bytes.Buffer{}
-	if code := RunContext(root, []string{"--skill", "devrites-audit", "--skills-root", skills}, stdout, stderr); code != 2 {
-		t.Fatalf("no-slug no-out: want 2\n%s", stderr)
-	}
-	out := filepath.Join(t.TempDir(), "audit.bundle.md")
-	stdout.Reset()
-	stderr.Reset()
-	if code := RunContext(root, []string{"--skill", "devrites-audit", "--out", out, "--skills-root", skills}, stdout, stderr); code != 0 {
-		t.Fatalf("no-slug with out: code=%d\n%s%s", code, stdout, stderr)
-	}
-	bundle, err := os.ReadFile(out)
-	if err != nil {
-		t.Fatal(err)
-	}
-	if !strings.Contains(string(bundle), "skipped: no feature workspace") {
-		t.Fatalf("workspace skip marker missing:\n%s", bundle)
-	}
-}
-
-func TestDispatchWaveBarrier(t *testing.T) {
-	root, _ := newWorkspace(t, "build")
-	run := func(args ...string) (int, *bytes.Buffer, *bytes.Buffer) {
-		out, err := &bytes.Buffer{}, &bytes.Buffer{}
-		return RunDispatch(root, args, out, err), out, err
-	}
-	if c, _, _ := run("feat", "open", "--phase", "review", "--wave", "w1", "--role", "a", "--role", "b"); c != 0 {
-		t.Fatal("open failed")
-	}
-	if c, _, e := run("feat", "status"); c == 0 {
-		t.Fatalf("bare status should fail while a wave is open: %s", e)
-	}
-	if c, _, e := run("feat", "seal", "--wave", "w1"); c == 0 {
-		t.Fatalf("seal before all starts should fail: %s", e)
-	}
-	if c, _, e := run("feat", "return", "--wave", "w1", "--role", "a"); c == 0 {
-		t.Fatalf("return before seal should fail: %s", e)
-	}
-	if c, _, _ := run("feat", "start", "--wave", "w1", "--role", "a", "--handle", "h1"); c != 0 {
-		t.Fatal("start a failed")
-	}
-	if c, _, e := run("feat", "start", "--wave", "w1", "--role", "b", "--handle", "h1"); c == 0 {
-		t.Fatalf("duplicate handle accepted: %s", e)
-	}
-	if c, _, _ := run("feat", "start", "--wave", "w1", "--role", "b", "--handle", "h2"); c != 0 {
-		t.Fatal("start b failed")
-	}
-	if c, _, _ := run("feat", "seal", "--wave", "w1"); c != 0 {
-		t.Fatal("seal failed after all starts")
-	}
-	if c, _, _ := run("feat", "return", "--wave", "w1", "--role", "a"); c != 0 {
-		t.Fatal("return a failed")
-	}
-	if c, _, e := run("feat", "status", "--wave", "w1"); c == 0 {
-		t.Fatalf("status should fail while b pending: %s", e)
-	}
-	if c, _, _ := run("feat", "return", "--wave", "w1", "--role", "b"); c != 0 {
-		t.Fatal("return b failed")
-	}
-	if c, o, _ := run("feat", "status", "--wave", "w1"); c != 0 || !strings.Contains(o.String(), "complete") {
-		t.Fatalf("status should report complete: %d %s", c, o)
-	}
-	if c, _, e := run("feat", "status"); c != 0 {
-		t.Fatalf("bare status should pass once every wave is complete: %s", e)
-	}
-	// metrics auto-recorded for start+return
-	stdout, stderr := &bytes.Buffer{}, &bytes.Buffer{}
-	if code := RunMetrics(root, []string{"summary", "feat"}, stdout, stderr); code != 0 ||
-		!strings.Contains(stdout.String(), "dispatch=2") || !strings.Contains(stdout.String(), "return=2") {
-		t.Fatalf("dispatch metrics missing:\n%s", stdout)
-	}
-}
-
-func TestDispatchReopenAndAbandon(t *testing.T) {
-	root, _ := newWorkspace(t, "build")
-	run := func(args ...string) int {
-		out, err := &bytes.Buffer{}, &bytes.Buffer{}
-		return RunDispatch(root, args, out, err)
-	}
-	if c := run("feat", "open", "--phase", "build", "--wave", "w", "--role", "x"); c != 0 {
-		t.Fatal("open")
-	}
-	if c := run("feat", "open", "--phase", "build", "--wave", "w", "--role", "x"); c == 0 {
-		t.Fatal("reopen of open wave should fail")
-	}
-	if c := run("feat", "abandon", "--wave", "w", "--reason", "host limit"); c == 0 {
-		t.Fatal("abandon must signal handoff (nonzero)")
-	}
-	if c := run("feat", "return", "--wave", "w", "--role", "x"); c == 0 {
-		t.Fatal("return into abandoned wave should fail")
-	}
-}
-
-func TestContextWorkspaceByRoleScopes(t *testing.T) {
-	root, featureDir := newWorkspace(t, "build")
-	writeFile(t, filepath.Join(featureDir, "spec.md"), "# spec\n")
-	writeFile(t, filepath.Join(featureDir, "plan.md"), "# plan\n")
-	writeFile(t, filepath.Join(featureDir, "eng-review.md"), "# review\n")
-	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\":[\"spec.md\",\"plan.md\",\"eng-review.md\"],\"workspaceByRole\":{\"slice-wright\":[\"spec.md\",\"tasks.md\"],\"proof-runner\":[]}} -->\n# build\n")
-	writeFile(t, filepath.Join(featureDir, "tasks.md"), "## SLICE-001 x\n")
-
-	stdout, stderr := &bytes.Buffer{}, &bytes.Buffer{}
-	code := RunContext(root, []string{"feat", "--phase", "build", "--role", "slice-wright", "--skills-root", skills}, stdout, stderr)
-	if code != 0 {
-		t.Fatalf("code=%d\n%s%s", code, stdout, stderr)
-	}
-	bundle, err := os.ReadFile(filepath.Join(featureDir, "ctx", "build-slice-wright.bundle.md"))
-	if err != nil {
-		t.Fatal(err)
-	}
-	text := string(bundle)
-	if !strings.Contains(text, "workspace/spec.md") || !strings.Contains(text, "workspace/tasks.md") {
-		t.Fatalf("scoped bundle missing role files:\n%s", text)
-	}
-	if strings.Contains(text, "eng-review.md") {
-		t.Fatalf("scoped bundle leaked excluded artifact:\n%s", text)
-	}
-	if !strings.Contains(stdout.String(), "role-scoped") {
-		t.Fatalf("role-scope not reported:\n%s", stdout)
-	}
-
-	// Role absent from workspaceByRole keeps the flat list.
-	stdout.Reset()
-	stderr.Reset()
-	code = RunContext(root, []string{"feat", "--phase", "build", "--role", "code-reviewer", "--skills-root", skills}, stdout, stderr)
-	if code != 0 {
-		t.Fatalf("code=%d\n%s%s", code, stdout, stderr)
-	}
-	bundle, err = os.ReadFile(filepath.Join(featureDir, "ctx", "build-code-reviewer.bundle.md"))
-	if err != nil {
-		t.Fatal(err)
-	}
-	if !strings.Contains(string(bundle), "eng-review.md") {
-		t.Fatal("unmapped role should get the flat workspace list")
-	}
-
-	// Empty role list bundles no workspace artifacts.
-	stdout.Reset()
-	stderr.Reset()
-	code = RunContext(root, []string{"feat", "--phase", "build", "--role", "proof-runner", "--skills-root", skills}, stdout, stderr)
-	if code != 0 {
-		t.Fatalf("code=%d\n%s%s", code, stdout, stderr)
-	}
-	bundle, err = os.ReadFile(filepath.Join(featureDir, "ctx", "build-proof-runner.bundle.md"))
-	if err != nil {
-		t.Fatal(err)
-	}
-	if !strings.Contains(string(bundle), "role-scoped read-set declares no workspace artifacts") {
-		t.Fatalf("empty role list should emit the skip marker:\n%s", bundle)
-	}
-	if strings.Contains(string(bundle), "workspace/spec.md") {
-		t.Fatal("empty role list still bundled workspace files")
-	}
-}
-
-func TestContextRoleAutoFiresAgentsTrigger(t *testing.T) {
-	root, featureDir := newWorkspace(t, "build")
-	skills := newSkillsRoot(t)
-	writeFile(t, filepath.Join(skills, "devrites-lib", "reference", "standards", "core.md"), "# core\n")
-	writeFile(t, filepath.Join(skills, "devrites-lib", "reference", "standards", "agents.md"), "# agents contract\n")
-	writeFile(t, filepath.Join(skills, "devrites-lib", "reference", "standards", "testing.md"), "# testing\n")
-	writeFile(t, filepath.Join(skills, "rite-build", "SKILL.md"),
-		"---\nname: rite-build\n---\n<!-- loads: {\"always\":[\"devrites-lib/reference/standards/core.md\"],\"triggers\":{\"agents\":[\"devrites-lib/reference/standards/agents.md\"],\"testing\":[\"devrites-lib/reference/standards/testing.md\"]},\"workspace\":[]} -->\n# build\n")
-
-	// A role call is a dispatch: the declared agents trigger auto-fires.
-	stdout, stderr := &bytes.Buffer{}, &bytes.Buffer{}
-	code := RunContext(root, []string{"feat", "--phase", "build", "--role", "slice-wright", "--skills-root", skills}, stdout, stderr)
-	if code != 0 {
-		t.Fatalf("code=%d\n%s%s", code, stdout, stderr)
-	}
-	bundle, err := os.ReadFile(filepath.Join(featureDir, "ctx", "build-slice-wright.bundle.md"))
-	if err != nil {
-		t.Fatal(err)
-	}
-	if !strings.Contains(string(bundle), "agents contract") {
-		t.Fatalf("auto-fired agents trigger missing from bundle:\n%s", bundle)
-	}
-	out := stdout.String()
-	if !strings.Contains(out, "auto=[agents]") {
-		t.Fatalf("auto-fire not reported:\n%s", out)
-	}
-	for _, line := range strings.Split(out, "\n") {
-		if strings.HasPrefix(line, "triggers: applied=") {
-			unsel := line[strings.Index(line, "unselected=["):]
-			if strings.Contains(unsel, "agents") {
-				t.Fatalf("agents listed as unselected:\n%s", line)
-			}
-		}
-	}
-
-	// Without --role the trigger stays unselected (no auto-fire).
-	stdout.Reset()
-	stderr.Reset()
-	code = RunContext(root, []string{"feat", "--phase", "build", "--skills-root", skills}, stdout, stderr)
-	if code != 0 {
-		t.Fatalf("code=%d\n%s%s", code, stdout, stderr)
-	}
-	if strings.Contains(stdout.String(), "auto=[agents]") {
-		t.Fatalf("auto-fire without --role:\n%s", stdout)
-	}
-	if !strings.Contains(stdout.String(), "agents") {
-		t.Fatalf("agents should appear in unselected list:\n%s", stdout)
-	}
-
-	// Explicit --trigger agents with --role does not double-report.
-	stdout.Reset()
-	stderr.Reset()
-	code = RunContext(root, []string{"feat", "--phase", "build", "--role", "slice-wright", "--trigger", "agents", "--skills-root", skills}, stdout, stderr)
-	if code != 0 {
-		t.Fatalf("code=%d\n%s%s", code, stdout, stderr)
-	}
-	if strings.Contains(stdout.String(), "auto=[agents]") {
-		t.Fatalf("explicit trigger also reported as auto:\n%s", stdout)
-	}
-
-	// A role with no agent contract file hard-fails: a dispatch packet
-	// without its contract is a bug, not a soft omission.
-	stdout.Reset()
-	stderr.Reset()
-	code = RunContext(root, []string{"feat", "--phase", "build", "--role", "ghost", "--skills-root", skills}, stdout, stderr)
-	if code != 3 {
-		t.Fatalf("missing agent contract should exit 3, got %d\n%s%s", code, stdout, stderr)
-	}
-	if !strings.Contains(stdout.String(), "MISSING: agents/devrites-ghost.md") {
-		t.Fatalf("missing agent not reported:\n%s", stdout)
-	}
-}
-
-func TestContextSuggestsTriggersFromFacts(t *testing.T) {
-	root, featureDir := newWorkspace(t, "build")
-	writeFile(t, filepath.Join(featureDir, "spec.md"), "# spec\nA React component with auth token handling.\n")
-	writeFile(t, filepath.Join(root, "AFK"), "max_parallel: 4\n")
-	writeFile(t, filepath.Join(root, "principles.md"), "# principles\n")
-	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\"],\"triggers\":{\"afk\":[\"devrites-lib/reference/standards/testing.md\"],\"parallel\":[\"devrites-lib/reference/standards/testing.md\"],\"frontend\":[\"devrites-lib/reference/standards/testing.md\"],\"security\":[\"devrites-lib/reference/standards/testing.md\"],\"principles\":[\"devrites-lib/reference/standards/testing.md\"],\"coding\":[\"devrites-lib/reference/standards/testing.md\"],\"cross-model\":[\"devrites-lib/reference/standards/testing.md\"]},\"workspace\":[]} -->\n# build\n")
-	stdout, stderr := &bytes.Buffer{}, &bytes.Buffer{}
-	code := RunContext(root, []string{"feat", "--phase", "build", "--role", "slice-wright", "--skills-root", skills}, stdout, stderr)
-	if code != 0 {
-		t.Fatalf("code=%d\n%s%s", code, stdout, stderr)
-	}
-	out := stdout.String()
-	for _, want := range []string{"afk", "parallel", "frontend", "security", "principles", "coding"} {
-		if !strings.Contains(out, want) {
-			t.Fatalf("suggestion %q missing:\n%s", want, out)
-		}
-	}
-	if !strings.Contains(out, "suggested=[") {
-		t.Fatalf("suggested line absent:\n%s", out)
-	}
-	if strings.Contains(out, "cross-model") && strings.Contains(out[strings.Index(out, "suggested="):], "cross-model") {
-		t.Fatalf("flag-only trigger must not be suggested:\n%s", out)
-	}
-}
-
-func TestContextUnchangedDigestSkipsRewrite(t *testing.T) {
-	root, featureDir := newWorkspace(t, "build")
-	writeFile(t, filepath.Join(featureDir, "spec.md"), "# spec\n")
-	skills := newSkillsRoot(t)
-	args := []string{"feat", "--phase", "build", "--role", "slice-wright", "--trigger", "tdd", "--skills-root", skills}
-	stdout, stderr := &bytes.Buffer{}, &bytes.Buffer{}
-	if code := RunContext(root, args, stdout, stderr); code != 0 {
-		t.Fatalf("first run code=%d\n%s", code, stderr)
-	}
-	bundlePath := filepath.Join(featureDir, "ctx", "build-slice-wright.bundle.md")
-	info1, err := os.Stat(bundlePath)
-	if err != nil {
-		t.Fatal(err)
-	}
-	stdout.Reset()
-	if code := RunContext(root, args, stdout, stderr); code != 0 {
-		t.Fatalf("second run code=%d\n%s", code, stderr)
-	}
-	if !strings.Contains(stdout.String(), "unchanged") {
-		t.Fatalf("unchanged marker absent:\n%s", stdout)
-	}
-	info2, err := os.Stat(bundlePath)
-	if err != nil {
-		t.Fatal(err)
-	}
-	if !info1.ModTime().Equal(info2.ModTime()) {
-		t.Fatal("unchanged bundle was rewritten")
-	}
-	writeFile(t, filepath.Join(featureDir, "spec.md"), "# spec v2\n")
-	stdout.Reset()
-	if code := RunContext(root, args, stdout, stderr); code != 0 {
-		t.Fatalf("third run code=%d\n%s", code, stderr)
-	}
-	if strings.Contains(stdout.String(), "unchanged") {
-		t.Fatal("changed input still reported unchanged")
-	}
-}
-
-func TestMetricsSummaryReportsRoles(t *testing.T) {
-	root, _ := newWorkspace(t, "build")
-	stdout, stderr := &bytes.Buffer{}, &bytes.Buffer{}
-	for _, args := range [][]string{
-		{"record", "feat", "--phase", "build", "--event", "context", "--role", "slice-wright", "--bytes", "100"},
-		{"record", "feat", "--phase", "build", "--event", "context", "--role", "slice-wright", "--bytes", "50"},
-		{"record", "feat", "--phase", "review", "--event", "context", "--role", "code-reviewer", "--bytes", "200"},
-	} {
-		if code := RunMetrics(root, args, stdout, stderr); code != 0 {
-			t.Fatalf("record %v code=%d\n%s", args, code, stderr)
-		}
-	}
-	stdout.Reset()
-	if code := RunMetrics(root, []string{"summary", "feat"}, stdout, stderr); code != 0 {
-		t.Fatalf("summary code=%d\n%s", code, stderr)
-	}
-	out := stdout.String()
-	if !strings.Contains(out, "roles:") || !strings.Contains(out, "slice-wright") || !strings.Contains(out, "bytes=150") {
-		t.Fatalf("role rollup missing:\n%s", out)
-	}
-}
-
-func TestContextPhaseAndSkillMutuallyExclusive(t *testing.T) {
-	root, _ := newWorkspace(t, "build")
-	stdout, stderr := &bytes.Buffer{}, &bytes.Buffer{}
-	for _, args := range [][]string{
-		{"feat", "--skills-root", "x"},
-		{"feat", "--phase", "build", "--skill", "devrites-audit"},
-		{"feat", "--skill", "../escape"},
-	} {
-		stdout.Reset()
-		stderr.Reset()
-		if code := RunContext(root, args, stdout, stderr); code != 2 {
-			t.Fatalf("args %v: code=%d want 2", args, code)
-		}
-	}
-}
-
-func TestNextReportsPhasePath(t *testing.T) {
-	root, featureDir := newWorkspace(t, "spec")
-	// spec requires: brief, spec, state, decisions, assumptions, questions
-	for _, name := range []string{"brief.md", "spec.md", "decisions.md", "questions.md"} {
-		writeFile(t, filepath.Join(featureDir, name), "x\n")
-	}
-	stdout, stderr := &bytes.Buffer{}, &bytes.Buffer{}
-	code := RunNext(root, []string{"feat"}, stdout, stderr)
-	out := stdout.String()
-	if code != 0 {
-		t.Fatalf("code=%d err=%s", code, stderr.String())
-	}
-	if !strings.Contains(out, "next-phase: spec") {
-		t.Fatalf("expected incomplete spec as next:\n%s", out)
-	}
-	if !strings.Contains(out, "missing: assumptions.md") {
-		t.Fatalf("assumptions.md should be missing:\n%s", out)
-	}
-}
-
-func TestNextBlocksOnOpenQuestions(t *testing.T) {
-	root, featureDir := newWorkspace(t, "spec")
-	for _, name := range []string{"brief.md", "spec.md", "decisions.md", "assumptions.md"} {
-		writeFile(t, filepath.Join(featureDir, name), "x\n")
-	}
-	writeFile(t, filepath.Join(featureDir, "questions.md"), "# Questions\n\n| Q-001 | open | g | q | | i |\n")
-	stdout, stderr := &bytes.Buffer{}, &bytes.Buffer{}
-	code := RunNext(root, []string{"feat"}, stdout, stderr)
-	out := stdout.String()
-	if code != 0 {
-		t.Fatalf("code=%d err=%s", code, stderr.String())
-	}
-	if !strings.Contains(out, "next-phase: clarify") {
-		t.Fatalf("expected clarify next:\n%s", out)
-	}
-	if !strings.Contains(out, "missing: decision-coverage.md") {
-		t.Fatalf("decision-coverage.md should be missing:\n%s", out)
-	}
-}
-
-func TestNextSkipsVacuousClarify(t *testing.T) {
-	root, featureDir := newWorkspace(t, "spec")
-	for _, name := range []string{"brief.md", "spec.md", "decisions.md", "assumptions.md"} {
-		writeFile(t, filepath.Join(featureDir, name), "x\n")
-	}
-	writeFile(t, filepath.Join(featureDir, "questions.md"), "# Questions\n\nNo open questions remain.\n")
-	stdout, stderr := &bytes.Buffer{}, &bytes.Buffer{}
-	code := RunNext(root, []string{"feat"}, stdout, stderr)
-	out := stdout.String()
-	if code != 0 {
-		t.Fatalf("code=%d err=%s", code, stderr.String())
-	}
-	if !strings.Contains(out, "skip: clarify (0 open questions)") {
-		t.Fatalf("expected clarify skip advisory:\n%s", out)
-	}
-	if !strings.Contains(out, "next-phase: temper") {
-		t.Fatalf("expected temper next:\n%s", out)
-	}
-}
-
-func TestDiffScopeAllowlist(t *testing.T) {
-	root, _ := newWorkspace(t, "build")
-	repo := t.TempDir()
-	initGitRepository(t, repo)
-	writeFile(t, filepath.Join(repo, "src", "ok.go"), "package ok\n")
-	writeFile(t, filepath.Join(repo, "src", "evil.go"), "package evil\n")
-	stdout, stderr := &bytes.Buffer{}, &bytes.Buffer{}
-	args := []string{"feat", "--allow", "src/ok.go", "--cwd", repo}
-	code := RunCheckDiffScope(root, args, stdout, stderr)
-	out := stdout.String()
-	if code != 3 || !strings.Contains(out, "src/evil.go outside allowlist") {
-		t.Fatalf("code=%d want violation\n%s", code, out)
-	}
-	stdout.Reset()
-	code = RunCheckDiffScope(root, []string{"feat", "--allow", "src", "--cwd", repo}, stdout, stderr)
-	if code != 0 || !strings.Contains(stdout.String(), "2 changed") {
-		t.Fatalf("code=%d\n%s", code, stdout.String())
-	}
-
-	// A changed path whose own name contains the porcelain rename separator
-	// is checked as that full path, never as a fragment of it. Windows forbids
-	// '>' in file names, so the case cannot exist there.
-	if runtime.GOOS != "windows" {
-		sepRepo := t.TempDir()
-		initGitRepository(t, sepRepo)
-		runDiffScopeGit(t, sepRepo, "config", "user.email", "tests@example.invalid")
-		runDiffScopeGit(t, sepRepo, "config", "user.name", "DevRites Tests")
-		writeFile(t, filepath.Join(sepRepo, "docs", "secret -> notes.md"), "v1\n")
-		writeFile(t, filepath.Join(sepRepo, "docs", "secret"), "v1\n")
-		runDiffScopeGit(t, sepRepo, "add", "-A")
-		runDiffScopeGit(t, sepRepo, "commit", "-qm", "base")
-		writeFile(t, filepath.Join(sepRepo, "docs", "secret -> notes.md"), "changed out of contract\n")
-
-		stdout.Reset()
-		stderr.Reset()
-		code = RunCheckDiffScope(root, []string{"feat", "--allow", "notes.md", "--cwd", sepRepo}, stdout, stderr)
-		if code != 3 || !strings.Contains(stdout.String(), "BLOCKED: docs/secret -> notes.md outside allowlist") {
-			t.Fatalf("separator-named path checked as its tail: code=%d want 3 with the full path\n%s", code, stdout.String())
-		}
-		stdout.Reset()
-		stderr.Reset()
-		code = RunCheckDiffScope(root, []string{"feat", "--allow", "docs/secret -> notes.md", "--cwd", sepRepo}, stdout, stderr)
-		if code != 0 {
-			t.Fatalf("declared path rejected: code=%d\n%s", code, stdout.String())
-		}
-
-		// A rename reports its new name and a separator-named file reports its
-		// full name, even when both end in the same tail.
-		runDiffScopeGit(t, sepRepo, "mv", "docs/secret", "notes.md")
-		stdout.Reset()
-		stderr.Reset()
-		code = RunCheckDiffScope(root, []string{"feat", "--allow", "notes.md", "--cwd", sepRepo}, stdout, stderr)
-		if code != 3 || !strings.Contains(stdout.String(), "BLOCKED: docs/secret -> notes.md outside allowlist") ||
-			!strings.Contains(stdout.String(), "BLOCKED: docs/secret outside allowlist") {
-			t.Fatalf("rename and separator-named file not distinguishable: code=%d\n%s", code, stdout.String())
-		}
-	}
-
-	// An ordinary rename is reported by its new name, and its old name is
-	// checked against the allowlist too.
-	renameRepo := t.TempDir()
-	initGitRepository(t, renameRepo)
-	runDiffScopeGit(t, renameRepo, "config", "user.email", "tests@example.invalid")
-	runDiffScopeGit(t, renameRepo, "config", "user.name", "DevRites Tests")
-	writeFile(t, filepath.Join(renameRepo, "old.go"), "package old\n")
-	runDiffScopeGit(t, renameRepo, "add", "-A")
-	runDiffScopeGit(t, renameRepo, "commit", "-qm", "base")
-	runDiffScopeGit(t, renameRepo, "mv", "old.go", "new.go")
-	stdout.Reset()
-	stderr.Reset()
-	code = RunCheckDiffScope(root, []string{"feat", "--allow", "old.go", "--cwd", renameRepo}, stdout, stderr)
-	if code != 3 || !strings.Contains(stdout.String(), "BLOCKED: new.go outside allowlist") {
-		t.Fatalf("rename not reported by its new name: code=%d\n%s", code, stdout.String())
-	}
-	stdout.Reset()
-	stderr.Reset()
-	code = RunCheckDiffScope(root, []string{"feat", "--allow", "new.go", "--cwd", renameRepo}, stdout, stderr)
-	if code != 3 || !strings.Contains(stdout.String(), "BLOCKED: old.go outside allowlist") {
-		t.Fatalf("rename old name not checked: code=%d\n%s", code, stdout.String())
-	}
-}
-
-func runDiffScopeGit(t *testing.T, repo string, args ...string) {
-	t.Helper()
-	if out, err := runGitCommand(repo, nil, args...); err != nil {
-		t.Fatalf("git %v: %v\n%s", args, err, out)
-	}
-}
-
-func TestDispatchConcurrentReturnsCompleteWave(t *testing.T) {
-	root, featureDir := newWorkspace(t, "build")
-	run := func(args ...string) int {
-		out, err := &bytes.Buffer{}, &bytes.Buffer{}
-		return RunDispatch(root, args, out, err)
-	}
-	roles := []string{"r0", "r1", "r2", "r3", "r4", "r5", "r6", "r7"}
-	open := []string{"feat", "open", "--phase", "review", "--wave", "w"}
-	for _, r := range roles {
-		open = append(open, "--role", r)
-	}
-	if c := run(open...); c != 0 {
-		t.Fatal("open failed")
-	}
-	for _, r := range roles {
-		if c := run("feat", "start", "--wave", "w", "--role", r, "--handle", "h-"+r); c != 0 {
-			t.Fatalf("start %s failed", r)
-		}
-	}
-	if c := run("feat", "seal", "--wave", "w"); c != 0 {
-		t.Fatal("seal failed")
-	}
-	var wg sync.WaitGroup
-	for _, r := range roles {
-		wg.Add(1)
-		go func() {
-			defer wg.Done()
-			if c := run("feat", "return", "--wave", "w", "--role", r); c != 0 {
-				t.Errorf("return %s failed: %d", r, c)
-			}
-		}()
-	}
-	wg.Wait()
-	if c := run("feat", "status", "--wave", "w"); c != 0 {
-		data, _ := os.ReadFile(filepath.Join(featureDir, "dispatch.json"))
-		t.Fatalf("concurrent returns lost an update; wave not complete:\n%s", data)
-	}
-}
-
-func TestDispatchAbandonRecordsReason(t *testing.T) {
-	root, featureDir := newWorkspace(t, "build")
-	out, errOut := &bytes.Buffer{}, &bytes.Buffer{}
-	if c := RunDispatch(root, []string{"feat", "open", "--phase", "build", "--wave", "w", "--role", "x"}, out, errOut); c != 0 {
-		t.Fatal("open failed")
-	}
-	RunDispatch(root, []string{"feat", "abandon", "--wave", "w", "--reason", "host limit"}, out, errOut)
-	data, err := os.ReadFile(filepath.Join(featureDir, "dispatch.json"))
-	if err != nil || !strings.Contains(string(data), `"reason": "host limit"`) {
-		t.Fatalf("abandon reason not persisted: %v\n%s", err, data)
-	}
-}
-
-func TestContextWorkspaceIncludeMarkerStaysLiteral(t *testing.T) {
-	root, featureDir := newWorkspace(t, "build")
-	marker := "<!-- include:../../outside.txt -->"
-	writeFile(t, filepath.Join(featureDir, "spec.md"), marker+"\n")
-	writeFile(t, filepath.Join(root, "outside.txt"), "SENTINEL-OUTSIDE\n")
-	skills := newSkillsRoot(t)
-	stdout, stderr := &bytes.Buffer{}, &bytes.Buffer{}
-	code := RunContext(root, []string{"feat", "--phase", "build", "--skills-root", skills}, stdout, stderr)
-	if code != 0 {
-		t.Fatalf("code=%d\n%s%s", code, stdout, stderr)
-	}
-	bundle, err := os.ReadFile(filepath.Join(featureDir, "ctx", "build.bundle.md"))
-	if err != nil {
-		t.Fatal(err)
-	}
-	text := string(bundle)
-	if strings.Contains(text, "SENTINEL-OUTSIDE") {
-		t.Fatalf("workspace include marker was expanded:\n%s", text)
-	}
-	if !strings.Contains(text, marker) {
-		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)
-		}
-	}
-}