Implement raw module output contracts

internal/framework/pipeline/runner_test.go

@@ -11,7 +11,6 @@ import (
 	"gitea.maximumdirect.net/eric/notarius/internal/core/artifacts"
 	"gitea.maximumdirect.net/eric/notarius/internal/core/source"
 	"gitea.maximumdirect.net/eric/notarius/internal/framework/contracts"
-	validate "gitea.maximumdirect.net/eric/notarius/internal/framework/validate"
 )
 
 func TestNewAndDataTypes(t *testing.T) {
@@ -29,17 +28,17 @@ func TestNewAndDataTypes(t *testing.T) {
 		Metadata:  map[string]any{"request": "test"},
 	}
 	output := RunOutput{
-		Manifest:    artifacts.RunManifest{PipelineID: "pipeline-1"},
-		Approved:    []artifacts.Artifact{{ExtractorKey: "extract-alpha"}},
-		Rejected:    []artifacts.RejectedArtifact{{ValidatorName: "validator"}},
-		Warnings:    []contracts.Warning{{ReasonCode: "note", Message: "message"}},
-		OutputFiles: []contracts.OutputFile{{Name: "artifacts/generic.json", ContentType: "application/json", Bytes: []byte(`{}`)}},
+		Manifest:         artifacts.RunManifest{PipelineID: "pipeline-1"},
+		NormalizeOutputs: []contracts.NormalizeOutput{{NormalizerKey: "normalize"}},
+		Rejected:         []contracts.RejectedOutput{{ValidatorName: "validator"}},
+		Warnings:         []contracts.Warning{{ReasonCode: "note", Message: "message"}},
+		OutputFiles:      []contracts.OutputFile{{Name: "outputs/generic.json", ContentType: "application/json", Bytes: []byte(`{}`)}},
 	}
 
 	if input.Pipeline.ID != "pipeline-1" || input.SourceID != "source-1" {
 		t.Fatalf("RunInput = %#v, want constructed fields", input)
 	}
-	if output.Manifest.PipelineID != "pipeline-1" || len(output.Approved) != 1 || len(output.Rejected) != 1 || len(output.Warnings) != 1 || len(output.OutputFiles) != 1 {
+	if output.Manifest.PipelineID != "pipeline-1" || len(output.NormalizeOutputs) != 1 || len(output.Rejected) != 1 || len(output.Warnings) != 1 || len(output.OutputFiles) != 1 {
 		t.Fatalf("RunOutput = %#v, want constructed fields", output)
 	}
 }
@@ -361,8 +360,8 @@ func TestRunAllowsPartialCoverageAndOverlappingChunks(t *testing.T) {
 	if err != nil {
 		t.Fatalf("Run() error = %v, want nil", err)
 	}
-	if len(output.Approved) != 2 {
-		t.Fatalf("len(Approved) = %d, want one candidate per accepted chunk", len(output.Approved))
+	if len(output.NormalizeOutputs) != 1 {
+		t.Fatalf("len(NormalizeOutputs) = %d, want one lane output", len(output.NormalizeOutputs))
 	}
 }
 
@@ -397,8 +396,8 @@ func TestRunCanonicalizesChunkUnitsBeforeExtraction(t *testing.T) {
 		t.Fatalf("Run() error = %v, want nil", err)
 	}
 
-	if len(output.Approved) != 1 {
-		t.Fatalf("len(Approved) = %d, want 1", len(output.Approved))
+	if len(output.NormalizeOutputs) != 1 {
+		t.Fatalf("len(NormalizeOutputs) = %d, want 1", len(output.NormalizeOutputs))
 	}
 
 	extractor := modules.extractors["extract-alpha"]
@@ -504,8 +503,8 @@ func TestRunExecutesChunksAndPassesChunkAndLLMClient(t *testing.T) {
 	if extractor.seenMetadata[0]["request"] != "test" {
 		t.Fatalf("seen metadata = %#v, want request metadata", extractor.seenMetadata)
 	}
-	if len(output.Approved) != 2 {
-		t.Fatalf("len(Approved) = %d, want 2", len(output.Approved))
+	if len(output.NormalizeOutputs) != 1 {
+		t.Fatalf("len(NormalizeOutputs) = %d, want one lane output", len(output.NormalizeOutputs))
 	}
 }
 
@@ -660,12 +659,6 @@ func TestRunPassesModuleBindingConfigToStageRequests(t *testing.T) {
 	if got := modules.normalizers["normalize"].requests[0].Options["normalize_option"]; got != "normalize-value" {
 		t.Fatalf("normalize Options = %#v, want normalize option", modules.normalizers["normalize"].requests[0].Options)
 	}
-	if got := modules.validators["configured"].requests[0].LLMProfile; got != "validator-profile" {
-		t.Fatalf("validator LLMProfile = %q, want validator-profile", got)
-	}
-	if got := modules.validators["configured"].requests[0].Options["validator_option"]; got != "validator-value" {
-		t.Fatalf("validator Options = %#v, want validator option", modules.validators["configured"].requests[0].Options)
-	}
 	if got := modules.output.requests[0].LLMProfile; got != "output-profile" {
 		t.Fatalf("output LLMProfile = %q, want output-profile", got)
 	}
@@ -801,7 +794,7 @@ func TestRunRecordsTopLevelModuleMetadataForSingletonModules(t *testing.T) {
 	}
 }
 
-func TestRunPassesPerChunkCandidatesToMergeAndNormalize(t *testing.T) {
+func TestRunPassesPerChunkRawOutputsToMergeAndNormalize(t *testing.T) {
 	modules := defaultRunnerModules()
 
 	_, err := New(newRunnerRegistries(t, modules)).Run(context.Background(), RunInput{Pipeline: resolvedPipeline()})
@@ -813,111 +806,31 @@ func TestRunPassesPerChunkCandidatesToMergeAndNormalize(t *testing.T) {
 	if len(merger.requests) != 1 {
 		t.Fatalf("len(merge requests) = %d, want 1", len(merger.requests))
 	}
-	chunkArtifacts := merger.requests[0].ChunkArtifacts
-	if len(chunkArtifacts) != 2 {
-		t.Fatalf("len(ChunkArtifacts) = %d, want 2", len(chunkArtifacts))
+	extractOutputs := merger.requests[0].ExtractOutputs
+	if len(extractOutputs) != 2 {
+		t.Fatalf("len(ExtractOutputs) = %d, want 2", len(extractOutputs))
 	}
-	if chunkArtifacts[0].Chunk.ID != "chunk-0" || chunkArtifacts[1].Chunk.ID != "chunk-1" {
-		t.Fatalf("merge chunks = %#v, want chunk order", chunkArtifacts)
+	if extractOutputs[0].ChunkID != "chunk-0" || extractOutputs[1].ChunkID != "chunk-1" {
+		t.Fatalf("merge chunks = %#v, want chunk order", extractOutputs)
 	}
-	if got := candidateIndices(chunkArtifacts[0].Candidates); !reflect.DeepEqual(got, []int{0}) {
-		t.Fatalf("first chunk candidate indices = %#v, want [0]", got)
+	if extractOutputs[0].ChunkIndex != 0 || string(extractOutputs[0].Payload.Content) != `{"chunk":"chunk-0"}` {
+		t.Fatalf("first extract output = %#v, want first chunk payload", extractOutputs[0])
 	}
-	if got := candidateIndices(chunkArtifacts[1].Candidates); !reflect.DeepEqual(got, []int{1}) {
-		t.Fatalf("second chunk candidate indices = %#v, want [1]", got)
+	if extractOutputs[1].ChunkIndex != 1 || string(extractOutputs[1].Payload.Content) != `{"chunk":"chunk-1"}` {
+		t.Fatalf("second extract output = %#v, want second chunk payload", extractOutputs[1])
 	}
 
 	normalizer := modules.normalizers["normalize"]
 	if len(normalizer.requests) != 1 {
 		t.Fatalf("len(normalize requests) = %d, want 1", len(normalizer.requests))
 	}
-	if got := candidateIndices(normalizer.requests[0].Candidates); !reflect.DeepEqual(got, []int{0, 1}) {
-		t.Fatalf("normalize candidate indices = %#v, want merged candidates", got)
+	if string(normalizer.requests[0].MergeOutput.Payload.Content) != `{"merged":true}` {
+		t.Fatalf("normalize merge output = %#v, want merged raw output", normalizer.requests[0].MergeOutput)
 	}
 }
 
-func TestRunRejectsInvalidPostNormalizeCandidateEnvelope(t *testing.T) {
-	tests := []struct {
-		name       string
-		candidates []artifacts.ArtifactCandidate
-		want       string
-	}{
-		{
-			name: "duplicate index",
-			candidates: []artifacts.ArtifactCandidate{
-				runnerCandidate(0),
-				runnerCandidate(0),
-			},
-			want: "duplicated",
-		},
-		{
-			name: "missing extractor key",
-			candidates: []artifacts.ArtifactCandidate{
-				{Index: 0, ArtifactType: "artifact", SchemaVersion: "v1", Payload: []byte(`{"value":true}`)},
-			},
-			want: "extractor_key",
-		},
-		{
-			name: "mismatched schema version",
-			candidates: []artifacts.ArtifactCandidate{
-				{Index: 0, ExtractorKey: "extract-alpha", ArtifactType: "artifact", SchemaVersion: "other", Payload: []byte(`{"value":true}`)},
-			},
-			want: "schema_version",
-		},
-	}
-
-	for _, test := range tests {
-		t.Run(test.name, func(t *testing.T) {
-			modules := defaultRunnerModules()
-			modules.normalizers["normalize"].result = test.candidates
-
-			output, err := New(newRunnerRegistries(t, modules)).Run(context.Background(), RunInput{Pipeline: resolvedPipeline()})
-
-			assertRunError(t, err, test.want)
-			if output.Manifest.ValidationStatus != "failed" {
-				t.Fatalf("ValidationStatus = %q, want failed", output.Manifest.ValidationStatus)
-			}
-			if len(output.Approved) != 0 {
-				t.Fatalf("len(Approved) = %d, want no approved artifacts", len(output.Approved))
-			}
-		})
-	}
-}
-
-func TestRunValidatorApprovalAndRejection(t *testing.T) {
+func TestRunRecordsConfiguredValidatorsInManifest(t *testing.T) {
 	modules := defaultRunnerModules()
-	rejectFirst := &runnerValidator{
-		name: "default-validator",
-		decisions: func(candidates []artifacts.ArtifactCandidate) []contracts.ValidationDecision {
-			return []contracts.ValidationDecision{
-				validate.Rejected(candidates[0].Index, "invalid", "not accepted"),
-				validate.Approved(candidates[1].Index),
-			}
-		},
-	}
-	modules.extractors["extract-alpha"].validators = []contracts.Validator{rejectFirst}
-
-	output, err := New(newRunnerRegistries(t, modules)).Run(context.Background(), RunInput{Pipeline: resolvedPipeline()})
-	if err != nil {
-		t.Fatalf("Run() error = %v, want nil", err)
-	}
-
-	if output.Manifest.ValidationStatus != "rejected" {
-		t.Fatalf("ValidationStatus = %q, want rejected", output.Manifest.ValidationStatus)
-	}
-	if len(output.Approved) != 1 || len(output.Rejected) != 1 {
-		t.Fatalf("approved/rejected = %d/%d, want 1/1", len(output.Approved), len(output.Rejected))
-	}
-	if output.Rejected[0].ValidatorName != "default-validator" || output.Rejected[0].ReasonCode != "invalid" {
-		t.Fatalf("Rejected[0] = %#v, want rejection details", output.Rejected[0])
-	}
-}
-
-func TestRunUsesConfiguredValidatorsInLaneOrder(t *testing.T) {
-	modules := defaultRunnerModules()
-	var order []string
-	modules.validators["configured"] = &runnerValidator{name: "configured", decisions: approveAll, order: &order}
-	modules.validators["second-validator"] = &runnerValidator{name: "second-validator", decisions: approveAll, order: &order}
 
 	output, err := New(newRunnerRegistries(t, modules)).Run(context.Background(), RunInput{
 		Pipeline: resolvedPipelineWithValidators("configured", "second-validator"),
@@ -926,93 +839,17 @@ func TestRunUsesConfiguredValidatorsInLaneOrder(t *testing.T) {
 		t.Fatalf("Run() error = %v, want nil", err)
 	}
 
-	if !reflect.DeepEqual(order, []string{"configured", "second-validator"}) {
-		t.Fatalf("validator order = %#v, want configured order", order)
-	}
 	if got := output.Manifest.ArtifactLanes[0].Validators; !reflect.DeepEqual(got, []string{"configured", "second-validator"}) {
 		t.Fatalf("manifest validators = %#v, want configured validators", got)
 	}
 }
 
-func TestRunUsesDefaultValidatorsWhenLaneDoesNotConfigureValidators(t *testing.T) {
-	modules := defaultRunnerModules()
-	defaultValidator := &runnerValidator{name: "default-validator", decisions: approveAll}
-	configuredValidator := &runnerValidator{name: "configured", decisions: approveAll}
-	modules.extractors["extract-alpha"].validators = []contracts.Validator{defaultValidator}
-	modules.validators["configured"] = configuredValidator
-
-	_, err := New(newRunnerRegistries(t, modules)).Run(context.Background(), RunInput{Pipeline: resolvedPipeline()})
-	if err != nil {
-		t.Fatalf("Run() error = %v, want nil", err)
-	}
-	if defaultValidator.calls != 1 {
-		t.Fatalf("default validator calls = %d, want 1", defaultValidator.calls)
-	}
-	if configuredValidator.calls != 0 {
-		t.Fatalf("configured validator calls = %d, want 0", configuredValidator.calls)
-	}
-}
-
-func TestRunConfiguredValidatorsReplaceExtractorDefaults(t *testing.T) {
-	modules := defaultRunnerModules()
-	defaultValidator := &runnerValidator{name: "default-validator", decisions: approveAll}
-	configuredValidator := &runnerValidator{name: "configured", decisions: approveAll}
-	modules.extractors["extract-alpha"].validators = []contracts.Validator{defaultValidator}
-	modules.validators["configured"] = configuredValidator
-
-	_, err := New(newRunnerRegistries(t, modules)).Run(context.Background(), RunInput{Pipeline: resolvedPipelineWithValidators("configured")})
-	if err != nil {
-		t.Fatalf("Run() error = %v, want nil", err)
-	}
-	if defaultValidator.calls != 0 {
-		t.Fatalf("default validator calls = %d, want 0", defaultValidator.calls)
-	}
-	if configuredValidator.calls != 1 {
-		t.Fatalf("configured validator calls = %d, want 1", configuredValidator.calls)
-	}
-}
-
-func TestRunAssignsGlobalCandidateIndicesAcrossLanesAndChunks(t *testing.T) {
-	modules := defaultRunnerModules()
-	var seenIndices []int
-	recordIndices := func(candidates []artifacts.ArtifactCandidate) []contracts.ValidationDecision {
-		seenIndices = append(seenIndices, candidateIndices(candidates)...)
-		return approveAll(candidates)
-	}
-	modules.extractors["extract-alpha"].validators = []contracts.Validator{&runnerValidator{name: "alpha-validator", decisions: recordIndices}}
-	modules.extractors["extract-beta"] = &runnerExtractor{key: "extract-beta", artifactType: "artifact", schemaVersion: "v1", validators: []contracts.Validator{&runnerValidator{name: "beta-validator", decisions: recordIndices}}}
-	pipeline := resolvedPipeline()
-	pipeline.ArtifactLanes = append(pipeline.ArtifactLanes, ResolvedArtifactLane{
-		ID:        "beta",
-		Extract:   Binding("extract-beta"),
-		Merge:     Binding("merge"),
-		Normalize: Binding("normalize"),
-	})
-
-	output, err := New(newRunnerRegistries(t, modules)).Run(context.Background(), RunInput{Pipeline: pipeline})
-	if err != nil {
-		t.Fatalf("Run() error = %v, want nil", err)
-	}
-
-	if !reflect.DeepEqual(seenIndices, []int{0, 1, 2, 3}) {
-		t.Fatalf("seen indices = %#v, want global indices", seenIndices)
-	}
-	if len(output.Approved) != 4 {
-		t.Fatalf("len(Approved) = %d, want 4", len(output.Approved))
-	}
-}
-
 func TestRunCollectsStageWarnings(t *testing.T) {
 	modules := defaultRunnerModules()
 	modules.chunker.warnings = []contracts.Warning{{ReasonCode: "chunk-warning", Message: "chunk warning"}}
 	modules.extractors["extract-alpha"].warnings = []contracts.Warning{{ReasonCode: "extract-warning", Message: "extract warning"}}
 	modules.mergers["merge"].warnings = []contracts.Warning{{ReasonCode: "merge-warning", Message: "merge warning"}}
 	modules.normalizers["normalize"].warnings = []contracts.Warning{{ReasonCode: "normalize-warning", Message: "normalize warning"}}
-	modules.extractors["extract-alpha"].validators = []contracts.Validator{&runnerValidator{
-		name:      "default-validator",
-		decisions: approveAll,
-		warnings:  []contracts.Warning{{ReasonCode: "validator-warning", Message: "validator warning"}},
-	}}
 	modules.output.warnings = []contracts.Warning{{ReasonCode: "output-warning", Message: "output warning"}}
 
 	output, err := New(newRunnerRegistries(t, modules)).Run(context.Background(), RunInput{Pipeline: resolvedPipeline()})
@@ -1020,13 +857,13 @@ func TestRunCollectsStageWarnings(t *testing.T) {
 		t.Fatalf("Run() error = %v, want nil", err)
 	}
 
-	want := []string{"chunk-warning", "extract-warning", "extract-warning", "merge-warning", "normalize-warning", "validator-warning", "output-warning"}
+	want := []string{"chunk-warning", "extract-warning", "extract-warning", "merge-warning", "normalize-warning", "output-warning"}
 	if got := warningReasons(output.Warnings); !reflect.DeepEqual(got, want) {
 		t.Fatalf("warning reasons = %#v, want %#v", got, want)
 	}
 }
 
-func TestRunOutputEncoderReceivesManifestAndArtifacts(t *testing.T) {
+func TestRunOutputEncoderReceivesManifestAndRawOutputs(t *testing.T) {
 	modules := defaultRunnerModules()
 
 	output, err := New(newRunnerRegistries(t, modules)).Run(context.Background(), RunInput{Pipeline: resolvedPipeline()})
@@ -1038,8 +875,8 @@ func TestRunOutputEncoderReceivesManifestAndArtifacts(t *testing.T) {
 		t.Fatalf("len(OutputFiles) = %d, want 1", len(output.OutputFiles))
 	}
 	file := output.OutputFiles[0]
-	if file.Name != "artifacts/generic.json" {
-		t.Fatalf("OutputFiles[0].Name = %q, want artifacts/generic.json", file.Name)
+	if file.Name != "outputs/generic.json" {
+		t.Fatalf("OutputFiles[0].Name = %q, want outputs/generic.json", file.Name)
 	}
 	if file.ContentType != "application/json" {
 		t.Fatalf("ContentType = %q, want application/json", file.ContentType)
@@ -1054,8 +891,11 @@ func TestRunOutputEncoderReceivesManifestAndArtifacts(t *testing.T) {
 	if req.Manifest.PipelineID != "pipeline-1" || req.Manifest.PipelineDigest != "sha256:pipeline" {
 		t.Fatalf("output manifest = %#v, want pipeline details", req.Manifest)
 	}
-	if len(req.Approved) != 2 {
-		t.Fatalf("len(output approved) = %d, want 2", len(req.Approved))
+	if len(req.NormalizeOutputs) != 1 {
+		t.Fatalf("len(output NormalizeOutputs) = %d, want 1", len(req.NormalizeOutputs))
+	}
+	if req.NormalizeOutputs[0].LaneID != "alpha" || req.NormalizeOutputs[0].NormalizerKey != "normalize" {
+		t.Fatalf("NormalizeOutputs[0] = %#v, want normalized alpha output", req.NormalizeOutputs[0])
 	}
 }
 
@@ -1066,9 +906,9 @@ func TestRunRejectsUnsafeOutputFileNames(t *testing.T) {
 	}{
 		{name: "empty", fileName: ""},
 		{name: "absolute", fileName: "/tmp/output.json"},
-		{name: "parent", fileName: "artifacts/../manifest.json"},
-		{name: "backslash", fileName: `artifacts\manifest.json`},
-		{name: "unclean", fileName: "artifacts//manifest.json"},
+		{name: "parent", fileName: "outputs/../manifest.json"},
+		{name: "backslash", fileName: `outputs\manifest.json`},
+		{name: "unclean", fileName: "outputs//manifest.json"},
 	}
 
 	for _, test := range tests {
@@ -1101,8 +941,8 @@ func TestRunReturnsFailedManifestWhenOutputEncoderFails(t *testing.T) {
 	if output.Manifest.CompletedAt == nil {
 		t.Fatal("CompletedAt = nil, want failed run completion timestamp")
 	}
-	if len(output.Approved) != 2 {
-		t.Fatalf("len(Approved) = %d, want partial approved output", len(output.Approved))
+	if len(output.NormalizeOutputs) != 1 {
+		t.Fatalf("len(NormalizeOutputs) = %d, want partial normalized output", len(output.NormalizeOutputs))
 	}
 }
 
@@ -1313,7 +1153,7 @@ func TestRunManifestIncludesExtractorMetadata(t *testing.T) {
 
 func TestRunReturnsPartialOutputWhenLaterLaneFails(t *testing.T) {
 	modules := defaultRunnerModules()
-	modules.extractors["extract-beta"] = &runnerExtractor{key: "extract-beta", artifactType: "artifact", schemaVersion: "v1", err: errors.New("extract failed")}
+	modules.extractors["extract-beta"] = &runnerExtractor{key: "extract-beta", err: errors.New("extract failed")}
 	pipeline := resolvedPipeline()
 	pipeline.ArtifactLanes = append(pipeline.ArtifactLanes, ResolvedArtifactLane{
 		ID:        "beta",
@@ -1328,46 +1168,8 @@ func TestRunReturnsPartialOutputWhenLaterLaneFails(t *testing.T) {
 	if output.Manifest.ValidationStatus != "failed" {
 		t.Fatalf("ValidationStatus = %q, want failed", output.Manifest.ValidationStatus)
 	}
-	if len(output.Approved) != 2 {
-		t.Fatalf("len(Approved) = %d, want first lane approved output", len(output.Approved))
-	}
-}
-
-func TestRunSurfacesValidatorErrors(t *testing.T) {
-	tests := []struct {
-		name      string
-		validator *runnerValidator
-		want      string
-	}{
-		{name: "name mismatch", validator: &runnerValidator{name: "default-validator", resultName: "other", decisions: approveAll}, want: "returned result"},
-		{name: "cardinality", validator: &runnerValidator{name: "default-validator", decisions: func(candidates []artifacts.ArtifactCandidate) []contracts.ValidationDecision { return nil }}, want: "0 decisions"},
-		{name: "error", validator: &runnerValidator{name: "default-validator", decisions: approveAll, err: errors.New("validator failed")}, want: "validator failed"},
-	}
-
-	for _, test := range tests {
-		t.Run(test.name, func(t *testing.T) {
-			modules := defaultRunnerModules()
-			modules.extractors["extract-alpha"].validators = []contracts.Validator{test.validator}
-
-			output, err := New(newRunnerRegistries(t, modules)).Run(context.Background(), RunInput{Pipeline: resolvedPipeline()})
-
-			assertRunError(t, err, test.want)
-			if output.Manifest.ValidationStatus != "failed" {
-				t.Fatalf("ValidationStatus = %q, want failed", output.Manifest.ValidationStatus)
-			}
-		})
-	}
-}
-
-func TestRunRejectsNilDefaultValidator(t *testing.T) {
-	modules := defaultRunnerModules()
-	modules.extractors["extract-alpha"].validators = []contracts.Validator{nil}
-
-	output, err := New(newRunnerRegistries(t, modules)).Run(context.Background(), RunInput{Pipeline: resolvedPipeline()})
-
-	assertRunError(t, err, "validator[0] must not be nil")
-	if output.Manifest.ValidationStatus != "failed" {
-		t.Fatalf("ValidationStatus = %q, want failed", output.Manifest.ValidationStatus)
+	if len(output.NormalizeOutputs) != 1 {
+		t.Fatalf("len(NormalizeOutputs) = %d, want first lane output", len(output.NormalizeOutputs))
 	}
 }
 
@@ -1438,7 +1240,7 @@ func defaultRunnerModules() *runnerModules {
 		input:   &runnerInputAdapter{key: "input", doc: validSourceDocument()},
 		chunker: &runnerChunker{key: "chunk", chunks: []contracts.SourceChunk{sourceChunkWithID("chunk-0", 0), sourceChunkWithID("chunk-1", 1)}},
 		extractors: map[string]*runnerExtractor{
-			"extract-alpha": {key: "extract-alpha", artifactType: "artifact", schemaVersion: "v1"},
+			"extract-alpha": {key: "extract-alpha"},
 		},
 		mergers: map[string]*runnerMerger{
 			"merge": {key: "merge"},
@@ -1447,13 +1249,13 @@ func defaultRunnerModules() *runnerModules {
 			"normalize": {key: "normalize"},
 		},
 		validators: map[string]*runnerValidator{
-			"configured":       {name: "configured", decisions: approveAll},
-			"second-validator": {name: "second-validator", decisions: approveAll},
+			"configured":       {name: "configured"},
+			"second-validator": {name: "second-validator"},
 		},
 		output: &runnerOutputEncoder{
 			key: "output",
 			files: []contracts.OutputFile{
-				{Name: "artifacts/generic.json", ContentType: "application/json", Bytes: []byte(`{"encoded":true}`)},
+				{Name: "outputs/generic.json", ContentType: "application/json", Bytes: []byte(`{"encoded":true}`)},
 			},
 		},
 	}
@@ -1572,11 +1374,8 @@ func (chunker *runnerChunker) ManifestMetadata() map[string]any {
 
 type runnerExtractor struct {
 	key              string
-	artifactType     string
-	schemaVersion    string
 	manifestMetadata map[string]any
-	candidates       []artifacts.ArtifactCandidate
-	validators       []contracts.Validator
+	output           *contracts.ExtractOutput
 	warnings         []contracts.Warning
 	err              error
 	requests         []contracts.ExtractionRequest
@@ -1589,14 +1388,6 @@ func (extractor *runnerExtractor) Key() string {
 	return extractor.key
 }
 
-func (extractor *runnerExtractor) ArtifactType() string {
-	return extractor.artifactType
-}
-
-func (extractor *runnerExtractor) SchemaVersion() string {
-	return extractor.schemaVersion
-}
-
 func (extractor *runnerExtractor) ReferenceSlots() []contracts.ReferenceSlot {
 	return nil
 }
@@ -1605,10 +1396,6 @@ func (extractor *runnerExtractor) ManifestMetadata() map[string]any {
 	return extractor.manifestMetadata
 }
 
-func (extractor *runnerExtractor) Validators() []contracts.Validator {
-	return extractor.validators
-}
-
 func (extractor *runnerExtractor) Extract(ctx context.Context, req contracts.ExtractionRequest) (contracts.ExtractionResult, error) {
 	extractor.requests = append(extractor.requests, req)
 	if req.Chunk != nil {
@@ -1617,19 +1404,28 @@ func (extractor *runnerExtractor) Extract(ctx context.Context, req contracts.Ext
 	extractor.seenLLMClients = append(extractor.seenLLMClients, req.LLMClient)
 	extractor.seenMetadata = append(extractor.seenMetadata, req.Metadata)
 
-	candidates := append([]artifacts.ArtifactCandidate(nil), extractor.candidates...)
-	if len(candidates) == 0 {
-		candidates = []artifacts.ArtifactCandidate{{Payload: []byte(`{"value":true}`)}}
+	output := contracts.ExtractOutput{
+		Schema: contracts.ResponseSchema{ID: "runner.raw", Name: "runner_raw", Version: "v1"},
+		Payload: contracts.RawPayload{
+			Content:   []byte(`{"value":true}`),
+			MediaType: "application/json",
+		},
+	}
+	if req.Chunk != nil {
+		output.Payload.Content = []byte(`{"chunk":"` + req.Chunk.ID + `"}`)
+	}
+	if extractor.output != nil {
+		output = *extractor.output
 	}
 	return contracts.ExtractionResult{
-		Candidates: candidates,
-		Warnings:   extractor.warnings,
+		Output:   output,
+		Warnings: extractor.warnings,
 	}, extractor.err
 }
 
 type runnerMerger struct {
 	key      string
-	result   []artifacts.ArtifactCandidate
+	result   *contracts.MergeOutput
 	warnings []contracts.Warning
 	err      error
 	requests []contracts.MergeRequest
@@ -1641,21 +1437,27 @@ func (merger *runnerMerger) Key() string {
 
 func (merger *runnerMerger) Merge(ctx context.Context, req contracts.MergeRequest) (contracts.MergeResult, error) {
 	merger.requests = append(merger.requests, req)
-	candidates := append([]artifacts.ArtifactCandidate(nil), merger.result...)
-	if candidates == nil {
-		for _, chunkArtifacts := range req.ChunkArtifacts {
-			candidates = append(candidates, chunkArtifacts.Candidates...)
-		}
+	output := contracts.MergeOutput{
+		LaneID:   req.LaneID,
+		SourceID: req.Source.ID,
+		Schema:   contracts.ResponseSchema{ID: "runner.raw", Name: "runner_raw", Version: "v1"},
+		Payload: contracts.RawPayload{
+			Content:   []byte(`{"merged":true}`),
+			MediaType: "application/json",
+		},
+	}
+	if merger.result != nil {
+		output = *merger.result
 	}
 	return contracts.MergeResult{
-		Candidates: candidates,
-		Warnings:   merger.warnings,
+		Output:   output,
+		Warnings: merger.warnings,
 	}, merger.err
 }
 
 type runnerNormalizer struct {
 	key      string
-	result   []artifacts.ArtifactCandidate
+	result   *contracts.NormalizeOutput
 	warnings []contracts.Warning
 	err      error
 	requests []contracts.NormalizeRequest
@@ -1671,13 +1473,18 @@ func (normalizer *runnerNormalizer) ReferenceSlots() []contracts.ReferenceSlot {
 
 func (normalizer *runnerNormalizer) Normalize(ctx context.Context, req contracts.NormalizeRequest) (contracts.NormalizeResult, error) {
 	normalizer.requests = append(normalizer.requests, req)
-	candidates := append([]artifacts.ArtifactCandidate(nil), normalizer.result...)
-	if candidates == nil {
-		candidates = append(candidates, req.Candidates...)
+	output := contracts.NormalizeOutput{
+		LaneID:   req.LaneID,
+		SourceID: req.MergeOutput.SourceID,
+		Schema:   req.MergeOutput.Schema,
+		Payload:  req.MergeOutput.Payload,
+	}
+	if normalizer.result != nil {
+		output = *normalizer.result
 	}
 	return contracts.NormalizeResult{
-		Candidates: candidates,
-		Warnings:   normalizer.warnings,
+		Output:   output,
+		Warnings: normalizer.warnings,
 	}, normalizer.err
 }
 
@@ -1757,14 +1564,6 @@ func (client manifestReportingLLMClient) LLMProfileManifests() []artifacts.LLMPr
 	return append([]artifacts.LLMProfileManifest(nil), client.profiles...)
 }
 
-func approveAll(candidates []artifacts.ArtifactCandidate) []contracts.ValidationDecision {
-	decisions := make([]contracts.ValidationDecision, 0, len(candidates))
-	for _, candidate := range candidates {
-		decisions = append(decisions, validate.Approved(candidate.Index))
-	}
-	return decisions
-}
-
 func validSourceDocument() *source.SourceDocument {
 	return &source.SourceDocument{
 		ID:     "source-1",
@@ -1866,24 +1665,6 @@ func warningReasons(warnings []contracts.Warning) []string {
 	return reasons
 }
 
-func candidateIndices(candidates []artifacts.ArtifactCandidate) []int {
-	indices := make([]int, 0, len(candidates))
-	for _, candidate := range candidates {
-		indices = append(indices, candidate.Index)
-	}
-	return indices
-}
-
-func runnerCandidate(index int) artifacts.ArtifactCandidate {
-	return artifacts.ArtifactCandidate{
-		Index:         index,
-		ExtractorKey:  "extract-alpha",
-		ArtifactType:  "artifact",
-		SchemaVersion: "v1",
-		Payload:       []byte(`{"value":true}`),
-	}
-}
-
 func assertRunError(t *testing.T, err error, want string) {
 	t.Helper()