// Package npcregistry normalizes merged D&D non-player character records. package npcregistry import ( "context" "fmt" "reflect" "sort" "strconv" "strings" "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/framework/semanticreconcile" "gitea.maximumdirect.net/eric/notarius/internal/modules/dnd" registrycodec "gitea.maximumdirect.net/eric/notarius/internal/modules/dnd/codec/npcregistry" "gitea.maximumdirect.net/eric/notarius/internal/modules/dnd/npcs/identity" "gitea.maximumdirect.net/eric/notarius/internal/modules/dnd/shared" "gitea.maximumdirect.net/eric/notarius/internal/modules/dnd/shared/diagnostics" "go.maximumdirect.net/promptkit" ) const ( Key = "dnd/npc-registry" PromptID = "notarius/dnd.npc_registry.normalize" CorrectionPromptID = "notarius/dnd.npc_registry.normalize.repair" ReasonCodeNPCFieldsNormalized = "npc_fields_normalized" ReasonCodeNPCIDRecomputed = "npc_id_recomputed" ReasonCodeSourceReferencesNormalized = "source_references_normalized" ReasonCodeDuplicateNPCCollapsed = "duplicate_npc_collapsed" ReasonCodeNPCSemanticReconciliationExhausted = "npc_semantic_reconciliation_exhausted" ) var requiredCapabilities = []string{"merged"} var providedCapabilities = []string{"normalized"} var _ contracts.Normalizer[dnd.NPCRegistry] = (*Normalizer)(nil) type Options struct{} type Normalizer struct { engine *promptkit.Engine } func New(engine *promptkit.Engine, _ Options) (*Normalizer, error) { if engine == nil { return nil, normalizerErrorf("native engine must not be nil") } return &Normalizer{engine: engine}, nil } func (n *Normalizer) Key() string { return Key } func (n *Normalizer) ReferenceSlots() []contracts.ReferenceSlot { return nil } func (n *Normalizer) Normalize(ctx context.Context, req contracts.TypedNormalizeRequest[dnd.NPCRegistry]) (contracts.TypedNormalizeResult[dnd.NPCRegistry], error) { if n == nil { return contracts.TypedNormalizeResult[dnd.NPCRegistry]{}, normalizerErrorf("normalizer must not be nil") } if n.engine == nil { return contracts.TypedNormalizeResult[dnd.NPCRegistry]{}, normalizerErrorf("native engine must not be nil") } if ctx == nil { return contracts.TypedNormalizeResult[dnd.NPCRegistry]{}, normalizerErrorf("context must not be nil") } if err := ctx.Err(); err != nil { return contracts.TypedNormalizeResult[dnd.NPCRegistry]{}, normalizerErrorf("context error before normalize: %w", err) } if req.Source == nil { return contracts.TypedNormalizeResult[dnd.NPCRegistry]{}, normalizerErrorf("source document must not be nil") } // Keep the already available merged artifact separate from preprocessed // originals. A failed native response must not recover an earlier proposal. merged := cloneRegistry(req.MergeOutput.Value) order := shared.NewSourceRefOrder(req.Source) records, baseFindings := preprocessRecords(merged, order) deterministic := recordList(records) if err := req.Operation.Execution.RecordEvidence("normalization/originals.json", deterministic); err != nil { return contracts.TypedNormalizeResult[dnd.NPCRegistry]{}, err } findings := append([]diagnostics.Finding(nil), baseFindings...) discardedGroups := -1 var omissionDetails []string fallback := func(_ context.Context, final *dnd.NPCRegistry) (dnd.NPCRegistry, error) { value := cloneRegistry(merged) if final != nil { // Each interpreted candidate was built afresh from fixed original records, // using only the final proposal's compatible, non-overlapping safe groups. value = cloneRegistry(*final) } else { findings = nil discardedGroups = -1 omissionDetails = nil } if err := validateFallback(value, req.Source); err != nil { return dnd.NPCRegistry{}, err } return value, nil } finish := func(value dnd.NPCRegistry, outcome contracts.ProducerOutcome, err error) (contracts.TypedNormalizeResult[dnd.NPCRegistry], error) { if err != nil { return contracts.TypedNormalizeResult[dnd.NPCRegistry]{}, normalizerErrorf("normalize NPCs: %w", err) } result, err := normalizationResult(value, findings) if err != nil { return contracts.TypedNormalizeResult[dnd.NPCRegistry]{}, err } result.Outcome = outcome if outcome.Disposition == contracts.ProducerFallback { details := append([]string(nil), omissionDetails...) details = append(details, outcome.FallbackReason) groups, err := diagnostics.Collect([]diagnostics.Finding{semanticFallbackFinding(discardedGroups, details...)}, contracts.DiagnosticDispositionWarning, contracts.DiagnosticCategoryFallback) if err != nil { return contracts.TypedNormalizeResult[dnd.NPCRegistry]{}, normalizerErrorf("collect fallback diagnostic: %w", err) } result.Diagnostics = append(result.Diagnostics, groups...) } return result, nil } noModel := func() (contracts.TypedNormalizeResult[dnd.NPCRegistry], error) { value, outcome, err := pipeline.AssessProducer(ctx, req.Operation, deterministic, func(ctx context.Context) (dnd.NPCRegistry, error) { return fallback(ctx, nil) }) return finish(value, outcome, err) } if len(records) < 2 { return noModel() } candidates, envelopes, err := reconciliationInputs(records) if err != nil { return contracts.TypedNormalizeResult[dnd.NPCRegistry]{}, normalizerErrorf("prepare semantic reconciliation inputs: %w", err) } preparation, err := semanticreconcile.Prepare(req.Source, candidates, semanticreconcile.DefaultLimits()) if err != nil { return contracts.TypedNormalizeResult[dnd.NPCRegistry]{}, normalizerErrorf("prepare semantic reconciliation: %w", err) } if err := req.Operation.Execution.RecordEvidence("normalization/preparation.json", map[string]any{ "disposition": preparation.Disposition(), "candidate_number_range": preparation.CandidateNumberRange(), "candidate_mappings": preparation.CandidateMappings(), "candidates": candidates, }); err != nil { return contracts.TypedNormalizeResult[dnd.NPCRegistry]{}, err } switch preparation.Disposition() { case semanticreconcile.InsufficientCandidates: return noModel() case semanticreconcile.LimitExceeded: value, outcome, err := pipeline.FinishProducerFailure(ctx, req.Operation.Controls.Mode, normalizerErrorf("candidate set exceeded semantic reconciliation preparation limits"), func(ctx context.Context) (dnd.NPCRegistry, error) { return fallback(ctx, nil) }) return finish(value, outcome, err) } initial, err := semanticreconcile.InitialRequest(preparation, PromptID, req.LLMProfile, req.SessionID) if err != nil { return contracts.TypedNormalizeResult[dnd.NPCRegistry]{}, normalizerErrorf("build native request: %w", err) } value, outcome, err := pipeline.RunProducer(ctx, n.engine, req.Operation, initial, func(_ context.Context, result *promptkit.RunResult) (*dnd.NPCRegistry, []string, error) { response, err := semanticreconcile.DecodeProposal(result.RawOutput) if err != nil { return nil, nil, err } assessment := preparation.Assess(response) if err := req.Operation.Execution.RecordEvidence("normalization/proposals/"+result.RunID+".json", map[string]any{"proposal": response, "issues": assessment.Issues(), "discarded_group_count": assessment.DiscardedGroupCount()}); err != nil { return nil, nil, err } applied, semanticFindings, err := applyReconciliationPlan(assessment.Plan(), records, envelopes, order) if err != nil { return nil, nil, normalizerErrorf("apply semantic reconciliation plan: %w", err) } findings = append(append([]diagnostics.Finding(nil), baseFindings...), semanticFindings...) discardedGroups = assessment.DiscardedGroupCount() omissionDetails = semanticreconcile.IssueDetails(assessment.Issues()) guidance, err := semanticreconcile.CorrectionDetails(assessment.Issues(), preparation.CandidateNumberRange()) if err != nil { return nil, nil, err } candidate := recordList(applied) return &candidate, guidance, nil }, func(_ context.Context, guidance []string) (promptkit.RunRequest, error) { return semanticreconcile.CorrectionRequest(CorrectionPromptID, req.LLMProfile, req.SessionID, guidance), nil }, fallback) return finish(value, outcome, err) } // validateFallback checks the durable artifact and the identity/source invariants // used by registry consumers, not the configured ordinary validator chain. func validateFallback(value dnd.NPCRegistry, document *source.SourceDocument) error { if _, err := registrycodec.New().Encode(value); err != nil { return normalizerErrorf("construct NPCs fallback: %w", err) } if issues := identity.ValidateList(value); len(issues) > 0 { return normalizerErrorf("construct NPCs fallback: registry identity is not usable downstream") } index := source.NewDocumentIndex(document) for _, npc := range value.NPCs { for _, reference := range npc.SourceRefs { if err := index.ValidateRef(reference); err != nil { return normalizerErrorf("construct NPCs fallback: %w", err) } } } return nil } func cloneRegistry(value dnd.NPCRegistry) dnd.NPCRegistry { if value.NPCs == nil { return dnd.NPCRegistry{} } result := dnd.NPCRegistry{NPCs: make([]dnd.NPC, len(value.NPCs))} for i, npc := range value.NPCs { result.NPCs[i] = cloneNPC(npc) } return result } func semanticFallbackFinding(discarded int, details ...string) diagnostics.Finding { message := "semantic reconciliation did not obtain ordinary acceptance; using supported fallback output" if discarded > 0 { message = fmt.Sprintf("%d proposal group(s) omitted from the final semantic proposal; all affected candidates were preserved separately", discarded) } if len(details) > 0 { message = diagnostics.Aggregate(message, details) } return diagnostics.Finding{Scope: "npcs", ReasonCode: ReasonCodeNPCSemanticReconciliationExhausted, Message: message} } func normalizationResult(value dnd.NPCRegistry, findings []diagnostics.Finding) (contracts.TypedNormalizeResult[dnd.NPCRegistry], error) { groups, err := diagnostics.Collect(findings, contracts.DiagnosticDispositionObservation, contracts.DiagnosticCategoryNormalization) if err != nil { return contracts.TypedNormalizeResult[dnd.NPCRegistry]{}, normalizerErrorf("collect normalization diagnostics: %w", err) } return contracts.TypedNormalizeResult[dnd.NPCRegistry]{Value: value, Diagnostics: groups}, nil } type normalizedRecord struct { npc dnd.NPC inputIndexes []int earliest int } func preprocessRecords(input dnd.NPCRegistry, order shared.SourceRefOrder) ([]normalizedRecord, []diagnostics.Finding) { if input.NPCs == nil { return nil, nil } records := make([]normalizedRecord, len(input.NPCs)) findings := make([]diagnostics.Finding, 0) for index, inputNPC := range input.NPCs { npc, fieldsChanged, referencesChanged := normalizeRecord(inputNPC, order) records[index] = normalizedRecord{npc: npc, inputIndexes: []int{index}, earliest: index} if fieldsChanged { findings = append(findings, diagnostics.Finding{Scope: npcScope(index), ReasonCode: ReasonCodeNPCFieldsNormalized, Message: fmt.Sprintf("input index %d: NPC name normalized for %s", index, diagnostics.Quote(inputNPC.Name))}) } if referencesChanged { findings = append(findings, diagnostics.Finding{Scope: npcScope(index), ReasonCode: ReasonCodeSourceReferencesNormalized, Message: fmt.Sprintf("input index %d: source references normalized (original count %d, final count %d)", index, len(inputNPC.SourceRefs), len(npc.SourceRefs))}) } if inputNPC.ID != npc.ID { findings = append(findings, diagnostics.Finding{Scope: npcScope(index), ReasonCode: ReasonCodeNPCIDRecomputed, Message: fmt.Sprintf("input index %d: NPC ID recomputed from %s", index, diagnostics.Quote(npc.Name))}) } } groups := canonicalNameGroups(records) output := make([]normalizedRecord, 0, len(groups)) for _, members := range groups { consolidated, referencesChanged := consolidate(records, members, order) output = append(output, consolidated) retainedIndex := consolidated.earliest if referencesChanged { findings = append(findings, diagnostics.Finding{Scope: npcScope(retainedIndex), ReasonCode: ReasonCodeSourceReferencesNormalized, Message: fmt.Sprintf("input index %d: source references normalized during identity consolidation (final count %d)", retainedIndex, len(consolidated.npc.SourceRefs))}) } if len(members) > 1 { findings = append(findings, duplicateFinding(retainedIndex, memberInputIndexes(records, members[1:]))) } } return output, findings } func normalizeRecord(input dnd.NPC, order shared.SourceRefOrder) (dnd.NPC, bool, bool) { output := cloneNPC(input) output.Name = identity.NormalizeDisplay(input.Name) output.SourceRefs = order.Canonicalize(input.SourceRefs) output.ID = identity.DeriveID(output.Name) return output, input.Name != output.Name, !reflect.DeepEqual(input.SourceRefs, output.SourceRefs) } func cloneNPC(input dnd.NPC) dnd.NPC { input.SourceRefs = cloneSourceRefs(input.SourceRefs) return input } func canonicalNameGroups(records []normalizedRecord) [][]int { groups := make([][]int, 0, len(records)) ownerByKey := make(map[string]int, len(records)) for index, record := range records { key := identity.ComparisonKey(record.npc.Name) if key != "" { if groupIndex, ok := ownerByKey[key]; ok { groups[groupIndex] = append(groups[groupIndex], index) continue } ownerByKey[key] = len(groups) } groups = append(groups, []int{index}) } return groups } func consolidate(records []normalizedRecord, members []int, order shared.SourceRefOrder) (normalizedRecord, bool) { output := cloneRecord(records[members[0]]) originalRefs := cloneSourceRefs(output.npc.SourceRefs) for _, member := range members[1:] { output.npc.SourceRefs = append(output.npc.SourceRefs, records[member].npc.SourceRefs...) output.inputIndexes = append(output.inputIndexes, records[member].inputIndexes...) if records[member].earliest < output.earliest { output.earliest = records[member].earliest } } output.inputIndexes = sortedUniqueIndexes(output.inputIndexes) output.npc.SourceRefs = order.Canonicalize(output.npc.SourceRefs) output.npc.ID = identity.DeriveID(output.npc.Name) return output, !reflect.DeepEqual(originalRefs, output.npc.SourceRefs) } func cloneRecord(input normalizedRecord) normalizedRecord { input.npc = cloneNPC(input.npc) input.inputIndexes = append([]int(nil), input.inputIndexes...) return input } func memberInputIndexes(records []normalizedRecord, members []int) []int { indexes := make([]int, 0, len(members)) for _, member := range members { indexes = append(indexes, records[member].inputIndexes...) } return sortedUniqueIndexes(indexes) } func sortedUniqueIndexes(indexes []int) []int { if len(indexes) == 0 { return nil } out := append([]int(nil), indexes...) sort.Ints(out) write := 1 for _, index := range out[1:] { if index != out[write-1] { out[write] = index write++ } } return out[:write] } func recordValues(records []normalizedRecord) []dnd.NPC { if records == nil { return nil } values := make([]dnd.NPC, len(records)) for index, record := range records { values[index] = cloneNPC(record.npc) } return values } func recordList(records []normalizedRecord) dnd.NPCRegistry { if records == nil { return dnd.NPCRegistry{} } return dnd.NPCRegistry{NPCs: recordValues(records)} } func cloneSourceRefs(input []source.SourceRef) []source.SourceRef { if input == nil { return nil } return append([]source.SourceRef(nil), input...) } func duplicateFinding(retainedIndex int, removed []int) diagnostics.Finding { const maxDisplayedIndices = 20 displayed := removed if len(displayed) > maxDisplayedIndices { displayed = displayed[:maxDisplayedIndices] } indices := make([]string, len(displayed)) for index, removedIndex := range displayed { indices[index] = strconv.Itoa(removedIndex) } message := fmt.Sprintf("retained input index %d; removed input indices [%s]", retainedIndex, strings.Join(indices, ", ")) if omitted := len(removed) - len(displayed); omitted > 0 { message += fmt.Sprintf("; %d additional removed input indices omitted", omitted) } return diagnostics.Finding{Scope: npcScope(retainedIndex), ReasonCode: ReasonCodeDuplicateNPCCollapsed, Message: message} } func npcScope(index int) string { return fmt.Sprintf("npcs[%d]", index) } func ModuleSpec() pipeline.ModuleSpec { return pipeline.ModuleSpec{Key: Key, Stage: pipeline.StageNormalize, ExecutionClass: contracts.ExecutionClassLLMBacked, Prompts: []string{PromptID, CorrectionPromptID}, Requires: append([]string(nil), requiredCapabilities...), Provides: append([]string(nil), providedCapabilities...), ArtifactKind: dnd.NPCRegistryKind} } func Register(registry *pipeline.NormalizerRegistry) error { return pipeline.RegisterNormalizerBuilder(registry, ModuleSpec(), validateOptions, func(request pipeline.BuildRequest) (contracts.Normalizer[dnd.NPCRegistry], error) { options, err := DecodeOptions(request.Options) if err != nil { return nil, err } return New(request.Dependencies.Engine, options) }) } func validateOptions(options map[string]any) error { _, err := DecodeOptions(options); return err } func DecodeOptions(options map[string]any) (Options, error) { if err := pipeline.RejectUnknownOptions(options); err != nil { return Options{}, normalizerErrorf("%w", err) } return Options{}, nil } func normalizerErrorf(format string, args ...any) error { return fmt.Errorf("dnd npc registry normalizer: "+format, args...) }