devrites 3.2.28 → 4.0.0

package/engine/testdata/golden/TestSpecSkeleton/present-all.golden

@@ -1,2 +0,0 @@
-exit 0
-spec-skeleton: OK: present/spec.md: all required top-level sections present

package/engine/testdata/golden/TestStuckLogHashParity.golden

@@ -1 +0,0 @@
-40bef27491bd911d9988892dafd1f124fdf377ca

package/engine/tests/adr_0006_clock_seam_test.go

@@ -1,36 +0,0 @@
-package main_test
-
-// Guard test for ADR-0006 (clock seam). The next-qid derivation must read the
-// clock through the DEVRITES_NOW seam so date-derived output is deterministic.
-// Without the seam this command tracked the real wall clock and its golden
-// snapshot rotted at every day boundary. This test pins the class of bug shut.
-
-import (
-	"path/filepath"
-	"strings"
-	"testing"
-)
-
-func TestADR0006NextQIDHonorsClockSeam(t *testing.T) {
-	dir := t.TempDir()
-	qpath := filepath.Join(dir, "questions.md")
-	writeFile(t, dir, "questions.md", "## q-2024-01-01-001\nstatus: open\n")
-
-	cases := []struct {
-		now  string
-		want string
-	}{
-		{"2026-03-04", "q-2026-03-04-001"},
-		{"2030-12-31T23:59:59Z", "q-2030-12-31-001"},
-	}
-	for _, c := range cases {
-		out, _, code := runDevritesIO(t, dir, "", []string{"DEVRITES_NOW=" + c.now},
-			"resolve", "next-qid", qpath)
-		if code != 0 {
-			t.Fatalf("DEVRITES_NOW=%s: exit = %d, want 0\n%s", c.now, code, out)
-		}
-		if got := strings.TrimSpace(out); got != c.want {
-			t.Errorf("DEVRITES_NOW=%s: qid = %q, want %q: clock seam not honored", c.now, got, c.want)
-		}
-	}
-}

package/engine/tests/budget_test.go

@@ -1,88 +0,0 @@
-package main_test
-
-import (
-	"strings"
-	"testing"
-)
-
-// TestStatusLiveWorkspace checks a canonical work/<slug> feature without
-// workspace-map frontmatter. Status must read the phase from state.md and
-// completeness from evidence.md and state.md instead of reporting
-// "feature not found".
-func TestStatusLiveWorkspace(t *testing.T) {
-	work := t.TempDir()
-	writeFile(t, work, ".devrites/work/live/state.md", "- Phase: build\n- Status: running\n")
-	for name, body := range map[string]string{
-		"brief.md":             "# Brief\n\nDo the thing.\n",
-		"spec.md":              "# Spec\n\nDo the thing.\n",
-		"decisions.md":         "# Decisions\n\nChose X.\n",
-		"assumptions.md":       "# Assumptions\n\nNone.\n",
-		"questions.md":         "# Questions\n\nNone.\n",
-		"decision-coverage.md": "# Decision coverage\n\nCLEAR.\n",
-		"architecture.md":      "# Architecture\n\nExisting layer.\n",
-		"plan.md":              "# Plan\n\nApproach.\n",
-		"tasks.md":             "# Tasks\n\n- [x] slice 1\n",
-		"traceability.md":      "# Traceability\n\nMapped.\n",
-		"eng-review.md":        "# Engineering review\n\nREADY.\n",
-		"test-plan.md":         "# Test plan\n\nRun tests.\n",
-	} {
-		writeFile(t, work, ".devrites/work/live/"+name, body)
-	}
-	(parityCase{
-		workdir: work,
-		env:     libRootEnv(work),
-		goArgs:  []string{"status", "live"},
-	}).assertEqual(t)
-}
-
-// TestParityBudget checks `budget` against golden snapshots: the within-budget
-// report, an over-budget advisory (exit 0) and its --strict block (exit 3), the
-// active-slug default, a stray *.md measured at the default ceiling, and the two
-// usage errors (missing feature, no active feature).
-func TestParityBudget(t *testing.T) {
-	nLines := func(n int) string { return strings.Repeat("x\n", n) }
-	work := t.TempDir()
-
-	// within: every file under its ceiling.
-	writeFeatureFile(t, work, "small", "spec.md", nLines(10))
-	writeFeatureFile(t, work, "small", "state.md", nLines(5))
-	writeFeatureFile(t, work, "small", "tasks.md", nLines(5))
-
-	// over: spec.md and tasks.md exceed their ceilings; state.md is fine.
-	writeFeatureFile(t, work, "big", "spec.md", nLines(300))
-	writeFeatureFile(t, work, "big", "tasks.md", nLines(160))
-	writeFeatureFile(t, work, "big", "state.md", nLines(5))
-
-	// extra: an unknown notes.md is measured at the default ceiling.
-	writeFeatureFile(t, work, "extra", "spec.md", nLines(5))
-	writeFeatureFile(t, work, "extra", "notes.md", nLines(210))
-
-	// active: default slug comes from ACTIVE.
-	writeFeatureFile(t, work, "act", "spec.md", nLines(5))
-
-	// ghost is never created (missing-feature error path).
-
-	for _, tc := range []struct {
-		name   string
-		active string // ACTIVE pointer to set ("" removes it)
-		args   []string
-	}{
-		{"within", "", []string{"budget", "small"}},
-		{"over-advisory", "", []string{"budget", "big"}},
-		{"over-strict", "", []string{"budget", "big", "--strict"}},
-		{"extra-md", "", []string{"budget", "extra"}},
-		{"default-active", "act", []string{"budget"}},
-		{"no-feature", "", []string{"budget", "ghost"}},
-		{"no-active", "", []string{"budget"}},
-	} {
-		tc := tc
-		t.Run(tc.name, func(t *testing.T) {
-			setActiveAFK(t, work, tc.active, false)
-			(parityCase{
-				workdir: work,
-				env:     libRootEnv(work),
-				goArgs:  tc.args,
-			}).assertEqual(t)
-		})
-	}
-}

package/engine/tests/canonical_ac_ids_test.go

@@ -1,44 +0,0 @@
-package main_test
-
-import (
-	"strings"
-	"testing"
-)
-
-func TestCanonicalAcceptanceIDsAcrossGates(t *testing.T) {
-	work := t.TempDir()
-	writeFeatureFile(t, work, "canonical", "spec.md",
-		"## Acceptance criteria\n- [ ] AC-001: alpha\n- [ ] AC-002: beta\n")
-	writeFeatureFile(t, work, "canonical", "tasks.md",
-		"## SLICE-001 alpha\nSatisfies: AC-001\n## SLICE-002 beta\nSatisfies: AC-002\n## SLICE-003 orphan\n")
-	writeFeatureFile(t, work, "canonical", "seal.md",
-		"## Acceptance Criteria\n- [x] AC-001: alpha: evidence t1\n- [x] AC-002: beta: evidence t2\n")
-
-	t.Run("analyze", func(t *testing.T) {
-		stdout, stderr, code := runGo(t, work, "analyze", "canonical")
-		if code != 0 || !strings.Contains(stdout, "AC-001: covered") || !strings.Contains(stdout, "slice 'SLICE-003 orphan'") {
-			t.Fatalf("exit=%d stdout=%q stderr=%q", code, stdout, stderr)
-		}
-	})
-
-	t.Run("coverage", func(t *testing.T) {
-		stdout, stderr, code := runGo(t, work, "coverage", "canonical")
-		if code != 0 || !strings.Contains(stdout, "| AC-001 | SLICE-001 alpha | yes |") {
-			t.Fatalf("exit=%d stdout=%q stderr=%q", code, stdout, stderr)
-		}
-	})
-
-	t.Run("check-acceptance", func(t *testing.T) {
-		stdout, stderr, code := runGo(t, work, "check-acceptance", ".devrites/features/canonical")
-		if code != 0 || !strings.Contains(stdout, "AC-001 AC-002") {
-			t.Fatalf("exit=%d stdout=%q stderr=%q", code, stdout, stderr)
-		}
-	})
-
-	t.Run("lanes", func(t *testing.T) {
-		stdout, stderr, code := runGo(t, work, "lanes", "plan", "canonical")
-		if code != 0 || !strings.Contains(stdout, "- SLICE-001 alpha:") {
-			t.Fatalf("exit=%d stdout=%q stderr=%q", code, stdout, stderr)
-		}
-	})
-}

package/engine/tests/concurrency_cli_test.go

@@ -1,131 +0,0 @@
-package main_test
-
-// Multi-process concurrency: DevRites fans out reviewer subagents that each
-// spawn the binary. This asserts concurrent read-only status calls stay
-// consistent against one workspace.
-
-import (
-	"bytes"
-	"errors"
-	"os"
-	"os/exec"
-	"path/filepath"
-	"strings"
-	"sync"
-	"testing"
-)
-
-// runProc runs the binary without touching *testing.T, so it is safe to call
-// from many goroutines. It returns stdout and exit code (and a fatal error only
-// for a non-exit failure like the binary being unrunnable).
-func runProc(root string, args ...string) (stdout string, code int, fatal error) {
-	return runProcInput(root, "", args...)
-}
-
-func runProcInput(root, stdin string, args ...string) (stdout string, code int, fatal error) {
-	cmd := exec.Command(binPath, args...)
-	cmd.Env = append(os.Environ(), "DEVRITES_ROOT="+root)
-	cmd.Stdin = strings.NewReader(stdin)
-	var out bytes.Buffer
-	cmd.Stdout = &out
-	cmd.Stderr = &bytes.Buffer{}
-	err := cmd.Run()
-	if err != nil {
-		var ee *exec.ExitError
-		if !errors.As(err, &ee) {
-			return out.String(), -1, err
-		}
-		code = ee.ExitCode()
-	}
-	return out.String(), code, nil
-}
-
-func TestConcurrentStatusProcessesStayConsistent(t *testing.T) {
-	if testing.Short() {
-		t.Skip("skipping process stress test in -short mode")
-	}
-	root := newWorkspace(t)
-	want := goldenStatus(t, "auth-tokens")
-
-	const n = 24
-	type res struct {
-		out   string
-		code  int
-		fatal error
-	}
-	results := make([]res, n)
-	var wg sync.WaitGroup
-	for i := 0; i < n; i++ {
-		wg.Add(1)
-		go func(i int) {
-			defer wg.Done()
-			out, code, fatal := runProc(root, "status", "auth-tokens")
-			results[i] = res{out, code, fatal}
-		}(i)
-	}
-	wg.Wait()
-
-	for i, r := range results {
-		if r.fatal != nil {
-			t.Fatalf("proc %d could not run: %v", i, r.fatal)
-		}
-		if r.code != 0 {
-			t.Errorf("proc %d exit = %d, want 0\n%s", i, r.code, r.out)
-			continue
-		}
-		if r.out != want {
-			t.Errorf("proc %d status output diverged under contention\n--- got ---\n%s--- want ---\n%s", i, r.out, want)
-		}
-	}
-}
-
-// TestConcurrentStopGateAppendsNeverTear spawns many concurrent stop-gate
-// processes (observe mode) that each append a would-block record to the same
-// per-feature log. Every record must land exactly once and intact: the
-// multi-PROCESS proof of the O_APPEND log path (the in-process proof lives in
-// internal/state/concurrency_test.go).
-func TestConcurrentStopGateAppendsNeverTear(t *testing.T) {
-	if testing.Short() {
-		t.Skip("skipping process stress test in -short mode")
-	}
-	root := newWorkspace(t)
-	setPhase(t, root, "auth-tokens", "seal") // claims done; proof.md is empty → would-block
-	writeActive(t, root, "auth-tokens")
-
-	const n = 24
-	var wg sync.WaitGroup
-	codes := make([]int, n)
-	for i := 0; i < n; i++ {
-		wg.Add(1)
-		go func(i int) {
-			defer wg.Done()
-			_, code, fatal := runProcInput(root, `{"stop_hook_active":false}`,
-				"hook", "stop-gate", "--harness=claude")
-			if fatal != nil {
-				code = -1
-			}
-			codes[i] = code
-		}(i)
-	}
-	wg.Wait()
-
-	for i, c := range codes {
-		if c != 0 {
-			t.Errorf("stop-gate proc %d exit = %d, want 0", i, c)
-		}
-	}
-
-	raw, err := os.ReadFile(filepath.Join(root, "features", "auth-tokens", ".stop-gate.log"))
-	if err != nil {
-		t.Fatalf("stop-gate log not written: %v", err)
-	}
-	lines := strings.Split(strings.TrimRight(string(raw), "\n"), "\n")
-	if len(lines) != n {
-		t.Fatalf("got %d log records, want %d (lost or torn appends)", len(lines), n)
-	}
-	for _, l := range lines {
-		if !strings.HasPrefix(l, "WOULD-BLOCK\t") || !strings.HasSuffix(l, "before stopping") {
-			t.Fatalf("interleaved/torn append record: %q", l)
-		}
-	}
-}

package/engine/tests/conventions_test.go

@@ -1,106 +0,0 @@
-package main_test
-
-import (
-	"os"
-	"path/filepath"
-	"strings"
-	"testing"
-)
-
-func TestConventionsLedgerCommand(t *testing.T) {
-	work := t.TempDir()
-
-	out, _, code := runGo(t, work, "conventions", "band", "--corroborations", "1")
-	if code != 0 || strings.TrimSpace(out) != "0.50" {
-		t.Fatalf("band c1/k0 = exit %d %q, want 0.50", code, out)
-	}
-	out, _, code = runGo(t, work, "conventions", "band", "--corroborations", "1", "--contradictions", "1")
-	if code != 0 || strings.TrimSpace(out) != "retired" {
-		t.Fatalf("band retired = exit %d %q, want retired", code, out)
-	}
-
-	out, _, code = runGo(t, work, "conventions", "read", "--root", work)
-	if code != 0 || out != "" {
-		t.Fatalf("read missing = exit %d %q, want empty success", code, out)
-	}
-
-	out, _, code = runGo(t, work, "conventions", "promote",
-		"--root", work,
-		"--key", "test-runner",
-		"--statement", "tests run with vitest, co-located *.test.ts",
-		"--kind", "test",
-		"--slug", "01-list",
-		"--evidence", "evidence.md: 12 passing",
-		"--date", "2026-06-20")
-	if code != 0 || !strings.Contains(out, "band 0.50") {
-		t.Fatalf("promote = exit %d %q, want band 0.50", code, out)
-	}
-
-	runGo(t, work, "conventions", "promote",
-		"--root", work,
-		"--key", "test-runner",
-		"--statement", "",
-		"--kind", "test",
-		"--slug", "02-detail",
-		"--evidence", "evidence.md: 8 passing",
-		"--date", "2026-06-21")
-	runGo(t, work, "conventions", "promote",
-		"--root", work,
-		"--key", "test-runner",
-		"--statement", "",
-		"--kind", "test",
-		"--slug", "02-detail",
-		"--evidence", "re-seal",
-		"--date", "2026-06-21")
-
-	ledgerPath := filepath.Join(work, ".devrites", "conventions.md")
-	ledger, err := os.ReadFile(ledgerPath)
-	if err != nil {
-		t.Fatal(err)
-	}
-	ledgerText := string(ledger)
-	for _, want := range []string{
-		"## test-runner",
-		"band: 0.60",
-		"corroborations: 2",
-		"01-list 2026-06-20",
-	} {
-		if !strings.Contains(ledgerText, want) {
-			t.Fatalf("ledger missing %q\n%s", want, ledgerText)
-		}
-	}
-
-	driftPath := filepath.Join(work, ".devrites", "features", "03-api", "drift.md")
-	out, _, code = runGo(t, work, "conventions", "contradict",
-		"--root", work,
-		"--key", "test-runner",
-		"--slug", "03-api",
-		"--evidence", "now uses jest",
-		"--date", "2026-06-22",
-		"--drift-file", driftPath)
-	if code != 0 || !strings.Contains(out, "DRIFT: convention 'test-runner' contradicted by 03-api") {
-		t.Fatalf("contradict = exit %d %q, want drift output", code, out)
-	}
-	drift, err := os.ReadFile(driftPath)
-	if err != nil {
-		t.Fatal(err)
-	}
-	if !strings.Contains(string(drift), "## convention-drift: test-runner") ||
-		!strings.Contains(string(drift), "- now: band 0.40") {
-		t.Fatalf("drift file missing expected entry\n%s", string(drift))
-	}
-
-	out, _, code = runGo(t, work, "conventions", "orient", "--root", work, "--min-band", "0.4")
-	if code != 0 || !strings.Contains(out, "- [0.40] test-runner (test): tests run with vitest") {
-		t.Fatalf("orient = exit %d %q, want active convention", code, out)
-	}
-
-	_, errOut, code := runGo(t, work, "conventions", "contradict",
-		"--root", work,
-		"--key", "missing",
-		"--slug", "04-missing",
-		"--evidence", "none")
-	if code != 3 || !strings.Contains(errOut, "no such convention: 'missing'") {
-		t.Fatalf("unknown contradict = exit %d stderr %q, want code 3", code, errOut)
-	}
-}

package/engine/tests/doctor_cli_test.go

@@ -1,223 +0,0 @@
-package main_test
-
-// CLI coverage for Issue 05: the `doctor` version triangle.
-
-import (
-	"bytes"
-	"errors"
-	"os"
-	"os/exec"
-	"path/filepath"
-	"strings"
-	"testing"
-)
-
-func TestDoctorPrintsTriangle(t *testing.T) {
-	root := newWorkspace(t)
-	out, errOut, code := runDevrites(t, root, "doctor")
-	if code != 0 {
-		t.Fatalf("exit = %d, want 0 (stderr: %s)", code, errOut)
-	}
-	for _, leg := range []string{"project:", "root:", "root-selection:", "binary:", "pack:", "state-schema:", "verdict:"} {
-		if !strings.Contains(out, leg) {
-			t.Errorf("doctor output missing %q leg\n%s", leg, out)
-		}
-	}
-}
-
-func TestDoctorVerboseMatchesPlainDoctor(t *testing.T) {
-	root := newWorkspace(t)
-	plainOut, plainErr, plainCode := runDevrites(t, root, "doctor")
-	verboseOut, verboseErr, verboseCode := runDevrites(t, root, "doctor", "--verbose")
-	if plainCode != 0 || verboseCode != 0 {
-		t.Fatalf("doctor exits: plain=%d verbose=%d", plainCode, verboseCode)
-	}
-	if verboseCode != plainCode || verboseOut != plainOut || verboseErr != plainErr {
-		t.Fatalf(
-			"doctor --verbose differs from doctor:\nplain: code=%d stdout=%q stderr=%q\nverbose: code=%d stdout=%q stderr=%q",
-			plainCode, plainOut, plainErr, verboseCode, verboseOut, verboseErr,
-		)
-	}
-}
-
-func TestDoctorReportsStaleActiveWithPasteableRepair(t *testing.T) {
-	root := newWorkspace(t)
-	if err := os.WriteFile(filepath.Join(root, "ACTIVE"), []byte("ghost\n"), 0o644); err != nil {
-		t.Fatal(err)
-	}
-	out, errOut, code := runDevrites(t, root, "doctor")
-	if code != 0 {
-		t.Fatalf("exit = %d, want warning exit 0 (stderr: %s)\n%s", code, errOut, out)
-	}
-	if !strings.Contains(out, "[DRV-ACTIVE-STALE]") || !strings.Contains(out, "fix: rm -f") {
-		t.Fatalf("doctor did not diagnose stale ACTIVE with remediation:\n%s", out)
-	}
-}
-
-func TestDoctorRefusesParentStateAcrossNestedRepositoryBoundary(t *testing.T) {
-	outer := doctorRepo(t, filepath.Join(t.TempDir(), "outer"))
-	if err := os.MkdirAll(filepath.Join(outer, ".devrites"), 0o755); err != nil {
-		t.Fatal(err)
-	}
-	child := doctorRepo(t, filepath.Join(outer, "services", "child"))
-	out, errOut, code := runDoctorAt(t, child)
-	if code != 3 {
-		t.Fatalf("exit = %d, want unsafe-root refusal (stderr: %s)\n%s", code, errOut, out)
-	}
-	if !strings.Contains(out, "[DRV-ROOT-OUTSIDE-GIT]") || !strings.Contains(out, "fix: cd ") {
-		t.Fatalf("doctor did not explain nested-repository boundary:\n%s", out)
-	}
-}
-
-func TestDoctorKeepsOrdinaryRootAbsenceDiagnosable(t *testing.T) {
-	repo := doctorRepo(t, filepath.Join(t.TempDir(), "repo"))
-	out, errOut, code := runDoctorAt(t, repo)
-	if code != 0 {
-		t.Fatalf("exit = %d, want diagnostic exit 0 (stderr: %s)\n%s", code, errOut, out)
-	}
-	if !strings.Contains(out, "root: none") || !strings.Contains(out, "[DRV-ROOT-NOT-FOUND]") {
-		t.Fatalf("doctor hid ordinary root absence:\n%s", out)
-	}
-}
-
-func TestDoctorRefusesWorkspaceOverrideWithoutRoot(t *testing.T) {
-	repo := doctorRepo(t, filepath.Join(t.TempDir(), "repo"))
-	out, errOut, code := runDoctorAtEnv(t, repo, "DEVRITES_WORKSPACE="+t.TempDir())
-	if code != 3 {
-		t.Fatalf("exit = %d, want unsafe-root refusal (stderr: %s)\n%s", code, errOut, out)
-	}
-	if !strings.Contains(out, "[DRV-WORKSPACE-WITHOUT-ROOT]") || !strings.Contains(out, "fix: unset DEVRITES_WORKSPACE") {
-		t.Fatalf("doctor hid workspace-without-root remediation:\n%s", out)
-	}
-}
-
-func TestDoctorReportsLinkedWorktreeAndSubmoduleTopology(t *testing.T) {
-	t.Run("linked worktree", func(t *testing.T) {
-		base := t.TempDir()
-		main := doctorRepo(t, filepath.Join(base, "main"))
-		worktree := filepath.Join(base, "linked")
-		doctorGit(t, main, "worktree", "add", "-q", "-b", "doctor-linked", worktree)
-		if err := os.MkdirAll(filepath.Join(worktree, ".devrites"), 0o755); err != nil {
-			t.Fatal(err)
-		}
-		out, errOut, code := runDoctorAt(t, worktree)
-		if code != 0 {
-			t.Fatalf("exit = %d stderr=%s\n%s", code, errOut, out)
-		}
-		if !strings.Contains(out, "linked-worktree=true") {
-			t.Fatalf("doctor omitted linked-worktree topology:\n%s", out)
-		}
-	})
-
-	t.Run("submodule", func(t *testing.T) {
-		base := t.TempDir()
-		origin := doctorRepo(t, filepath.Join(base, "origin"))
-		super := doctorRepo(t, filepath.Join(base, "super"))
-		doctorGit(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(sub, ".devrites"), 0o755); err != nil {
-			t.Fatal(err)
-		}
-		out, errOut, code := runDoctorAt(t, sub)
-		if code != 0 {
-			t.Fatalf("exit = %d stderr=%s\n%s", code, errOut, out)
-		}
-		if !strings.Contains(out, "submodule=true") || !strings.Contains(out, "git-superproject:") {
-			t.Fatalf("doctor omitted submodule topology:\n%s", out)
-		}
-	})
-}
-
-func TestDoctorReportsMergeInProgress(t *testing.T) {
-	root := newWorkspace(t)
-	git := filepath.Join(filepath.Dir(root), ".git")
-	if err := os.MkdirAll(git, 0o755); err != nil {
-		t.Fatal(err)
-	}
-	if err := os.WriteFile(filepath.Join(git, "MERGE_HEAD"), []byte("abc123\n"), 0o644); err != nil {
-		t.Fatal(err)
-	}
-
-	out, errOut, code := runDevrites(t, root, "doctor")
-	if code != 0 {
-		t.Fatalf("exit = %d, want 0 (stderr: %s)", code, errOut)
-	}
-	if !strings.Contains(out, "git-state: merge in progress") || !strings.Contains(out, "git-workflow.md#merge-conflict-recovery") {
-		t.Fatalf("doctor did not point to merge conflict recovery\n%s", out)
-	}
-}
-
-func TestDoctorRefusesNewerStateSchema(t *testing.T) {
-	root := newWorkspace(t)
-	// Drop in a feature declaring a far-newer schema than the binary supports.
-	dir := filepath.Join(root, "features", "from-the-future")
-	if err := os.MkdirAll(dir, 0o755); err != nil {
-		t.Fatal(err)
-	}
-	fm := "---\nslug: from-the-future\nphase: build\nschemaVersion: 99\n---\n\nx\n"
-	if err := os.WriteFile(filepath.Join(dir, "feature.md"), []byte(fm), 0o644); err != nil {
-		t.Fatal(err)
-	}
-	out, _, code := runDevrites(t, root, "doctor")
-	if code != 3 {
-		t.Fatalf("exit = %d, want 3 (refuse) for a newer-major state schema\n%s", code, out)
-	}
-	if !strings.Contains(out, "REFUSE") {
-		t.Errorf("verdict not a REFUSE\n%s", out)
-	}
-}
-
-func runDoctorAt(t *testing.T, dir string) (stdout, stderr string, code int) {
-	t.Helper()
-	return runDoctorAtEnv(t, dir)
-}
-
-func runDoctorAtEnv(t *testing.T, dir string, extraEnv ...string) (stdout, stderr string, code int) {
-	t.Helper()
-	cmd := exec.Command(binPath, "doctor")
-	cmd.Dir = dir
-	for _, item := range os.Environ() {
-		if strings.HasPrefix(item, "DEVRITES_ROOT=") || strings.HasPrefix(item, "DEVRITES_WORKSPACE=") {
-			continue
-		}
-		cmd.Env = append(cmd.Env, item)
-	}
-	cmd.Env = append(cmd.Env, extraEnv...)
-	var outBuf, errBuf bytes.Buffer
-	cmd.Stdout = &outBuf
-	cmd.Stderr = &errBuf
-	err := cmd.Run()
-	if err != nil {
-		var exitErr *exec.ExitError
-		if !errors.As(err, &exitErr) {
-			t.Fatalf("doctor: %v", err)
-		}
-		code = exitErr.ExitCode()
-	}
-	return outBuf.String(), errBuf.String(), code
-}
-
-func doctorRepo(t *testing.T, path string) string {
-	t.Helper()
-	if err := os.MkdirAll(path, 0o755); err != nil {
-		t.Fatal(err)
-	}
-	doctorGit(t, path, "init", "-q")
-	doctorGit(t, path, "config", "user.email", "devrites@example.invalid")
-	doctorGit(t, path, "config", "user.name", "DevRites Test")
-	if err := os.WriteFile(filepath.Join(path, ".fixture"), []byte("fixture\n"), 0o644); err != nil {
-		t.Fatal(err)
-	}
-	doctorGit(t, path, "add", ".fixture")
-	doctorGit(t, path, "commit", "-q", "-m", "fixture")
-	return path
-}
-
-func doctorGit(t *testing.T, dir string, args ...string) {
-	t.Helper()
-	cmd := exec.Command("git", append([]string{"-C", dir}, args...)...)
-	cmd.Env = append(os.Environ(), "GIT_TERMINAL_PROMPT=0")
-	if out, err := cmd.CombinedOutput(); err != nil {
-		t.Fatalf("git %s: %v\n%s", strings.Join(args, " "), err, out)
-	}
-}