devrites 6.0.4 → 6.1.0

package/engine/internal/gate/gate_test.go

@@ -1,865 +0,0 @@
-package gate
-
-import (
-	"os"
-	"path/filepath"
-	"slices"
-	"strings"
-	"testing"
-
-	"github.com/devrites/devrites/internal/reason"
-	"github.com/devrites/devrites/internal/state"
-	"github.com/devrites/devrites/internal/testutil"
-)
-
-func TestCheckBlocksCyclicTaskGraphWhenTasksAreRequired(t *testing.T) {
-	root := t.TempDir()
-	workspace := writeReadinessFixture(t, root, "cyclic", "build")
-	testutil.WriteFile(t, filepath.Join(workspace, "tasks.md"), `# Tasks
-
-## SLICE-001 A
-Dependencies: SLICE-002
-
-## SLICE-002 B
-Dependencies: SLICE-001
-`)
-	binding := mustReadinessBinding(t, root, "cyclic")
-	testutil.AppendFile(t, filepath.Join(workspace, "eng-review.md"), "\n"+binding+"\n")
-
-	res, err := Check(Readiness, root, "cyclic")
-	if err != nil {
-		t.Fatal(err)
-	}
-	if !res.Blocked || res.ReasonID != reason.GateReadinessMissing {
-		t.Fatalf("blocked=%v reason=%q, want blocked missing", res.Blocked, res.ReasonID)
-	}
-	joined := strings.Join(res.StateProblems, "\n")
-	if !strings.Contains(joined, "task-graph: dependency cycle:") {
-		t.Fatalf("StateProblems=%q", joined)
-	}
-	if !strings.Contains(res.Render(), "result: blocked (state invariant)") {
-		t.Fatalf("Render()=\n%s", res.Render())
-	}
-}
-
-func TestCheckBlocksCyclicTaskGraphAtSeal(t *testing.T) {
-	root := t.TempDir()
-	writeCompleteGateFeature(t, root, "cyclic-seal", state.PhaseSeal, state.PhaseSeal, "none\n")
-	workspace := filepath.Join(root, "work", "cyclic-seal")
-	testutil.WriteFile(t, filepath.Join(workspace, "tasks.md"), `# Tasks
-
-## SLICE-001 A
-Dependencies: SLICE-002
-
-## SLICE-002 B
-Dependencies: SLICE-001
-`)
-	binding := mustReadinessBinding(t, root, "cyclic-seal")
-	testutil.AppendFile(t, filepath.Join(workspace, "eng-review.md"), "\n"+binding+"\n")
-
-	res, err := Check(Seal, root, "cyclic-seal")
-	if err != nil {
-		t.Fatal(err)
-	}
-	if !res.Blocked || res.ReasonID != reason.GateSealMissing {
-		t.Fatalf("blocked=%v reason=%q, want blocked %s", res.Blocked, res.ReasonID, reason.GateSealMissing)
-	}
-	joined := strings.Join(res.StateProblems, "\n")
-	if !strings.Contains(joined, "task-graph: dependency cycle:") {
-		t.Fatalf("StateProblems=%q", joined)
-	}
-	if !strings.Contains(res.Render(), "result: blocked (state invariant)") {
-		t.Fatalf("Render()=\n%s", res.Render())
-	}
-}
-
-func TestCheckBlocksMalformedTaskGraphInsteadOfDroppingTokens(t *testing.T) {
-	root := t.TempDir()
-	workspace := writeReadinessFixture(t, root, "malformed", "define")
-	testutil.WriteFile(t, filepath.Join(workspace, "tasks.md"), `# Tasks
-
-## SLICE-001 Ready
-Dependencies: none
-
-## SLICE-002 Next
-Dependencies: SLICE-001 and later
-`)
-
-	res, err := Check(Readiness, root, "malformed")
-	if err != nil {
-		t.Fatal(err)
-	}
-	if !res.Blocked {
-		t.Fatal("expected malformed dependency to block readiness")
-	}
-	joined := strings.Join(res.StateProblems, "\n")
-	if !strings.Contains(joined, `malformed dependency "and"`) || !strings.Contains(joined, `malformed dependency "later"`) {
-		t.Fatalf("StateProblems=%q", joined)
-	}
-}
-
-func TestCheckBlocksMissingDependenciesInsteadOfTreatingSliceAsIndependent(t *testing.T) {
-	root := t.TempDir()
-	workspace := writeReadinessFixture(t, root, "nodeps", "define")
-	testutil.WriteFile(t, filepath.Join(workspace, "tasks.md"), `# Tasks
-
-## SLICE-001 Ready
-Goal: looks complete without an ordering field
-`)
-
-	res, err := Check(Readiness, root, "nodeps")
-	if err != nil {
-		t.Fatal(err)
-	}
-	if !res.Blocked {
-		t.Fatal("expected missing Dependencies to block readiness")
-	}
-	joined := strings.Join(res.StateProblems, "\n")
-	if !strings.Contains(joined, "SLICE-001 is missing Dependencies") {
-		t.Fatalf("StateProblems=%q", joined)
-	}
-}
-
-func TestCheckAndRenderReadiness(t *testing.T) {
-	root := t.TempDir()
-	writeFeature(t, root, "alpha", map[string]string{
-		"state.md":             "- Phase: build\n- Schema: 4\n",
-		"brief.md":             "brief\n",
-		"spec.md":              "real spec\n",
-		"assumptions.md":       "none\n",
-		"questions.md":         "none\n",
-		"decision-coverage.md": "clear\n",
-		"architecture.md":      "architecture\n",
-		"plan.md":              "real plan\n",
-		"traceability.md":      "traceability\n",
-		"eng-review.md":        "ready\n",
-		"test-plan.md":         "tests\n",
-		"gates.md":             testutil.CanonicalGatesMarkdown,
-	})
-
-	res, err := Check(Readiness, root, "alpha")
-	if err != nil {
-		t.Fatal(err)
-	}
-	if !res.Blocked {
-		t.Fatalf("Check blocked=false, want true")
-	}
-	if res.ReasonID != reason.GateReadinessMissing {
-		t.Fatalf("Check reason=%q, want %q", res.ReasonID, reason.GateReadinessMissing)
-	}
-	got := res.Render()
-	for _, want := range []string{
-		"gate: readiness",
-		"feature: alpha",
-		"phase: build",
-		"reason: DRV-GATE-READINESS-MISSING",
-		`result: blocked (missing to leave "build": decisions.md, tasks.md)`,
-		"retry: devrites-engine check readiness alpha",
-	} {
-		if !strings.Contains(got, want) {
-			t.Fatalf("Render() missing %q in:\n%s", want, got)
-		}
-	}
-}
-
-func TestCheckUsesConcreteWorkspaceRequirements(t *testing.T) {
-	root := t.TempDir()
-	files := map[string]string{
-		"state.md":             "| phase | vet |\n| schema | 4 |\n",
-		"brief.md":             "brief\n",
-		"spec.md":              "spec\n",
-		"decisions.md":         "decisions\n",
-		"assumptions.md":       "assumptions\n",
-		"questions.md":         "none\n",
-		"decision-coverage.md": "clear\n",
-		"architecture.md":      "architecture\n",
-		"plan.md":              "plan\n",
-		"tasks.md":             "tasks\n",
-		"traceability.md":      "traceability\n",
-		"eng-review.md":        "ready\n",
-		"test-plan.md":         "", // an empty required file must not satisfy the gate
-		"gates.md":             testutil.CanonicalGatesMarkdown,
-	}
-	writeWorkFeature(t, root, "concrete", files)
-
-	res, err := Check(Readiness, root, "concrete")
-	if err != nil {
-		t.Fatal(err)
-	}
-	if !res.Blocked || strings.Join(res.MissingFiles, ",") != "test-plan.md" {
-		t.Fatalf("blocked=%v missing=%v, want only test-plan.md", res.Blocked, res.MissingFiles)
-	}
-}
-
-func TestSealRequiresDurableReviewAndSealArtifacts(t *testing.T) {
-	root := t.TempDir()
-	files := map[string]string{
-		"state.md":             "| phase | seal |\n| schema | 4 |\n",
-		"brief.md":             "brief\n",
-		"spec.md":              "spec\n",
-		"decisions.md":         "decisions\n",
-		"assumptions.md":       "assumptions\n",
-		"questions.md":         "none\n",
-		"decision-coverage.md": "clear\n",
-		"architecture.md":      "architecture\n",
-		"plan.md":              "plan\n",
-		"tasks.md":             "tasks\n",
-		"traceability.md":      "traceability\n",
-		"eng-review.md":        "ready\n",
-		"test-plan.md":         "tests\n",
-		"gates.md":             testutil.CanonicalGatesMarkdown,
-		"evidence.md":          "evidence\n",
-		"touched-files.md":     "none\n",
-	}
-	writeWorkFeature(t, root, "final", files)
-
-	res, err := Check(Seal, root, "final")
-	if err != nil {
-		t.Fatal(err)
-	}
-	if !res.Blocked || strings.Join(res.MissingFiles, ",") != "review.md,seal.md" {
-		t.Fatalf("blocked=%v missing=%v, want review.md and seal.md", res.Blocked, res.MissingFiles)
-	}
-}
-
-func TestCheckReturnsMissingSectionsInSelectedPolicyOrder(t *testing.T) {
-	tests := []struct {
-		name           string
-		kind           Kind
-		current        state.Phase
-		required       state.Phase
-		emptyArtifacts []string
-		wantMissing    []state.Section
-	}{
-		{
-			name:           "readiness",
-			kind:           Readiness,
-			current:        state.PhaseBuild,
-			required:       state.PhaseBuild,
-			emptyArtifacts: []string{"tasks.md", "spec.md"},
-			wantMissing:    []state.Section{state.SectionSpec, state.SectionTasks},
-		},
-		{
-			name:           "seal",
-			kind:           Seal,
-			current:        state.PhaseSpec,
-			required:       state.PhaseSeal,
-			emptyArtifacts: []string{state.EvidenceFile, "tasks.md"},
-			wantMissing:    []state.Section{state.SectionTasks, state.SectionProof},
-		},
-	}
-
-	for _, test := range tests {
-		t.Run(test.name, func(t *testing.T) {
-			root := t.TempDir()
-			writeCompleteGateFeature(t, root, test.name, test.current, test.required, "none\n")
-			for _, name := range test.emptyArtifacts {
-				testutil.WriteFile(t, filepath.Join(root, "work", test.name, name), "# Empty\n")
-			}
-
-			result, err := Check(test.kind, root, test.name)
-			if err != nil {
-				t.Fatal(err)
-			}
-			if !slices.Equal(result.Missing, test.wantMissing) {
-				t.Fatalf("Missing=%v, want %v", result.Missing, test.wantMissing)
-			}
-		})
-	}
-}
-
-func TestRenderIncludesReasonForPassedGate(t *testing.T) {
-	result := Result{
-		Kind:     Seal,
-		Slug:     "alpha",
-		Phase:    "seal",
-		ReasonID: reason.GateSealPassed,
-	}
-	got := result.Render()
-	for _, want := range []string{"result: pass", "reason: DRV-GATE-SEAL-PASSED"} {
-		if !strings.Contains(got, want) {
-			t.Fatalf("Render() missing %q in:\n%s", want, got)
-		}
-	}
-}
-
-func TestResultReasonIDsAreStableForEveryGateOutcome(t *testing.T) {
-	cases := []struct {
-		kind    Kind
-		blocked bool
-		want    reason.ID
-	}{
-		{Readiness, false, reason.GateReadinessPassed},
-		{Readiness, true, reason.GateReadinessMissing},
-		{Seal, false, reason.GateSealPassed},
-		{Seal, true, reason.GateSealMissing},
-	}
-	for _, tc := range cases {
-		if got := ResultReasonID(tc.kind, tc.blocked); got != tc.want {
-			t.Fatalf("ResultReasonID(%q, %v)=%q, want %q", tc.kind, tc.blocked, got, tc.want)
-		}
-	}
-}
-
-func TestStateAwaitingHumanReadsCanonicalCursor(t *testing.T) {
-	data := []byte("| Key | Value |\n| --- | --- |\n| status | awaiting_human |\n")
-	if !stateAwaitingHuman(data) {
-		t.Fatal("stateAwaitingHuman ignored canonical cursor table")
-	}
-}
-
-func TestCheckAppliesOpenQuestionsByTargetPolicy(t *testing.T) {
-	const openQuestion = "## q-1\nstatus: open\ngate: blocking\n"
-	cases := []struct {
-		name          string
-		kind          Kind
-		current       state.Phase
-		required      state.Phase
-		wantTarget    state.Phase
-		wantBlocked   bool
-		wantReason    reason.ID
-		wantInvariant string
-	}{
-		{name: "frame readiness", kind: Readiness, current: state.PhaseFrame, required: state.PhaseFrame, wantTarget: state.PhaseFrame, wantReason: reason.GateReadinessPassed},
-		{name: "spec readiness", kind: Readiness, current: state.PhaseSpec, required: state.PhaseSpec, wantTarget: state.PhaseSpec, wantReason: reason.GateReadinessPassed},
-		{name: "clarify readiness", kind: Readiness, current: state.PhaseClarify, required: state.PhaseClarify, wantTarget: state.PhaseClarify, wantBlocked: true, wantReason: reason.GateReadinessMissing, wantInvariant: "open blocking human question(s) remain in questions.md but state.md is not awaiting_human"},
-		{name: "seal from spec", kind: Seal, current: state.PhaseSpec, required: state.PhaseSeal, wantTarget: state.PhaseSeal, wantBlocked: true, wantReason: reason.GateSealMissing, wantInvariant: "open blocking human question(s) remain in questions.md but state.md is not awaiting_human"},
-	}
-
-	for _, tc := range cases {
-		t.Run(tc.name, func(t *testing.T) {
-			root := t.TempDir()
-			writeCompleteGateFeature(t, root, "phase-policy", tc.current, tc.required, openQuestion)
-			if tc.kind == Seal {
-				binding, err := ReadinessBinding(root, "phase-policy")
-				if err != nil {
-					t.Fatal(err)
-				}
-				testutil.AppendFile(t, filepath.Join(root, "work", "phase-policy", "eng-review.md"), "\n"+binding+"\n")
-			}
-
-			got, err := Check(tc.kind, root, "phase-policy")
-			if err != nil {
-				t.Fatal(err)
-			}
-			if got.Target != tc.wantTarget || got.Blocked != tc.wantBlocked || got.ReasonID != tc.wantReason {
-				t.Fatalf("target=%q blocked=%v reason=%q, want target=%q blocked=%v reason=%q", got.Target, got.Blocked, got.ReasonID, tc.wantTarget, tc.wantBlocked, tc.wantReason)
-			}
-			if tc.wantInvariant == "" {
-				if len(got.StateProblems) != 0 {
-					t.Fatalf("StateProblems=%v, want none", got.StateProblems)
-				}
-			} else if strings.Join(got.StateProblems, "\n") != tc.wantInvariant {
-				t.Fatalf("StateProblems=%q, want %q", got.StateProblems, tc.wantInvariant)
-			}
-		})
-	}
-}
-
-func TestCheckBlocksOpenHumanQuestions(t *testing.T) {
-	for _, tc := range []struct {
-		name             string
-		status           string
-		wantInvariantSub string
-	}{
-		{
-			name:             "unsurfaced gate",
-			status:           "running",
-			wantInvariantSub: "state.md is not awaiting_human",
-		},
-		{
-			name:             "surfaced gate",
-			status:           "awaiting_human",
-			wantInvariantSub: "open blocking/validating human question(s) remain",
-		},
-	} {
-		t.Run(tc.name, func(t *testing.T) {
-			root := t.TempDir()
-			writeFeature(t, root, "alpha", map[string]string{
-				"state.md":     "- Phase: build\n- Status: " + tc.status + "\n- Schema: 4\n",
-				"spec.md":      "spec\n",
-				"plan.md":      "plan\n",
-				"decisions.md": "decisions\n",
-				"tasks.md":     "tasks\n",
-				"questions.md": "## q-1\nstatus: open\ngate: blocking\n\n## q-2\nstatus: open\ngate: validating\n",
-			})
-
-			got, err := Check(Readiness, root, "alpha")
-			if err != nil {
-				t.Fatal(err)
-			}
-			if !got.Blocked {
-				t.Fatal("Check blocked=false, want true")
-			}
-			invariants := strings.Join(got.StateProblems, "\n")
-			if !strings.Contains(invariants, tc.wantInvariantSub) {
-				t.Fatalf("StateProblems=%q, want substring %q", invariants, tc.wantInvariantSub)
-			}
-			if got.ReasonID != reason.GateReadinessMissing {
-				t.Fatalf("reason_id=%q, want %q", got.ReasonID, reason.GateReadinessMissing)
-			}
-		})
-	}
-}
-
-func TestCheckUsesWorkspaceOverrideForStateInvariants(t *testing.T) {
-	project := t.TempDir()
-	root := filepath.Join(project, ".devrites")
-	if err := os.MkdirAll(root, 0o755); err != nil {
-		t.Fatal(err)
-	}
-	physicalRoot, err := filepath.EvalSymlinks(root)
-	if err != nil {
-		t.Fatal(err)
-	}
-	override := filepath.Join(physicalRoot, "work", "alpha")
-	t.Setenv("DEVRITES_WORKSPACE", override)
-	testutil.WriteFile(t, filepath.Join(override, "README.md"), "---\nphase: spec\nschemaVersion: 1\n---\n")
-	testutil.WriteFile(t, filepath.Join(override, "state.md"), "- Phase: build\n- Status: running\n- Schema: 4\n")
-	testutil.WriteFile(t, filepath.Join(override, "spec.md"), "spec\n")
-	testutil.WriteFile(t, filepath.Join(override, "questions.md"), "## q-1\nstatus: open\ngate: blocking\n")
-
-	got, err := Check(Readiness, physicalRoot, "alpha")
-	if err != nil {
-		t.Fatal(err)
-	}
-	if !got.Blocked || len(got.StateProblems) == 0 {
-		t.Fatalf("Check did not inspect override workspace: blocked=%v problems=%v", got.Blocked, got.StateProblems)
-	}
-}
-
-func TestOpenBlockingQuestionGates(t *testing.T) {
-	got := OpenBlockingQuestionGates([]byte("## Q-1\nstatus: open\ngate: blocking\n\n## Not a question\n\n## q-2\nstatus: open\ngate: validating\n\n## q-3\nstatus: resolved\ngate: blocking\n\n## q-4\nstatus: open\ngate: blocking\n\n## Q-5\nstatus: open\ngate: escalating\n"))
-	want := []string{"blocking", "validating", "escalating"}
-	if strings.Join(got, ",") != strings.Join(want, ",") {
-		t.Fatalf("openBlockingQuestionGates=%v, want %v", got, want)
-	}
-}
-
-func TestOpenBlockingQuestionGatesFieldPrefixesAreCaseInsensitive(t *testing.T) {
-	got := OpenBlockingQuestionGates([]byte("## Q-2026-01-001-003\nStatus: open\nGate: blocking\n"))
-	if strings.Join(got, ",") != "blocking" {
-		t.Fatalf("OpenBlockingQuestionGates=%v, want [blocking]", got)
-	}
-}
-
-func TestOpenBlockingQuestionGatesIgnoresFencedExamples(t *testing.T) {
-	const live = "## q-1\nstatus: open\ngate: blocking\n"
-	for _, tc := range []struct {
-		name string
-		data string
-		want string
-	}{
-		{"fenced only is documentation", "# Questions\n\n```markdown\n" + live + "```\n", ""},
-		{"tilde fenced only is documentation", "~~~markdown\n" + live + "~~~\n", ""},
-		{"unfenced control still blocks", live, "blocking"},
-		{"live question beside a fenced example", "```markdown\n" + live + "```\n\n## q-2\nstatus: open\ngate: escalating\n", "escalating"},
-	} {
-		t.Run(tc.name, func(t *testing.T) {
-			if got := strings.Join(OpenBlockingQuestionGates([]byte(tc.data)), ","); got != tc.want {
-				t.Fatalf("OpenBlockingQuestionGates=%q, want %q", got, tc.want)
-			}
-		})
-	}
-}
-
-func TestOpenBlockingQuestionGatesRejectsUnmaskableInput(t *testing.T) {
-	gates, err := openBlockingQuestionGates([]byte("## q-1\nstatus: open\ngate: blocking\n\xff\n"))
-	if err == nil || len(gates) != 0 {
-		t.Fatalf("unmaskable input gates=%v err=%v, want no gates and an error", gates, err)
-	}
-}
-
-func TestOpenBlockingQuestionGatesFailsClosedOnUnmaskableInput(t *testing.T) {
-	got := OpenBlockingQuestionGates([]byte("## q-1\nstatus: open\ngate: blocking\n\xff\n"))
-	if len(got) == 0 {
-		t.Fatalf("OpenBlockingQuestionGates=%v for unparseable input, want a non-empty fail-closed result", got)
-	}
-}
-
-func TestCheckObservationUsesRetainedPhaseQuestionsReadinessAndReview(t *testing.T) {
-	root := t.TempDir()
-	workspace := writeReadinessFixture(t, root, "retained", "build")
-	binding := mustReadinessBinding(t, root, "retained")
-	testutil.AppendFile(t, filepath.Join(workspace, "eng-review.md"), "\n"+binding+"\n")
-
-	observation, err := state.ObserveWorkspace(root, "retained")
-	if err != nil {
-		t.Fatal(err)
-	}
-	testutil.WriteFile(t, filepath.Join(workspace, "state.md"), "- Phase: spec\n- Status: running\n- Schema: 4\n")
-	testutil.WriteFile(t, filepath.Join(workspace, "questions.md"), "## q-1\nstatus: open\ngate: blocking\n")
-	testutil.WriteFile(t, filepath.Join(workspace, "plan.md"), "# Plan\n\nChanged after observation.\n")
-	testutil.WriteFile(t, filepath.Join(workspace, "eng-review.md"), "# Engineering review\n\nNo binding.\n")
-
-	result, err := checkObservation(Readiness, observation)
-	if err != nil {
-		t.Fatal(err)
-	}
-	if result.Phase != state.PhaseBuild || result.Blocked || len(result.StateProblems) != 0 {
-		t.Fatalf("retained result phase=%q blocked=%v problems=%v", result.Phase, result.Blocked, result.StateProblems)
-	}
-}
-
-func TestGateDiagnosticRecoveryLines(t *testing.T) {
-	for _, tc := range []struct {
-		diagnostic state.ArtifactDiagnostic
-		required   string
-		optional   string
-	}{
-		{
-			state.ArtifactDiagnostic{Path: "spec.md", State: state.ArtifactMalformed, Code: state.DiagnosticMalformedMarkdown},
-			"next: repair spec.md: replace invalid Markdown with valid Markdown; required artifacts need substantive content",
-			"next: repair spec.md: replace invalid Markdown with valid Markdown; optional readiness input may instead be removed",
-		},
-		{
-			state.ArtifactDiagnostic{Path: "spec.md", State: state.ArtifactUnsafe, Code: state.DiagnosticParentSymlink},
-			"next: repair spec.md: replace the symlinked parent with a real directory",
-			"next: repair spec.md: replace the symlinked parent with a real directory; optional readiness input may instead be removed",
-		},
-		{
-			state.ArtifactDiagnostic{Path: "spec.md", State: state.ArtifactUnsafe, Code: state.DiagnosticFinalSymlink},
-			"next: repair spec.md: replace the symlink with a regular file",
-			"next: repair spec.md: replace the symlink with a regular file; optional readiness input may instead be removed",
-		},
-		{
-			state.ArtifactDiagnostic{Path: "spec.md", State: state.ArtifactUnsafe, Code: state.DiagnosticNonRegular},
-			"next: repair spec.md: replace the non-regular entry with a regular file",
-			"next: repair spec.md: replace the non-regular entry with a regular file; optional readiness input may instead be removed",
-		},
-		{
-			state.ArtifactDiagnostic{Path: "spec.md", State: state.ArtifactUnsafe, Code: state.DiagnosticFileTooLarge},
-			"next: repair spec.md: reduce the file to at most 1 MiB",
-			"next: repair spec.md: reduce the file to at most 1 MiB; optional readiness input may instead be removed",
-		},
-		{
-			state.ArtifactDiagnostic{Path: "spec.md", State: state.ArtifactUnreadable, Code: state.DiagnosticPermissionDenied},
-			"next: repair spec.md: grant read permission",
-			"next: repair spec.md: grant read permission; optional readiness input may instead be removed",
-		},
-		{
-			state.ArtifactDiagnostic{Path: "spec.md", State: state.ArtifactUnreadable, Code: state.DiagnosticReadFailure},
-			"next: repair spec.md: restore a readable regular file",
-			"next: repair spec.md: restore a readable regular file; optional readiness input may instead be removed",
-		},
-	} {
-		if got := diagnosticRecovery(tc.diagnostic, true); got != tc.required {
-			t.Errorf("required diagnosticRecovery(%+v)=%q, want %q", tc.diagnostic, got, tc.required)
-		}
-		if got := diagnosticRecovery(tc.diagnostic, false); got != tc.optional {
-			t.Errorf("optional diagnosticRecovery(%+v)=%q, want %q", tc.diagnostic, got, tc.optional)
-		}
-	}
-
-	unknown := state.ArtifactDiagnostic{Path: "strategy.md", State: state.ArtifactUnsafe, Code: "unknown"}
-	if got := diagnosticRecovery(unknown, true); got != "" {
-		t.Fatalf("required unknown diagnosticRecovery()=%q, want empty", got)
-	}
-	if got := diagnosticRecovery(unknown, false); got != "" {
-		t.Fatalf("optional unknown diagnosticRecovery()=%q, want empty", got)
-	}
-}
-
-func TestCheckRendersRequiredDiagnosticBeforeRecoveryWithoutGenericRecovery(t *testing.T) {
-	root := t.TempDir()
-	writeCompleteGateFeature(t, root, "diagnostic", state.PhaseSpec, state.PhaseSpec, "none\n")
-	testutil.WriteFile(t, filepath.Join(root, "work", "diagnostic", "spec.md"), "hostile-secret\x00")
-
-	result, err := Check(Readiness, root, "diagnostic")
-	if err != nil {
-		t.Fatal(err)
-	}
-	want := "gate: readiness\n" +
-		"feature: diagnostic\n" +
-		"phase: spec\n" +
-		"result: blocked (missing to leave \"spec\": spec.md)\n" +
-		"reason: DRV-GATE-READINESS-MISSING\n" +
-		"artifact: spec.md: malformed (malformed_markdown)\n" +
-		"next: repair spec.md: replace invalid Markdown with valid Markdown; required artifacts need substantive content\n" +
-		"retry: devrites-engine check readiness diagnostic\n"
-	if got := result.Render(); got != want {
-		t.Fatalf("Render()=\n%q\nwant\n%q", got, want)
-	}
-	if strings.Contains(result.Render(), "next: add real content") || strings.Contains(result.Render(), "hostile-secret") {
-		t.Fatalf("diagnostic output used generic recovery or disclosed content:\n%s", result.Render())
-	}
-}
-
-func TestCheckOmitsUnselectedEvidenceDiagnostic(t *testing.T) {
-	root := t.TempDir()
-	const slug = "unselected-evidence"
-	writeCompleteGateFeature(t, root, slug, state.PhaseSpec, state.PhaseSpec, "none\n")
-	workspace := filepath.Join(root, "work", slug)
-	if err := os.Symlink("brief.md", filepath.Join(workspace, state.EvidenceFile)); err != nil {
-		t.Fatalf("create unselected evidence symlink: %v", err)
-	}
-
-	result, err := Check(Readiness, root, slug)
-	if err != nil {
-		t.Fatal(err)
-	}
-	want := "gate: readiness\n" +
-		"feature: unselected-evidence\n" +
-		"phase: spec\n" +
-		"result: pass\n" +
-		"reason: DRV-GATE-READINESS-PASSED\n"
-	if got := result.Render(); got != want {
-		t.Fatalf("Render()=\n%q\nwant\n%q", got, want)
-	}
-	if strings.Contains(result.Render(), "artifact:") || strings.Contains(result.Render(), "next:") {
-		t.Fatalf("unselected evidence emitted diagnostic or recovery:\n%s", result.Render())
-	}
-}
-
-func TestCheckSelectsOptionalReadinessDiagnosticInBindingOrder(t *testing.T) {
-	root := t.TempDir()
-	workspace := writeReadinessFixture(t, root, "optional-diagnostic", "build")
-	testutil.WriteFile(t, filepath.Join(workspace, "strategy.md"), "bad\x00strategy")
-
-	result, err := Check(Readiness, root, "optional-diagnostic")
-	if err != nil {
-		t.Fatal(err)
-	}
-	if !result.Blocked || result.ReasonID != reason.GateReadinessStale || len(result.Diagnostics) != 1 {
-		t.Fatalf("blocked=%v reason=%q diagnostics=%+v", result.Blocked, result.ReasonID, result.Diagnostics)
-	}
-	rendered := result.Render()
-	ordered := []string{
-		"reason: DRV-GATE-READINESS-STALE\n",
-		"artifact: strategy.md: malformed (malformed_markdown)\n",
-		"next: repair strategy.md: replace invalid Markdown with valid Markdown; optional readiness input may instead be removed\n",
-		"invariant: readiness input strategy.md is malformed (malformed_markdown); replace invalid Markdown with valid Markdown; repair the input and rerun /rite-vet\n",
-		"retry: devrites-engine check readiness optional-diagnostic\n",
-	}
-	position := -1
-	for _, line := range ordered {
-		next := strings.Index(rendered, line)
-		if next <= position {
-			t.Fatalf("Render() missing ordered line %q:\n%s", line, rendered)
-		}
-		position = next
-	}
-}
-
-func writeCompleteGateFeature(t *testing.T, root, slug string, current, required state.Phase, questions string) {
-	t.Helper()
-	policy, ok := state.PolicyFor(required)
-	if !ok {
-		t.Fatalf("PolicyFor(%q) returned unknown", required)
-	}
-	questionsRequired := false
-	for _, artifact := range policy.RequiredArtifacts {
-		name := string(artifact)
-		content := "# " + name + "\n\nreal\n"
-		switch name {
-		case "state.md":
-			content = "- Phase: " + string(current) + "\n- Status: running\n- Schema: 4\n"
-		case "questions.md":
-			questionsRequired = true
-			content = questions
-		case "tasks.md":
-			content = testutil.CanonicalTasksMarkdown
-		case "gates.md":
-			content = testutil.CanonicalGatesMarkdown
-		}
-		testutil.WriteFile(t, filepath.Join(root, "work", slug, name), content)
-	}
-	if !questionsRequired {
-		testutil.WriteFile(t, filepath.Join(root, "work", slug, "questions.md"), questions)
-	}
-}
-
-func writeFeature(t *testing.T, root, slug string, files map[string]string) {
-	t.Helper()
-	for name, content := range files {
-		testutil.WriteFile(t, filepath.Join(root, "work", slug, name), content)
-	}
-}
-
-func writeWorkFeature(t *testing.T, root, slug string, files map[string]string) {
-	t.Helper()
-	for name, content := range files {
-		testutil.WriteFile(t, filepath.Join(root, "work", slug, name), content)
-	}
-}
-
-func TestCheckBlocksMaterialBudgetOvershootWithoutOverride(t *testing.T) {
-	root := t.TempDir()
-	writeCompleteGateFeature(t, root, "oversized", state.PhaseBuild, state.PhaseBuild, "none\n")
-	workspace := filepath.Join(root, "work", "oversized")
-	oversized := "# Tasks\n\n## SLICE-001 A\nDependencies: none\n\n" + strings.Repeat("long line of planning prose\n", 500)
-	testutil.WriteFile(t, filepath.Join(workspace, "tasks.md"), oversized)
-	binding := mustReadinessBinding(t, root, "oversized")
-	testutil.AppendFile(t, filepath.Join(workspace, "eng-review.md"), "\n"+binding+"\n")
-
-	res, err := Check(Readiness, root, "oversized")
-	if err != nil {
-		t.Fatal(err)
-	}
-	if !res.Blocked {
-		t.Fatalf("blocked=false, want true")
-	}
-	joined := strings.Join(res.StateProblems, "\n")
-	if !strings.Contains(joined, "budget: tasks.md is") || !strings.Contains(joined, "Budget override") {
-		t.Fatalf("StateProblems=%q", joined)
-	}
-
-	testutil.AppendFile(t, filepath.Join(workspace, "tasks.md"), "\nBudget override: vendored requirement matrix, relocation pending\n")
-	res, err = Check(Readiness, root, "oversized")
-	if err != nil {
-		t.Fatal(err)
-	}
-	if strings.Contains(strings.Join(res.StateProblems, "\n"), "budget: tasks.md") {
-		t.Fatalf("override did not clear the budget problem: %v", res.StateProblems)
-	}
-}
-
-func TestCheckKeepsNonMaterialOvershootAdvisory(t *testing.T) {
-	root := t.TempDir()
-	writeCompleteGateFeature(t, root, "slightly-over", state.PhaseBuild, state.PhaseBuild, "none\n")
-	workspace := filepath.Join(root, "work", "slightly-over")
-	// 300 lines against a 280-line budget: over, but below the material factor.
-	testutil.WriteFile(t, filepath.Join(workspace, "tasks.md"), testutil.CanonicalTasksMarkdown+"\n"+strings.Repeat("note\n", 200))
-	binding := mustReadinessBinding(t, root, "slightly-over")
-	testutil.AppendFile(t, filepath.Join(workspace, "eng-review.md"), "\n"+binding+"\n")
-
-	res, err := Check(Readiness, root, "slightly-over")
-	if err != nil {
-		t.Fatal(err)
-	}
-	if strings.Contains(strings.Join(res.StateProblems, "\n"), "budget:") {
-		t.Fatalf("non-material overshoot must stay advisory: %v", res.StateProblems)
-	}
-}
-
-func TestCheckBlocksOversizedPacketInWorkspaceRoot(t *testing.T) {
-	root := t.TempDir()
-	writeCompleteGateFeature(t, root, "stray", state.PhaseBuild, state.PhaseBuild, "none\n")
-	workspace := filepath.Join(root, "work", "stray")
-	binding := mustReadinessBinding(t, root, "stray")
-	testutil.AppendFile(t, filepath.Join(workspace, "eng-review.md"), "\n"+binding+"\n")
-
-	// Sanctioned conditional artifact over the ceiling: placement stays legal.
-	testutil.WriteFile(t, filepath.Join(workspace, "references.md"),
-		"# refs\n\n"+strings.Repeat("reference line\n", 6000))
-	// Engine-owned machine files over the ceiling: placement stays legal.
-	testutil.WriteFile(t, filepath.Join(workspace, "metrics.jsonl"),
-		strings.Repeat("{}\n", state.PacketMaxBytes/2))
-	// Unsanctioned root payload over the ceiling: blocked.
-	testutil.WriteFile(t, filepath.Join(workspace, "vet-review-input-031.json"),
-		strings.Repeat("x", state.PacketMaxBytes+1))
-
-	res, err := Check(Readiness, root, "stray")
-	if err != nil {
-		t.Fatal(err)
-	}
-	joined := strings.Join(res.StateProblems, "\n")
-	if !res.Blocked || !strings.Contains(joined, "placement: vet-review-input-031.json") {
-		t.Fatalf("blocked=%v StateProblems=%q", res.Blocked, joined)
-	}
-	if !strings.Contains(joined, "packets/") {
-		t.Fatalf("remediation must name packets/: %q", joined)
-	}
-	if strings.Contains(joined, "references.md") || strings.Contains(joined, "metrics.jsonl") {
-		t.Fatalf("sanctioned root artifact must not be treated as misplaced: %q", joined)
-	}
-}
-
-func TestCheckNamesSizeRemediesForArtifactOverReadCap(t *testing.T) {
-	root := t.TempDir()
-	writeCompleteGateFeature(t, root, "huge", state.PhaseBuild, state.PhaseBuild, "none\n")
-	workspace := filepath.Join(root, "work", "huge")
-	// Over the read cap, so the artifact cannot be measured against its line budget.
-	// No binding: an over-cap file cannot be hashed into one, and this asserts the
-	// size signal alone rather than a passing gate.
-	testutil.WriteFile(t, filepath.Join(workspace, "tasks.md"),
-		"# Tasks\n\n"+strings.Repeat("n\n", state.MaxArtifactBytes/2+1))
-
-	res, err := Check(Readiness, root, "huge")
-	if err != nil {
-		t.Fatal(err)
-	}
-	joined := strings.Join(res.StateProblems, "\n")
-	if !res.Blocked || !strings.Contains(joined, "budget: tasks.md exceeds the") {
-		t.Fatalf("blocked=%v StateProblems=%q", res.Blocked, joined)
-	}
-	if !strings.Contains(joined, "history/") || !strings.Contains(joined, "/rite-plan") {
-		t.Fatalf("size remedies must be named: %q", joined)
-	}
-}
-
-func TestCheckLeavesProofLedgerOvershootAdvisory(t *testing.T) {
-	root := t.TempDir()
-	writeCompleteGateFeature(t, root, "big-ledger", state.PhaseProve, state.PhaseProve, "none\n")
-	workspace := filepath.Join(root, "work", "big-ledger")
-	testutil.WriteFile(t, filepath.Join(workspace, "evidence.md"), strings.Repeat("EVID-001 proof line\n", 800))
-	testutil.WriteFile(t, filepath.Join(workspace, "touched-files.md"), strings.Repeat("trail line\n", 600))
-
-	res, err := Check(Readiness, root, "big-ledger")
-	if err != nil {
-		t.Fatal(err)
-	}
-	if joined := strings.Join(res.StateProblems, "\n"); strings.Contains(joined, "budget:") {
-		t.Fatalf("proof ledgers must stay advisory: %v", res.StateProblems)
-	}
-}
-
-func TestAcceptanceMapBlocksSpecsItCannotParse(t *testing.T) {
-	for _, tc := range []struct {
-		name string
-		spec string
-		want string
-	}{
-		{"canonical control", "# Spec\n\n## Acceptance criteria\n- AC-001: a.\n- AC-002: b.\n", "acceptance AC-001 is not referenced in test-plan.md"},
-		{"trailing colon", "# Spec\n\n## Acceptance criteria:\n- AC-001: a.\n", "## Acceptance criteria"},
-		{"h3 heading", "# Spec\n\n### Acceptance criteria\n- AC-001: a.\n", "## Acceptance criteria"},
-		{"suffixed heading", "# Spec\n\n## Acceptance criteria (draft)\n- AC-001: a.\n", "## Acceptance criteria"},
-		{"two digit id", "# Spec\n\n## Acceptance criteria\n- AC-01: a.\n", "AC-###"},
-		{"four digit id", "# Spec\n\n## Acceptance criteria\n- AC-0001: a.\n", "AC-###"},
-		{"one digit id", "# Spec\n\n## Acceptance criteria\n- AC-1: a.\n", "AC-###"},
-		{"trailing heading whitespace", "# Spec\n\n## Acceptance criteria   \n- AC-001: a.\n", "acceptance AC-001 is not referenced in test-plan.md"},
-	} {
-		t.Run(tc.name, func(t *testing.T) {
-			root := t.TempDir()
-			workspace := writeReadinessFixture(t, root, "unparsed", "build")
-			testutil.WriteFile(t, filepath.Join(workspace, "spec.md"), tc.spec)
-			testutil.AppendFile(t, filepath.Join(workspace, "eng-review.md"), "\n"+mustReadinessBinding(t, root, "unparsed")+"\n")
-			result, err := Check(Readiness, root, "unparsed")
-			if err != nil {
-				t.Fatal(err)
-			}
-			joined := strings.Join(result.StateProblems, "\n")
-			if !result.Blocked || !strings.Contains(joined, "acceptance-map: ") || !strings.Contains(joined, tc.want) {
-				t.Fatalf("blocked=%v want acceptance-map problem containing %q, got %q", result.Blocked, tc.want, joined)
-			}
-		})
-	}
-}
-
-func TestAcceptanceMapBlocksPartiallyParsedSpecs(t *testing.T) {
-	for _, tc := range []struct {
-		name string
-		spec string
-		want string
-	}{
-		{"canonical id beside two digit id", "# Spec\n\n## Acceptance criteria\n- AC-001: a.\n- AC-02: b.\n", "AC-02"},
-		{"second acceptance heading", "# Spec\n\n## Acceptance criteria\n- AC-001: a.\n\n## Acceptance criteria (phase 2)\n- AC-002: b.\n", "## Acceptance criteria (phase 2)"},
-	} {
-		t.Run(tc.name, func(t *testing.T) {
-			root := t.TempDir()
-			workspace := writeReadinessFixture(t, root, "partial", "build")
-			testutil.WriteFile(t, filepath.Join(workspace, "spec.md"), tc.spec)
-			testutil.AppendFile(t, filepath.Join(workspace, "tasks.md"), "\nAC-001 AC-002\n")
-			testutil.AppendFile(t, filepath.Join(workspace, "test-plan.md"), "\nAC-001 AC-002\n")
-			testutil.AppendFile(t, filepath.Join(workspace, "eng-review.md"), "\n"+mustReadinessBinding(t, root, "partial")+"\n")
-			result, err := Check(Readiness, root, "partial")
-			if err != nil {
-				t.Fatal(err)
-			}
-			joined := strings.Join(result.StateProblems, "\n")
-			if !result.Blocked || !strings.Contains(joined, "acceptance-map: ") || !strings.Contains(joined, tc.want) {
-				t.Fatalf("blocked=%v want acceptance-map problem containing %q, got %q", result.Blocked, tc.want, joined)
-			}
-		})
-	}
-}