devrites 4.1.0 → 4.2.0

package/engine/internal/gate/gate_test.go

@@ -3,10 +3,12 @@ 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"
 )
 
@@ -109,6 +111,52 @@ func TestSealRequiresDurableReviewAndSealArtifacts(t *testing.T) {
 	}
 }
 
+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,
@@ -149,6 +197,54 @@ func TestStateAwaitingHumanReadsCanonicalCursor(t *testing.T) {
 	}
 }
 
+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
@@ -201,14 +297,18 @@ func TestCheckUsesWorkspaceOverrideForStateInvariants(t *testing.T) {
 	if err := os.MkdirAll(root, 0o755); err != nil {
 		t.Fatal(err)
 	}
-	override := filepath.Join(root, "work", "alpha")
+	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")
 	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, root, "alpha")
+	got, err := Check(Readiness, physicalRoot, "alpha")
 	if err != nil {
 		t.Fatal(err)
 	}
@@ -225,6 +325,194 @@ func TestOpenBlockingQuestionGates(t *testing.T) {
 	}
 }
 
+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")
+	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"
+		case "questions.md":
+			questionsRequired = true
+			content = questions
+		}
+		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 {

package/engine/internal/gate/readiness_binding.go

@@ -7,26 +7,20 @@ import (
 	"errors"
 	"fmt"
 	"hash"
-	"io"
-	"os"
-	"path/filepath"
 	"strings"
 
-	"github.com/devrites/devrites/internal/devritespaths"
 	"github.com/devrites/devrites/internal/markdowntext"
 	"github.com/devrites/devrites/internal/state"
 )
 
 const (
-	readinessBindingLabel         = "Readiness inputs SHA-256: "
-	readinessBindingDomain        = "devrites-readiness-inputs"
-	readinessBindingVersion       = "1"
-	maxReadinessInputBytes  int64 = 1 << 20
-	maxReadinessTotalBytes  int64 = 8 << 20
+	readinessBindingLabel   = "Readiness inputs SHA-256: "
+	readinessBindingDomain  = "devrites-readiness-inputs"
+	readinessBindingVersion = "1"
 )
 
 type readinessInput struct {
-	logical  string
+	logical  state.ArtifactPath
 	required bool
 }
 
@@ -46,31 +40,24 @@ var readinessInputs = [...]readinessInput{
 
 // ReadinessBinding returns the exact line Vet records in eng-review.md.
 func ReadinessBinding(root, slug string) (string, error) {
-	workspace, err := devritespaths.ExistingFeatureDirChecked(root, slug)
+	observation, err := state.ObserveWorkspace(root, slug)
 	if err != nil {
-		return "", errors.New("readiness inputs: feature workspace is unavailable")
+		return "", err
 	}
+	return readinessBindingFromObservation(observation)
+}
 
+func readinessBindingFromObservation(observation *state.WorkspaceObservation) (string, error) {
 	digest := sha256.New()
 	writeReadinessField(digest, readinessBindingDomain)
 	writeReadinessField(digest, readinessBindingVersion)
 	writeReadinessField(digest, fmt.Sprintf("%d", len(readinessInputs)))
-	var total int64
 	for _, input := range readinessInputs {
-		path := filepath.Join(workspace, filepath.FromSlash(input.logical))
-		if input.logical == ".devrites/principles.md" {
-			path = filepath.Join(root, "principles.md")
-		}
-		content, present, err := readReadinessInput(path, input.logical, input.required)
+		content, present, err := retainedReadinessInput(observation, input)
 		if err != nil {
 			return "", err
 		}
-		total += int64(len(content))
-		if total > maxReadinessTotalBytes {
-			return "", fmt.Errorf("readiness input %s exceeds the 8 MiB aggregate limit", input.logical)
-		}
-
-		writeReadinessField(digest, input.logical)
+		writeReadinessField(digest, string(input.logical))
 		if present {
 			writeReadinessField(digest, "present")
 		} else {
@@ -79,31 +66,64 @@ func ReadinessBinding(root, slug string) (string, error) {
 		writeReadinessLength(digest, uint64(len(content)))
 		_, _ = digest.Write(content)
 	}
-
 	return readinessBindingLabel + hex.EncodeToString(digest.Sum(nil)), nil
 }
 
-func verifyReadinessBinding(root, slug string) (string, error) {
-	expected, err := ReadinessBinding(root, slug)
+func retainedReadinessInput(observation *state.WorkspaceObservation, input readinessInput) ([]byte, bool, error) {
+	fact, ok := observation.Fact(input.logical)
+	if !ok {
+		return nil, false, fmt.Errorf("readiness input %s cannot be inspected", input.logical)
+	}
+	switch fact.State() {
+	case state.ArtifactAbsent:
+		if input.required {
+			return nil, false, fmt.Errorf("readiness input %s is missing", input.logical)
+		}
+		return nil, false, nil
+	case state.ArtifactEmpty, state.ArtifactPresent:
+		return fact.Bytes(), true, nil
+	case state.ArtifactMalformed, state.ArtifactUnsafe, state.ArtifactUnreadable:
+		diagnostic, _ := fact.Diagnostic()
+		return nil, false, readinessDiagnosticError(diagnostic)
+	default:
+		return nil, false, fmt.Errorf("readiness input %s cannot be inspected", input.logical)
+	}
+}
+
+func readinessDiagnostics(observation *state.WorkspaceObservation) []state.ArtifactDiagnostic {
+	var diagnostics []state.ArtifactDiagnostic
+	for _, input := range readinessInputs {
+		fact, ok := observation.Fact(input.logical)
+		if !ok {
+			continue
+		}
+		if diagnostic, hasDiagnostic := fact.Diagnostic(); hasDiagnostic {
+			diagnostics = append(diagnostics, diagnostic)
+		}
+	}
+	return diagnostics
+}
+
+func verifyReadinessBinding(observation *state.WorkspaceObservation) (string, error) {
+	expected, err := readinessBindingFromObservation(observation)
 	if err != nil {
 		return "", err
 	}
-	workspace, err := devritespaths.ExistingFeatureDirChecked(root, slug)
-	if err != nil {
-		return "", errors.New("readiness input eng-review.md cannot be inspected")
+	fact, ok := observation.Fact("eng-review.md")
+	if !ok || fact.State() == state.ArtifactAbsent {
+		return expected, errors.New("readiness input eng-review.md is missing")
 	}
-	content, _, err := readReadinessInput(filepath.Join(workspace, "eng-review.md"), "eng-review.md", true)
-	if err != nil {
-		return expected, err
+	if diagnostic, hasDiagnostic := fact.Diagnostic(); hasDiagnostic {
+		return expected, readinessDiagnosticError(diagnostic)
 	}
-	structural, err := markdowntext.Structural(content)
+	visible, err := markdowntext.Structural(fact.Bytes())
 	if err != nil {
 		return expected, errors.New("readiness input eng-review.md is invalid Markdown")
 	}
 
 	attempts := 0
 	matches := 0
-	for _, raw := range strings.Split(string(structural), "\n") {
+	for _, raw := range strings.Split(string(visible), "\n") {
 		line := strings.TrimSuffix(raw, "\r")
 		if !strings.Contains(line, readinessBindingLabel) {
 			continue
@@ -119,76 +139,22 @@ func verifyReadinessBinding(root, slug string) (string, error) {
 	return expected, nil
 }
 
-func phaseRequiresReadinessBinding(phase state.Phase) bool {
-	for _, name := range state.RequiredWorkspaceFiles(phase) {
-		if name == "eng-review.md" {
-			return true
-		}
+func readinessDiagnosticError(diagnostic state.ArtifactDiagnostic) error {
+	prefix := fmt.Sprintf("readiness input %s is %s (%s); ", diagnostic.Path, diagnostic.State, diagnostic.Code)
+	repair := diagnosticRepair(diagnostic.Code)
+	if repair == "" {
+		repair = "restore a readable regular file"
 	}
-	return false
+	return errors.New(prefix + repair)
 }
 
-func readReadinessInput(path, logical string, required bool) ([]byte, bool, error) {
-	before, err := os.Lstat(path)
-	if errors.Is(err, os.ErrNotExist) {
-		if required {
-			return nil, false, fmt.Errorf("readiness input %s is missing", logical)
+func phaseRequiresReadinessBinding(policy state.PhasePolicy) bool {
+	for _, artifact := range policy.RequiredArtifacts {
+		if artifact == "eng-review.md" {
+			return true
 		}
-		return nil, false, nil
-	}
-	if err != nil {
-		return nil, false, fmt.Errorf("readiness input %s cannot be inspected", logical)
-	}
-	if before.Mode()&os.ModeSymlink != 0 {
-		return nil, false, fmt.Errorf("readiness input %s is a symlink", logical)
-	}
-	if !before.Mode().IsRegular() {
-		return nil, false, fmt.Errorf("readiness input %s is not a regular file", logical)
-	}
-	if before.Size() < 0 || before.Size() > maxReadinessInputBytes {
-		return nil, false, fmt.Errorf("readiness input %s exceeds the 1 MiB limit", logical)
-	}
-
-	file, err := os.Open(path)
-	if err != nil {
-		return nil, false, fmt.Errorf("readiness input %s cannot be opened", logical)
-	}
-	defer file.Close()
-	opened, err := file.Stat()
-	if err != nil {
-		return nil, false, fmt.Errorf("readiness input %s cannot be inspected", logical)
 	}
-	if !opened.Mode().IsRegular() || opened.Size() != before.Size() || !os.SameFile(before, opened) {
-		return nil, false, fmt.Errorf("readiness input %s changed type while opening", logical)
-	}
-	content, err := io.ReadAll(io.LimitReader(file, maxReadinessInputBytes+1))
-	if err != nil {
-		return nil, false, fmt.Errorf("readiness input %s cannot be read", logical)
-	}
-	if int64(len(content)) > maxReadinessInputBytes {
-		return nil, false, fmt.Errorf("readiness input %s exceeds the 1 MiB limit", logical)
-	}
-	after, err := file.Stat()
-	if err != nil {
-		return nil, false, fmt.Errorf("readiness input %s cannot be inspected", logical)
-	}
-	current, err := os.Lstat(path)
-	if err != nil {
-		return nil, false, fmt.Errorf("readiness input %s cannot be inspected", logical)
-	}
-	if current.Mode()&os.ModeSymlink != 0 ||
-		!current.Mode().IsRegular() ||
-		!after.Mode().IsRegular() ||
-		after.Size() != opened.Size() ||
-		after.Size() != int64(len(content)) ||
-		!os.SameFile(opened, after) ||
-		!os.SameFile(opened, current) {
-		return nil, false, fmt.Errorf("readiness input %s changed size or type while reading", logical)
-	}
-	if _, err := markdowntext.Structural(content); err != nil {
-		return nil, false, fmt.Errorf("readiness input %s is invalid Markdown", logical)
-	}
-	return content, true, nil
+	return false
 }
 
 func writeReadinessField(digest hash.Hash, value string) {