Hydrate accepted producer checkpoints

2026-07-22 02:27:19 +00:00
parent 9de399432e
commit 7aadb088a6
11 changed files with 565 additions and 21 deletions
--- a/internal/framework/checkpoint/filesystem_test.go
+++ b/internal/framework/checkpoint/filesystem_test.go
@@ -322,6 +322,107 @@ func TestFilesystemCheckpointDecisionFamiliesAreStableAndSafe(t *testing.T) {
 	}
 }

+func TestFilesystemLoaderReadsAcceptedNormalizeWithoutStageDependencies(t *testing.T) {
+	fixture := seedAcceptedNormalizeCheckpoint(t)
+	identityRoot := filepath.Join(fixture.root, mustRelativePath(t, fixture.identity))
+	for _, stage := range []string{"extract", "merge"} {
+		if _, err := os.Stat(filepath.Join(identityRoot, laneManifestPath(stage, "step-1", "lane-a"))); !os.IsNotExist(err) {
+			t.Fatalf("%s checkpoint stat error = %v, want absent prerequisite", stage, err)
+		}
+	}
+	checkpoint, decision := fixture.loader.AcceptedNormalize("step-1", "lane-a", "normalize-module")
+	if !decision.Reused || decision.Category != pipeline.CheckpointDecisionReused || decision.ReasonCode != pipeline.CheckpointReasonAcceptedArtifactReused {
+		t.Fatalf("accepted normalize decision = %#v", decision)
+	}
+	if checkpoint.Output.Artifact.Content == nil || string(checkpoint.Output.Artifact.Content) != string(fixture.normalize.Artifact.Content) {
+		t.Fatalf("accepted normalize output = %#v, want recorded artifact", checkpoint.Output)
+	}
+	if len(checkpoint.Warnings) != 1 || checkpoint.Warnings[0].ReasonCode != "normalized" {
+		t.Fatalf("accepted normalize warnings = %#v", checkpoint.Warnings)
+	}
+}
+
+func TestFilesystemLoaderRejectsInvalidAcceptedNormalize(t *testing.T) {
+	tests := []struct {
+		name   string
+		mutate func(*testing.T, *filesystemCheckpointFixture)
+		code   pipeline.CheckpointReasonCode
+	}{
+		{"missing", func(t *testing.T, fixture *filesystemCheckpointFixture) {
+			if err := os.Remove(acceptedNormalizeManifest(t, *fixture)); err != nil {
+				t.Fatal(err)
+			}
+		}, pipeline.CheckpointReasonMissing},
+		{"rejected status", func(t *testing.T, fixture *filesystemCheckpointFixture) {
+			editManifest(t, acceptedNormalizeManifest(t, *fixture), func(m map[string]any) { m["status"] = string(StatusSucceededWithRejections) })
+		}, pipeline.CheckpointReasonStatusNotReusable},
+		{"corrupt payload", func(t *testing.T, fixture *filesystemCheckpointFixture) {
+			if err := os.WriteFile(acceptedNormalizePayload(t, *fixture), []byte("{"), 0o600); err != nil {
+				t.Fatal(err)
+			}
+		}, pipeline.CheckpointReasonDecodeFailed},
+		{"wrong codec identity", func(t *testing.T, fixture *filesystemCheckpointFixture) {
+			editJSON(t, acceptedNormalizePayload(t, *fixture), func(m map[string]any) { m["output"].(map[string]any)["artifact_kind"] = "" })
+		}, pipeline.CheckpointReasonArtifactCodecIncompatible},
+		{"wrong content digest", func(t *testing.T, fixture *filesystemCheckpointFixture) {
+			editJSON(t, acceptedNormalizePayload(t, *fixture), func(m map[string]any) {
+				m["output"].(map[string]any)["content"].(map[string]any)["content_digest"] = "sha256:wrong"
+			})
+		}, pipeline.CheckpointReasonArtifactDigestMismatch},
+		{"unverifiable identity", func(t *testing.T, fixture *filesystemCheckpointFixture) {
+			loader := fixture.loader.(*FilesystemLoader)
+			fixture.loader = &FilesystemLoader{root: loader.root}
+		}, pipeline.CheckpointReasonIdentityMismatch},
+	}
+	for _, test := range tests {
+		t.Run(test.name, func(t *testing.T) {
+			fixture := seedAcceptedNormalizeCheckpoint(t)
+			test.mutate(t, &fixture)
+			_, decision := fixture.loader.AcceptedNormalize("step-1", "lane-a", "normalize-module")
+			if decision.Reused || decision.ReasonCode != test.code {
+				t.Fatalf("accepted normalize decision = %#v, want %q", decision, test.code)
+			}
+			if strings.Contains(decision.Detail, fixture.root) || strings.Contains(decision.Detail, string(fixture.normalize.Artifact.Content)) {
+				t.Fatalf("accepted normalize decision leaked path or content: %#v", decision)
+			}
+			if _, err := os.Stat(acceptedNormalizePayload(t, fixture)); err != nil {
+				t.Fatalf("accepted normalize payload was removed after rejection: %v", err)
+			}
+		})
+	}
+}
+
+func seedAcceptedNormalizeCheckpoint(t *testing.T) filesystemCheckpointFixture {
+	t.Helper()
+	root := t.TempDir()
+	identity := testIdentity(t)
+	artifact := checkpointArtifact("normalize-module", `{"accepted":true}`)
+	recorder, err := NewFilesystemRecorder(root, identity)
+	if err != nil {
+		t.Fatal(err)
+	}
+	stepRecorder := recorder.(pipeline.StepCheckpointRecorder)
+	warnings := []contracts.Warning{{Scope: "normalize", ReasonCode: "normalized", Message: "normalized warning"}}
+	if err := stepRecorder.NormalizeSucceededForStep("step-1", "lane-a", "normalize-module", []pipeline.CheckpointFingerprint{{Name: "merge", Value: "sha256:unavailable"}}, artifact, warnings); err != nil {
+		t.Fatal(err)
+	}
+	loader, err := NewFilesystemLoader(root, identity)
+	if err != nil {
+		t.Fatal(err)
+	}
+	return filesystemCheckpointFixture{root: root, identity: identity, loader: loader, normalize: artifact}
+}
+
+func acceptedNormalizeManifest(t *testing.T, fixture filesystemCheckpointFixture) string {
+	t.Helper()
+	return filepath.Join(fixture.root, mustRelativePath(t, fixture.identity), laneManifestPath("normalize", "step-1", "lane-a"))
+}
+
+func acceptedNormalizePayload(t *testing.T, fixture filesystemCheckpointFixture) string {
+	t.Helper()
+	return filepath.Join(fixture.root, mustRelativePath(t, fixture.identity), lanePayloadPath("normalize", "step-1", "lane-a", "output.json"))
+}
+
 type checkpointStage struct {
 	name     string
 	manifest func(filesystemCheckpointFixture) string
--- a/internal/framework/checkpoint/loader.go
+++ b/internal/framework/checkpoint/loader.go
@@ -141,6 +141,57 @@ func (l *FilesystemLoader) NormalizeForStep(stepID, laneID, moduleKey string, de
 	return pipeline.NormalizeCheckpoint{Output: values[0], Warnings: cloneWarnings(payload.Warnings)}, reusedDecision()
 }

+func (l *FilesystemLoader) AcceptedNormalize(stepID, laneID, moduleKey string) (pipeline.NormalizeCheckpoint, pipeline.CheckpointDecision) {
+	var manifest NormalizeLaneManifest
+	if d := l.readJSON(laneManifestPath("normalize", stepID, laneID), &manifest); !d.Reused {
+		return pipeline.NormalizeCheckpoint{}, d
+	}
+	if d := l.validateAcceptedNormalizeManifest(manifest.StageManifest, stepID, laneID, moduleKey); !d.Reused {
+		return pipeline.NormalizeCheckpoint{}, d
+	}
+	var payload artifactSingleEnvelope
+	if d := l.readJSON(lanePayloadPath("normalize", stepID, laneID, "output.json"), &payload); !d.Reused {
+		return pipeline.NormalizeCheckpoint{}, d
+	}
+	values, err := artifactCheckpointOutputs([]artifactCheckpointEnvelope{payload.Output})
+	if err != nil {
+		return pipeline.NormalizeCheckpoint{}, artifactDecision(err, "accepted normalize checkpoint artifact is invalid")
+	}
+	if len(values) != 1 {
+		return pipeline.NormalizeCheckpoint{}, decision(pipeline.CheckpointDecisionExecuted, pipeline.CheckpointReasonArtifactPayloadInvalid, "accepted normalize checkpoint payload is invalid")
+	}
+	if !fingerprintsEqual(checkpointToPipelineFingerprints(manifest.OutputDigests), artifactOutputDigests(values)) {
+		return pipeline.NormalizeCheckpoint{}, decision(pipeline.CheckpointDecisionExecuted, pipeline.CheckpointReasonArtifactDigestMismatch, "accepted normalize checkpoint digest does not match its payload")
+	}
+	return pipeline.NormalizeCheckpoint{Output: values[0], Warnings: cloneWarnings(payload.Warnings)}, decision(pipeline.CheckpointDecisionReused, pipeline.CheckpointReasonAcceptedArtifactReused, "accepted normalized artifact is reusable")
+}
+
+func (l *FilesystemLoader) validateAcceptedNormalizeManifest(manifest StageManifest, stepID, laneID, moduleKey string) pipeline.CheckpointDecision {
+	if manifest.WorkspaceSchemaVersion != WorkspaceSchemaVersion {
+		return decision(pipeline.CheckpointDecisionExecuted, pipeline.CheckpointReasonWorkspaceSchemaIncompatible, "checkpoint workspace schema is incompatible")
+	}
+	identity := strings.TrimSpace(l.identityDigest)
+	if identity == "" || strings.TrimSpace(manifest.Metadata["checkpoint_identity_digest"]) == "" || manifest.Metadata["checkpoint_identity_digest"] != identity {
+		return decision(pipeline.CheckpointDecisionExecuted, pipeline.CheckpointReasonIdentityMismatch, "checkpoint identity is unavailable or does not match the current invocation")
+	}
+	if manifest.Stage != StageNormalize {
+		return decision(pipeline.CheckpointDecisionExecuted, pipeline.CheckpointReasonStageMismatch, "checkpoint stage does not match normalize")
+	}
+	if strings.TrimSpace(stepID) == "" || manifest.StepID != stepID {
+		return decision(pipeline.CheckpointDecisionExecuted, pipeline.CheckpointReasonStepMismatch, "checkpoint step does not match the requested step")
+	}
+	if strings.TrimSpace(laneID) == "" || manifest.LaneID != laneID {
+		return decision(pipeline.CheckpointDecisionExecuted, pipeline.CheckpointReasonLaneMismatch, "checkpoint lane does not match the requested lane")
+	}
+	if strings.TrimSpace(moduleKey) == "" || manifest.ModuleKey != moduleKey {
+		return decision(pipeline.CheckpointDecisionExecuted, pipeline.CheckpointReasonModuleMismatch, "checkpoint module does not match the requested normalizer")
+	}
+	if manifest.Status != StatusSucceeded {
+		return decision(pipeline.CheckpointDecisionExecuted, pipeline.CheckpointReasonStatusNotReusable, "checkpoint status cannot provide an accepted normalized artifact")
+	}
+	return reusedDecision()
+}
+
 func artifactCheckpointOutputs(values []artifactCheckpointEnvelope) ([]pipeline.CheckpointArtifact, error) {
 	if len(values) == 0 {
 		return nil, nil