devrites 6.0.4 → 6.1.1

package/engine/internal/overhaul/bench/run_test.go

@@ -1,316 +0,0 @@
-package bench
-
-import (
-	"bytes"
-	"encoding/json"
-	"fmt"
-	"math"
-	"math/rand/v2"
-	"os"
-	"path/filepath"
-	"strings"
-	"testing"
-
-	"github.com/devrites/devrites/internal/overhaul/ovio"
-)
-
-func gauss(rng *rand.Rand, mean, sd float64, n int) []float64 {
-	out := make([]float64, n)
-	for i := range out {
-		out[i] = mean + rng.NormFloat64()*sd
-	}
-	return out
-}
-
-func interleaved(n int) []string {
-	var o []string
-	for range n {
-		o = append(o, "A", "B")
-	}
-	return o
-}
-
-// run writes d as the result file, runs the CLI and decodes its output.
-func run(t *testing.T, d map[string]any) (int, map[string]any, string) {
-	t.Helper()
-	b, _ := json.Marshal(d)
-	path := filepath.Join(t.TempDir(), "result.json")
-	if err := os.WriteFile(path, b, 0o600); err != nil {
-		t.Fatal(err)
-	}
-	var out, errb bytes.Buffer
-	code := Run([]string{path}, &out, &errb)
-	var res map[string]any
-	if code == 0 {
-		if err := json.Unmarshal(out.Bytes(), &res); err != nil {
-			t.Fatalf("bad output %q: %v", out.String(), err)
-		}
-	}
-	return code, res, errb.String()
-}
-
-func with(d map[string]any, kv ...any) map[string]any {
-	c := map[string]any{}
-	for k, v := range d {
-		c[k] = v
-	}
-	for i := 0; i < len(kv); i += 2 {
-		c[kv[i].(string)] = kv[i+1]
-	}
-	return c
-}
-
-func verdict(t *testing.T, d map[string]any) (string, map[string]any) {
-	t.Helper()
-	code, res, stderr := run(t, d)
-	if code != 0 {
-		t.Fatalf("exit %d: %s", code, stderr)
-	}
-	return res["verdict"].(string), res
-}
-
-func fixture() (fast map[string]any, rng *rand.Rand) {
-	rng = rand.New(rand.NewPCG(7, 0))
-	fast = map[string]any{
-		"direction": "lower_is_better",
-		"baseline":  gauss(rng, 30, 1, 20), "candidate": gauss(rng, 10, 0.4, 20),
-		"order": interleaved(20), "target": 2.0, "materiality": 1.05,
-	}
-	return fast, rng
-}
-
-func TestBench(t *testing.T) {
-	fast, rng := fixture()
-
-	t.Run("clear 3x speedup supports target 2", func(t *testing.T) {
-		if v, res := verdict(t, fast); v != "SUPPORTS_TARGET" {
-			t.Fatalf("got %v", res)
-		}
-	})
-	t.Run("noisy data does not support target", func(t *testing.T) {
-		noisy := map[string]any{
-			"direction": "lower_is_better", "baseline": gauss(rng, 20, 9, 12), "candidate": gauss(rng, 10, 6, 12),
-			"order": interleaved(12), "target": 2.0, "materiality": 1.05,
-		}
-		v, res := verdict(t, noisy)
-		if lo := res["ci95"].([]any)[0].(float64); v == "SUPPORTS_TARGET" || lo >= 2 {
-			t.Fatalf("got %v", res)
-		}
-	})
-	t.Run("three cherry-picked samples are inconclusive", func(t *testing.T) {
-		picked := with(fast, "baseline", fast["baseline"].([]float64)[:3],
-			"candidate", fast["candidate"].([]float64)[:3], "order", interleaved(3))
-		if v, res := verdict(t, picked); v != "INCONCLUSIVE" {
-			t.Fatalf("got %v", res)
-		}
-	})
-	t.Run("blocked order is inconclusive", func(t *testing.T) {
-		order := append(strings.Split(strings.Repeat("A", 20), ""), strings.Split(strings.Repeat("B", 20), "")...)
-		if v, res := verdict(t, with(fast, "order", order)); v != "INCONCLUSIVE" {
-			t.Fatalf("got %v", res)
-		}
-	})
-	t.Run("swapped arms regress", func(t *testing.T) {
-		if v, res := verdict(t, with(fast, "baseline", fast["candidate"], "candidate", fast["baseline"])); v != "REGRESSION" {
-			t.Fatalf("got %v", res)
-		}
-	})
-	t.Run("zero baseline has no ratio", func(t *testing.T) {
-		if v, res := verdict(t, with(fast, "baseline", make([]float64, 20))); v != "NO_RATIO" {
-			t.Fatalf("got %v", res)
-		}
-	})
-	t.Run("higher is better throughput", func(t *testing.T) {
-		thr := map[string]any{
-			"direction": "higher_is_better", "baseline": gauss(rng, 100, 2, 15), "candidate": gauss(rng, 320, 5, 15),
-			"order": interleaved(15), "target": 3.0,
-		}
-		if v, res := verdict(t, thr); v != "SUPPORTS_TARGET" {
-			t.Fatalf("got %v", res)
-		}
-	})
-	t.Run("unknown or missing direction is an error", func(t *testing.T) {
-		swapped := with(fast, "baseline", fast["candidate"], "candidate", fast["baseline"])
-		missing := with(swapped)
-		delete(missing, "direction")
-		for _, d := range []map[string]any{with(swapped, "direction", "latency_ms"), missing} {
-			code, _, stderr := run(t, d)
-			if code != 2 || !strings.Contains(stderr, "direction must be lower_is_better or higher_is_better") {
-				t.Fatalf("exit %d stderr %q", code, stderr)
-			}
-		}
-	})
-}
-
-func assertFinite(t *testing.T, v any, path string) {
-	t.Helper()
-	switch x := v.(type) {
-	case float64:
-		if math.IsInf(x, 0) || math.IsNaN(x) {
-			t.Fatalf("%s is not finite: %v", path, x)
-		}
-	case []any:
-		for i, e := range x {
-			assertFinite(t, e, fmt.Sprintf("%s[%d]", path, i))
-		}
-	case map[string]any:
-		for k, e := range x {
-			assertFinite(t, e, path+"."+k)
-		}
-	}
-}
-
-func TestBenchNonFiniteInputs(t *testing.T) {
-	fast, _ := fixture()
-	someZeros := append(make([]float64, 8), gauss(rand.New(rand.NewPCG(3, 0)), 10, 0.4, 12)...)
-
-	t.Run("zero-valued resamples give a finite verdict", func(t *testing.T) {
-		for name, d := range map[string]map[string]any{
-			"lower is better":  with(fast, "candidate", someZeros),
-			"higher is better": with(fast, "direction", "higher_is_better", "baseline", someZeros, "candidate", fast["baseline"]),
-		} {
-			v, res := verdict(t, d)
-			if v != "NO_RATIO" && v != "INCONCLUSIVE" {
-				t.Fatalf("%s: got %v", name, res)
-			}
-			assertFinite(t, res, name)
-		}
-	})
-	t.Run("negative resolution is an error", func(t *testing.T) {
-		code, _, stderr := run(t, with(fast, "resolution", -1))
-		if code != 2 || !strings.Contains(stderr, "resolution") {
-			t.Fatalf("exit %d %q", code, stderr)
-		}
-	})
-	t.Run("every float of a normal result is finite", func(t *testing.T) {
-		_, res := verdict(t, fast)
-		assertFinite(t, res, "result")
-	})
-}
-
-func TestStats(t *testing.T) {
-	if k := tailCount(10, 10, 0.05); k != 24 {
-		t.Fatalf("n=m=10 alpha .05: k=%d, want 24 (Hollander-Wolfe D_(24), D_(77))", k)
-	}
-	if k := tailCount(30, 30, 1e-3); 2*k != 464 {
-		t.Fatalf("n=m=30 misrate 1e-3: margin %d, want 464 (Pragmastat PairwiseMargin)", 2*k)
-	}
-	if k := tailCount(3, 3, 0.05); k != 0 {
-		t.Fatalf("n=m=3 has no finite 95%% interval, got k=%d", k)
-	}
-	xs := []float64{1, 2, 3, 4, 5, 6, 7, 8, 9, 10}
-	if lcb, ucb := quantileBounds(xs, 0.5, 0.05); lcb != 2 || ucb != 9 {
-		t.Fatalf("median bounds n=10: [%v, %v], want [2, 9]", lcb, ucb)
-	}
-	if _, ucb := quantileBounds(xs, 0.99, 0.05); !math.IsInf(ucb, 1) {
-		t.Fatalf("p99 with n=10 has no upper bound, got %v", ucb)
-	}
-}
-
-func TestBenchExtensions(t *testing.T) {
-	fast, rng := fixture()
-	if _, res := verdict(t, fast); res["hodges_lehmann"] == nil {
-		t.Fatalf("no Hodges-Lehmann bounds: %v", res)
-	}
-	raw := func(mean float64, invocations, requests int) []any {
-		var arm []any
-		for range invocations {
-			arm = append(arm, gauss(rng, mean, mean/10, requests))
-		}
-		return arm
-	}
-	tail := map[string]any{"direction": "lower_is_better", "quantile": 0.99, "order": interleaved(12), "target": 2.0,
-		"baseline": raw(100, 12, 1000), "candidate": raw(30, 12, 1000)}
-
-	t.Run("tail quantile from raw requests", func(t *testing.T) {
-		if v, res := verdict(t, tail); v != "SUPPORTS_TARGET" || res["quantile"] != 0.99 {
-			t.Fatalf("got %v", res)
-		}
-	})
-	t.Run("thin tail is inconclusive", func(t *testing.T) {
-		thin := with(tail, "baseline", raw(100, 12, 50), "candidate", raw(30, 12, 50))
-		if v, res := verdict(t, thin); v != "INCONCLUSIVE" || !strings.Contains(fmt.Sprint(res["notes"]), "too few requests") {
-			t.Fatalf("got %v", res)
-		}
-	})
-	t.Run("per-invocation quantiles need request counts", func(t *testing.T) {
-		code, _, stderr := run(t, with(fast, "quantile", 0.95))
-		if code != 2 || !strings.Contains(stderr, "requests_per_invocation") {
-			t.Fatalf("exit %d %q", code, stderr)
-		}
-	})
-	t.Run("guardrail", func(t *testing.T) {
-		same := with(fast, "candidate", gauss(rng, 30, 1, 20), "tolerance", 0.1)
-		if _, res := verdict(t, same); ovio.Get(res, "guardrail.verdict") != "NON_INFERIOR" {
-			t.Fatalf("equal arms: %v", res["guardrail"])
-		}
-		slow := with(fast, "candidate", gauss(rng, 45, 1, 20), "tolerance", 0.1)
-		if _, res := verdict(t, slow); ovio.Get(res, "guardrail.verdict") != "REGRESSION" {
-			t.Fatalf("1.5x slower: %v", res["guardrail"])
-		}
-	})
-	t.Run("budget", func(t *testing.T) {
-		bytes := func(xs ...float64) []float64 { return xs }
-		for name, tc := range map[string]struct {
-			cand   []float64
-			budget map[string]any
-			want   string
-		}{
-			"deterministic pass":   {bytes(100, 100), map[string]any{"value": 120, "deterministic": true}, "PASS"},
-			"deterministic fail":   {bytes(130, 130), map[string]any{"value": 120, "deterministic": true}, "FAIL"},
-			"nondeterministic":     {bytes(100, 101), map[string]any{"value": 120, "deterministic": true}, "NONDETERMINISTIC"},
-			"p75 under budget":     {gauss(rng, 10, 0.4, 20), map[string]any{"value": 12, "quantile": 0.75}, "PASS"},
-			"p75 over budget":      {gauss(rng, 10, 0.4, 20), map[string]any{"value": 8, "quantile": 0.75}, "FAIL"},
-			"p99 needs more runs":  {gauss(rng, 10, 0.4, 20), map[string]any{"value": 12, "quantile": 0.99}, "INSUFFICIENT_DATA"},
-			"budget straddles p75": {bytes(1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20), map[string]any{"value": 15, "quantile": 0.75}, "INCONCLUSIVE"},
-		} {
-			if _, res := verdict(t, with(fast, "candidate", tc.cand, "budget", tc.budget)); ovio.Get(res, "budget.verdict") != tc.want {
-				t.Fatalf("%s: %v", name, res["budget"])
-			}
-		}
-	})
-	t.Run("error-rate guardrail", func(t *testing.T) {
-		zeros := make([]float64, 20)
-		clean := map[string]any{"baseline": zeros, "candidate": zeros, "tolerance": 0.001,
-			"requests": map[string]any{"baseline": 20000, "candidate": 20000}}
-		if _, res := verdict(t, with(fast, "error_rates", clean)); ovio.Get(res, "error_rate.verdict") != "PASS" {
-			t.Fatalf("clean: %v", res["error_rate"])
-		}
-		few := with(clean, "requests", map[string]any{"baseline": 200, "candidate": 200})
-		if _, res := verdict(t, with(fast, "error_rates", few)); ovio.Get(res, "error_rate.verdict") != "INCONCLUSIVE" {
-			t.Fatalf("zero errors in 200 requests proves nothing at 0.1%%: %v", res["error_rate"])
-		}
-		worse := with(clean, "candidate", gauss(rng, 0.05, 0.005, 20))
-		if _, res := verdict(t, with(fast, "error_rates", worse)); ovio.Get(res, "error_rate.verdict") != "FAIL" {
-			t.Fatalf("5%% errors: %v", res["error_rate"])
-		}
-	})
-	t.Run("saturated load caps every verdict", func(t *testing.T) {
-		load := map[string]any{"offered": map[string]any{"baseline": 1000, "candidate": 1000},
-			"completed": map[string]any{"baseline": 1000, "candidate": 900}}
-		clean := map[string]any{"baseline": make([]float64, 20), "candidate": make([]float64, 20), "tolerance": 0.01}
-		v, res := verdict(t, with(fast, "load", load, "error_rates", clean))
-		if v != "INCONCLUSIVE" || !strings.Contains(fmt.Sprint(res["notes"]), "saturated") || ovio.Get(res, "error_rate.verdict") != "INCONCLUSIVE" {
-			t.Fatalf("got %v", res)
-		}
-	})
-	t.Run("thin tail caps the budget", func(t *testing.T) {
-		thin := with(tail, "baseline", raw(100, 12, 50), "candidate", raw(30, 12, 50), "budget", map[string]any{"value": 1000})
-		if _, res := verdict(t, thin); ovio.Get(res, "budget.verdict") != "INCONCLUSIVE" {
-			t.Fatalf("got %v", res["budget"])
-		}
-	})
-	t.Run("invalid inputs are errors", func(t *testing.T) {
-		rates := func(x float64) []float64 { return []float64{x, x, x} }
-		for want, d := range map[string]map[string]any{
-			"proportions in [0, 1]": with(fast, "error_rates", map[string]any{"baseline": rates(1), "candidate": rates(1.5), "tolerance": 1}),
-			"must be positive": with(fast, "error_rates", map[string]any{"baseline": rates(0), "candidate": rates(0), "tolerance": 0.01,
-				"requests": map[string]any{"baseline": 0, "candidate": 1000}}),
-			"mixes raw request arrays": with(tail, "candidate", append(raw(30, 11, 1000), 30.0)),
-		} {
-			if code, _, stderr := run(t, d); code != 2 || !strings.Contains(stderr, want) {
-				t.Fatalf("%s: exit %d %q", want, code, stderr)
-			}
-		}
-	})
-}

package/engine/internal/overhaul/ovio/ovio_test.go

@@ -1,75 +0,0 @@
-package ovio
-
-import (
-	"bytes"
-	"encoding/json"
-	"os"
-	"path/filepath"
-	"runtime"
-	"testing"
-)
-
-func TestTruthyNumberZeroSpellingsAreFalse(t *testing.T) {
-	t.Parallel()
-	for _, n := range []json.Number{"0", "0.0", "0.00", "0.000", "-0", "-0.0", "0e0", "0e-1"} {
-		if Truthy(n) {
-			t.Errorf("Truthy(json.Number(%q)) = true, want false", n)
-		}
-	}
-}
-
-func TestTruthyNumberNonZeroValuesAreTrue(t *testing.T) {
-	t.Parallel()
-	for _, n := range []json.Number{"1", "0.5", "-1", "-0.5", "1e-3", "1e400"} {
-		if !Truthy(n) {
-			t.Errorf("Truthy(json.Number(%q)) = false, want true", n)
-		}
-	}
-}
-
-func TestTruthyNumberZeroAndNonZeroAreDistinguishable(t *testing.T) {
-	t.Parallel()
-	zero, one := Truthy(json.Number("0.00")), Truthy(json.Number("1"))
-	if zero == one {
-		t.Errorf("Truthy(json.Number(\"0.00\")) = Truthy(json.Number(\"1\")) = %v, want false and true", zero)
-	}
-}
-
-func TestTruthyMissingAndNullKeysAreFalse(t *testing.T) {
-	t.Parallel()
-	var record map[string]any
-	if err := json.Unmarshal([]byte(`{"present": 1, "explicit_null": null}`), &record); err != nil {
-		t.Fatal(err)
-	}
-	for _, key := range []string{"absent", "explicit_null"} {
-		if Truthy(Get(record, key)) {
-			t.Errorf("Truthy(Get(record, %q)) = true, want false", key)
-		}
-	}
-}
-
-func TestSHA256FileStreamsWithoutBufferingTheFile(t *testing.T) {
-	const size = 32 << 20
-	path := filepath.Join(t.TempDir(), "big.bin")
-	want := func() string {
-		data := bytes.Repeat([]byte("0123456789abcdef"), size/16)
-		if err := os.WriteFile(path, data, 0o600); err != nil {
-			t.Fatal(err)
-		}
-		return SHA256Bytes(data)
-	}()
-	var before, after runtime.MemStats
-	runtime.GC()
-	runtime.ReadMemStats(&before)
-	got, err := SHA256File(path)
-	runtime.ReadMemStats(&after)
-	if err != nil {
-		t.Fatal(err)
-	}
-	if got != want {
-		t.Errorf("SHA256File digest = %s, want %s", got, want)
-	}
-	if delta := after.TotalAlloc - before.TotalAlloc; delta > 1<<20 {
-		t.Errorf("SHA256File allocated %d bytes for a %d byte file, want under 1MiB", delta, size)
-	}
-}

package/engine/internal/overhaul/packet/packet_test.go

@@ -1,263 +0,0 @@
-package packet
-
-import (
-	"bytes"
-	"encoding/json"
-	"os"
-	"path/filepath"
-	"strings"
-	"testing"
-)
-
-func jsonString(s string) string {
-	b, _ := json.Marshal(s)
-	return string(b)
-}
-
-func runArea(t *testing.T) string {
-	t.Helper()
-	return filepath.Join(t.TempDir(), "full-1")
-}
-
-func writeArgs(run string, extra ...string) []string {
-	base := []string{"write", run, "TASK-1", "a1", "implementer",
-		"--phase", "REMEDIATING", "--lane", "backend", "--snapshot", "abc",
-		"--authorized-by", "APPROVAL-1", "--brief", "packets/BRIEF.md"}
-	return append(base, extra...)
-}
-
-func mustMkdir(t *testing.T, dir string) {
-	t.Helper()
-	if err := os.MkdirAll(dir, 0o700); err != nil {
-		t.Fatal(err)
-	}
-}
-
-func TestWriteThenLoadRoundTrip(t *testing.T) {
-	run := runArea(t)
-	mustMkdir(t, run)
-	var out, errb bytes.Buffer
-	if code := Run(writeArgs(run, "--write-path", "a.go", "--write-path", "b.go"), &out, &errb); code != 0 {
-		t.Fatalf("exit %d: %s", code, errb.String())
-	}
-	path := filepath.Join(run, "packets", "full-1__TASK-1__a1__implementer.json")
-	if got := strings.TrimSpace(out.String()); got != path {
-		t.Fatalf("printed %q, want %q", got, path)
-	}
-	p, err := Load(path)
-	if err != nil {
-		t.Fatal(err)
-	}
-	if p["receipt_path"] != filepath.Join(run, "receipts", "full-1__TASK-1__a1__implementer.json") {
-		t.Errorf("receipt_path = %v", p["receipt_path"])
-	}
-	if wp, _ := p["write_paths"].([]any); len(wp) != 2 || wp[0] != "a.go" || wp[1] != "b.go" {
-		t.Errorf("write_paths = %v", p["write_paths"])
-	}
-	if p["run_id"] != "full-1" || p["lane"] != "backend" || p["authorized_by"] != "APPROVAL-1" {
-		t.Errorf("fields not carried: %v", p)
-	}
-}
-
-func TestWriteRefusesToOverwrite(t *testing.T) {
-	run := runArea(t)
-	mustMkdir(t, run)
-	if code := Run(writeArgs(run), &bytes.Buffer{}, &bytes.Buffer{}); code != 0 {
-		t.Fatalf("first write exit %d", code)
-	}
-	path := filepath.Join(run, "packets", "full-1__TASK-1__a1__implementer.json")
-	before, _ := os.ReadFile(path)
-	var errb bytes.Buffer
-	if code := Run(writeArgs(run, "--lane", "frontend"), &bytes.Buffer{}, &errb); code != 1 {
-		t.Fatalf("second write exit %d, want 1", code)
-	}
-	if !strings.Contains(errb.String(), "already exists") {
-		t.Errorf("stderr = %q", errb.String())
-	}
-	if after, _ := os.ReadFile(path); !bytes.Equal(before, after) {
-		t.Error("existing packet was modified")
-	}
-	if ents, _ := os.ReadDir(filepath.Dir(path)); len(ents) != 1 {
-		t.Errorf("packets dir has %d entries, want 1", len(ents))
-	}
-}
-
-func TestWriteRejectsBadIDs(t *testing.T) {
-	for _, bad := range []string{"../x", "a/b", `a\b`, "..", "a__b"} {
-		run := runArea(t)
-		mustMkdir(t, run)
-		args := writeArgs(run)
-		args[2] = bad
-		var errb bytes.Buffer
-		if code := Run(args, &bytes.Buffer{}, &errb); code != 1 {
-			t.Errorf("task %q: exit %d, want 1", bad, code)
-		}
-		if _, err := os.Stat(filepath.Join(run, "packets")); err == nil {
-			t.Errorf("task %q: packets dir created", bad)
-		}
-	}
-}
-
-func TestWriteRejectsMissingFieldAndMissingRun(t *testing.T) {
-	run := runArea(t)
-	mustMkdir(t, run)
-	args := []string{"write", run, "TASK-1", "a1", "implementer", "--phase", "P"}
-	var errb bytes.Buffer
-	if code := Run(args, &bytes.Buffer{}, &errb); code != 1 || !strings.Contains(errb.String(), "missing or empty lane") {
-		t.Errorf("exit/stderr = %q", errb.String())
-	}
-	if code := Run(writeArgs(filepath.Join(t.TempDir(), "nope")), &bytes.Buffer{}, &bytes.Buffer{}); code != 2 {
-		t.Errorf("missing run area exit %d, want 2", code)
-	}
-}
-
-func TestFromFileSuppliesPlanAndFlagsOverride(t *testing.T) {
-	run := runArea(t)
-	mustMkdir(t, run)
-	from := filepath.Join(t.TempDir(), "extra.json")
-	if err := os.WriteFile(from, []byte(`{"lane":"other","plan":{"file":"revisions/plan-r1.json","rev":1},"write_paths":["x.go"]}`), 0o600); err != nil {
-		t.Fatal(err)
-	}
-	if code := Run(writeArgs(run, "--from", from), &bytes.Buffer{}, &bytes.Buffer{}); code != 0 {
-		t.Fatalf("exit %d", code)
-	}
-	p, err := Load(filepath.Join(run, "packets", "full-1__TASK-1__a1__implementer.json"))
-	if err != nil {
-		t.Fatal(err)
-	}
-	if p["lane"] != "backend" {
-		t.Errorf("lane = %v, flag should override file", p["lane"])
-	}
-	if wp, _ := p["write_paths"].([]any); len(wp) != 1 || wp[0] != "x.go" {
-		t.Errorf("write_paths = %v, want file value kept", p["write_paths"])
-	}
-	if p["plan"] == nil {
-		t.Error("plan from file lost")
-	}
-}
-
-func TestLoadRejectsMismatchedNameAndBadPlan(t *testing.T) {
-	run := runArea(t)
-	mustMkdir(t, run)
-	Run(writeArgs(run), &bytes.Buffer{}, &bytes.Buffer{})
-	src := filepath.Join(run, "packets", "full-1__TASK-1__a1__implementer.json")
-	b, _ := os.ReadFile(src)
-	moved := filepath.Join(run, "packets", "full-1__TASK-2__a1__implementer.json")
-	if err := os.WriteFile(moved, b, 0o600); err != nil {
-		t.Fatal(err)
-	}
-	if _, err := Load(moved); err == nil || !strings.Contains(err.Error(), "file name does not match") {
-		t.Errorf("Load of renamed packet: %v", err)
-	}
-	p := map[string]any{"plan": map[string]any{}}
-	if why := Validate("", p); !strings.Contains(strings.Join(why, ";"), "plan must be an object with a file") {
-		t.Errorf("Validate plan: %v", why)
-	}
-}
-
-func TestUsage(t *testing.T) {
-	var errb bytes.Buffer
-	if code := Run([]string{"write", "run"}, &bytes.Buffer{}, &errb); code != 2 || !strings.Contains(errb.String(), "usage:") {
-		t.Errorf("exit/stderr = %q", errb.String())
-	}
-}
-
-func TestWriteRejectsReceiptPathOutsideRunArea(t *testing.T) {
-	for i, bad := range []string{"/etc/evil.json", "../../outside/evil.json", "receipts/other.json", ""} {
-		run := runArea(t)
-		mustMkdir(t, run)
-		from := filepath.Join(t.TempDir(), "extra.json")
-		body := `{"receipt_path":"` + bad + `"}`
-		if err := os.WriteFile(from, []byte(body), 0o600); err != nil {
-			t.Fatal(err)
-		}
-		var errb bytes.Buffer
-		code := Run(writeArgs(run, "--from", from), &bytes.Buffer{}, &errb)
-		if bad == "" {
-			// An empty receipt_path falls back to the derived default.
-			if code != 0 {
-				t.Errorf("case %d: exit %d, want 0", i, code)
-			}
-			continue
-		}
-		if code != 1 || !strings.Contains(errb.String(), "receipt_path") {
-			t.Errorf("receipt_path %q: exit %d stderr %q, want 1 naming receipt_path", bad, code, errb.String())
-		}
-		if _, err := os.Stat(filepath.Join(run, "packets")); err == nil {
-			t.Errorf("receipt_path %q: packet written", bad)
-		}
-	}
-}
-
-func TestLoadRejectsReceiptPathOutsideRunArea(t *testing.T) {
-	run := runArea(t)
-	mustMkdir(t, run)
-	if code := Run(writeArgs(run), &bytes.Buffer{}, &bytes.Buffer{}); code != 0 {
-		t.Fatalf("exit %d", code)
-	}
-	path := filepath.Join(run, "packets", "full-1__TASK-1__a1__implementer.json")
-	if _, err := Load(path); err != nil {
-		t.Fatalf("derived receipt_path rejected: %v", err)
-	}
-	b, _ := os.ReadFile(path)
-	good := filepath.Join(run, "receipts", "full-1__TASK-1__a1__implementer.json")
-	for _, bad := range []string{"/etc/evil.json", "../../outside/evil.json", filepath.Join(run, "receipts", "..", "x.json")} {
-		// The packet is JSON, so match the encoded form (Windows paths carry escaped separators).
-		edited := strings.Replace(string(b), jsonString(good), jsonString(bad), 1)
-		if edited == string(b) {
-			t.Fatal("receipt_path not found in packet")
-		}
-		if err := os.WriteFile(path, []byte(edited), 0o600); err != nil {
-			t.Fatal(err)
-		}
-		if _, err := Load(path); err == nil || !strings.Contains(err.Error(), "receipt_path") {
-			t.Errorf("Load accepted receipt_path %q: %v", bad, err)
-		}
-	}
-}
-
-func TestWriteRefusesSymlinkedRunOrPacketsDir(t *testing.T) {
-	outside := t.TempDir()
-	base := t.TempDir()
-
-	linkedRun := filepath.Join(base, "full-1")
-	if err := os.Symlink(outside, linkedRun); err != nil {
-		t.Skip("symlinks unavailable:", err)
-	}
-	if code := Run(writeArgs(linkedRun), &bytes.Buffer{}, &bytes.Buffer{}); code != 2 {
-		t.Errorf("symlinked run dir: exit %d, want 2", code)
-	}
-	if ents, _ := os.ReadDir(outside); len(ents) != 0 {
-		t.Errorf("symlinked run dir: wrote %d entries outside", len(ents))
-	}
-
-	run := filepath.Join(base, "full-2")
-	mustMkdir(t, run)
-	if err := os.Symlink(outside, filepath.Join(run, "packets")); err != nil {
-		t.Fatal(err)
-	}
-	if code := Run(writeArgs(run), &bytes.Buffer{}, &bytes.Buffer{}); code != 2 {
-		t.Errorf("symlinked packets dir: exit %d, want 2", code)
-	}
-	if ents, _ := os.ReadDir(outside); len(ents) != 0 {
-		t.Errorf("symlinked packets dir: wrote %d entries outside", len(ents))
-	}
-}
-
-func TestWriteRejectsExtraPositionals(t *testing.T) {
-	for _, tc := range [][]string{
-		append(writeArgs("RUN"), "stray"),
-		append([]string{"write", "RUN", "TASK-1", "a1", "implementer", "stray"}, writeArgs("RUN")[5:]...),
-	} {
-		run := runArea(t)
-		mustMkdir(t, run)
-		tc[1] = run
-		var errb bytes.Buffer
-		if code := Run(tc, &bytes.Buffer{}, &errb); code != 2 || !strings.Contains(errb.String(), "unexpected argument") {
-			t.Errorf("%v: exit %d stderr %q, want 2 unexpected argument", tc[5:], code, errb.String())
-		}
-		if _, err := os.Stat(filepath.Join(run, "packets")); err == nil {
-			t.Errorf("%v: packet written", tc[5:])
-		}
-	}
-}