devrites 6.0.4 → 6.1.0

package/engine/internal/lib/migrate_test.go

@@ -1,213 +0,0 @@
-package lib
-
-import (
-	"os"
-	"path/filepath"
-	"strings"
-	"testing"
-)
-
-// seedPreV5Workspace builds a pre-v5 workspace with a bullet cursor, prose,
-// and no required artifacts beyond state.md.
-func seedPreV5Workspace(t *testing.T, phase string) (root, workspace string) {
-	t.Helper()
-	root = t.TempDir()
-	workspace = filepath.Join(root, "work", "feature")
-	if err := os.MkdirAll(workspace, 0o755); err != nil {
-		t.Fatal(err)
-	}
-	body := "- Phase: " + phase + "\n- Status: running\n- Next step: continue slice S-2\n\n# Status\n\nMinting middleware landed.\n"
-	if err := os.WriteFile(filepath.Join(workspace, "state.md"), []byte(body), 0o644); err != nil {
-		t.Fatal(err)
-	}
-	return root, workspace
-}
-
-func TestMigrateDryRunPlansWithoutWriting(t *testing.T) {
-	root, workspace := seedPreV5Workspace(t, "build")
-	var stdout, stderr strings.Builder
-	if code := Migrate(root, []string{"feature", "--dry-run"}, &stdout, &stderr); code != 0 {
-		t.Fatalf("code=%d stderr=%q", code, stderr.String())
-	}
-	out := stdout.String()
-	if !strings.Contains(out, "migrate: plan for feature") ||
-		!strings.Contains(out, "[cursor] convert legacy cursor bullets") ||
-		!strings.Contains(out, "[schema] record schema") ||
-		!strings.Contains(out, "[stub] create missing spec.md") {
-		t.Fatalf("plan incomplete:\n%s", out)
-	}
-	// Nothing written: state.md bytes unchanged and no stub exists.
-	body, err := os.ReadFile(filepath.Join(workspace, "state.md"))
-	if err != nil || !strings.HasPrefix(string(body), "- Phase: build\n") {
-		t.Fatalf("state.md changed during dry run: %v %q", err, body)
-	}
-	if _, err := os.Stat(filepath.Join(workspace, "spec.md")); !os.IsNotExist(err) {
-		t.Fatalf("stub created during dry run: %v", err)
-	}
-}
-
-func TestMigrateExecutesCursorConversionAndStubs(t *testing.T) {
-	root, workspace := seedPreV5Workspace(t, "build")
-	var stdout, stderr strings.Builder
-	if code := Migrate(root, []string{"feature"}, &stdout, &stderr); code != 0 {
-		t.Fatalf("code=%d stderr=%q", code, stderr.String())
-	}
-	body, err := os.ReadFile(filepath.Join(workspace, "state.md"))
-	if err != nil {
-		t.Fatal(err)
-	}
-	text := string(body)
-	if !strings.Contains(text, "| phase | build |") || !strings.Contains(text, "| status | running |") {
-		t.Fatalf("cursor bullets not converted:\n%s", text)
-	}
-	if !strings.Contains(text, "| next_action | continue slice S-2 |") {
-		t.Fatalf("next step not converted to canonical spelling:\n%s", text)
-	}
-	if strings.Contains(text, "- Next step:") {
-		t.Fatalf("legacy next step bullet survived:\n%s", text)
-	}
-	if !strings.Contains(text, "| schema | 4 |") {
-		t.Fatalf("schema row missing:\n%s", text)
-	}
-	if !strings.Contains(text, "# Status\n\nMinting middleware landed.") {
-		t.Fatalf("prose not preserved:\n%s", text)
-	}
-	// Required artifacts for build exist as empty stubs.
-	for _, name := range []string{"spec.md", "brief.md", "eng-review.md", "test-plan.md", "gates.md"} {
-		info, err := os.Stat(filepath.Join(workspace, name))
-		if err != nil {
-			t.Fatalf("stub %s: %v", name, err)
-		}
-		if info.Size() != 0 {
-			t.Fatalf("stub %s synthesized content", name)
-		}
-	}
-	// Idempotent: a second run is a no-op.
-	stdout.Reset()
-	if code := Migrate(root, []string{"feature"}, &stdout, &stderr); code != 0 {
-		t.Fatalf("second run code=%d stderr=%q", code, stderr.String())
-	}
-	if !strings.Contains(stdout.String(), "nothing to do") {
-		t.Fatalf("second run should be a no-op, got %q", stdout.String())
-	}
-}
-
-func TestMigrateUnknownPhaseAsksAndWritesNothing(t *testing.T) {
-	root, workspace := seedPreV5Workspace(t, "research")
-	var stdout, stderr strings.Builder
-	if code := Migrate(root, []string{"feature"}, &stdout, &stderr); code != 3 {
-		t.Fatalf("code=%d want 3", code)
-	}
-	if !strings.Contains(stderr.String(), "question phase:") || !strings.Contains(stderr.String(), "nothing written") {
-		t.Fatalf("stderr=%q", stderr.String())
-	}
-	body, _ := os.ReadFile(filepath.Join(workspace, "state.md"))
-	if !strings.HasPrefix(string(body), "- Phase: research\n") {
-		t.Fatalf("state.md changed on refusal: %q", body)
-	}
-
-	// Answering the question on rerun proceeds.
-	if code := Migrate(root, []string{"feature", "--answer", "phase=build"}, &stdout, &stderr); code != 0 {
-		t.Fatalf("answer rerun code=%d stderr=%q", code, stderr.String())
-	}
-	body, _ = os.ReadFile(filepath.Join(workspace, "state.md"))
-	if !strings.Contains(string(body), "| phase | build |") || !strings.Contains(string(body), "| schema | 4 |") {
-		t.Fatalf("answer rerun did not migrate:\n%s", body)
-	}
-}
-
-// A done workspace migrates like any other: it is fully artifacted (zero
-// stubs), and normalizing it unblocks `state close`, which refuses pre-v5
-// workspaces. A special no-op would strand done workspaces between migrate
-// and close.
-func TestMigrateDoneWorkspaceNormalizesWithoutStubs(t *testing.T) {
-	root, workspace := seedPreV5Workspace(t, "done")
-	var stdout, stderr strings.Builder
-	if code := Migrate(root, []string{"feature"}, &stdout, &stderr); code != 0 {
-		t.Fatalf("code=%d stderr=%q", code, stderr.String())
-	}
-	body, _ := os.ReadFile(filepath.Join(workspace, "state.md"))
-	if !strings.Contains(string(body), "| schema | 4 |") {
-		t.Fatalf("done workspace not normalized:\n%s", body)
-	}
-	if !strings.Contains(stdout.String(), "normalized to schema 4") {
-		t.Fatalf("stdout=%q", stdout.String())
-	}
-}
-
-func TestMigrateCurrentAndNewerSchemaAreRefused(t *testing.T) {
-	root, workspace := seedPreV5Workspace(t, "build")
-	if err := os.WriteFile(filepath.Join(workspace, "state.md"), []byte("| phase | build |\n| schema | 4 |\n"), 0o644); err != nil {
-		t.Fatal(err)
-	}
-	var stdout, stderr strings.Builder
-	if code := Migrate(root, []string{"feature"}, &stdout, &stderr); code != 0 || !strings.Contains(stdout.String(), "nothing to do") {
-		t.Fatalf("current schema: code=%d stdout=%q", code, stdout.String())
-	}
-
-	if err := os.WriteFile(filepath.Join(workspace, "state.md"), []byte("| phase | build |\n| schema | 9 |\n"), 0o644); err != nil {
-		t.Fatal(err)
-	}
-	if code := Migrate(root, []string{"feature"}, &stdout, &stderr); code != 3 || !strings.Contains(stderr.String(), "upgrade devrites") {
-		t.Fatalf("newer schema: code=%d stderr=%q", code, stderr.String())
-	}
-}
-
-// End to end through the `migrate` command path. migrate.go
-// calls state.ConvertCursorToTable (apply, unconditional) and state.CursorForm
-// (plan), so a fenced example in state.md — the phase-authority ledger — must
-// survive a migration byte for byte, and a migration plan must not advertise a
-// conversion that only fenced content would have performed.
-
-func seedLedger(t *testing.T, body string) (root, workspace string) {
-	t.Helper()
-	root = t.TempDir()
-	workspace = filepath.Join(root, "work", "feature")
-	if err := os.MkdirAll(workspace, 0o755); err != nil {
-		t.Fatal(err)
-	}
-	if err := os.WriteFile(filepath.Join(workspace, "state.md"), []byte(body), 0o644); err != nil {
-		t.Fatal(err)
-	}
-	return root, workspace
-}
-
-const ledgerBody = "# State\n\n## Recovery note\n\nThe pre-v5 ledger looked like this:\n\n~~~md\n- Phase: build\n- Status: running\n~~~\n\n## Cursor\n\n- Phase: build\n- Status: running\n"
-
-func TestMigrateLeavesFencedCursorExamplesByteIdentical(t *testing.T) {
-	root, workspace := seedLedger(t, ledgerBody)
-	var stdout, stderr strings.Builder
-	if code := Migrate(root, []string{"feature"}, &stdout, &stderr); code != 0 {
-		t.Fatalf("code=%d stdout=%q stderr=%q", code, stdout.String(), stderr.String())
-	}
-	body, err := os.ReadFile(filepath.Join(workspace, "state.md"))
-	if err != nil {
-		t.Fatal(err)
-	}
-	text := string(body)
-	if got := strings.Count(text, "- Phase: build"); got != 1 {
-		t.Fatalf("fenced example rewritten: %d surviving \"- Phase: build\" lines in\n%s", got, text)
-	}
-	if !strings.Contains(text, "| phase | build |") {
-		t.Fatalf("live cursor bullet not converted to the canonical table row:\n%s", text)
-	}
-	fenced := "~~~md\n- Phase: build\n- Status: running\n~~~"
-	if !strings.Contains(text, fenced) {
-		t.Fatalf("fenced block not preserved byte for byte:\n%s", text)
-	}
-}
-
-func TestMigratePlanDoesNotOfferConversionForFencedCursorsOnly(t *testing.T) {
-	body := "# State\n\n## Recovery note\n\n~~~md\n- Phase: build\n- Status: running\n~~~\n"
-	root, _ := seedLedger(t, body)
-	var stdout, stderr strings.Builder
-	if code := Migrate(root, []string{"feature", "--dry-run", "--answer", "phase=build"}, &stdout, &stderr); code != 0 {
-		t.Fatalf("code=%d stdout=%q stderr=%q", code, stdout.String(), stderr.String())
-	}
-	if strings.Contains(stdout.String(), "[cursor]") {
-		t.Fatalf("plan offers a cursor conversion for a ledger whose only legacy bullets are fenced:\n%s", stdout.String())
-	}
-	if !strings.Contains(stdout.String(), "[schema] record schema") {
-		t.Fatalf("plan incomplete:\n%s", stdout.String())
-	}
-}

package/engine/internal/lib/observe_budgets_test.go

@@ -1,428 +0,0 @@
-package lib
-
-import (
-	"bytes"
-
-	"encoding/json"
-	"os"
-	"path/filepath"
-	"runtime"
-	"strings"
-	"testing"
-
-	"github.com/devrites/devrites/internal/state"
-)
-
-const budgetTasks = `# Tasks
-
-Current checkpoint: intro text.
-
-## SLICE-001 First
-Goal: one
-Dependencies: none
-depends_on: []
-
-### Notes
-nested heading stays inside the slice
-
-## SLICE-002 Second
-Goal: two
-Dependencies: SLICE-001
-depends_on: [SLICE-001]
-
-## Trailing section
-not a slice
-`
-
-func writeBudgetWorkspace(t *testing.T, files map[string]string) (root, workspace string) {
-	t.Helper()
-	root = filepath.Join(t.TempDir(), ".devrites")
-	workspace = filepath.Join(root, "work", "feature")
-	if err := os.MkdirAll(workspace, 0o755); err != nil {
-		t.Fatal(err)
-	}
-	for name, body := range files {
-		if err := os.WriteFile(filepath.Join(workspace, name), []byte(body), 0o644); err != nil {
-			t.Fatal(err)
-		}
-	}
-	return root, workspace
-}
-
-func TestExtractTaskSliceStopsAtNextH2AndKeepsH3(t *testing.T) {
-	block, ok := state.ExtractTaskSlice([]byte(budgetTasks), "SLICE-001")
-	if !ok {
-		t.Fatal("expected SLICE-001")
-	}
-	if !strings.HasPrefix(block, "## SLICE-001 First\n") || !strings.Contains(block, "### Notes") {
-		t.Fatalf("block=%q", block)
-	}
-	if strings.Contains(block, "SLICE-002") || strings.Contains(block, "Trailing") {
-		t.Fatalf("block leaked past the next heading: %q", block)
-	}
-	last, ok := state.ExtractTaskSlice([]byte(budgetTasks), "SLICE-002")
-	if !ok || strings.Contains(last, "Trailing section") {
-		t.Fatalf("last=%q ok=%v", last, ok)
-	}
-	if _, ok := state.ExtractTaskSlice([]byte(budgetTasks), "SLICE-003"); ok {
-		t.Fatal("SLICE-003 must not resolve")
-	}
-}
-
-func TestRunObserveSlicePrintsOneSection(t *testing.T) {
-	root, _ := writeBudgetWorkspace(t, map[string]string{"tasks.md": budgetTasks})
-	var stdout, stderr bytes.Buffer
-	if code := RunObserveSlice(root, "feature", "SLICE-002", &stdout, &stderr); code != 0 {
-		t.Fatalf("code=%d stderr=%s", code, stderr.String())
-	}
-	if got := stdout.String(); !strings.HasPrefix(got, "## SLICE-002 Second\n") || strings.Contains(got, "SLICE-001 First") {
-		t.Fatalf("stdout=%q", got)
-	}
-
-	stdout.Reset()
-	if code := RunObserveSlice(root, "feature", "SLICE-009", &stdout, &stderr); code != 3 || !strings.Contains(stdout.String(), "BLOCKED") {
-		t.Fatalf("code=%d stdout=%q", code, stdout.String())
-	}
-	if code := RunObserveSlice(root, "feature", "slice-1", &stdout, &stderr); code != 2 {
-		t.Fatalf("code=%d for malformed id", code)
-	}
-}
-
-func TestObserveSummaryReportsBudgetsAndBulkFiles(t *testing.T) {
-	longLine := strings.Repeat("x", 60_000) + "\n"
-	root, _ := writeBudgetWorkspace(t, map[string]string{
-		"state.md":                "| phase | build |\n| schema | 4 |\n" + longLine,
-		"tasks.md":                budgetTasks,
-		"vet-review-input-1.json": strings.Repeat("{}", 40_000),
-		"small-note.json":         "{}",
-	})
-	summary, err := ObserveSummaryFor(root, "feature")
-	if err != nil {
-		t.Fatal(err)
-	}
-	byFile := map[string]ArtifactBudget{}
-	for _, b := range summary.ArtifactBudgets {
-		byFile[b.File] = b
-	}
-	if st, ok := byFile["state.md"]; !ok || !st.Over || st.Lines != 3 || st.ByteBudget != 120*state.BudgetBytesPerLine {
-		t.Fatalf("state.md budget=%+v ok=%v (long line must trip the byte budget)", st, ok)
-	}
-	if tk, ok := byFile["tasks.md"]; !ok || tk.Over {
-		t.Fatalf("tasks.md budget=%+v ok=%v", tk, ok)
-	}
-	if summary.TaskGraph == nil || len(summary.TaskGraph.Slices) != 2 ||
-		summary.TaskGraph.Slices[0].ID != "SLICE-001" || len(summary.TaskGraph.Slices[0].DependsOn) != 0 ||
-		summary.TaskGraph.Slices[1].DependsOn[0] != "SLICE-001" {
-		t.Fatalf("task_graph.slices=%+v", summary.TaskGraph)
-	}
-	if len(summary.BulkFiles) != 1 || summary.BulkFiles[0].File != "vet-review-input-1.json" {
-		t.Fatalf("bulk_files=%+v", summary.BulkFiles)
-	}
-}
-
-func TestObserveSummaryReportsSequenceCursor(t *testing.T) {
-	root, _ := writeBudgetWorkspace(t, map[string]string{
-		"state.md": "| phase | build |\n| schema | 4 |\n| sequence_parent | feat-1 |\n| sequence_position | 2 |\n| sequence_workspaces_remaining | 3 |\n",
-	})
-	summary, err := ObserveSummaryFor(root, "feature")
-	if err != nil {
-		t.Fatal(err)
-	}
-	seq := summary.Sequence
-	if seq == nil || seq.Parent != "feat-1" || seq.Position != "2" || seq.WorkspacesRemaining != "3" {
-		t.Fatalf("sequence=%+v", seq)
-	}
-	root, _ = writeBudgetWorkspace(t, map[string]string{
-		"state.md": "| phase | build |\n| schema | 4 |\n",
-	})
-	summary, err = ObserveSummaryFor(root, "feature")
-	if err != nil {
-		t.Fatal(err)
-	}
-	if summary.Sequence != nil {
-		t.Fatalf("sequence must be absent without cursor fields: %+v", summary.Sequence)
-	}
-}
-
-// summaryUnreadable decodes the emitted summary JSON and fails when the consumer has
-// no way to tell an omitted section from an empty one.
-func summaryUnreadable(t *testing.T, out []byte) []string {
-	t.Helper()
-	var doc map[string]json.RawMessage
-	if err := json.Unmarshal(out, &doc); err != nil {
-		t.Fatalf("summary is not a JSON object: %v (%s)", err, out)
-	}
-	raw, ok := doc["unreadable"]
-	if !ok {
-		t.Fatalf("summary carries no \"unreadable\" key, so an artifact that could not be read is indistinguishable from one that does not exist: %s", out)
-	}
-	var names []string
-	if err := json.Unmarshal(raw, &names); err != nil {
-		t.Fatalf("unreadable is not a list of artifact names: %v (%s)", err, raw)
-	}
-	return names
-}
-
-func summaryFiles(t *testing.T, out []byte, key string) []string {
-	t.Helper()
-	var doc map[string]json.RawMessage
-	if err := json.Unmarshal(out, &doc); err != nil {
-		t.Fatalf("summary is not a JSON object: %v (%s)", err, out)
-	}
-	var rows []struct {
-		File string `json:"file"`
-	}
-	raw, ok := doc[key]
-	if !ok {
-		t.Fatalf("summary key %q is absent entirely: %s", key, out)
-	}
-	if err := json.Unmarshal(raw, &rows); err != nil {
-		t.Fatalf("%s is not a list: %v (%s)", key, err, raw)
-	}
-	names := make([]string, 0, len(rows))
-	for _, row := range rows {
-		names = append(names, row.File)
-	}
-	return names
-}
-
-// One canonical artifact that exists but cannot be read must not take the
-// task graph, the artifact budgets and the bulk-file list down with it.
-func TestObserveSummaryNamesUnreadableArtifactAndKeepsReadableBudgets(t *testing.T) {
-	if os.Geteuid() == 0 || runtime.GOOS == "windows" {
-		t.Skip("file permissions do not bind root or windows")
-	}
-	root, workspace := writeBudgetWorkspace(t, map[string]string{
-		"state.md":                "| phase | build |\n| schema | 4 |\n",
-		"tasks.md":                budgetTasks,
-		"vet-review-input-1.json": strings.Repeat("{}", 40_000),
-	})
-	// spec.md is canonical and sorts first; the entries behind it must survive.
-	spec := filepath.Join(workspace, "spec.md")
-	if err := os.WriteFile(spec, []byte("# Spec\n"), 0o000); err != nil {
-		t.Fatal(err)
-	}
-	if err := os.Chmod(spec, 0o000); err != nil {
-		t.Fatal(err)
-	}
-	t.Cleanup(func() { _ = os.Chmod(spec, 0o644) })
-
-	var out, errOut bytes.Buffer
-	if code := RunObserveSummary(root, "feature", &out, &errOut); code != 0 {
-		t.Fatalf("exit=%d stderr=%s", code, errOut.String())
-	}
-	names := summaryUnreadable(t, out.Bytes())
-	if len(names) != 1 || names[0] != "spec.md" {
-		t.Fatalf("unreadable=%v, want exactly [spec.md]", names)
-	}
-	budgets := summaryFiles(t, out.Bytes(), "artifact_budgets")
-	for _, want := range []string{"state.md", "tasks.md"} {
-		found := false
-		for _, got := range budgets {
-			if got == want {
-				found = true
-			}
-		}
-		if !found {
-			t.Fatalf("artifact_budgets=%v lost %q to the unreadable spec.md: %s", budgets, want, out.String())
-		}
-	}
-	bulk := summaryFiles(t, out.Bytes(), "bulk_files")
-	if len(bulk) != 1 || bulk[0] != "vet-review-input-1.json" {
-		t.Fatalf("bulk_files=%v lost the readable 80 KiB file to the unreadable spec.md: %s", bulk, out.String())
-	}
-}
-
-// A tasks.md that is not a readable regular file must be named, not dropped.
-func TestObserveSummaryNamesUnreadableTasksInsteadOfOmittingTaskGraph(t *testing.T) {
-	root, workspace := writeBudgetWorkspace(t, map[string]string{
-		"state.md": "| phase | build |\n| schema | 4 |\n",
-		"tasks.md": budgetTasks,
-	})
-	if err := os.Remove(filepath.Join(workspace, "tasks.md")); err != nil {
-		t.Fatal(err)
-	}
-	if err := os.Mkdir(filepath.Join(workspace, "tasks.md"), 0o755); err != nil {
-		t.Fatal(err)
-	}
-
-	var out, errOut bytes.Buffer
-	if code := RunObserveSummary(root, "feature", &out, &errOut); code != 0 {
-		t.Fatalf("exit=%d stderr=%s", code, errOut.String())
-	}
-	names := summaryUnreadable(t, out.Bytes())
-	if len(names) != 1 || names[0] != "tasks.md" {
-		t.Fatalf("unreadable=%v, want exactly [tasks.md]", names)
-	}
-	if _, ok := map[string]json.RawMessage(mustDecode(t, out.Bytes()))["task_graph"]; ok {
-		t.Fatalf("task_graph must stay absent when tasks.md cannot be read: %s", out.String())
-	}
-	if budgets := summaryFiles(t, out.Bytes(), "artifact_budgets"); len(budgets) != 1 || budgets[0] != "state.md" {
-		t.Fatalf("artifact_budgets=%v, want [state.md]", budgets)
-	}
-}
-
-func mustDecode(t *testing.T, out []byte) map[string]json.RawMessage {
-	t.Helper()
-	var doc map[string]json.RawMessage
-	if err := json.Unmarshal(out, &doc); err != nil {
-		t.Fatalf("summary is not a JSON object: %v (%s)", err, out)
-	}
-	return doc
-}
-
-// A workspace that has not reached define has no tasks.md; that is absence, not a read failure.
-func TestObserveSummaryOmitsUnreadableWhenTasksAbsent(t *testing.T) {
-	root, _ := writeBudgetWorkspace(t, map[string]string{
-		"state.md": "| phase | spec |\n| schema | 4 |\n",
-	})
-	var out, errOut bytes.Buffer
-	if code := RunObserveSummary(root, "feature", &out, &errOut); code != 0 {
-		t.Fatalf("exit=%d stderr=%s", code, errOut.String())
-	}
-	if _, ok := mustDecode(t, out.Bytes())["unreadable"]; ok {
-		t.Fatalf("a missing tasks.md must not be reported as unreadable: %s", out.String())
-	}
-}
-
-// A tasks.md that fails both the task-graph read and the budget read is named once.
-func TestObserveSummaryNamesUnreadableTasksOnce(t *testing.T) {
-	if os.Geteuid() == 0 || runtime.GOOS == "windows" {
-		t.Skip("file permissions do not bind root or windows")
-	}
-	root, workspace := writeBudgetWorkspace(t, map[string]string{
-		"state.md": "| phase | build |\n| schema | 4 |\n",
-		"tasks.md": budgetTasks,
-	})
-	tasks := filepath.Join(workspace, "tasks.md")
-	if err := os.Chmod(tasks, 0o000); err != nil {
-		t.Fatal(err)
-	}
-	t.Cleanup(func() { _ = os.Chmod(tasks, 0o644) })
-
-	var out, errOut bytes.Buffer
-	if code := RunObserveSummary(root, "feature", &out, &errOut); code != 0 {
-		t.Fatalf("exit=%d stderr=%s", code, errOut.String())
-	}
-	if names := summaryUnreadable(t, out.Bytes()); len(names) != 1 || names[0] != "tasks.md" {
-		t.Fatalf("unreadable=%v, want exactly [tasks.md]", names)
-	}
-}
-
-const (
-	artifactSchemaDocPath  = "../../../pack/.claude/skills/devrites-lib/reference/workspace-artifact-schema.md"
-	outlineTemplateDocPath = "../../../pack/.claude/skills/devrites-lib/reference/visual-playbooks/outline-template.md"
-)
-
-// Every artifact the schema's Budget column names must either be measured by the
-// engine or say in its Budget cell that the budget is advisory.
-func TestSchemaBudgetRowsAreEnforcedOrMarkedAdvisory(t *testing.T) {
-	raw, err := os.ReadFile(artifactSchemaDocPath)
-	if err != nil {
-		t.Fatal(err)
-	}
-	rows := 0
-	for _, line := range strings.Split(string(raw), "\n") {
-		cells := strings.Split(line, "|")
-		if len(cells) != 5 || !strings.Contains(cells[3], "lines") {
-			continue
-		}
-		first, budget := strings.TrimSpace(cells[1]), cells[3]
-		if !strings.HasPrefix(first, "`") || !strings.HasSuffix(first, "`") {
-			continue
-		}
-		rows++
-		name := strings.Trim(first, "`")
-		if _, canonical := state.ArtifactLineBudget(name); canonical {
-			continue
-		}
-		if !strings.Contains(strings.ToLower(budget), "advisory") {
-			t.Errorf("%s has a budget %q but is neither in state.artifactLineBudgets nor marked advisory", name, strings.TrimSpace(budget))
-		}
-	}
-	if rows < 30 {
-		t.Fatalf("parsed %d budget rows from the schema table, want at least 30", rows)
-	}
-}
-
-func TestOutlineTemplateBudgetIsMarkedAdvisory(t *testing.T) {
-	raw, err := os.ReadFile(outlineTemplateDocPath)
-	if err != nil {
-		t.Fatal(err)
-	}
-	for _, line := range strings.Split(string(raw), "\n") {
-		if strings.HasPrefix(line, "- Budget:") {
-			if !strings.Contains(strings.ToLower(line), "advisory") {
-				t.Fatalf("outline budget line %q does not say the budget is advisory", line)
-			}
-			return
-		}
-	}
-	t.Fatal("outline template has no \"- Budget:\" line")
-}
-
-// A canonical artifact larger than the read cap is reported over budget from its
-// size alone, without being read whole.
-func TestObserveArtifactBudgetsOversizedArtifactIsOverWithoutFullRead(t *testing.T) {
-	const size = 32 << 20
-	_, workspace := writeBudgetWorkspace(t, map[string]string{"state.md": "| phase | build |\n"})
-	file, err := os.OpenFile(filepath.Join(workspace, "state.md"), os.O_WRONLY, 0o644)
-	if err != nil {
-		t.Fatal(err)
-	}
-	if err := file.Truncate(size); err != nil {
-		t.Fatal(err)
-	}
-	if err := file.Close(); err != nil {
-		t.Fatal(err)
-	}
-
-	var before, after runtime.MemStats
-	runtime.ReadMemStats(&before)
-	budgets, _, unreadable, err := observeArtifactBudgets(workspace)
-	runtime.ReadMemStats(&after)
-	if err != nil {
-		t.Fatal(err)
-	}
-	if len(unreadable) != 0 {
-		t.Fatalf("unreadable=%v, an oversized artifact is over budget, not unreadable", unreadable)
-	}
-	if len(budgets) != 1 || !budgets[0].Over || budgets[0].Bytes != size {
-		t.Fatalf("budgets=%+v, want state.md over budget with Bytes=%d", budgets, size)
-	}
-	if allocated := after.TotalAlloc - before.TotalAlloc; allocated > size/4 {
-		t.Fatalf("allocated %d bytes for a %d byte artifact; the read must be bounded", allocated, size)
-	}
-}
-
-func TestUnreturnedWavesWarnAndSurfaceInOrient(t *testing.T) {
-	root, _ := writeBudgetWorkspace(t, map[string]string{
-		"state.md": "| phase | build |\n| schema | 4 |\n",
-		"tasks.md": budgetTasks,
-	})
-	open := func(wave string) string {
-		stdout, stderr := &bytes.Buffer{}, &bytes.Buffer{}
-		args := []string{"feature", "open", "--phase", "build", "--wave", wave, "--role", "slice-wright", "--slice", "SLICE-001"}
-		if code := RunDispatch(root, args, stdout, stderr); code != 0 {
-			t.Fatalf("open %s: code=%d\n%s%s", wave, code, stdout, stderr)
-		}
-		return stdout.String()
-	}
-	if out := open("r1"); strings.Contains(out, "WARNING") {
-		t.Fatalf("first wave must not warn:\n%s", out)
-	}
-	if out := open("r2"); !strings.Contains(out, "WARNING: SLICE-001 earlier wave(s) r1 never returned") {
-		t.Fatalf("unreturned earlier wave not warned:\n%s", out)
-	}
-	summary, err := ObserveSummaryFor(root, "feature")
-	if err != nil {
-		t.Fatal(err)
-	}
-	if len(summary.InflightWaves) != 2 {
-		t.Fatalf("inflight waves=%+v", summary.InflightWaves)
-	}
-	first := summary.InflightWaves[0]
-	if first.Wave != "r1" || first.State != "open" || len(first.Pending) != 1 || first.Pending[0] != "slice-wright" || first.Slices[0] != "SLICE-001" {
-		t.Fatalf("inflight wave=%+v", first)
-	}
-}