devrites 3.2.28 → 4.0.0

package/engine/tests/migrate_cli_test.go

@@ -1,195 +0,0 @@
-package main_test
-
-// CLI coverage for Issue 06: `migrate` workspace normalization.
-
-import (
-	"os"
-	"path/filepath"
-	"strings"
-	"testing"
-)
-
-// workWorkspace writes a canonical .devrites/work/<slug> workspace with one
-// feature and an ACTIVE pointer, and returns the .devrites root.
-func workWorkspace(t *testing.T) (root, slug string) {
-	t.Helper()
-	root = filepath.Join(t.TempDir(), ".devrites")
-	slug = "legacy-feat"
-	work := filepath.Join(root, "work", slug)
-	if err := os.MkdirAll(work, 0o755); err != nil {
-		t.Fatal(err)
-	}
-	files := map[string]string{
-		"state.md":     "# State\n\n| Key | Value |\n| --- | --- |\n| phase | temper |\n| status | running |\n",
-		"spec.md":      "# Spec\n\nRotate tokens.\n",
-		"plan.md":      "# Plan\n\nStep 1, step 2.\n",
-		"tasks.md":     "# Tasks\n\n- [x] one\n",
-		"evidence.md":  "# Evidence\n\nTests green.\n",
-		"decisions.md": "# Decisions\n\nUse HMAC.\n",
-	}
-	for name, body := range files {
-		if err := os.WriteFile(filepath.Join(work, name), []byte(body), 0o644); err != nil {
-			t.Fatal(err)
-		}
-	}
-	if err := os.WriteFile(filepath.Join(root, "ACTIVE"), []byte(slug+"\n"), 0o644); err != nil {
-		t.Fatal(err)
-	}
-	return root, slug
-}
-
-func backupDirs(t *testing.T, root string) []string {
-	t.Helper()
-	m, err := filepath.Glob(filepath.Join(root, ".migrate-backup-*"))
-	if err != nil {
-		t.Fatal(err)
-	}
-	return m
-}
-
-func TestMigrateNormalizesCanonicalWorkSchema(t *testing.T) {
-	root, slug := workWorkspace(t)
-	out, errOut, code := runDevrites(t, root, "migrate")
-	if code != 0 {
-		t.Fatalf("exit = %d, want 0 (stderr: %s)", code, errOut)
-	}
-	if !strings.Contains(out, "migrated 1 feature(s)") {
-		t.Errorf("unexpected migrate output\n%s", out)
-	}
-
-	feat := filepath.Join(root, "work", slug)
-	// Current canonical files stay canonical; migration adds only the missing map.
-	for _, want := range []string{"README.md", "state.md", "spec.md", "plan.md", "decisions.md", "tasks.md", "evidence.md"} {
-		if _, err := os.Stat(filepath.Join(feat, want)); err != nil {
-			t.Errorf("missing new-schema file %s: %v", want, err)
-		}
-	}
-	readme, err := os.ReadFile(filepath.Join(feat, "README.md"))
-	if err != nil {
-		t.Fatal(err)
-	}
-	if !strings.Contains(string(readme), "phase: temper") {
-		t.Errorf("README.md phase not derived from state.md\n%s", readme)
-	}
-	if !strings.Contains(string(readme), "schemaVersion: 2") {
-		t.Errorf("README.md missing schemaVersion\n%s", readme)
-	}
-	for _, unwanted := range []string{"feature.md", "proof.md", "status.md"} {
-		if _, err := os.Stat(filepath.Join(feat, unwanted)); !os.IsNotExist(err) {
-			t.Errorf("migration created legacy alias %s: %v", unwanted, err)
-		}
-	}
-
-	// A backup of the pre-migration state must exist.
-	if got := backupDirs(t, root); len(got) != 1 {
-		t.Errorf("want exactly one backup dir, got %v", got)
-	}
-}
-
-func TestMigratePostStatusWorks(t *testing.T) {
-	root, slug := workWorkspace(t)
-	if _, _, code := runDevrites(t, root, "migrate"); code != 0 {
-		t.Fatal("migrate failed")
-	}
-	out, errOut, code := runDevrites(t, root, "status", slug)
-	if code != 0 {
-		t.Fatalf("status after migrate exit = %d (stderr: %s)", code, errOut)
-	}
-	if !strings.Contains(out, "phase: temper") {
-		t.Errorf("migrated feature status is wrong\n%s", out)
-	}
-}
-
-func TestMigrateIsIdempotent(t *testing.T) {
-	root, _ := workWorkspace(t)
-	if _, _, code := runDevrites(t, root, "migrate"); code != 0 {
-		t.Fatal("first migrate failed")
-	}
-	before := backupDirs(t, root)
-
-	out, _, code := runDevrites(t, root, "migrate")
-	if code != 0 {
-		t.Fatalf("second migrate exit = %d, want 0", code)
-	}
-	if !strings.Contains(out, "already up to date") {
-		t.Errorf("second migrate was not a no-op\n%s", out)
-	}
-	// A no-op re-run must not create another backup.
-	if after := backupDirs(t, root); len(after) != len(before) {
-		t.Errorf("re-run created a new backup: before=%v after=%v", before, after)
-	}
-}
-
-func TestMigrateNormalizesLiveFeatureInPlace(t *testing.T) {
-	root := filepath.Join(t.TempDir(), ".devrites")
-	slug := "live-feat"
-	feat := filepath.Join(root, "features", slug)
-	if err := os.MkdirAll(feat, 0o755); err != nil {
-		t.Fatal(err)
-	}
-	files := map[string]string{
-		"feature.md":   "# Legacy feature map\n",
-		"status.md":    "# State\n\n- Phase: prove\n- Status: running\n",
-		"spec.md":      "# Spec\n\nRotate tokens.\n",
-		"plan.md":      "# Plan\n\nStep 1, step 2.\n",
-		"tasks.md":     "# Tasks\n\n- [x] one\n",
-		"proof.md":     "# Evidence\n\nTests green.\n",
-		"decisions.md": "# Decisions\n\nUse HMAC.\n",
-	}
-	for name, body := range files {
-		if err := os.WriteFile(filepath.Join(feat, name), []byte(body), 0o644); err != nil {
-			t.Fatal(err)
-		}
-	}
-
-	out, errOut, code := runDevrites(t, root, "migrate")
-	if code != 0 {
-		t.Fatalf("exit = %d, want 0 (stderr: %s)", code, errOut)
-	}
-	if !strings.Contains(out, "migrated 1 feature(s)") {
-		t.Errorf("unexpected migrate output\n%s", out)
-	}
-	for _, want := range []string{"README.md", "feature.md", "proof.md", "status.md", "state.md", "evidence.md"} {
-		if _, err := os.Stat(filepath.Join(feat, want)); err != nil {
-			t.Errorf("missing normalized file %s: %v", want, err)
-		}
-	}
-	readme, err := os.ReadFile(filepath.Join(feat, "README.md"))
-	if err != nil {
-		t.Fatal(err)
-	}
-	if !strings.Contains(string(readme), "Legacy feature map") {
-		t.Errorf("README.md did not carry feature.md content\n%s", readme)
-	}
-	stateFile, _ := os.ReadFile(filepath.Join(feat, "state.md"))
-	if !strings.Contains(string(stateFile), "running") {
-		t.Errorf("state.md did not carry status.md content\n%s", stateFile)
-	}
-	evidence, _ := os.ReadFile(filepath.Join(feat, "evidence.md"))
-	if !strings.Contains(string(evidence), "Tests green") {
-		t.Errorf("evidence.md did not carry proof.md content\n%s", evidence)
-	}
-	if got := backupDirs(t, root); len(got) != 1 {
-		t.Errorf("want exactly one backup dir, got %v", got)
-	}
-
-	out, errOut, code = runDevrites(t, root, "status", slug)
-	if code != 0 {
-		t.Fatalf("status after normalize exit = %d (stderr: %s)", code, errOut)
-	}
-	if !strings.Contains(out, "phase: prove") || !strings.Contains(out, "proof      present") || !strings.Contains(out, "status     present") {
-		t.Errorf("normalized feature status is wrong\n%s", out)
-	}
-
-	before := backupDirs(t, root)
-	out, _, code = runDevrites(t, root, "migrate")
-	if code != 0 {
-		t.Fatalf("second migrate exit = %d, want 0", code)
-	}
-	if !strings.Contains(out, "already up to date") {
-		t.Errorf("second migrate was not a no-op\n%s", out)
-	}
-	if after := backupDirs(t, root); len(after) != len(before) {
-		t.Errorf("re-run created a new backup: before=%v after=%v", before, after)
-	}
-}

package/engine/tests/parity_analyze_test.go

@@ -1,55 +0,0 @@
-package main_test
-
-import "testing"
-
-// TestParityAnalyze checks `analyze`'s coverage/consistency report against the
-// golden snapshots for each spec↔tasks fixture.
-func TestParityAnalyze(t *testing.T) {
-	work := t.TempDir()
-
-	// covered: every spec AC has a slice that Satisfies it → clear (exit 0).
-	writeFeatureFile(t, work, "covered", "spec.md", "# spec\n- [AC1] must foo\n")
-	writeFeatureFile(t, work, "covered", "tasks.md", "## Slice 1: foo\nSatisfies: AC1\n")
-
-	// uncovered: a spec AC no slice satisfies → CRITICAL (exit 1).
-	writeFeatureFile(t, work, "uncovered", "spec.md", "# spec\n- [AC1] must foo\n- [AC2] must bar\n")
-	writeFeatureFile(t, work, "uncovered", "tasks.md", "## Slice 1: foo\nSatisfies: AC1\n")
-
-	// dangling: a slice Satisfies an AC the spec never defines → CRITICAL (exit 1).
-	writeFeatureFile(t, work, "dangling", "spec.md", "# spec\n- [AC1] must foo\n")
-	writeFeatureFile(t, work, "dangling", "tasks.md", "## Slice 1: foo\nSatisfies: AC1, AC9\n")
-
-	// noac: spec has no [ACn] ids → warn, nothing dangling/orphan → clear (exit 0).
-	writeFeatureFile(t, work, "noac", "spec.md", "# spec\njust prose, no acceptance ids\n")
-	writeFeatureFile(t, work, "noac", "tasks.md", "# tasks\njust prose, no slices\n")
-
-	// orphan: a slice with no Satisfies line → warn, still clear (exit 0).
-	writeFeatureFile(t, work, "orphan", "spec.md", "# spec\n- [AC1] must foo\n")
-	writeFeatureFile(t, work, "orphan", "tasks.md",
-		"## Slice 1: foo\nSatisfies: AC1\n## Slice 2: bar\n- does stuff\n")
-
-	// order: byte-order sort must place AC10 before AC2 (LC_ALL=C), all covered.
-	writeFeatureFile(t, work, "order", "spec.md", "# spec\n- [AC1] a\n- [AC2] b\n- [AC10] c\n")
-	writeFeatureFile(t, work, "order", "tasks.md", "## Slice 1: all\nSatisfies: AC1, AC2, AC10\n")
-
-	// ghost: slug with no workspace → need spec.md+tasks.md (exit 2, empty stdout).
-
-	for _, slug := range []string{"covered", "uncovered", "dangling", "noac", "orphan", "order", "ghost"} {
-		c := parityCase{
-			workdir: work,
-			env:     libRootEnv(work),
-			goArgs:  []string{"analyze", slug},
-		}
-		t.Run("slug="+slug, func(t *testing.T) { c.assertEqual(t) })
-	}
-
-	// no active workspace: no slug arg and no .devrites/ACTIVE → exit 2, empty stdout.
-	noactive := t.TempDir()
-	t.Run("noactive", func(t *testing.T) {
-		(parityCase{
-			workdir: noactive,
-			env:     libRootEnv(noactive),
-			goArgs:  []string{"analyze"},
-		}).assertEqual(t)
-	})
-}

package/engine/tests/parity_buildreadiness_test.go

@@ -1,199 +0,0 @@
-package main_test
-
-// TestParityBuildReadiness checks the build-readiness gate's stdout and exit code
-// against the golden snapshot for each state.md fixture.
-
-import (
-	"fmt"
-	"os"
-	"path/filepath"
-	"strings"
-	"testing"
-
-	"github.com/devrites/devrites/internal/lib"
-)
-
-func TestParityBuildReadiness(t *testing.T) {
-	work := t.TempDir()
-
-	// Status halts write only to stderr; parity covers stdout and the exit code.
-	writeFeatureFile(t, work, "await", "state.md", "- Status: awaiting_human\n") // exit 3
-	writeFeatureFile(t, work, "blocked", "state.md", "- Status: blocked\n")      // exit 4
-
-	writeReadyArtifacts := func(slug string) {
-		t.Helper()
-		writeCoverageArtifacts(t, work, slug)
-		for name, body := range map[string]string{
-			"architecture.md": "# Architecture\n\nExisting layer.\n",
-			"plan.md":         "# Plan\n\nOne slice.\n",
-			"tasks.md":        "# Tasks\n\n## SLICE-001\nBuild.\n",
-			"traceability.md": "# Traceability\n\nAC-001 -> SLICE-001.\n",
-			"test-plan.md": `# Test plan
-
-DevRites contract: devrites.readiness-artifacts.v2
-
-## Build-entry preflight
-| Gate | Command | Cwd | Expected | Prerequisites | Provenance to recapture |
-| --- | --- | --- | --- | --- | --- |
-| unit | go test ./... | engine | exit 0 | none | go version |
-
-## Per-gap test requirements
-| ID | Path / flow | Test file | Asserts | Kind | Slice | Priority |
-| --- | --- | --- | --- | --- | --- | --- |
-| T1 | flow | flow_test.go | request → success | unit | SLICE-001 | P1 |
-
-## Acceptance → test map
-- AC-001 → T1
-`,
-		} {
-			writeFeatureFile(t, work, slug, name, body)
-		}
-		root := filepath.Join(work, ".devrites")
-		digest, err := lib.ReadinessInputDigest(root, slug, "engineering")
-		if err != nil {
-			t.Fatal(err)
-		}
-		writeFeatureFile(t, work, slug, "eng-review.md", fmt.Sprintf(`# Eng review
-
-DevRites contract: devrites.readiness-artifacts.v2
-Implementation readiness: READY
-Readiness inputs SHA-256: %s
-
-## 2a. Build-entry preflight
-| Gate | Command + cwd | Tool/version | Prerequisite owner | Full provenance inputs | Fixture/smoke | Verdict |
-| --- | --- | --- | --- | --- | --- | --- |
-| unit | go test ./... | go | none | go.mod | focused | pass |
-
-## 2b. Implementation readiness
-| Surface | Requirement/decision | Boundary/wiring | Slice | Proof | Verdict |
-| --- | --- | --- | --- | --- | --- |
-| flow | AC-001 | existing | SLICE-001 | T1 | ready |
-
-## 4. Failure modes
-| New codepath | Realistic failure | Test? | Handling? | Silent? | Verdict |
-| --- | --- | --- | --- | --- | --- |
-| flow | invalid | yes | yes | no | ok |
-
-## 7. Completion summary
-- Ready.
-`, digest))
-	}
-
-	// A ready feature has an approved plan, running status, and current
-	// clarification and vet artifacts.
-	for _, slug := range []string{"approved", "trailpipe", "trailhash", "emptystatus"} {
-		writeReadyArtifacts(slug)
-	}
-	writeFeatureFile(t, work, "approved", "state.md", "- Phase: vet\n- Plan approved: 2024-01-01\n- Status: running\n") // exit 0
-
-	// Plan not approved: missing line, or the literal "none".
-	writeCoverageArtifacts(t, work, "noapprove")
-	writeCoverageArtifacts(t, work, "approvenone")
-	writeFeatureFile(t, work, "noapprove", "state.md", "- Status: running\n")                          // exit 2
-	writeFeatureFile(t, work, "approvenone", "state.md", "- Plan approved: none\n- Status: running\n") // exit 2
-
-	// field() strip: a trailing " | none" / " # note" annotation is trimmed off
-	// Status before the case match, so both stay "running" and reach OK.
-	writeFeatureFile(t, work, "trailpipe", "state.md", "- Phase: vet\n- Plan approved: 2024-01-01\n- Status: running | none\n") // exit 0
-	writeFeatureFile(t, work, "trailhash", "state.md", "- Phase: vet\n- Plan approved: 2024-01-01\n- Status: running # note\n") // exit 0
-
-	// An empty Status with an approved plan renders as "running".
-	writeFeatureFile(t, work, "emptystatus", "state.md", "- Phase: vet\n- Plan approved: 2024-01-01\n- Status: \n") // exit 0
-
-	// A plan cannot build without an explicit closed clarification scan and a
-	// successful engineering-readiness verdict. These are objective routes, not
-	// human questions.
-	writeFeatureFile(t, work, "noclarify", "state.md", "- Phase: vet\n- Plan approved: 2024-01-01\n- Status: running\n") // exit 6
-
-	writeFeatureFile(t, work, "clarifyopen", "state.md", "- Phase: vet\n- Plan approved: 2024-01-01\n- Status: running\n") // exit 6
-	writeFeatureFile(t, work, "clarifyopen", "brief.md", "# Brief\n\nOutcome.\n")
-	writeFeatureFile(t, work, "clarifyopen", "spec.md", "# Spec\n\nAC-001.\n")
-	writeFeatureFile(t, work, "clarifyopen", "decision-coverage.md", "# Decision coverage\n\n- Decision coverage: NEEDS CLARIFICATION\n")
-
-	writeFeatureFile(t, work, "novet", "state.md", "- Phase: plan\n- Plan approved: 2024-01-01\n- Status: running\n") // exit 7
-	writeCoverageArtifacts(t, work, "novet")
-
-	writeFeatureFile(t, work, "vetnotready", "state.md", "- Phase: vet\n- Plan approved: 2024-01-01\n- Status: running\n") // exit 7
-	writeCoverageArtifacts(t, work, "vetnotready")
-	writeFeatureFile(t, work, "vetnotready", "eng-review.md", "# Engineering review\n\n- Implementation readiness: NEEDS REPLAN\n")
-
-	writeReadyArtifacts("stalevet")
-	writeFeatureFile(t, work, "stalevet", "state.md", "- Phase: plan\n- Plan approved: 2024-01-01\n- Status: running\n") // exit 7
-
-	writeCoverageArtifacts(t, work, "legacycontract")
-	writeFeatureFile(t, work, "legacycontract", "state.md", "- Phase: vet\n- Plan approved: 2024-01-01\n- Status: running\n") // exit 8
-	legacyCoverage := filepath.Join(work, ".devrites", "features", "legacycontract", "decision-coverage.md")
-	replaceInFile(t, legacyCoverage, "DevRites contract: devrites.readiness-artifacts.v2\n", "")
-
-	// "ghost" is intentionally never created → no workspace/state.md (exit 5).
-	for _, arg := range []string{
-		"await", "blocked", "approved", "noapprove", "approvenone",
-		"trailpipe", "trailhash", "emptystatus", "noclarify", "clarifyopen",
-		"novet", "vetnotready", "stalevet", "legacycontract", "ghost",
-	} {
-		c := parityCase{
-			workdir: work,
-			env:     libRootEnv(work),
-			goArgs:  []string{"build-readiness", arg},
-		}
-		t.Run("arg="+arg, func(t *testing.T) { c.assertEqual(t) })
-	}
-}
-
-func replaceInFile(t *testing.T, path, old, replacement string) {
-	t.Helper()
-	data, err := os.ReadFile(path)
-	if err != nil {
-		t.Fatal(err)
-	}
-	body := string(data)
-	if strings.Count(body, old) != 1 {
-		t.Fatalf("%s: expected exactly one %q", path, old)
-	}
-	if err := os.WriteFile(path, []byte(strings.Replace(body, old, replacement, 1)), 0o644); err != nil {
-		t.Fatal(err)
-	}
-}
-
-func writeCoverageArtifacts(t *testing.T, work, slug string) {
-	t.Helper()
-	writeFeatureFile(t, work, slug, "brief.md", "# Brief\n\nOutcome.\n")
-	writeFeatureFile(t, work, slug, "spec.md", "# Spec\n\n## Acceptance criteria\n- AC-001 succeeds.\n")
-	writeFeatureFile(t, work, slug, "decisions.md", "# Decisions\n\nNo open product decisions.\n")
-	writeFeatureFile(t, work, slug, "assumptions.md", "# Assumptions\n\nNo material assumptions.\n")
-	writeFeatureFile(t, work, slug, "questions.md", "# Questions\n\nNone.\n")
-	root := filepath.Join(work, ".devrites")
-	digest, err := lib.ReadinessInputDigest(root, slug, "coverage")
-	if err != nil {
-		t.Fatal(err)
-	}
-	writeFeatureFile(t, work, slug, "decision-coverage.md", fmt.Sprintf(`# Decision coverage
-
-DevRites contract: devrites.readiness-artifacts.v2
-Decision coverage: CLEAR
-Coverage inputs SHA-256: %s
-
-## Topology
-| Surface | Kind | Related IDs | Evidence |
-| --- | --- | --- | --- |
-| flow | behavior | AC-001 | spec.md |
-
-## Coverage matrix
-| Surface | Dimension | Status | Canonical reference | Owner / validation gate | Consequence if wrong |
-| --- | --- | --- | --- | --- | --- |
-| flow | behavior | closed | AC-001 | rite-prove | failure |
-
-## Assumption audit
-| Assumption | Evidence | Confidence | Owner | Validation | Consequence if wrong |
-| --- | --- | --- | --- | --- | --- |
-| none | n/a | high | n/a | n/a | n/a |
-
-## Residual uncertainty
-| Item | Why nonblocking | Owner | Validation gate |
-| --- | --- | --- | --- |
-| none | n/a | n/a | n/a |
-
-## Readiness verdict
-No unresolved decision remains.
-`, digest))
-}

package/engine/tests/parity_learnings_test.go

@@ -1,89 +0,0 @@
-package main_test
-
-// TestParityLearnings checks the learnings command against the golden snapshots.
-// Learning state lives at the root selected by DEVRITES_ROOT. The mine and nudge
-// fixtures use counts of 3 and 2 so sorting never depends on a platform-specific
-// tie.
-
-import (
-	"path/filepath"
-	"testing"
-)
-
-func TestParityLearnings(t *testing.T) {
-	learn := func(a ...string) []string { return append([]string{"learnings"}, a...) }
-
-	// Add to a fresh workspace. Bash creates the ledger and a dated entry, then Go
-	// appends another. Only stdout ("learnings: recorded.") and exit 0 belong to
-	// the contract because the dated file entry is nondeterministic.
-	addw := t.TempDir()
-	mkdirAllT(t, addw, ".devrites")
-	t.Run("add", func(t *testing.T) {
-		(parityCase{
-			workdir: addw, env: libRootEnv(addw),
-			goArgs: learn("add", "my-slug", "a recurring correction", "note"),
-		}).assertEqual(t)
-	})
-
-	// List a prepared ledger. Both implementations print the file unchanged.
-	listw := t.TempDir()
-	writeFile(t, listw, filepath.Join(".devrites", "learnings.md"),
-		"# DevRites learnings ledger\n\n"+
-			"- [2026-01-01] (note · feat-x) prefer explicit error handling\n"+
-			"- [2026-01-02] (bug · feat-y) the linter false-positive recurs\n")
-	t.Run("list", func(t *testing.T) {
-		(parityCase{
-			workdir: listw, env: libRootEnv(listw),
-			goArgs: learn("list"),
-		}).assertEqual(t)
-	})
-
-	// Mine and nudge use two archived features. Normalization strips IDs, paths,
-	// and numbers, so "recurring finding" has count 3 and "second dead end" has
-	// count 2. The distinct counts keep sort order stable.
-	arch := t.TempDir()
-	writeFile(t, arch, filepath.Join(".devrites", "archive", "feat-a", "decisions.md"),
-		"# decisions for feat-a\n"+
-			"- recurring finding: stale cache after deploy 3 times on `foo.js`\n"+
-			"- recurring finding: stale cache after deploy 8 times on `baz.ts`\n"+
-			"- second dead end: retry backoff exceeded 5 attempts\n"+
-			"some prose line that does not match the grep at all\n")
-	writeFile(t, arch, filepath.Join(".devrites", "archive", "feat-b", "decisions.md"),
-		"# decisions for feat-b\n"+
-			"- recurring finding: stale cache after deploy 7 times on `bar.js`\n"+
-			"- second dead end: retry backoff exceeded 9 attempts\n"+
-			"- a one-off dismiss note about the flaky linter run\n")
-
-	// Both implementations resolve the default archive to the same directory.
-	t.Run("mine", func(t *testing.T) {
-		(parityCase{
-			workdir: arch, env: libRootEnv(arch),
-			goArgs: learn("mine"),
-		}).assertEqual(t)
-	})
-
-	// Both implementations resolve an explicit relative path against workdir, so
-	// the missing path in the message is identical.
-	t.Run("mine-no-archive", func(t *testing.T) {
-		(parityCase{
-			workdir: arch, env: libRootEnv(arch),
-			goArgs: learn("mine", "no-such-archive"),
-		}).assertEqual(t)
-	})
-
-	// Two features, three occurrences, and no review marker produce a nudge.
-	t.Run("nudge", func(t *testing.T) {
-		(parityCase{
-			workdir: arch, env: libRootEnv(arch),
-			goArgs: learn("nudge"),
-		}).assertEqual(t)
-	})
-
-	// An unknown command writes usage to stderr and exits 2 without stdout.
-	t.Run("unknown", func(t *testing.T) {
-		(parityCase{
-			workdir: arch, env: libRootEnv(arch),
-			goArgs: learn("bogus"),
-		}).assertEqual(t)
-	})
-}

package/engine/tests/parity_mutationgate_test.go

@@ -1,36 +0,0 @@
-package main_test
-
-import (
-	"path/filepath"
-	"testing"
-)
-
-// TestParityMutationGate runs mutation-gate in a NON-git temp dir with no
-// manifests so it resolves gitroot="" and detects no runner: the deterministic
-// advisory-skip path, and checks stdout + exit against the golden snapshot. (If
-// the host happens to have a runner on PATH, it is detected via the same lookup,
-// so the golden check still holds.)
-func TestParityMutationGate(t *testing.T) {
-	work := t.TempDir()
-
-	// The workspace directory must exist for the gate to proceed past its exit-2.
-	makeFeatureDir(t, work, "feat")
-	writeFile(t, work, filepath.Join(".devrites", "ACTIVE"), "feat\n")
-
-	cases := []struct {
-		name string
-		slug []string // extra args after the subcommand
-	}{
-		{"explicit-slug", []string{"feat"}},
-		{"active-slug", nil},         // resolves slug from ACTIVE
-		{"ghost", []string{"ghost"}}, // no workspace -> exit 2
-	}
-	for _, tc := range cases {
-		c := parityCase{
-			workdir: work,
-			env:     libRootEnv(work),
-			goArgs:  append([]string{"mutation-gate"}, tc.slug...),
-		}
-		t.Run(tc.name, func(t *testing.T) { c.assertEqual(t) })
-	}
-}

package/engine/tests/parity_reconcile_test.go

@@ -1,94 +0,0 @@
-package main_test
-
-import (
-	"fmt"
-	"strings"
-	"testing"
-)
-
-// TestParityReconcile checks reconcile against the golden snapshots: snapshot
-// captures the worktree as a tree object, check diffs it and flags changes
-// outside the orchestrator-authored allowlist, and close ends the retained
-// post-slice baseline. It runs Git in a real repository, so stdout and exit are
-// captured from the live command.
-func TestParityReconcile(t *testing.T) {
-	requireGit(t)
-
-	newRepo := func(t *testing.T) string {
-		t.Helper()
-		work := t.TempDir()
-		initGitRepo(t, work)
-		writeFile(t, work, "src/a.js", "console.log(1)\n")
-		writeFile(t, work, "src/b.js", "console.log(2)\n")
-		gitCommitAll(t, work, "baseline")
-		makeFeatureDir(t, work, "feat")
-		return work
-	}
-	// snapshot is also a setup step for the check-* cases, so it snapshots under a
-	// distinct key to avoid colliding with check's golden in the same subtest.
-	snapshot := func(t *testing.T, work string, allowed ...string) {
-		body := ""
-		if len(allowed) > 0 {
-			body = strings.Join(allowed, "\n") + "\n"
-		}
-		writeFeatureFile(t, work, "feat", ".wright-allowlist", body)
-		out, code := runArgv(t, work, libRootEnv(work), "", binPath, "reconcile", "snapshot", "feat")
-		assertGoldenKey(t, t.Name()+"/snapshot", fmt.Sprintf("exit %d\n%s", code, out))
-	}
-	check := func(t *testing.T, work string) {
-		out, code := runArgv(t, work, libRootEnv(work), "", binPath, "reconcile", "check", "feat")
-		assertGolden(t, out, code)
-	}
-
-	t.Run("snapshot", func(t *testing.T) { snapshot(t, newRepo(t)) })
-
-	t.Run("check-clean", func(t *testing.T) {
-		work := newRepo(t)
-		snapshot(t, work, "src/a.js")
-		writeFile(t, work, "src/a.js", "console.log(999)\n") // the wright's change
-		check(t, work)
-	})
-
-	t.Run("check-violation", func(t *testing.T) {
-		work := newRepo(t)
-		snapshot(t, work, "src/a.js")
-		writeFile(t, work, "src/a.js", "console.log(999)\n")
-		writeFile(t, work, "src/b.js", "console.log(888)\n") // Outside the allowlist; an A1 breach.
-		check(t, work)
-	})
-
-	t.Run("check-no-base", func(t *testing.T) {
-		work := newRepo(t)
-		check(t, work) // No snapshot, so exit 6.
-	})
-
-	t.Run("snapshot-no-allowlist", func(t *testing.T) {
-		work := newRepo(t)
-		out, code := runArgv(t, work, libRootEnv(work), "", binPath, "reconcile", "snapshot", "feat")
-		assertGolden(t, out, code)
-	})
-
-	t.Run("close-window", func(t *testing.T) {
-		work := newRepo(t)
-		snapshot(t, work)
-		if out, code := runArgv(t, work, libRootEnv(work), "", binPath, "reconcile", "check", "feat"); code != 0 {
-			t.Fatalf("pre-close reconcile check = %d, want 0\n%s", code, out)
-		}
-		out, code := runArgv(t, work, libRootEnv(work), "", binPath, "reconcile", "close", "feat")
-		assertGolden(t, out, code)
-	})
-
-	t.Run("not-git", func(t *testing.T) {
-		work := t.TempDir()
-		makeFeatureDir(t, work, "feat")
-		check(t, work) // fail closed outside Git
-	})
-
-	t.Run("bad-mode", func(t *testing.T) {
-		work := newRepo(t)
-		(parityCase{
-			workdir: work, env: libRootEnv(work),
-			goArgs: []string{"reconcile", "bogus", "feat"},
-		}).assertEqual(t)
-	})
-}