Implement raw module output contracts

internal/modules/extract/dnd/spells/extractor.go

@@ -4,10 +4,7 @@ import (
 	"context"
 	"encoding/json"
 	"fmt"
-	"strings"
 
-	"gitea.maximumdirect.net/eric/notarius/internal/core/artifacts"
-	"gitea.maximumdirect.net/eric/notarius/internal/core/source"
 	"gitea.maximumdirect.net/eric/notarius/internal/framework/contracts"
 	"gitea.maximumdirect.net/eric/notarius/internal/framework/pipeline"
 	"gitea.maximumdirect.net/eric/notarius/internal/modules/sharedassets/dnd"
@@ -45,14 +42,6 @@ func (e *Extractor) Key() string {
 	return Key
 }
 
-func (e *Extractor) ArtifactType() string {
-	return ArtifactType
-}
-
-func (e *Extractor) SchemaVersion() string {
-	return SchemaVersion
-}
-
 func (e *Extractor) ReferenceSlots() []contracts.ReferenceSlot {
 	return dnd.ReferenceSlots(referenceSlotDescriptions)
 }
@@ -77,13 +66,6 @@ func (e *Extractor) ManifestMetadata() map[string]any {
 	return metadata
 }
 
-func (e *Extractor) Validators() []contracts.Validator {
-	return []contracts.Validator{
-		ShapeValidator{},
-		SourceRefValidator{},
-	}
-}
-
 func (e *Extractor) Extract(ctx context.Context, req contracts.ExtractionRequest) (contracts.ExtractionResult, error) {
 	if e == nil {
 		return contracts.ExtractionResult{}, extractorErrorf("extractor must not be nil")
@@ -121,22 +103,26 @@ func (e *Extractor) Extract(ctx context.Context, req contracts.ExtractionRequest
 	if response.SpellCasts == nil {
 		return contracts.ExtractionResult{}, extractorErrorf("malformed structured output: spell_casts must be present")
 	}
-	if len(response.SpellCasts) == 0 {
-		return contracts.ExtractionResult{}, nil
+	content, err := json.Marshal(response)
+	if err != nil {
+		return contracts.ExtractionResult{}, extractorErrorf("marshal raw output: %w", err)
 	}
-
-	candidates := make([]artifacts.ArtifactCandidate, 0, len(response.SpellCasts))
-	for i, spellCast := range response.SpellCasts {
-		payload, err := spellCastPayload(spellCast)
-		if err != nil {
-			return contracts.ExtractionResult{}, extractorErrorf("marshal spell cast[%d]: %w", i, err)
-		}
-		candidates = append(candidates, artifacts.ArtifactCandidate{
-			Payload:    payload,
-			SourceRefs: sourceRefCandidates(req.Source, spellCast.SourceRefs),
-		})
-	}
-	return contracts.ExtractionResult{Candidates: candidates}, nil
+	return contracts.ExtractionResult{
+		Output: contracts.ExtractOutput{
+			Schema: contracts.ResponseSchema{
+				ID:      ResponseSchemaID,
+				Name:    ResponseSchemaName,
+				Version: SchemaVersion,
+			},
+			Payload: contracts.RawPayload{
+				Content:   content,
+				MediaType: "application/json",
+				Metadata: map[string]any{
+					"spell_cast_count": len(response.SpellCasts),
+				},
+			},
+		},
+	}, nil
 }
 
 func ModuleSpec() pipeline.ModuleSpec {
@@ -155,26 +141,6 @@ func Register(registry *pipeline.ExtractorRegistry) error {
 	})
 }
 
-func spellCastPayload(spellCast spellCastResponse) (json.RawMessage, error) {
-	return json.Marshal(SpellCast{
-		Caster:               strings.TrimSpace(spellCast.Caster),
-		Spell:                strings.TrimSpace(spellCast.Spell),
-		Effect:               strings.TrimSpace(spellCast.Effect),
-		NarrativeDescription: strings.TrimSpace(spellCast.NarrativeDescription),
-	})
-}
-
-func sourceRefCandidates(doc *source.SourceDocument, refs []dnd.SourceRefResponse) []source.SourceRef {
-	if len(refs) == 0 {
-		return nil
-	}
-	out := make([]source.SourceRef, 0, len(refs))
-	for _, ref := range refs {
-		out = append(out, dnd.SourceRefCandidate(doc, ref))
-	}
-	return out
-}
-
 func extractorErrorf(format string, args ...any) error {
 	return fmt.Errorf("dnd spells extractor: "+format, args...)
 }

internal/modules/extract/dnd/spells/extractor_test.go

@@ -7,12 +7,11 @@ import (
 	"strings"
 	"testing"
 
-	"gitea.maximumdirect.net/eric/notarius/internal/core/source"
 	"gitea.maximumdirect.net/eric/notarius/internal/framework/contracts"
 	"gitea.maximumdirect.net/eric/notarius/internal/modules/sharedassets/dnd"
 )
 
-func TestExtractReturnsSpellCandidateFromStructuredOutput(t *testing.T) {
+func TestExtractReturnsRawOutputFromStructuredResponse(t *testing.T) {
 	client := &fakeSpellsLLMClient{
 		response: extractionResponse{
 			SpellCasts: []spellCastResponse{
@@ -53,29 +52,19 @@ func TestExtractReturnsSpellCandidateFromStructuredOutput(t *testing.T) {
 		t.Fatalf("transcript content = %q, want original source input", got)
 	}
 
-	if len(result.Candidates) != 1 {
-		t.Fatalf("len(Candidates) = %d, want 1", len(result.Candidates))
+	if result.Output.Payload.MediaType != "application/json" {
+		t.Fatalf("MediaType = %q, want application/json", result.Output.Payload.MediaType)
 	}
-	candidate := result.Candidates[0]
-	if candidate.Index != 0 || candidate.ExtractorKey != "" || candidate.ArtifactType != "" || candidate.SchemaVersion != "" {
-		t.Fatalf("candidate envelope fields = %#v, want runner-normalized zero values", candidate)
+	if result.Output.Schema.ID != ResponseSchemaID || result.Output.Schema.Name != ResponseSchemaName || result.Output.Schema.Version != SchemaVersion {
+		t.Fatalf("schema = %#v, want response schema provenance", result.Output.Schema)
 	}
-	var payload SpellCast
-	if err := json.Unmarshal(candidate.Payload, &payload); err != nil {
-		t.Fatalf("Unmarshal(Payload) error = %v, want nil", err)
+
+	var payload extractionResponse
+	if err := json.Unmarshal(result.Output.Payload.Content, &payload); err != nil {
+		t.Fatalf("Unmarshal(Content) error = %v, want nil", err)
 	}
-	wantPayload := SpellCast{
-		Caster:               "Aria",
-		Spell:                "Cure Wounds",
-		Effect:               "Heals an injured ally.",
-		NarrativeDescription: "Aria restores the fighter after the fight.",
-	}
-	if payload != wantPayload {
-		t.Fatalf("payload = %#v, want %#v", payload, wantPayload)
-	}
-	wantRef := source.SourceRef{SourceID: "session-alpha", StartUnitID: 1, EndUnitID: 2}
-	if len(candidate.SourceRefs) != 1 || candidate.SourceRefs[0] != wantRef {
-		t.Fatalf("SourceRefs = %#v, want %#v", candidate.SourceRefs, []source.SourceRef{wantRef})
+	if len(payload.SpellCasts) != 1 || payload.SpellCasts[0].Spell != " Cure Wounds " {
+		t.Fatalf("payload = %#v, want raw structured response", payload)
 	}
 }
 
@@ -174,15 +163,19 @@ func TestPromptInputsMapLegacyRosterReferenceToParty(t *testing.T) {
 	}
 }
 
-func TestExtractReturnsNoCandidatesForEmptyResponse(t *testing.T) {
+func TestExtractReturnsRawOutputForEmptyResponse(t *testing.T) {
 	client := &fakeSpellsLLMClient{response: extractionResponse{SpellCasts: []spellCastResponse{}}}
 
 	result, err := New().Extract(context.Background(), extractionRequestWithClient(client))
 	if err != nil {
 		t.Fatalf("Extract() error = %v, want nil", err)
 	}
-	if len(result.Candidates) != 0 {
-		t.Fatalf("Candidates = %#v, want none", result.Candidates)
+	var payload extractionResponse
+	if err := json.Unmarshal(result.Output.Payload.Content, &payload); err != nil {
+		t.Fatalf("Unmarshal(Content) error = %v, want nil", err)
+	}
+	if len(payload.SpellCasts) != 0 {
+		t.Fatalf("SpellCasts = %#v, want none", payload.SpellCasts)
 	}
 }
 
@@ -271,23 +264,16 @@ func TestExtractPreservesResponseOrder(t *testing.T) {
 	if err != nil {
 		t.Fatalf("Extract() error = %v, want nil", err)
 	}
-	if len(result.Candidates) != 2 {
-		t.Fatalf("len(Candidates) = %d, want 2", len(result.Candidates))
+	var payload extractionResponse
+	if err := json.Unmarshal(result.Output.Payload.Content, &payload); err != nil {
+		t.Fatalf("Unmarshal(Content) error = %v, want nil", err)
 	}
-
-	var first, second SpellCast
-	if err := json.Unmarshal(result.Candidates[0].Payload, &first); err != nil {
-		t.Fatalf("Unmarshal(first) error = %v, want nil", err)
-	}
-	if err := json.Unmarshal(result.Candidates[1].Payload, &second); err != nil {
-		t.Fatalf("Unmarshal(second) error = %v, want nil", err)
-	}
-	if first.Spell != "Cure Wounds" || second.Spell != "Fire Bolt" {
-		t.Fatalf("candidate order = %q, %q; want response order", first.Spell, second.Spell)
+	if len(payload.SpellCasts) != 2 || payload.SpellCasts[0].Spell != "Cure Wounds" || payload.SpellCasts[1].Spell != "Fire Bolt" {
+		t.Fatalf("spell order = %#v, want response order", payload.SpellCasts)
 	}
 }
 
-func TestExtractCopiesCandidateSourceRefs(t *testing.T) {
+func TestExtractDefensivelyCopiesRawContent(t *testing.T) {
 	client := &fakeSpellsLLMClient{
 		response: extractionResponse{
 			SpellCasts: []spellCastResponse{
@@ -308,8 +294,12 @@ func TestExtractCopiesCandidateSourceRefs(t *testing.T) {
 	}
 	client.response.SpellCasts[0].SourceRefs[0].StartUnitID = dnd.UnitRefFromInt(99)
 
-	if got := result.Candidates[0].SourceRefs[0].StartUnitID; got != 1 {
-		t.Fatalf("candidate source ref start = %d, want copied 1", got)
+	var payload extractionResponse
+	if err := json.Unmarshal(result.Output.Payload.Content, &payload); err != nil {
+		t.Fatalf("Unmarshal(Content) error = %v, want nil", err)
+	}
+	if got := payload.SpellCasts[0].SourceRefs[0].StartUnitID.String(); got != "1" {
+		t.Fatalf("source ref start = %q, want copied 1", got)
 	}
 }
 

internal/modules/extract/dnd/spells/registry_test.go

@@ -17,12 +17,6 @@ func TestNewReturnsExtractorWithMetadata(t *testing.T) {
 	if extractor.Key() != Key {
 		t.Fatalf("extractor.Key() = %q, want %q", extractor.Key(), Key)
 	}
-	if extractor.ArtifactType() != ArtifactType {
-		t.Fatalf("extractor.ArtifactType() = %q, want %q", extractor.ArtifactType(), ArtifactType)
-	}
-	if extractor.SchemaVersion() != SchemaVersion {
-		t.Fatalf("extractor.SchemaVersion() = %q, want %q", extractor.SchemaVersion(), SchemaVersion)
-	}
 }
 
 func TestModuleSpec(t *testing.T) {

internal/modules/extract/dnd/spells/runner_test.go

@@ -48,31 +48,30 @@ func TestRunnerProcessesSeriatimInputWithDNDSpellsExtractor(t *testing.T) {
 		t.Fatalf("Run() error = %v, want nil", err)
 	}
 
-	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 1", len(output.NormalizeOutputs))
 	}
-	var first, second SpellCast
-	if err := json.Unmarshal(output.Approved[0].Payload, &first); err != nil {
-		t.Fatalf("Unmarshal(first payload) error = %v, want nil", err)
+	rawOutput := output.NormalizeOutputs[0]
+	if rawOutput.LaneID != "spells" || rawOutput.Schema.ID != ResponseSchemaID || rawOutput.Schema.Version != SchemaVersion {
+		t.Fatalf("raw output envelope = %#v, want dnd spells schema on spells lane", rawOutput)
 	}
-	if err := json.Unmarshal(output.Approved[1].Payload, &second); err != nil {
-		t.Fatalf("Unmarshal(second payload) error = %v, want nil", err)
+	response := decodeRunnerSpellResponse(t, rawOutput.Payload.Content)
+	if len(response.SpellCasts) != 2 {
+		t.Fatalf("len(spell_casts) = %d, want 2", len(response.SpellCasts))
 	}
+	first, second := response.SpellCasts[0], response.SpellCasts[1]
 	if first.Spell != "Cure Wounds" || second.Spell != "Fire Bolt" {
-		t.Fatalf("approved spell order = %q, %q; want response order", first.Spell, second.Spell)
+		t.Fatalf("spell order = %q, %q; want response order", first.Spell, second.Spell)
 	}
 	if first.Caster != "Aria" || second.Caster != "Borin" {
-		t.Fatalf("approved casters = %q, %q; want spell data", first.Caster, second.Caster)
+		t.Fatalf("casters = %q, %q; want spell data", first.Caster, second.Caster)
 	}
-	for _, artifact := range output.Approved {
-		if artifact.ExtractorKey != Key || artifact.ArtifactType != ArtifactType || artifact.SchemaVersion != SchemaVersion {
-			t.Fatalf("approved artifact envelope = %#v, want dnd spells envelope", artifact)
+	for _, spell := range response.SpellCasts {
+		if len(spell.SourceRefs) != 1 {
+			t.Fatalf("len(SourceRefs) = %d, want 1", len(spell.SourceRefs))
 		}
-		if len(artifact.SourceRefs) != 1 {
-			t.Fatalf("len(SourceRefs) = %d, want 1", len(artifact.SourceRefs))
-		}
-		if err := source.ValidateRef(expectedDoc, artifact.SourceRefs[0]); err != nil {
-			t.Fatalf("ValidateRef() error = %v, want nil", err)
+		if spell.SourceRefs[0].SourceID != expectedDoc.ID {
+			t.Fatalf("SourceID = %q, want fixture document ID", spell.SourceRefs[0].SourceID)
 		}
 	}
 
@@ -137,8 +136,8 @@ func TestRunnerPassesPartyAndGlossaryReferencesToDNDSpellsPrompt(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))
 	}
 	if len(output.Manifest.References) != 2 {
 		t.Fatalf("manifest references = %#v, want party and glossary provenance", output.Manifest.References)
@@ -178,8 +177,12 @@ func TestRunnerDoesNotExtractSpellMentionedOnlyInPartyReference(t *testing.T) {
 		t.Fatalf("Run() error = %v, want nil", err)
 	}
 
-	if len(output.Approved) != 0 {
-		t.Fatalf("approved artifacts = %#v, want no party-reference-only spell casts", output.Approved)
+	if len(output.NormalizeOutputs) != 1 {
+		t.Fatalf("len(NormalizeOutputs) = %d, want empty spell response output", len(output.NormalizeOutputs))
+	}
+	response := decodeRunnerSpellResponse(t, output.NormalizeOutputs[0].Payload.Content)
+	if len(response.SpellCasts) != 0 {
+		t.Fatalf("spell_casts = %#v, want no party-reference-only spell casts", response.SpellCasts)
 	}
 	if len(llmClient.requests) != 1 {
 		t.Fatalf("LLM calls = %d, want 1", len(llmClient.requests))
@@ -196,7 +199,7 @@ func TestRunnerDoesNotExtractSpellMentionedOnlyInPartyReference(t *testing.T) {
 	}
 }
 
-func TestRunnerRejectsDNDSpellCastWithInvalidSourceRef(t *testing.T) {
+func TestRunnerCarriesDNDSpellCastWithInvalidSourceRefAsRawOutput(t *testing.T) {
 	raw := readDNDSpellsFixture(t)
 	resolved := resolveDNDSpellsPipeline(t)
 	llmClient := &fakeSpellsLLMClient{
@@ -221,21 +224,21 @@ func TestRunnerRejectsDNDSpellCastWithInvalidSourceRef(t *testing.T) {
 	if err != nil {
 		t.Fatalf("Run() error = %v, want nil", err)
 	}
-	if len(output.Approved) != 0 {
-		t.Fatalf("len(Approved) = %d, want 0", len(output.Approved))
+	if len(output.NormalizeOutputs) != 1 {
+		t.Fatalf("len(NormalizeOutputs) = %d, want 1", len(output.NormalizeOutputs))
 	}
-	if len(output.Rejected) != 1 {
-		t.Fatalf("len(Rejected) = %d, want 1", len(output.Rejected))
+	response := decodeRunnerSpellResponse(t, output.NormalizeOutputs[0].Payload.Content)
+	if len(response.SpellCasts) != 1 {
+		t.Fatalf("len(spell_casts) = %d, want 1", len(response.SpellCasts))
 	}
-	rejected := output.Rejected[0]
-	if rejected.ValidatorName != sourceRefValidatorName {
-		t.Fatalf("ValidatorName = %q, want %q", rejected.ValidatorName, sourceRefValidatorName)
+	if response.SpellCasts[0].SourceRefs[0].SourceID != "spell-session" {
+		t.Fatalf("SourceID = %q, want raw invalid source ref preserved", response.SpellCasts[0].SourceRefs[0].SourceID)
 	}
-	if rejected.ReasonCode != reasonInvalidSourceRef {
-		t.Fatalf("ReasonCode = %q, want %q", rejected.ReasonCode, reasonInvalidSourceRef)
+	if len(output.Rejected) != 0 {
+		t.Fatalf("len(Rejected) = %d, want 0", len(output.Rejected))
 	}
-	if output.Manifest.ValidationStatus != "rejected" {
-		t.Fatalf("ValidationStatus = %q, want rejected", output.Manifest.ValidationStatus)
+	if output.Manifest.ValidationStatus != "approved" {
+		t.Fatalf("ValidationStatus = %q, want approved", output.Manifest.ValidationStatus)
 	}
 }
 
@@ -345,3 +348,13 @@ func parseDNDSpellsFixture(t *testing.T, raw []byte) *source.SourceDocument {
 	}
 	return doc
 }
+
+func decodeRunnerSpellResponse(t *testing.T, raw []byte) extractionResponse {
+	t.Helper()
+
+	var response extractionResponse
+	if err := json.Unmarshal(raw, &response); err != nil {
+		t.Fatalf("Unmarshal(raw output) error = %v, want nil", err)
+	}
+	return response
+}

internal/modules/extract/dnd/spells/validator_test.go

@@ -12,26 +12,6 @@ import (
 	"gitea.maximumdirect.net/eric/notarius/internal/framework/validate"
 )
 
-func TestExtractorValidatorsReturnsExpectedChain(t *testing.T) {
-	validators := New().Validators()
-
-	if len(validators) != 2 {
-		t.Fatalf("len(Validators()) = %d, want 2", len(validators))
-	}
-	if validators[0].Name() != shapeValidatorName {
-		t.Fatalf("Validators()[0].Name() = %q, want %q", validators[0].Name(), shapeValidatorName)
-	}
-	if validators[1].Name() != sourceRefValidatorName {
-		t.Fatalf("Validators()[1].Name() = %q, want %q", validators[1].Name(), sourceRefValidatorName)
-	}
-
-	validators[0] = nil
-	again := New().Validators()
-	if len(again) != 2 || again[0] == nil || again[0].Name() != shapeValidatorName {
-		t.Fatalf("Validators() after caller mutation = %#v, want fresh validators", again)
-	}
-}
-
 func TestValidatorsApproveValidCandidate(t *testing.T) {
 	candidate := validSpellCandidate(7)