devrites 6.0.3 → 6.1.0

package/engine/internal/rootfacts/facts_test.go

@@ -1,364 +0,0 @@
-package rootfacts
-
-import (
-	"errors"
-	"os"
-	"os/exec"
-	"path/filepath"
-	"strings"
-	"testing"
-)
-
-func TestResolveNormalCheckoutAndOrdinaryAbsence(t *testing.T) {
-	repo := initRepository(t, filepath.Join(t.TempDir(), "repo"))
-	root := filepath.Join(repo, ".devrites")
-	if err := os.MkdirAll(root, 0o755); err != nil {
-		t.Fatal(err)
-	}
-	facts, err := ResolveFrom(filepath.Join(repo, "nested"), "")
-	if err == nil {
-		t.Fatal("missing nested directory should fail before root resolution")
-	}
-	if err := os.MkdirAll(filepath.Join(repo, "nested"), 0o755); err != nil {
-		t.Fatal(err)
-	}
-	facts, err = ResolveFrom(filepath.Join(repo, "nested"), "")
-	if err != nil {
-		t.Fatal(err)
-	}
-	wantRoot, _ := physical(root)
-	if facts.PhysicalRoot != wantRoot || facts.SelectionReason != "git-ancestor" {
-		t.Fatalf("facts = %+v, want root %q selected by Git-bounded search", facts, wantRoot)
-	}
-	if facts.Git.TopLevel == "" || facts.Git.Dir == "" || facts.Git.CommonDir == "" {
-		t.Fatalf("missing Git identities: %+v", facts.Git)
-	}
-
-	if err := os.RemoveAll(root); err != nil {
-		t.Fatal(err)
-	}
-	facts, err = ResolveFrom(repo, "")
-	if !errors.Is(err, ErrNoRoot) || hazard(facts, "DRV-ROOT-NOT-FOUND") == nil || facts.Refuses() {
-		t.Fatalf("ordinary absence facts=%+v err=%v", facts, err)
-	}
-
-	t.Setenv("DEVRITES_WORKSPACE", filepath.Join(t.TempDir(), "outside"))
-	facts, err = ResolveFrom(repo, "")
-	if !errors.Is(err, ErrUnsafeRoot) || hazard(facts, "DRV-WORKSPACE-WITHOUT-ROOT") == nil || !facts.Refuses() {
-		t.Fatalf("workspace without root facts=%+v err=%v", facts, err)
-	}
-}
-
-func TestResolveStopsAtNestedRepositoryAndMultiRepoBoundaries(t *testing.T) {
-	parent := t.TempDir()
-	outer := initRepository(t, filepath.Join(parent, "outer"))
-	if err := os.MkdirAll(filepath.Join(outer, ".devrites"), 0o755); err != nil {
-		t.Fatal(err)
-	}
-	child := initRepository(t, filepath.Join(outer, "services", "child"))
-
-	facts, err := ResolveFrom(child, "")
-	if !errors.Is(err, ErrUnsafeRoot) {
-		t.Fatalf("nested repo error = %v, want unsafe root", err)
-	}
-	h := hazard(facts, "DRV-ROOT-OUTSIDE-GIT")
-	if h == nil || !h.Refuse || h.Remediation == "" {
-		t.Fatalf("nested repo hazard = %+v", h)
-	}
-	if facts.PhysicalRoot != "" {
-		t.Fatalf("nested repository inherited parent root %q", facts.PhysicalRoot)
-	}
-
-	multi := t.TempDir()
-	if err := os.MkdirAll(filepath.Join(multi, ".devrites"), 0o755); err != nil {
-		t.Fatal(err)
-	}
-	a := initRepository(t, filepath.Join(multi, "a"))
-	_ = initRepository(t, filepath.Join(multi, "b"))
-	facts, err = ResolveFrom(a, "")
-	if !errors.Is(err, ErrUnsafeRoot) || hazard(facts, "DRV-ROOT-OUTSIDE-GIT") == nil {
-		t.Fatalf("multi-repository parent facts=%+v err=%v", facts, err)
-	}
-}
-
-func TestResolveKeepsRepositoryBoundaryWhenGitProbeIsUnavailable(t *testing.T) {
-	outer := t.TempDir()
-	if err := os.MkdirAll(filepath.Join(outer, ".devrites"), 0o755); err != nil {
-		t.Fatal(err)
-	}
-	repo := filepath.Join(outer, "repo")
-	if err := os.MkdirAll(filepath.Join(repo, ".git"), 0o755); err != nil {
-		t.Fatal(err)
-	}
-	t.Setenv("PATH", "")
-
-	facts, err := ResolveFrom(repo, "")
-	if !errors.Is(err, ErrUnsafeRoot) {
-		t.Fatalf("Git-unavailable error = %v, want bounded refusal", err)
-	}
-	if hazard(facts, "DRV-GIT-FACTS-UNAVAILABLE") == nil || hazard(facts, "DRV-ROOT-OUTSIDE-GIT") == nil {
-		t.Fatalf("Git-unavailable facts lost boundary diagnostics: %+v", facts)
-	}
-}
-
-func TestGitPathIgnoresInheritedRepositoryTargets(t *testing.T) {
-	target := initRepository(t, filepath.Join(t.TempDir(), "target repo"))
-	poison := initRepository(t, filepath.Join(t.TempDir(), "poison repo"))
-	t.Setenv("GIT_DIR", filepath.Join(poison, ".git"))
-	t.Setenv("GIT_WORK_TREE", poison)
-	t.Setenv("GIT_CONFIG_COUNT", "1")
-	t.Setenv("GIT_CONFIG_KEY_0", "core.worktree")
-	t.Setenv("GIT_CONFIG_VALUE_0", poison)
-	t.Setenv("GIT_AUTHOR_NAME", "Retained Author")
-	want, err := physical(target)
-	if err != nil {
-		t.Fatal(err)
-	}
-
-	got, ok := gitPath(target, "--show-toplevel")
-	if !ok || got != want {
-		t.Fatalf("gitPath() = %q, %v, want %q, true", got, ok, want)
-	}
-}
-
-func TestResolveLinkedWorktreeUsesPerWorktreeRootAndCommonDir(t *testing.T) {
-	base := t.TempDir()
-	main := initRepository(t, filepath.Join(base, "main"))
-	worktree := filepath.Join(base, "linked")
-	runGit(t, main, "worktree", "add", "-q", "-b", "linked-test", worktree)
-	root := filepath.Join(worktree, ".devrites")
-	if err := os.MkdirAll(root, 0o755); err != nil {
-		t.Fatal(err)
-	}
-
-	facts, err := ResolveFrom(worktree, "")
-	if err != nil {
-		t.Fatal(err)
-	}
-	if !facts.Git.LinkedWorktree || facts.Git.Dir == facts.Git.CommonDir {
-		t.Fatalf("linked worktree identities = %+v", facts.Git)
-	}
-	want, _ := physical(root)
-	if facts.PhysicalRoot != want {
-		t.Fatalf("root = %q, want per-worktree %q", facts.PhysicalRoot, want)
-	}
-}
-
-func TestResolveSubmoduleNeverInheritsSuperprojectState(t *testing.T) {
-	base := t.TempDir()
-	origin := initRepository(t, filepath.Join(base, "origin"))
-	super := initRepository(t, filepath.Join(base, "super"))
-	runGit(t, super, "-c", "protocol.file.allow=always", "submodule", "add", "-q", origin, "deps/sub")
-	sub := filepath.Join(super, "deps", "sub")
-	if err := os.MkdirAll(filepath.Join(super, ".devrites"), 0o755); err != nil {
-		t.Fatal(err)
-	}
-
-	facts, err := ResolveFrom(sub, "")
-	if !errors.Is(err, ErrUnsafeRoot) || !facts.Git.Submodule || facts.Git.Superproject == "" {
-		t.Fatalf("submodule without root facts=%+v err=%v", facts, err)
-	}
-	if facts.PhysicalRoot != "" || hazard(facts, "DRV-ROOT-OUTSIDE-GIT") == nil {
-		t.Fatalf("submodule inherited superproject state: %+v", facts)
-	}
-
-	subRoot := filepath.Join(sub, ".devrites")
-	if err := os.MkdirAll(subRoot, 0o755); err != nil {
-		t.Fatal(err)
-	}
-	facts, err = ResolveFrom(sub, "")
-	if err != nil {
-		t.Fatal(err)
-	}
-	want, _ := physical(subRoot)
-	if facts.PhysicalRoot != want || !facts.Git.Submodule {
-		t.Fatalf("submodule local facts=%+v, want root %q", facts, want)
-	}
-
-	superFacts, err := ResolveFrom(super, "")
-	if err != nil {
-		t.Fatal(err)
-	}
-	if superFacts.Git.Submodule || superFacts.Git.Superproject != "" {
-		t.Fatalf("superproject mislabeled as submodule: %+v", superFacts.Git)
-	}
-}
-
-func TestResolveCanonicalizesExplicitSymlinkAndRejectsRootEscape(t *testing.T) {
-	base := t.TempDir()
-	real := initRepository(t, filepath.Join(base, "real"))
-	if err := os.MkdirAll(filepath.Join(real, ".devrites"), 0o755); err != nil {
-		t.Fatal(err)
-	}
-	link := filepath.Join(base, "project-link")
-	if err := os.Symlink(real, link); err != nil {
-		t.Skipf("symlinks unavailable: %v", err)
-	}
-	facts, err := ResolveFrom(base, link)
-	if err != nil {
-		t.Fatal(err)
-	}
-	want, _ := physical(filepath.Join(real, ".devrites"))
-	if facts.LexicalRoot != filepath.Join(link, ".devrites") || facts.PhysicalRoot != want {
-		t.Fatalf("symlink facts=%+v, want lexical link and physical root %q", facts, want)
-	}
-
-	escapedProject := filepath.Join(base, "escaped-project")
-	if err := os.MkdirAll(escapedProject, 0o755); err != nil {
-		t.Fatal(err)
-	}
-	outside := filepath.Join(base, "outside-root")
-	if err := os.MkdirAll(outside, 0o755); err != nil {
-		t.Fatal(err)
-	}
-	if err := os.Symlink(outside, filepath.Join(escapedProject, ".devrites")); err != nil {
-		t.Fatal(err)
-	}
-	facts, err = ResolveFrom(base, escapedProject)
-	if !errors.Is(err, ErrUnsafeRoot) || hazard(facts, "DRV-ROOT-SYMLINK-ESCAPE") == nil {
-		t.Fatalf("root symlink escape facts=%+v err=%v", facts, err)
-	}
-}
-
-func TestResolveRejectsWorkspaceAndActiveSymlinkState(t *testing.T) {
-	project := filepath.Join(t.TempDir(), "project")
-	root := filepath.Join(project, ".devrites")
-	outside := filepath.Join(t.TempDir(), "outside")
-	if err := os.MkdirAll(filepath.Join(root, "work"), 0o755); err != nil {
-		t.Fatal(err)
-	}
-	if err := os.MkdirAll(outside, 0o755); err != nil {
-		t.Fatal(err)
-	}
-	workspaceLink := filepath.Join(root, "work", "escaped")
-	if err := os.Symlink(outside, workspaceLink); err != nil {
-		t.Skipf("symlinks unavailable: %v", err)
-	}
-	facts, err := ResolveFrom(project, project)
-	if !errors.Is(err, ErrUnsafeRoot) || hazard(facts, "DRV-WORKSPACE-SYMLINK-ESCAPE") == nil {
-		t.Fatalf("workspace symlink facts=%+v err=%v", facts, err)
-	}
-
-	if err := os.Remove(workspaceLink); err != nil {
-		t.Fatal(err)
-	}
-	activeTarget := filepath.Join(outside, "ACTIVE")
-	if err := os.WriteFile(activeTarget, []byte("ghost\n"), 0o644); err != nil {
-		t.Fatal(err)
-	}
-	if err := os.Symlink(activeTarget, filepath.Join(root, "ACTIVE")); err != nil {
-		t.Fatal(err)
-	}
-	facts, err = ResolveFrom(project, project)
-	if !errors.Is(err, ErrUnsafeRoot) || hazard(facts, "DRV-ACTIVE-SYMLINK") == nil {
-		t.Fatalf("ACTIVE symlink facts=%+v err=%v", facts, err)
-	}
-}
-
-func TestResolveReportsStaleActiveAndExternalWorkspace(t *testing.T) {
-	project := initRepository(t, filepath.Join(t.TempDir(), "repo"))
-	root := filepath.Join(project, ".devrites")
-	if err := os.MkdirAll(root, 0o755); err != nil {
-		t.Fatal(err)
-	}
-	if err := os.WriteFile(filepath.Join(root, "ACTIVE"), []byte("ghost\n"), 0o644); err != nil {
-		t.Fatal(err)
-	}
-	facts, err := ResolveFrom(project, project)
-	if err != nil {
-		t.Fatal(err)
-	}
-	h := hazard(facts, "DRV-ACTIVE-STALE")
-	if h == nil || !strings.Contains(h.Remediation, "rm -f") {
-		t.Fatalf("stale ACTIVE hazard = %+v", h)
-	}
-
-	t.Setenv("DEVRITES_WORKSPACE", filepath.Join(t.TempDir(), "ghost"))
-	facts, err = ResolveFrom(project, project)
-	if !errors.Is(err, ErrUnsafeRoot) {
-		t.Fatalf("external workspace error = %v, want unsafe root", err)
-	}
-	h = hazard(facts, "DRV-WORKSPACE-OUTSIDE-ROOT")
-	if h == nil || h.Remediation != "unset DEVRITES_WORKSPACE" || !h.Refuse {
-		t.Fatalf("external workspace hazard = %+v", h)
-	}
-
-	facts, err = ResolveFrom(project, "")
-	if !errors.Is(err, ErrUnsafeRoot) || hazard(facts, "DRV-WORKSPACE-OUTSIDE-ROOT") == nil {
-		t.Fatalf("implicit external workspace facts=%+v err=%v", facts, err)
-	}
-}
-
-func hazard(facts Facts, id string) *Hazard {
-	for i := range facts.Hazards {
-		if facts.Hazards[i].ID == id {
-			return &facts.Hazards[i]
-		}
-	}
-	return nil
-}
-
-func initRepository(t *testing.T, path string) string {
-	t.Helper()
-	if err := os.MkdirAll(path, 0o755); err != nil {
-		t.Fatal(err)
-	}
-	runGit(t, path, "init", "-q")
-	runGit(t, path, "config", "user.email", "devrites@example.invalid")
-	runGit(t, path, "config", "user.name", "DevRites Test")
-	if err := os.WriteFile(filepath.Join(path, ".fixture"), []byte("fixture\n"), 0o644); err != nil {
-		t.Fatal(err)
-	}
-	runGit(t, path, "add", ".fixture")
-	runGit(t, path, "commit", "-q", "-m", "fixture")
-	return path
-}
-
-func runGit(t *testing.T, dir string, args ...string) string {
-	t.Helper()
-	cmd := exec.Command("git", append([]string{"-C", dir}, args...)...)
-	cmd.Env = append(os.Environ(), "GIT_TERMINAL_PROMPT=0")
-	out, err := cmd.CombinedOutput()
-	if err != nil {
-		t.Fatalf("git %s: %v\n%s", strings.Join(args, " "), err, out)
-	}
-	return strings.TrimSpace(string(out))
-}
-
-func TestResolveRefusesUnreadableWorkDirectory(t *testing.T) {
-	for _, mode := range []os.FileMode{0o111, 0o000} {
-		project := filepath.Join(t.TempDir(), "project")
-		work := filepath.Join(project, ".devrites", "work")
-		outside := filepath.Join(t.TempDir(), "outside")
-		for _, dir := range []string{work, outside} {
-			if err := os.MkdirAll(dir, 0o755); err != nil {
-				t.Fatal(err)
-			}
-		}
-		if err := os.Symlink(outside, filepath.Join(work, "escaped")); err != nil {
-			t.Skipf("symlinks unavailable: %v", err)
-		}
-		if err := os.Chmod(work, mode); err != nil {
-			t.Fatal(err)
-		}
-		t.Cleanup(func() { _ = os.Chmod(work, 0o755) })
-		if _, err := os.ReadDir(work); err == nil {
-			t.Skip("work stays readable (running as root?)")
-		}
-		facts, err := ResolveFrom(project, project)
-		if !errors.Is(err, ErrUnsafeRoot) || hazard(facts, "DRV-WORKSPACE-SCAN-FAILED") == nil {
-			t.Fatalf("mode %o: unreadable work facts=%+v err=%v", mode, facts, err)
-		}
-	}
-}
-
-func TestResolveAcceptsRootWithoutWorkDirectory(t *testing.T) {
-	project := filepath.Join(t.TempDir(), "project")
-	if err := os.MkdirAll(filepath.Join(project, ".devrites"), 0o755); err != nil {
-		t.Fatal(err)
-	}
-	facts, err := ResolveFrom(project, project)
-	if err != nil || len(facts.Hazards) != 0 {
-		t.Fatalf("missing work facts=%+v err=%v", facts, err)
-	}
-}

package/engine/internal/safepath/safepath_fuzz_test.go

@@ -1,21 +0,0 @@
-package safepath
-
-import "testing"
-
-func FuzzWithinResolved(f *testing.F) {
-	f.Add("child/file.txt", "/tmp/parent")
-	f.Add("..", "/tmp/parent")
-	f.Add("", "")
-	f.Fuzz(func(t *testing.T, candidate, parent string) {
-		_ = WithinResolved(candidate, parent)
-	})
-}
-
-func FuzzResolveExisting(f *testing.F) {
-	f.Add("/tmp/example")
-	f.Add("relative/path")
-	f.Add("")
-	f.Fuzz(func(t *testing.T, filename string) {
-		_, _ = ResolveExisting(filename)
-	})
-}

package/engine/internal/safepath/safepath_test.go

@@ -1,69 +0,0 @@
-package safepath
-
-import (
-	"os"
-	"path/filepath"
-	"runtime"
-	"strings"
-	"testing"
-)
-
-func TestWithinResolvedHandlesExistingSymlinksAndMissingTails(t *testing.T) {
-	base := t.TempDir()
-	parent := filepath.Join(base, "real")
-	outside := filepath.Join(base, "outside")
-	if err := os.MkdirAll(parent, 0o755); err != nil {
-		t.Fatal(err)
-	}
-	if err := os.MkdirAll(outside, 0o755); err != nil {
-		t.Fatal(err)
-	}
-	link := filepath.Join(base, "link")
-	if err := os.Symlink(parent, link); err != nil {
-		t.Skipf("symlinks unavailable: %v", err)
-	}
-	escape := filepath.Join(parent, "escape")
-	if err := os.Symlink(outside, escape); err != nil {
-		t.Fatal(err)
-	}
-
-	cases := []struct {
-		name      string
-		candidate string
-		parent    string
-		want      bool
-	}{
-		{"same path", parent, parent, true},
-		{"symlinked existing prefix", filepath.Join(link, "new", "file"), parent, true},
-		{"missing parent tail", filepath.Join(parent, "new", "file"), filepath.Join(parent, "new"), true},
-		{"symlink escape", filepath.Join(escape, "file"), parent, false},
-		{"lexical escape", filepath.Join(parent, "..", "outside"), parent, false},
-	}
-	for _, tc := range cases {
-		t.Run(tc.name, func(t *testing.T) {
-			if got := WithinResolved(tc.candidate, tc.parent); got != tc.want {
-				t.Fatalf("WithinResolved(%q, %q) = %v, want %v", tc.candidate, tc.parent, got, tc.want)
-			}
-		})
-	}
-}
-
-func TestWithinResolvedDoesNotInventCaseFolding(t *testing.T) {
-	parent := filepath.Join(t.TempDir(), "CaseSensitiveName")
-	if err := os.MkdirAll(parent, 0o755); err != nil {
-		t.Fatal(err)
-	}
-	wrongCase := filepath.Join(filepath.Dir(parent), strings.ToLower(filepath.Base(parent)))
-	_, err := os.Stat(wrongCase)
-	if err == nil {
-		// The host filesystem treats the paths as the same. Native filepath
-		// semantics are the authority on that host.
-		if !WithinResolved(wrongCase, parent) {
-			t.Fatalf("%s considers paths equivalent but containment disagrees", runtime.GOOS)
-		}
-		return
-	}
-	if WithinResolved(wrongCase, parent) {
-		t.Fatalf("%s filesystem is case-sensitive; containment folded case", runtime.GOOS)
-	}
-}

package/engine/internal/safepath/safepath_windows_test.go

@@ -1,26 +0,0 @@
-//go:build windows
-
-package safepath
-
-import (
-	"path/filepath"
-	"testing"
-)
-
-func TestWindowsNativeVolumeAndSeparatorContainment(t *testing.T) {
-	parent := t.TempDir()
-	if !WithinResolved(filepath.Join(parent, "child", "file"), parent) {
-		t.Fatal("native Windows child path should remain contained")
-	}
-	volume := filepath.VolumeName(parent)
-	if volume == "" {
-		t.Fatalf("temporary path %q has no Windows volume", parent)
-	}
-	other := `Z:\outside`
-	if filepath.VolumeName(parent) == "Z:" {
-		other = `Y:\outside`
-	}
-	if WithinResolved(other, parent) {
-		t.Fatalf("different Windows volumes reported contained: %q in %q", other, parent)
-	}
-}

package/engine/internal/state/acceptance_test.go

@@ -1,57 +0,0 @@
-package state
-
-import (
-	"slices"
-	"testing"
-)
-
-func TestParseAcceptanceMapEmptySpecPasses(t *testing.T) {
-	got := ParseAcceptanceMap([]byte("# Spec\n\nReady.\n"), []byte("tasks"), []byte("plan"), true, true)
-	if len(got.SpecIDs) != 0 || len(got.Problems) != 0 {
-		t.Fatalf("ids=%v problems=%v", got.SpecIDs, got.Problems)
-	}
-}
-
-func TestParseAcceptanceMapRequiresTasksAndTestPlan(t *testing.T) {
-	spec := []byte("# Spec\n\n## Acceptance criteria\n- [ ] AC-001: export CSV\n- [ ] AC-002: reject cross-user\n")
-	tasks := []byte("# Tasks\nSatisfies: AC-001\n")
-	plan := []byte("# Test plan\nAC-001 → T1\n")
-	got := ParseAcceptanceMap(spec, tasks, plan, true, true)
-	if !slices.Equal(got.SpecIDs, []string{"AC-001", "AC-002"}) {
-		t.Fatalf("ids=%v", got.SpecIDs)
-	}
-	if !slices.Equal(got.Problems, []string{
-		"acceptance AC-002 is not referenced in tasks.md",
-		"acceptance AC-002 is not referenced in test-plan.md",
-	}) {
-		t.Fatalf("problems=%v", got.Problems)
-	}
-}
-
-func TestParseAcceptanceMapSkipsUnrequiredArtifacts(t *testing.T) {
-	spec := []byte("## Acceptance Criteria\n- AC-001: bind readiness inputs.\n")
-	got := ParseAcceptanceMap(spec, nil, nil, false, false)
-	if !slices.Equal(got.SpecIDs, []string{"AC-001"}) || len(got.Problems) != 0 {
-		t.Fatalf("ids=%v problems=%v", got.SpecIDs, got.Problems)
-	}
-}
-
-func TestParseAcceptanceMapIgnoresNoncanonicalAndDuplicates(t *testing.T) {
-	spec := []byte("## Acceptance criteria\n- AC-001: one\n- AC1: ignored\n- AC-001: again\n")
-	tasks := []byte("Satisfies: AC-001\n")
-	plan := []byte("AC-001\n")
-	got := ParseAcceptanceMap(spec, tasks, plan, true, true)
-	if !slices.Equal(got.SpecIDs, []string{"AC-001"}) || len(got.Problems) != 0 {
-		t.Fatalf("ids=%v problems=%v", got.SpecIDs, got.Problems)
-	}
-}
-
-func TestParseAcceptanceMapStopsAtNextH2(t *testing.T) {
-	spec := []byte("## Acceptance criteria\n- AC-001: in section\n\n## Non-goals\n- AC-999: outside\n")
-	tasks := []byte("AC-001\n")
-	plan := []byte("AC-001\n")
-	got := ParseAcceptanceMap(spec, tasks, plan, true, true)
-	if !slices.Equal(got.SpecIDs, []string{"AC-001"}) || len(got.Problems) != 0 {
-		t.Fatalf("ids=%v problems=%v", got.SpecIDs, got.Problems)
-	}
-}

package/engine/internal/state/budgets_test.go

@@ -1,135 +0,0 @@
-package state
-
-import (
-	"strings"
-
-	"slices"
-	"testing"
-)
-
-func TestArtifactBudgetMeasuresLinesBytesAndMateriality(t *testing.T) {
-	if _, ok := ArtifactBudget("notes.json", []byte("x")); ok {
-		t.Fatal("non-canonical files have no budget")
-	}
-	within, ok := ArtifactBudget("tasks.md", []byte("# Tasks\n## SLICE-001 A\nDependencies: none\n"))
-	if !ok || within.Over || within.Material {
-		t.Fatalf("within=%+v", within)
-	}
-	over, _ := ArtifactBudget("tasks.md", []byte(strings.Repeat("x\n", 300)))
-	if !over.Over || over.Material {
-		t.Fatalf("300 lines against a 280-line budget must be over but not material: %+v", over)
-	}
-	material, _ := ArtifactBudget("tasks.md", []byte(strings.Repeat("x\n", 500)))
-	if !material.Material {
-		t.Fatalf("500 lines must be material: %+v", material)
-	}
-	longLine, _ := ArtifactBudget("state.md", []byte(strings.Repeat("y", 100_000)+"\n"))
-	if !longLine.Material || longLine.Lines != 1 {
-		t.Fatalf("one very long line must trip the byte budget: %+v", longLine)
-	}
-}
-
-func TestHasBudgetOverrideIgnoresFencedExamples(t *testing.T) {
-	if HasBudgetOverride([]byte("plain text\nBudget override: relocation pending\n")) != true {
-		t.Fatal("structural override line must be recognized")
-	}
-	fenced := "See the schema:\n\n```markdown\nBudget override: <reason>\n```\n\nNothing recorded.\n"
-	if HasBudgetOverride([]byte(fenced)) {
-		t.Fatal("a fenced example is not an override")
-	}
-	indented := "  Budget override: table form is required\n"
-	if !HasBudgetOverride([]byte(indented)) {
-		t.Fatal("leading whitespace must not hide a real override line")
-	}
-	for _, bare := range []string{"x\nBudget override:\n", "x\nBudget override:   \n", "x\n  Budget override:\t\n"} {
-		if HasBudgetOverride([]byte(bare)) {
-			t.Fatalf("an override line with no reason must not count: %q", bare)
-		}
-	}
-}
-
-// Every fence style that opens a CommonMark fenced block must reach the same
-// fenced-code guard, so a quoted example can never record an override.
-func TestHasBudgetOverrideMasksEveryFenceStyle(t *testing.T) {
-	for _, fence := range []string{"```", "~~~", "````", "~~~markdown", "   ~~~"} {
-		t.Run(fence, func(t *testing.T) {
-			closer := strings.TrimRight(fence, "abcdefghijklmnopqrstuvwxyz")
-			closed := "Intro paragraph.\n\n" + fence + "\nBudget override: <reason>\n" + closer + "\n\nClosing prose.\n"
-			if HasBudgetOverride([]byte(closed)) {
-				t.Fatalf("fence %q: a closed fenced example is not a structural override", fence)
-			}
-			unterminated := "Intro paragraph.\n\n" + fence + "\nBudget override: <reason>\n\nStill open.\n"
-			if HasBudgetOverride([]byte(unterminated)) {
-				t.Fatalf("fence %q: an unterminated fence masks to end of artifact", fence)
-			}
-			after := "Intro paragraph.\n\n" + fence + "\nSchema reference.\n" + closer + "\n\nBudget override: relocation pending\n"
-			if !HasBudgetOverride([]byte(after)) {
-				t.Fatalf("fence %q: the guard must close and a later real override line still counts", fence)
-			}
-		})
-	}
-}
-
-func TestHasBudgetOverrideFenceStyleIsNotOutcomeBearing(t *testing.T) {
-	bodies := []string{
-		"Budget override: relocation pending\n",
-		"text\nBudget override: <reason>\n```\nmore\n```\nBudget override: second\n",
-	}
-	for _, body := range bodies {
-		backtick := "```\n" + body + "```\n"
-		tilde := "~~~\n" + body + "~~~\n"
-		if got, want := HasBudgetOverride([]byte(tilde)), HasBudgetOverride([]byte(backtick)); got != want {
-			t.Fatalf("fence style changed the outcome for %q: tilde=%v backtick=%v", body, got, want)
-		}
-	}
-}
-
-func TestHasBudgetOverrideNestedAndIndentedFences(t *testing.T) {
-	cases := []struct {
-		name string
-		raw  string
-		want bool
-	}{
-		{"backtick block quoted inside tilde fence", "~~~markdown\n```\nBudget override: <reason>\n```\n~~~\n", false},
-		{"tilde block quoted inside backtick fence", "```markdown\n~~~\nBudget override: <reason>\n~~~\n```\n", false},
-		{"four-space indent is not a fence", "    ~~~\nBudget override: real\n", true},
-		{"malformed markdown has no structural override", "Budget override: real\n\x00", false},
-	}
-	for _, c := range cases {
-		if got := HasBudgetOverride([]byte(c.raw)); got != c.want {
-			t.Errorf("%s: got %v want %v", c.name, got, c.want)
-		}
-	}
-}
-
-func TestAcceptanceSectionIgnoresFencedExamples(t *testing.T) {
-	spec := []byte("# Spec\n\nHere is the shape we want:\n\n```markdown\n## Acceptance criteria\n- AC-900: phantom\n```\n\nNo real section exists.\n")
-	got := ParseAcceptanceMap(spec, []byte("no ids here"), []byte("no ids here"), true, true)
-	if len(got.SpecIDs) != 0 {
-		t.Fatalf("a fenced example must not fabricate acceptance ids: ids=%v", got.SpecIDs)
-	}
-	if len(got.Problems) != 0 {
-		t.Fatalf("no real section means no required ids: problems=%v", got.Problems)
-	}
-}
-
-func TestAcceptanceSectionKeepsRealSectionPastFencedHeadings(t *testing.T) {
-	spec := []byte("# Spec\n\n## Acceptance criteria\n\n```markdown\n## Non-goals\n- AC-900: phantom\n```\n\n- AC-001: export CSV\n\n## Non-goals\n- AC-998: outside\n")
-	tasks := []byte("Satisfies: AC-001\n")
-	plan := []byte("AC-001\n")
-	got := ParseAcceptanceMap(spec, tasks, plan, true, true)
-	if !slices.Equal(got.SpecIDs, []string{"AC-001"}) {
-		t.Fatalf("a fenced heading must not truncate the real section: ids=%v", got.SpecIDs)
-	}
-	if len(got.Problems) != 0 {
-		t.Fatalf("problems=%v", got.Problems)
-	}
-}
-
-func TestAcceptanceSectionIgnoresMalformedMarkdown(t *testing.T) {
-	spec := []byte("## Acceptance criteria\n- AC-001: export CSV\n\x00")
-	got := ParseAcceptanceMap(spec, []byte("no ids here"), []byte("no ids here"), true, true)
-	if len(got.SpecIDs) != 0 || len(got.Problems) != 0 {
-		t.Fatalf("malformed input carries no usable section: ids=%v problems=%v", got.SpecIDs, got.Problems)
-	}
-}