Add NPC registry grounding for spell extraction

internal/modules/integration/dnd_npc_spell_sequential_test.go

@@ -0,0 +1,130 @@
+package integration_test
+
+import (
+	"os"
+	"path/filepath"
+	"strings"
+	"testing"
+
+	"gitea.maximumdirect.net/eric/notarius/internal/core/config"
+	"gitea.maximumdirect.net/eric/notarius/internal/framework/contracts"
+	"gitea.maximumdirect.net/eric/notarius/internal/framework/pipeline"
+	npccodec "gitea.maximumdirect.net/eric/notarius/internal/modules/dnd/codec/npcs"
+	"gitea.maximumdirect.net/eric/notarius/internal/modules/dnd/extract/spells"
+)
+
+func TestSequentialNPCOutputCanGroundIndependentSpellRun(t *testing.T) {
+	registries := productionNPCRegistries(t)
+	catalog := moduleCatalog(registries)
+	configValue := loadSequentialPipelineConfig(t)
+
+	npcEffective, err := configValue.Resolve(config.ResolveInput{PipelineID: "dnd-npcs", Catalog: catalog})
+	if err != nil {
+		t.Fatalf("resolve NPC pipeline: %v", err)
+	}
+	npcClient := &fakeNPCProductionLLMClient{response: npcProductionResponse{NPCs: []npcProductionRecord{{
+		Name:        "Mira Thorn",
+		Aliases:     []string{"The Greencloak"},
+		Description: "A guarded ranger who watches the northern road.",
+		Relationships: []npcProductionRelationship{{
+			Target: "Captain Vale", Relationship: "reports to",
+		}},
+		SourceRefs: []npcProductionSourceRef{{StartUnitID: 1, EndUnitID: 2}},
+	}}}}
+	npcOutput, err := runPreparedPipeline(t, registries, npcEffective.ResolvedPipeline, npcClient, pipeline.RunInput{RawInput: readNPCFixture(t)})
+	if err != nil {
+		t.Fatalf("run NPC pipeline: %v", err)
+	}
+	if len(npcOutput.NormalizeOutputs) != 1 || npcOutput.NormalizeOutputs[0].LaneID != "npcs" {
+		t.Fatalf("NPC normalized outputs = %#v, want one npcs lane", npcOutput.NormalizeOutputs)
+	}
+	npcPayload := npcOutput.NormalizeOutputs[0].Artifact.Content
+	if _, err := npccodec.New().Decode(npcPayload); err != nil {
+		t.Fatalf("decode normalized NPC payload: %v", err)
+	}
+
+	npcRunDir := t.TempDir()
+	npcPath := filepath.Join(npcRunDir, "lanes", "npcs.json")
+	if err := os.MkdirAll(filepath.Dir(npcPath), 0o700); err != nil {
+		t.Fatalf("create NPC output directory: %v", err)
+	}
+	if err := os.WriteFile(npcPath, npcPayload, 0o600); err != nil {
+		t.Fatalf("write NPC output payload: %v", err)
+	}
+
+	spellEffective, err := configValue.Resolve(config.ResolveInput{PipelineID: "dnd-spells", Catalog: catalog})
+	if err != nil {
+		t.Fatalf("resolve spell pipeline: %v", err)
+	}
+	spellEffective.ResolvedPipeline.ArtifactLanes[0].ExtractReferences.Bindings = []pipeline.ReferenceBinding{{
+		Stage:         pipeline.StageExtract,
+		LaneID:        "spells",
+		SlotName:      spells.NPCRegistryReferenceSlot,
+		Source:        npcPath,
+		BindingSource: contracts.ReferenceBindingSourceCLI,
+	}}
+	materialized, warnings, err := pipeline.MaterializeReferences(spellEffective.ResolvedPipeline, catalog, pipeline.ReferenceMaterializationOptions{WorkingDir: npcRunDir})
+	if err != nil {
+		t.Fatalf("materialize NPC registry reference: %v", err)
+	}
+	if len(warnings) != 0 {
+		t.Fatalf("reference materialization warnings = %#v, want none", warnings)
+	}
+
+	spellClient := &fakeSpellsLLMClient{response: extractionResponse{SpellCasts: []spellCastResponse{{
+		Caster:               "Mira Thorn",
+		Spell:                "Cure Wounds",
+		Effect:               "Restores the injured ally.",
+		NarrativeDescription: "Mira Thorn restores the ally after the fight.",
+		SourceRefs:           responseSourceRefs("spell-session", 1, 1),
+	}}}}
+	spellOutput, err := runPreparedPipeline(t, registries, materialized, spellClient, pipeline.RunInput{RawInput: readDNDSpellsFixture(t)})
+	if err != nil {
+		t.Fatalf("run spell pipeline: %v", err)
+	}
+	if len(spellOutput.NormalizeOutputs) != 1 || spellOutput.NormalizeOutputs[0].LaneID != "spells" {
+		t.Fatalf("spell normalized outputs = %#v, want one spells lane", spellOutput.NormalizeOutputs)
+	}
+	spellValue := decodeRunnerSpellResponse(t, spellOutput.NormalizeOutputs[0].Artifact.Content)
+	if len(spellValue.SpellCasts) != 1 || spellValue.SpellCasts[0].Caster != "Mira Thorn" {
+		t.Fatalf("spell output = %#v, want one registry-grounded caster", spellValue)
+	}
+	if len(spellValue.SpellCasts[0].SourceRefs) != 1 || spellValue.SpellCasts[0].SourceRefs[0].SourceID != "spell-session" {
+		t.Fatalf("spell source refs = %#v, want current spell session only", spellValue.SpellCasts[0].SourceRefs)
+	}
+	if len(spellClient.requests) != 1 {
+		t.Fatalf("spell LLM requests = %d, want one", len(spellClient.requests))
+	}
+	registryInput := spellClient.requests[0].Inputs[spells.NPCRegistryReferenceSlot]
+	if string(registryInput.Content) != string(npcPayload) || registryInput.MediaType != npccodec.MediaType || registryInput.OriginURI != "" {
+		t.Fatalf("spell NPC prompt input = %#v, want canonical payload without origin", registryInput)
+	}
+	if len(spellOutput.Manifest.References) != 1 {
+		t.Fatalf("spell manifest references = %#v, want one NPC provenance entry", spellOutput.Manifest.References)
+	}
+	provenance := spellOutput.Manifest.References[0]
+	if provenance.Stage != "extract" || provenance.LaneID != "spells" || provenance.SlotName != spells.NPCRegistryReferenceSlot || provenance.BindingSource != contracts.ReferenceBindingSourceCLI || !strings.Contains(provenance.OriginURI, "npcs.json") {
+		t.Fatalf("spell NPC provenance = %#v, want extract CLI reference provenance", provenance)
+	}
+	metadata, ok := spellOutput.Manifest.ArtifactLanes[0].Metadata["extractor"].(map[string]any)
+	if !ok || metadata["npc_count"] != 1 || metadata["npc_registry_digest"] != registryInput.Digest {
+		t.Fatalf("spell extractor metadata = %#v, want NPC count and semantic digest", spellOutput.Manifest.ArtifactLanes[0].Metadata)
+	}
+}
+
+func loadSequentialPipelineConfig(t *testing.T) config.Config {
+	t.Helper()
+	data, err := os.ReadFile("testdata/dnd_npc_spell_sequential_pipeline.yml")
+	if err != nil {
+		t.Fatalf("read sequential pipeline config: %v", err)
+	}
+	fileConfig, err := config.ParseFileConfigYAML(data)
+	if err != nil {
+		t.Fatalf("parse sequential pipeline config: %v", err)
+	}
+	configValue := config.Default()
+	if err := configValue.ApplyFileConfig(fileConfig); err != nil {
+		t.Fatalf("apply sequential pipeline config: %v", err)
+	}
+	return configValue
+}

internal/modules/integration/testdata/dnd_npc_spell_sequential_pipeline.yml

@@ -0,0 +1,25 @@
+version: 3
+output:
+  directory: ./notarius-output
+cache:
+  chunk_plans:
+    mode: bypass
+  checkpoints: {}
+debug:
+  directory: ./notarius-debug
+pipelines:
+  dnd-npcs:
+    input: seriatim
+    chunk: generic
+    artifacts:
+      npcs:
+        extract:
+          module: dnd/npcs
+        normalize: dnd/npcs
+  dnd-spells:
+    input: seriatim
+    chunk: generic
+    artifacts:
+      spells:
+        extract: dnd/spells
+        normalize: dnd/spells