devrites 2.6.1 → 3.0.0

package/engine/tests/budget_test.go

@@ -0,0 +1,77 @@
+package main_test
+
+import (
+	"strings"
+	"testing"
+)
+
+// TestStatusLiveWorkspace is the P2 acceptance check: `devrites-engine status <slug>`
+// must report a canonical work/<slug> feature the live pack created without a
+// feature.md manifest — phase from the state.md ledger, proof/status via their
+// evidence.md/state.md aliases. Before the schema unification this returned
+// "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")
+	writeFile(t, work, ".devrites/work/live/spec.md", "# Spec\n\nDo the thing.\n")
+	writeFile(t, work, ".devrites/work/live/plan.md", "# Plan\n\nApproach.\n")
+	writeFile(t, work, ".devrites/work/live/decisions.md", "# Decisions\n\nChose X.\n")
+	writeFile(t, work, ".devrites/work/live/tasks.md", "# Tasks\n\n- [x] slice 1\n")
+	(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/cli_test.go

@@ -0,0 +1,209 @@
+package main_test
+
+// CLI black-box tests: build the real binary, run it as a subprocess against a
+// fixture .devrites/, and assert stdout + exit code. This is the primary test
+// seam — it exercises external behavior only, never internals.
+//
+// Each test runs against a fresh COPY of the fixture in a temp dir, so a test
+// may hand-edit files without disturbing the committed fixture or another test.
+
+import (
+	"bytes"
+	"encoding/json"
+	"errors"
+	"os"
+	"os/exec"
+	"path/filepath"
+	"runtime"
+	"strings"
+	"testing"
+
+	"github.com/devrites/devrites/internal/testutil"
+)
+
+var (
+	binPath    string
+	engineRoot string
+)
+
+func TestMain(m *testing.M) {
+	wd, err := os.Getwd()
+	if err != nil {
+		panic(err)
+	}
+	engineRoot = filepath.Clean(filepath.Join(wd, ".."))
+	dir, err := os.MkdirTemp("", "devrites-bin-*")
+	if err != nil {
+		panic(err)
+	}
+	name := "devrites"
+	if runtime.GOOS == "windows" {
+		name += ".exe"
+	}
+	binPath = filepath.Join(dir, name)
+	build := exec.Command("go", "build", "-o", binPath, ".")
+	build.Dir = engineRoot
+	build.Env = append(os.Environ(), "CGO_ENABLED=0")
+	if out, err := build.CombinedOutput(); err != nil {
+		os.RemoveAll(dir)
+		panic("go build failed: " + err.Error() + "\n" + string(out))
+	}
+	code := m.Run()
+	os.RemoveAll(dir)
+	os.Exit(code)
+}
+
+// newWorkspace copies the committed fixture workspace into a fresh temp dir and
+// returns the path to the copied .devrites root. (The committed fixture dir is
+// named devrites-root/ rather than .devrites/ only because the repo-root
+// .gitignore ignores every .devrites/ directory; the engine keys off the
+// DEVRITES_ROOT path, not the directory name.)
+func newWorkspace(t *testing.T) string {
+	t.Helper()
+	src, err := filepath.Abs(filepath.Join(engineRoot, "testdata", "fixtures", "basic", "devrites-root"))
+	if err != nil {
+		t.Fatal(err)
+	}
+	root := filepath.Join(t.TempDir(), ".devrites")
+	testutil.CopyTree(t, src, root)
+	return root
+}
+
+// runDevrites runs the built binary against the given .devrites root and returns
+// stdout, stderr, and the exit code.
+func runDevrites(t *testing.T, root string, args ...string) (stdout, stderr string, code int) {
+	t.Helper()
+	cmd := exec.Command(binPath, args...)
+	cmd.Env = append(os.Environ(), "DEVRITES_ROOT="+root)
+	var outBuf, errBuf bytes.Buffer
+	cmd.Stdout = &outBuf
+	cmd.Stderr = &errBuf
+	err := cmd.Run()
+	code = 0
+	if err != nil {
+		var ee *exec.ExitError
+		if !errors.As(err, &ee) {
+			t.Fatalf("running %v: %v", args, err)
+		}
+		code = ee.ExitCode()
+	}
+	return outBuf.String(), errBuf.String(), code
+}
+
+func goldenStatus(t *testing.T, slug string) string {
+	t.Helper()
+	b, err := os.ReadFile(filepath.Join(engineRoot, "testdata", "golden", "status", slug+".txt"))
+	if err != nil {
+		t.Fatal(err)
+	}
+	return strings.ReplaceAll(string(b), "\r\n", "\n")
+}
+
+func TestStatusMatchesGolden(t *testing.T) {
+	for _, slug := range []string{"auth-tokens", "search-ranking"} {
+		slug := slug
+		t.Run(slug, func(t *testing.T) {
+			root := newWorkspace(t)
+			out, errOut, code := runDevrites(t, root, "status", slug)
+			if code != 0 {
+				t.Fatalf("exit = %d, want 0 (stderr: %s)", code, errOut)
+			}
+			if want := goldenStatus(t, slug); out != want {
+				t.Errorf("stdout mismatch\n--- got ---\n%s--- want ---\n%s", out, want)
+			}
+		})
+	}
+}
+
+func TestSnapshotEmitsDevRitesWorkspaceJSON(t *testing.T) {
+	root := newWorkspace(t)
+	out, errOut, code := runDevrites(t, root, "snapshot", "auth-tokens")
+	if code != 0 {
+		t.Fatalf("snapshot exit = %d, want 0 (stderr: %s)", code, errOut)
+	}
+	var got struct {
+		SchemaVersion   string   `json:"schemaVersion"`
+		Slug            string   `json:"slug"`
+		Phase           string   `json:"phase"`
+		RunMode         string   `json:"runMode"`
+		Complete        bool     `json:"complete"`
+		MissingSections []string `json:"missingSections"`
+		NextCommand     string   `json:"nextCommand"`
+		NextCommands    struct {
+			Verb   string `json:"verb"`
+			Claude string `json:"claude"`
+			Codex  string `json:"codex"`
+		} `json:"nextCommands"`
+	}
+	if err := json.Unmarshal([]byte(out), &got); err != nil {
+		t.Fatalf("snapshot output is not JSON: %v\n%s", err, out)
+	}
+	if got.SchemaVersion != "devrites.workspace.v1" {
+		t.Fatalf("schemaVersion = %q, want devrites.workspace.v1", got.SchemaVersion)
+	}
+	if got.Slug != "auth-tokens" || got.Phase != "build" || got.RunMode != "HITL" {
+		t.Fatalf("unexpected identity fields: %+v", got)
+	}
+	if got.Complete {
+		t.Fatalf("auth-tokens fixture should be incomplete before tasks are filled")
+	}
+	if len(got.MissingSections) != 1 || got.MissingSections[0] != "tasks" {
+		t.Fatalf("missingSections = %#v, want [tasks]", got.MissingSections)
+	}
+	if got.NextCommand != "/rite-build" {
+		t.Fatalf("nextCommand = %q, want /rite-build", got.NextCommand)
+	}
+	if got.NextCommands.Verb != "build" || got.NextCommands.Claude != "/rite-build" || got.NextCommands.Codex != "$rite-build" {
+		t.Fatalf("nextCommands = %+v, want build with Claude/Codex forms", got.NextCommands)
+	}
+}
+
+func TestStatusUnknownSlugExitsNonZero(t *testing.T) {
+	root := newWorkspace(t)
+	out, errOut, code := runDevrites(t, root, "status", "does-not-exist")
+	if code == 0 {
+		t.Fatalf("exit = 0, want non-zero for unknown slug")
+	}
+	if out != "" {
+		t.Errorf("stdout = %q, want empty on error", out)
+	}
+	if !bytes.Contains([]byte(errOut), []byte("not found")) {
+		t.Errorf("stderr = %q, want it to mention 'not found'", errOut)
+	}
+}
+
+func TestStatusMissingSlugArgExitsNonZero(t *testing.T) {
+	root := newWorkspace(t)
+	if _, _, code := runDevrites(t, root, "status"); code == 0 {
+		t.Fatalf("exit = 0, want non-zero when slug arg is missing")
+	}
+}
+
+func TestUnknownCommandExitsNonZero(t *testing.T) {
+	root := newWorkspace(t)
+	if _, _, code := runDevrites(t, root, "frobnicate"); code == 0 {
+		t.Fatalf("exit = 0, want non-zero for an unknown command")
+	}
+}
+
+func TestStatusReflectsHandEdit(t *testing.T) {
+	root := newWorkspace(t)
+	// Before: tasks is a heading-only stub → incomplete.
+	if out, _, _ := runDevrites(t, root, "status", "auth-tokens"); !bytes.Contains([]byte(out), []byte("result: incomplete")) {
+		t.Fatalf("precondition failed, expected incomplete, got:\n%s", out)
+	}
+	// Hand-edit the file to add real content; status reads files directly.
+	tasks := filepath.Join(root, "features", "auth-tokens", "tasks.md")
+	testutil.AppendFile(t, tasks, "\n- [x] mint\n- [x] verify\n")
+
+	out, _, code := runDevrites(t, root, "status", "auth-tokens")
+	if code != 0 {
+		t.Fatalf("status exit = %d, want 0", code)
+	}
+	if !bytes.Contains([]byte(out), []byte("  tasks      present")) {
+		t.Errorf("tasks still not present after edit\n%s", out)
+	}
+	if !bytes.Contains([]byte(out), []byte("result: complete")) {
+		t.Errorf("expected complete after edit\n%s", out)
+	}
+}

package/engine/tests/concurrency_cli_test.go

@@ -0,0 +1,125 @@
+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) {
+	cmd := exec.Command(binPath, args...)
+	cmd.Env = append(os.Environ(), "DEVRITES_ROOT="+root)
+	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 := runProc(root, "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

@@ -0,0 +1,106 @@
+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

@@ -0,0 +1,62 @@
+package main_test
+
+// Issue 05: `doctor` version triangle, at the CLI seam.
+
+import (
+	"os"
+	"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{"binary:", "pack:", "state-schema:", "verdict:"} {
+		if !strings.Contains(out, leg) {
+			t.Errorf("doctor output missing %q leg\n%s", leg, 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)
+	}
+}