devrites 5.11.0 → 5.12.0

package/engine/internal/lib/context_next_test.go

@@ -0,0 +1,521 @@
+package lib
+
+import (
+	"bytes"
+	"os"
+	"path/filepath"
+	"strings"
+	"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", "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)
+	}
+	// 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())
+	}
+}