Finalize structured diagnostic aggregation

internal/modules/dnd/normalize/combatturns/normalizer.go

@@ -132,13 +132,13 @@ type actorCanonicalization struct {
 	to   string
 }
 
-func normalizeList(input dnd.CombatTurnList, documentIndex source.DocumentIndex, order shared.SourceRefOrder, registry *npcregistry.Registry) (dnd.CombatTurnList, []contracts.Warning) {
+func normalizeList(input dnd.CombatTurnList, documentIndex source.DocumentIndex, order shared.SourceRefOrder, registry *npcregistry.Registry) (dnd.CombatTurnList, []diagnostics.Finding) {
 	if input.CombatTurns == nil {
 		return dnd.CombatTurnList{}, nil
 	}
 
 	records := make([]normalizedRecord, len(input.CombatTurns))
-	warnings := make([]contracts.Warning, 0)
+	warnings := make([]diagnostics.Finding, 0)
 	for index, inputTurn := range input.CombatTurns {
 		turn, actorChange, refsChanged := normalizeTurn(inputTurn, order, registry)
 		earliest, hasEvidence := order.EarliestValid(turn.SourceRefs)
@@ -149,7 +149,7 @@ func normalizeList(input dnd.CombatTurnList, documentIndex source.DocumentIndex,
 			hasEvidence: hasEvidence,
 		}
 		if actorChange != nil {
-			warnings = append(warnings, contracts.Warning{
+			warnings = append(warnings, diagnostics.Finding{
 				Scope:      turnScope(index),
 				ReasonCode: ReasonCodeActorCanonicalized,
 				Message: fmt.Sprintf("input index %d: actor canonicalized from %s to %s",
@@ -157,7 +157,7 @@ func normalizeList(input dnd.CombatTurnList, documentIndex source.DocumentIndex,
 			})
 		}
 		if refsChanged {
-			warnings = append(warnings, contracts.Warning{
+			warnings = append(warnings, diagnostics.Finding{
 				Scope:      turnScope(index),
 				ReasonCode: ReasonCodeSourceRefsNormalized,
 				Message: fmt.Sprintf("input index %d: source references normalized (original count %d, final count %d)",
@@ -179,7 +179,7 @@ func normalizeList(input dnd.CombatTurnList, documentIndex source.DocumentIndex,
 		if position == record.inputIndex {
 			continue
 		}
-		warnings = append(warnings, contracts.Warning{
+		warnings = append(warnings, diagnostics.Finding{
 			Scope:      turnScope(record.inputIndex),
 			ReasonCode: ReasonCodeTurnsReordered,
 			Message: fmt.Sprintf("input index %d moved to normalized position %d by source chronology",
@@ -236,7 +236,7 @@ type duplicateGroup struct {
 	removed       []int
 }
 
-func collapseDuplicates(records []normalizedRecord, documentIndex source.DocumentIndex) ([]dnd.CombatTurn, []contracts.Warning) {
+func collapseDuplicates(records []normalizedRecord, documentIndex source.DocumentIndex) ([]dnd.CombatTurn, []diagnostics.Finding) {
 	if len(records) == 0 {
 		return make([]dnd.CombatTurn, 0), nil
 	}
@@ -267,7 +267,7 @@ func collapseDuplicates(records []normalizedRecord, documentIndex source.Documen
 		}
 	}
 
-	warnings := make([]contracts.Warning, 0)
+	warnings := make([]diagnostics.Finding, 0)
 	for _, group := range groups {
 		if len(group.removed) == 0 {
 			continue
@@ -309,12 +309,12 @@ func writeKeyInt(builder *strings.Builder, value int) {
 	builder.WriteByte(';')
 }
 
-func duplicateWarning(retainedIndex int, removed []int) contracts.Warning {
+func duplicateWarning(retainedIndex int, removed []int) diagnostics.Finding {
 	issues := make([]string, len(removed))
 	for index, removedIndex := range removed {
 		issues[index] = fmt.Sprintf("removed input index %d", removedIndex)
 	}
-	return contracts.Warning{
+	return diagnostics.Finding{
 		Scope:      turnScope(retainedIndex),
 		ReasonCode: ReasonCodeDuplicateCollapsed,
 		Message: diagnostics.Aggregate(

internal/modules/dnd/normalize/combatturns/normalizer_test.go

@@ -15,7 +15,6 @@ import (
 	"gitea.maximumdirect.net/eric/notarius/internal/modules/dnd"
 	npccodec "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/diagnostics"
 )
 
 func TestNormalizeCanonicalizesFieldsAndRegistryIdentities(t *testing.T) {
@@ -61,7 +60,7 @@ func TestNormalizeCanonicalizesFieldsAndRegistryIdentities(t *testing.T) {
 }
 
 func TestNormalizeLimitsWarningsWithoutChangingCombatTurnValues(t *testing.T) {
-	units := make([]source.SourceUnit, diagnostics.MaxWarnings+1)
+	units := make([]source.SourceUnit, contracts.MaxDiagnosticSamples+1)
 	turns := make([]dnd.CombatTurn, len(units))
 	for index := range units {
 		unitID := index + 1
@@ -82,7 +81,7 @@ func TestNormalizeLimitsWarningsWithoutChangingCombatTurnValues(t *testing.T) {
 	if len(result.Value.CombatTurns) != len(turns) || result.Value.CombatTurns[0].Actor != "Aria" {
 		t.Fatalf("normalized turns = %#v, want canonicalized values", result.Value.CombatTurns)
 	}
-	if len(result.Warnings) != 0 || len(result.Diagnostics) == 0 || result.Diagnostics[0].Disposition != contracts.DiagnosticDispositionObservation || result.Diagnostics[0].OccurrenceCount != len(turns) || len(result.Diagnostics[0].Samples) != contracts.MaxDiagnosticSamples {
+	if len(result.Diagnostics) == 0 || result.Diagnostics[0].Disposition != contracts.DiagnosticDispositionObservation || result.Diagnostics[0].OccurrenceCount != len(turns) || len(result.Diagnostics[0].Samples) != contracts.MaxDiagnosticSamples {
 		t.Fatalf("diagnostics = %#v", result.Diagnostics)
 	}
 }

internal/modules/dnd/normalize/enemyevents/normalizer.go

@@ -123,17 +123,17 @@ type nameCanonicalization struct {
 	to   string
 }
 
-func normalizeList(input dnd.EnemyEventList, order shared.SourceRefOrder, registry *npcregistry.Registry) (dnd.EnemyEventList, []contracts.Warning) {
+func normalizeList(input dnd.EnemyEventList, order shared.SourceRefOrder, registry *npcregistry.Registry) (dnd.EnemyEventList, []diagnostics.Finding) {
 	if input.Events == nil {
 		return dnd.EnemyEventList{}, nil
 	}
 	records := make([]normalizedRecord, len(input.Events))
-	warnings := make([]contracts.Warning, 0)
+	warnings := make([]diagnostics.Finding, 0)
 	for index, inputEvent := range input.Events {
 		event, nameChange, refsChanged := normalizeEvent(inputEvent, order, registry)
 		records[index] = normalizedRecord{event: event, identity: enemyeventmodel.CanonicalIdentity(event), inputIndex: index}
 		if nameChange != nil {
-			warnings = append(warnings, contracts.Warning{
+			warnings = append(warnings, diagnostics.Finding{
 				Scope:      eventScope(index),
 				ReasonCode: ReasonCodeNameCanonicalized,
 				Message: fmt.Sprintf("input index %d: subject canonicalized from %s to %s",
@@ -141,7 +141,7 @@ func normalizeList(input dnd.EnemyEventList, order shared.SourceRefOrder, regist
 			})
 		}
 		if refsChanged {
-			warnings = append(warnings, contracts.Warning{
+			warnings = append(warnings, diagnostics.Finding{
 				Scope:      eventScope(index),
 				ReasonCode: ReasonCodeSourceRefsNormalized,
 				Message: fmt.Sprintf("input index %d: source references normalized (original count %d, final count %d)",
@@ -157,7 +157,7 @@ func normalizeList(input dnd.EnemyEventList, order shared.SourceRefOrder, regist
 		if position == record.inputIndex {
 			continue
 		}
-		warnings = append(warnings, contracts.Warning{
+		warnings = append(warnings, diagnostics.Finding{
 			Scope:      eventScope(record.inputIndex),
 			ReasonCode: ReasonCodeEventsReordered,
 			Message:    fmt.Sprintf("input index %d moved to normalized position %d", record.inputIndex, position),
@@ -208,7 +208,7 @@ type duplicateGroup struct {
 	removed       []int
 }
 
-func collapseDuplicates(records []normalizedRecord) ([]dnd.EnemyEvent, []contracts.Warning) {
+func collapseDuplicates(records []normalizedRecord) ([]dnd.EnemyEvent, []diagnostics.Finding) {
 	if len(records) == 0 {
 		return make([]dnd.EnemyEvent, 0), nil
 	}
@@ -235,7 +235,7 @@ func collapseDuplicates(records []normalizedRecord) ([]dnd.EnemyEvent, []contrac
 	for index, record := range kept {
 		output[index] = cloneEvent(record.event)
 	}
-	warnings := make([]contracts.Warning, 0)
+	warnings := make([]diagnostics.Finding, 0)
 	for _, group := range groups {
 		if len(group.removed) == 0 {
 			continue
@@ -244,7 +244,7 @@ func collapseDuplicates(records []normalizedRecord) ([]dnd.EnemyEvent, []contrac
 		for index, removed := range group.removed {
 			issues[index] = fmt.Sprintf("removed input index %d", removed)
 		}
-		warnings = append(warnings, contracts.Warning{
+		warnings = append(warnings, diagnostics.Finding{
 			Scope:      eventScope(group.retainedIndex),
 			ReasonCode: ReasonCodeDuplicateCollapsed,
 			Message: diagnostics.Aggregate(

internal/modules/dnd/normalize/enemyevents/normalizer_test.go

@@ -13,7 +13,6 @@ import (
 	"gitea.maximumdirect.net/eric/notarius/internal/modules/dnd"
 	npccodec "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/diagnostics"
 )
 
 func TestNormalizeCanonicalizesSubjectsEvidenceOrderAndDuplicates(t *testing.T) {
@@ -162,7 +161,7 @@ func TestNormalizerContractAndWarningBound(t *testing.T) {
 		t.Fatalf("unsafe metadata = %s, %v", encoded, err)
 	}
 
-	count := diagnostics.MaxWarnings + 5
+	count := contracts.MaxDiagnosticSamples + 5
 	document := &source.SourceDocument{ID: "session", Units: make([]source.SourceUnit, count)}
 	input := dnd.EnemyEventList{Events: make([]dnd.EnemyEvent, count)}
 	for index := range document.Units {
@@ -170,7 +169,7 @@ func TestNormalizerContractAndWarningBound(t *testing.T) {
 		input.Events[index] = dnd.EnemyEvent{Name: "  ÁRIA ", Kind: dnd.EnemyEventKindEngaged, SourceRefs: []source.SourceRef{{SourceID: document.ID, StartUnitID: count - index, EndUnitID: count - index}}}
 	}
 	result, err := normalizer.Normalize(context.Background(), normalizeRequest(document, input, contracts.ReferenceSet{}))
-	if err != nil || len(result.Warnings) != 0 || len(result.Diagnostics) == 0 {
+	if err != nil || len(result.Diagnostics) == 0 {
 		t.Fatalf("diagnostics = %#v, %v", result.Diagnostics, err)
 	}
 }

internal/modules/dnd/normalize/itemoccurrences/normalizer.go

@@ -120,18 +120,18 @@ type normalizedRecord struct {
 	inputIndex int
 }
 
-func normalizeList(input dnd.ItemOccurrenceList, index source.DocumentIndex, order shared.SourceRefOrder, registry *itemregistry.Registry) (dnd.ItemOccurrenceList, []contracts.Warning) {
+func normalizeList(input dnd.ItemOccurrenceList, index source.DocumentIndex, order shared.SourceRefOrder, registry *itemregistry.Registry) (dnd.ItemOccurrenceList, []diagnostics.Finding) {
 	if input.Occurrences == nil {
 		return dnd.ItemOccurrenceList{}, nil
 	}
 
 	records := make([]normalizedRecord, len(input.Occurrences))
-	warnings := make([]contracts.Warning, 0)
+	warnings := make([]diagnostics.Finding, 0)
 	for index, inputOccurrence := range input.Occurrences {
 		occurrence, changedFields, found, refsChanged := normalizeOccurrence(inputOccurrence, order, registry)
 		records[index] = normalizedRecord{occurrence: occurrence, identity: itemoccurrencemodel.CanonicalExactIdentity(occurrence), inputIndex: index}
 		if len(changedFields) != 0 {
-			warnings = append(warnings, contracts.Warning{
+			warnings = append(warnings, diagnostics.Finding{
 				Scope:      occurrenceScope(index),
 				ReasonCode: ReasonCodeNameCanonicalized,
 				Message: fmt.Sprintf("input index %d: normalized display whitespace in %s", index,
@@ -139,15 +139,15 @@ func normalizeList(input dnd.ItemOccurrenceList, index source.DocumentIndex, ord
 			})
 		}
 		if found && inputOccurrence.Name != occurrence.Name {
-			warnings = append(warnings, contracts.Warning{Scope: occurrenceScope(index), ReasonCode: ReasonCodeNameCanonicalized,
+			warnings = append(warnings, diagnostics.Finding{Scope: occurrenceScope(index), ReasonCode: ReasonCodeNameCanonicalized,
 				Message: fmt.Sprintf("input index %d: item name canonicalized from %s to %s", index, diagnostics.Quote(inputOccurrence.Name), diagnostics.Quote(occurrence.Name))})
 		}
 		if !found {
-			warnings = append(warnings, contracts.Warning{Scope: occurrenceScope(index), ReasonCode: ReasonCodeUnknownItemID,
+			warnings = append(warnings, diagnostics.Finding{Scope: occurrenceScope(index), ReasonCode: ReasonCodeUnknownItemID,
 				Message: fmt.Sprintf("input index %d: item ID %s is not in the supplied registry", index, diagnostics.Quote(inputOccurrence.ItemID))})
 		}
 		if refsChanged {
-			warnings = append(warnings, contracts.Warning{
+			warnings = append(warnings, diagnostics.Finding{
 				Scope:      occurrenceScope(index),
 				ReasonCode: ReasonCodeSourceRefsNormalized,
 				Message: fmt.Sprintf("input index %d: source references normalized (original count %d, final count %d)",
@@ -163,7 +163,7 @@ func normalizeList(input dnd.ItemOccurrenceList, index source.DocumentIndex, ord
 		if position == record.inputIndex {
 			continue
 		}
-		warnings = append(warnings, contracts.Warning{
+		warnings = append(warnings, diagnostics.Finding{
 			Scope:      occurrenceScope(record.inputIndex),
 			ReasonCode: ReasonCodeOccurrencesReordered,
 			Message:    fmt.Sprintf("input index %d moved to normalized position %d", record.inputIndex, position),
@@ -217,7 +217,7 @@ type duplicateGroup struct {
 	removed        []int
 }
 
-func collapseDuplicates(records []normalizedRecord, index source.DocumentIndex) ([]dnd.ItemOccurrence, []contracts.Warning) {
+func collapseDuplicates(records []normalizedRecord, index source.DocumentIndex) ([]dnd.ItemOccurrence, []diagnostics.Finding) {
 	if len(records) == 0 {
 		return make([]dnd.ItemOccurrence, 0), nil
 	}
@@ -253,7 +253,7 @@ func collapseDuplicates(records []normalizedRecord, index source.DocumentIndex)
 			output = append(output, cloneOccurrence(record.occurrence))
 		}
 	}
-	warnings := make([]contracts.Warning, 0)
+	warnings := make([]diagnostics.Finding, 0)
 	for _, group := range groups {
 		if len(group.removed) != 0 {
 			warnings = append(warnings, duplicateWarning(group.retainedIndex, group.removed))
@@ -262,12 +262,12 @@ func collapseDuplicates(records []normalizedRecord, index source.DocumentIndex)
 	return output, warnings
 }
 
-func duplicateWarning(retainedIndex int, removed []int) contracts.Warning {
+func duplicateWarning(retainedIndex int, removed []int) diagnostics.Finding {
 	issues := make([]string, len(removed))
 	for index, removedIndex := range removed {
 		issues[index] = fmt.Sprintf("removed input index %d", removedIndex)
 	}
-	return contracts.Warning{
+	return diagnostics.Finding{
 		Scope:      occurrenceScope(retainedIndex),
 		ReasonCode: ReasonCodeDuplicateCollapsed,
 		Message: diagnostics.Aggregate(

internal/modules/dnd/normalize/itemregistry/normalizer.go

@@ -149,11 +149,11 @@ func (n *Normalizer) Normalize(ctx context.Context, req contracts.TypedNormalize
 	return retryResult(recordList(applied), findings, advisoryFindings, reconciliation, rejectedGroups)
 }
 
-func (n *Normalizer) invalidStructuredResult(value dnd.ItemRegistry, findings []contracts.Warning) (contracts.TypedNormalizeResult[dnd.ItemRegistry], error) {
+func (n *Normalizer) invalidStructuredResult(value dnd.ItemRegistry, findings []diagnostics.Finding) (contracts.TypedNormalizeResult[dnd.ItemRegistry], error) {
 	return retryResultWithFallback(value, findings, nil, nil, ReasonCodeItemSemanticRetryProposalInvalid, "semantic proposal requires retry: invalid structured output", semanticFallbackFinding(-1))
 }
 
-func retryResult(value dnd.ItemRegistry, findings, advisoryFindings []contracts.Warning, reconciliation semanticreconcile.Result, rejectedGroups int) (contracts.TypedNormalizeResult[dnd.ItemRegistry], error) {
+func retryResult(value dnd.ItemRegistry, findings, advisoryFindings []diagnostics.Finding, reconciliation semanticreconcile.Result, rejectedGroups int) (contracts.TypedNormalizeResult[dnd.ItemRegistry], error) {
 	details := semanticreconcile.IssueDetails(reconciliation.Issues())
 	if rejectedGroups > 0 {
 		details = append(details, "currency may only be consolidated with aliases of one denomination")
@@ -162,15 +162,15 @@ func retryResult(value dnd.ItemRegistry, findings, advisoryFindings []contracts.
 	return retryResultWithFallback(value, findings, advisoryFindings, reconciliation.ModelCandidate(), ReasonCodeItemSemanticRetryProposalInvalid, diagnostics.Aggregate("semantic proposal requires retry", details), semanticFallbackFinding(discardedGroups))
 }
 
-func semanticFallbackFinding(discarded int) contracts.Warning {
+func semanticFallbackFinding(discarded int) diagnostics.Finding {
 	message := "semantic proposal could not be applied"
 	if discarded >= 0 {
 		message = fmt.Sprintf("%d proposal group(s) omitted after semantic proposal retry exhaustion", discarded)
 	}
-	return contracts.Warning{Scope: "items", ReasonCode: ReasonCodeItemSemanticReconciliationExhausted, Message: message}
+	return diagnostics.Finding{Scope: "items", ReasonCode: ReasonCodeItemSemanticReconciliationExhausted, Message: message}
 }
 
-func normalizationResult(value dnd.ItemRegistry, findings, advisoryFindings []contracts.Warning, candidate *contracts.ModelCandidate) (contracts.TypedNormalizeResult[dnd.ItemRegistry], error) {
+func normalizationResult(value dnd.ItemRegistry, findings, advisoryFindings []diagnostics.Finding, candidate *contracts.ModelCandidate) (contracts.TypedNormalizeResult[dnd.ItemRegistry], error) {
 	diagnosticGroups, err := diagnostics.Collect(findings, contracts.DiagnosticDispositionObservation, contracts.DiagnosticCategoryNormalization)
 	if err != nil {
 		return contracts.TypedNormalizeResult[dnd.ItemRegistry]{}, normalizerErrorf("collect normalization diagnostics: %w", err)
@@ -183,12 +183,12 @@ func normalizationResult(value dnd.ItemRegistry, findings, advisoryFindings []co
 	return contracts.TypedNormalizeResult[dnd.ItemRegistry]{Value: value, Diagnostics: diagnosticGroups, ModelCandidate: candidate}, nil
 }
 
-func fallbackResult(value dnd.ItemRegistry, findings, advisoryFindings []contracts.Warning, fallback contracts.Warning) (contracts.TypedNormalizeResult[dnd.ItemRegistry], error) {
+func fallbackResult(value dnd.ItemRegistry, findings, advisoryFindings []diagnostics.Finding, fallback diagnostics.Finding) (contracts.TypedNormalizeResult[dnd.ItemRegistry], error) {
 	result, err := normalizationResult(value, findings, advisoryFindings, nil)
 	if err != nil {
 		return contracts.TypedNormalizeResult[dnd.ItemRegistry]{}, err
 	}
-	fallbackGroups, err := diagnostics.Collect([]contracts.Warning{fallback}, contracts.DiagnosticDispositionWarning, contracts.DiagnosticCategoryFallback)
+	fallbackGroups, err := diagnostics.Collect([]diagnostics.Finding{fallback}, contracts.DiagnosticDispositionWarning, contracts.DiagnosticCategoryFallback)
 	if err != nil {
 		return contracts.TypedNormalizeResult[dnd.ItemRegistry]{}, normalizerErrorf("collect fallback diagnostic: %w", err)
 	}
@@ -196,12 +196,12 @@ func fallbackResult(value dnd.ItemRegistry, findings, advisoryFindings []contrac
 	return result, nil
 }
 
-func retryResultWithFallback(value dnd.ItemRegistry, findings, advisoryFindings []contracts.Warning, candidate *contracts.ModelCandidate, reasonCode, message string, fallback contracts.Warning) (contracts.TypedNormalizeResult[dnd.ItemRegistry], error) {
+func retryResultWithFallback(value dnd.ItemRegistry, findings, advisoryFindings []diagnostics.Finding, candidate *contracts.ModelCandidate, reasonCode, message string, fallback diagnostics.Finding) (contracts.TypedNormalizeResult[dnd.ItemRegistry], error) {
 	result, err := normalizationResult(value, findings, advisoryFindings, candidate)
 	if err != nil {
 		return contracts.TypedNormalizeResult[dnd.ItemRegistry]{}, err
 	}
-	fallbackGroups, err := diagnostics.Collect([]contracts.Warning{fallback}, contracts.DiagnosticDispositionWarning, contracts.DiagnosticCategoryFallback)
+	fallbackGroups, err := diagnostics.Collect([]diagnostics.Finding{fallback}, contracts.DiagnosticDispositionWarning, contracts.DiagnosticCategoryFallback)
 	if err != nil {
 		return contracts.TypedNormalizeResult[dnd.ItemRegistry]{}, normalizerErrorf("collect fallback diagnostic: %w", err)
 	}
@@ -215,23 +215,23 @@ type normalizedRecord struct {
 	earliest     int
 }
 
-func preprocessRecords(input dnd.ItemRegistry, order shared.SourceRefOrder) ([]normalizedRecord, []contracts.Warning) {
+func preprocessRecords(input dnd.ItemRegistry, order shared.SourceRefOrder) ([]normalizedRecord, []diagnostics.Finding) {
 	if input.Items == nil {
 		return nil, nil
 	}
 	records := make([]normalizedRecord, len(input.Items))
-	findings := make([]contracts.Warning, 0)
+	findings := make([]diagnostics.Finding, 0)
 	for index, inputItem := range input.Items {
 		item, fieldsChanged, refsChanged := normalizeRecord(inputItem, order)
 		records[index] = normalizedRecord{item: item, inputIndexes: []int{index}, earliest: index}
 		if fieldsChanged {
-			findings = append(findings, contracts.Warning{Scope: itemScope(index), ReasonCode: ReasonCodeItemFieldsNormalized, Message: fmt.Sprintf("input index %d: item name normalized for %s", index, diagnostics.Quote(inputItem.Name))})
+			findings = append(findings, diagnostics.Finding{Scope: itemScope(index), ReasonCode: ReasonCodeItemFieldsNormalized, Message: fmt.Sprintf("input index %d: item name normalized for %s", index, diagnostics.Quote(inputItem.Name))})
 		}
 		if refsChanged {
-			findings = append(findings, contracts.Warning{Scope: itemScope(index), ReasonCode: ReasonCodeSourceReferencesNormalized, Message: fmt.Sprintf("input index %d: source references normalized (original count %d, final count %d)", index, len(inputItem.SourceRefs), len(item.SourceRefs))})
+			findings = append(findings, diagnostics.Finding{Scope: itemScope(index), ReasonCode: ReasonCodeSourceReferencesNormalized, Message: fmt.Sprintf("input index %d: source references normalized (original count %d, final count %d)", index, len(inputItem.SourceRefs), len(item.SourceRefs))})
 		}
 		if inputItem.ID != item.ID {
-			findings = append(findings, contracts.Warning{Scope: itemScope(index), ReasonCode: ReasonCodeItemIDRecomputed, Message: fmt.Sprintf("input index %d: item ID recomputed from %s", index, diagnostics.Quote(item.Name))})
+			findings = append(findings, diagnostics.Finding{Scope: itemScope(index), ReasonCode: ReasonCodeItemIDRecomputed, Message: fmt.Sprintf("input index %d: item ID recomputed from %s", index, diagnostics.Quote(item.Name))})
 		}
 	}
 	groups := comparisonNameGroups(records)
@@ -328,7 +328,7 @@ func recordList(records []normalizedRecord) dnd.ItemRegistry {
 	return dnd.ItemRegistry{Items: recordValues(records)}
 }
 
-func duplicateWarning(retainedIndex int, removed []int) contracts.Warning {
+func duplicateWarning(retainedIndex int, removed []int) diagnostics.Finding {
 	const maxDisplayedIndices = 20
 	displayed := removed
 	if len(displayed) > maxDisplayedIndices {
@@ -342,7 +342,7 @@ func duplicateWarning(retainedIndex int, removed []int) contracts.Warning {
 	if omitted := len(removed) - len(displayed); omitted > 0 {
 		message += fmt.Sprintf("; %d additional removed input indices omitted", omitted)
 	}
-	return contracts.Warning{Scope: itemScope(retainedIndex), ReasonCode: ReasonCodeDuplicateItemCollapsed, Message: message}
+	return diagnostics.Finding{Scope: itemScope(retainedIndex), ReasonCode: ReasonCodeDuplicateItemCollapsed, Message: message}
 }
 func itemScope(index int) string { return fmt.Sprintf("items[%d]", index) }
 

internal/modules/dnd/normalize/itemregistry/reconciliation.go

@@ -4,7 +4,6 @@ import (
 	"fmt"
 	"sort"
 
-	"gitea.maximumdirect.net/eric/notarius/internal/framework/contracts"
 	"gitea.maximumdirect.net/eric/notarius/internal/framework/semanticreconcile"
 	"gitea.maximumdirect.net/eric/notarius/internal/modules/dnd"
 	"gitea.maximumdirect.net/eric/notarius/internal/modules/dnd/items/identity"
@@ -31,7 +30,7 @@ func reconciliationInputs(records []normalizedRecord) ([]semanticreconcile.Candi
 	return candidates, envelopes, nil
 }
 
-func applyReconciliationPlan(plan semanticreconcile.Plan, records []normalizedRecord, envelopes []semanticreconcile.Record[dnd.Item], order shared.SourceRefOrder) ([]normalizedRecord, []contracts.Warning, []contracts.Warning, int, error) {
+func applyReconciliationPlan(plan semanticreconcile.Plan, records []normalizedRecord, envelopes []semanticreconcile.Record[dnd.Item], order shared.SourceRefOrder) ([]normalizedRecord, []diagnostics.Finding, []diagnostics.Finding, int, error) {
 	application, err := semanticreconcile.ApplyPlan(plan, envelopes, semanticreconcile.ApplicationPolicy[dnd.Item]{
 		CloneValue: cloneItem,
 		RejectGroup: func(members []dnd.Item, _ dnd.Item) semanticreconcile.RejectionCategory {
@@ -66,7 +65,7 @@ func applyReconciliationPlan(plan semanticreconcile.Plan, records []normalizedRe
 	}
 	type orderedFinding struct {
 		position int
-		finding  contracts.Warning
+		finding  diagnostics.Finding
 	}
 	observations := make([]orderedFinding, 0, len(application.AppliedGroups()))
 	advisories := make([]orderedFinding, 0, len(application.RejectedGroups()))
@@ -81,7 +80,7 @@ func applyReconciliationPlan(plan semanticreconcile.Plan, records []normalizedRe
 		provenance := event.Provenance()
 		advisories = append(advisories, orderedFinding{
 			position: provenance.EarliestInputPosition(),
-			finding: contracts.Warning{
+			finding: diagnostics.Finding{
 				Scope:      itemScope(provenance.EarliestInputPosition()),
 				ReasonCode: ReasonCodeItemSemanticProposalInvalid,
 				Message:    "proposal group preserved because currency may only be consolidated with aliases of one denomination",
@@ -90,11 +89,11 @@ func applyReconciliationPlan(plan semanticreconcile.Plan, records []normalizedRe
 	}
 	sort.SliceStable(observations, func(left, right int) bool { return observations[left].position < observations[right].position })
 	sort.SliceStable(advisories, func(left, right int) bool { return advisories[left].position < advisories[right].position })
-	observationFindings := make([]contracts.Warning, len(observations))
+	observationFindings := make([]diagnostics.Finding, len(observations))
 	for index, entry := range observations {
 		observationFindings[index] = entry.finding
 	}
-	advisoryFindings := make([]contracts.Warning, len(advisories))
+	advisoryFindings := make([]diagnostics.Finding, len(advisories))
 	for index, entry := range advisories {
 		advisoryFindings[index] = entry.finding
 	}
@@ -139,7 +138,7 @@ func currencyDenomination(name string) string {
 	}
 }
 
-func semanticDuplicateFinding(provenance semanticreconcile.GroupProvenance, canonical normalizedRecord) contracts.Warning {
+func semanticDuplicateFinding(provenance semanticreconcile.GroupProvenance, canonical normalizedRecord) diagnostics.Finding {
 	inputIndexes := provenance.OriginalInputIndexes()
 	details := make([]string, 0, len(inputIndexes)+1)
 	for _, inputIndex := range inputIndexes {
@@ -148,7 +147,7 @@ func semanticDuplicateFinding(provenance semanticreconcile.GroupProvenance, cano
 	if canonical.earliest != provenance.EarliestInputPosition() {
 		details = append(details, fmt.Sprintf("canonical display name from input index %d", canonical.earliest))
 	}
-	return contracts.Warning{
+	return diagnostics.Finding{
 		Scope:      itemScope(provenance.EarliestInputPosition()),
 		ReasonCode: ReasonCodeDuplicateItemCollapsed,
 		Message:    diagnostics.Aggregate("semantic duplicate consolidation", details),

internal/modules/dnd/normalize/locationoccurrences/normalizer.go

@@ -122,25 +122,25 @@ type normalizedRecord struct {
 
 type nameCanonicalization struct{ from, to string }
 
-func normalizeList(input dnd.LocationOccurrenceList, documentIndex source.DocumentIndex, order shared.SourceRefOrder, registry *locationregistry.Registry) (dnd.LocationOccurrenceList, []contracts.Warning) {
+func normalizeList(input dnd.LocationOccurrenceList, documentIndex source.DocumentIndex, order shared.SourceRefOrder, registry *locationregistry.Registry) (dnd.LocationOccurrenceList, []diagnostics.Finding) {
 	if input.Occurrences == nil {
 		return dnd.LocationOccurrenceList{}, nil
 	}
 	records := make([]normalizedRecord, len(input.Occurrences))
-	warnings := make([]contracts.Warning, 0)
+	warnings := make([]diagnostics.Finding, 0)
 	for index, inputOccurrence := range input.Occurrences {
 		occurrence, change, found, refsChanged := normalizeOccurrence(inputOccurrence, order, registry)
 		records[index] = normalizedRecord{occurrence: occurrence, inputIndex: index}
 		if change != nil {
-			warnings = append(warnings, contracts.Warning{Scope: occurrenceScope(index), ReasonCode: ReasonCodeNameCanonicalized,
+			warnings = append(warnings, diagnostics.Finding{Scope: occurrenceScope(index), ReasonCode: ReasonCodeNameCanonicalized,
 				Message: fmt.Sprintf("input index %d: location name canonicalized from %s to %s", index, diagnostics.Quote(change.from), diagnostics.Quote(change.to))})
 		}
 		if !found {
-			warnings = append(warnings, contracts.Warning{Scope: occurrenceScope(index), ReasonCode: ReasonCodeUnknownLocationID,
+			warnings = append(warnings, diagnostics.Finding{Scope: occurrenceScope(index), ReasonCode: ReasonCodeUnknownLocationID,
 				Message: fmt.Sprintf("input index %d: location ID %s is not in the supplied registry", index, diagnostics.Quote(inputOccurrence.LocationID))})
 		}
 		if refsChanged {
-			warnings = append(warnings, contracts.Warning{Scope: occurrenceScope(index), ReasonCode: ReasonCodeSourceRefsNormalized,
+			warnings = append(warnings, diagnostics.Finding{Scope: occurrenceScope(index), ReasonCode: ReasonCodeSourceRefsNormalized,
 				Message: fmt.Sprintf("input index %d: source references normalized (original count %d, final count %d)", index, len(inputOccurrence.SourceRefs), len(occurrence.SourceRefs))})
 		}
 	}
@@ -149,7 +149,7 @@ func normalizeList(input dnd.LocationOccurrenceList, documentIndex source.Docume
 	})
 	for position, record := range records {
 		if position != record.inputIndex {
-			warnings = append(warnings, contracts.Warning{Scope: occurrenceScope(record.inputIndex), ReasonCode: ReasonCodeOccurrencesReordered,
+			warnings = append(warnings, diagnostics.Finding{Scope: occurrenceScope(record.inputIndex), ReasonCode: ReasonCodeOccurrencesReordered,
 				Message: fmt.Sprintf("input index %d moved to normalized position %d by canonical occurrence order", record.inputIndex, position)})
 		}
 	}
@@ -194,7 +194,7 @@ type duplicateGroup struct {
 	removed       []int
 }
 
-func collapseDuplicates(records []normalizedRecord, documentIndex source.DocumentIndex) ([]dnd.LocationOccurrence, []contracts.Warning) {
+func collapseDuplicates(records []normalizedRecord, documentIndex source.DocumentIndex) ([]dnd.LocationOccurrence, []diagnostics.Finding) {
 	if len(records) == 0 {
 		return make([]dnd.LocationOccurrence, 0), nil
 	}
@@ -222,7 +222,7 @@ func collapseDuplicates(records []normalizedRecord, documentIndex source.Documen
 			output = append(output, cloneOccurrence(record.occurrence))
 		}
 	}
-	warnings := make([]contracts.Warning, 0)
+	warnings := make([]diagnostics.Finding, 0)
 	for _, group := range groups {
 		if len(group.removed) > 0 {
 			warnings = append(warnings, duplicateWarning(group.retainedIndex, group.removed))
@@ -316,12 +316,12 @@ func sourceRefsLess(order shared.SourceRefOrder, left, right []source.SourceRef)
 	return len(left) < len(right)
 }
 
-func duplicateWarning(retainedIndex int, removed []int) contracts.Warning {
+func duplicateWarning(retainedIndex int, removed []int) diagnostics.Finding {
 	issues := make([]string, len(removed))
 	for index, removedIndex := range removed {
 		issues[index] = fmt.Sprintf("removed input index %d", removedIndex)
 	}
-	return contracts.Warning{Scope: occurrenceScope(retainedIndex), ReasonCode: ReasonCodeDuplicateCollapsed,
+	return diagnostics.Finding{Scope: occurrenceScope(retainedIndex), ReasonCode: ReasonCodeDuplicateCollapsed,
 		Message: diagnostics.Aggregate(fmt.Sprintf("duplicate location occurrence collapsed; retained input index %d", retainedIndex), issues)}
 }
 

internal/modules/dnd/normalize/locationoccurrences/normalizer_test.go

@@ -12,7 +12,6 @@ import (
 	"gitea.maximumdirect.net/eric/notarius/internal/modules/dnd"
 	locationcodec "gitea.maximumdirect.net/eric/notarius/internal/modules/dnd/codec/locationregistry"
 	"gitea.maximumdirect.net/eric/notarius/internal/modules/dnd/locations/identity"
-	"gitea.maximumdirect.net/eric/notarius/internal/modules/dnd/shared/diagnostics"
 )
 
 func TestNormalizeCanonicalizesNamesByIDAndClonesInputs(t *testing.T) {
@@ -125,7 +124,7 @@ func TestNormalizerContractsRequiredRegistryAndWarningBounds(t *testing.T) {
 		t.Fatalf("unbound registry error = %v", err)
 	}
 
-	count := diagnostics.MaxWarnings + 5
+	count := contracts.MaxDiagnosticSamples + 5
 	doc := &source.SourceDocument{ID: "session", Units: make([]source.SourceUnit, count)}
 	input := dnd.LocationOccurrenceList{Occurrences: make([]dnd.LocationOccurrence, count)}
 	location := registryLocations("The Mill").Locations[0]
@@ -134,7 +133,7 @@ func TestNormalizerContractsRequiredRegistryAndWarningBounds(t *testing.T) {
 		input.Occurrences[index] = dnd.LocationOccurrence{LocationID: location.ID, Name: "not canonical", Kind: dnd.LocationOccurrenceKindMentioned, SourceRefs: []source.SourceRef{{SourceID: doc.ID, StartUnitID: count - index, EndUnitID: count - index}}}
 	}
 	bounded, err := newNormalizer(t, registryReferences(t, dnd.LocationRegistry{Locations: []dnd.Location{location}})).Normalize(context.Background(), normalizeRequest(input, doc, contracts.ReferenceSet{}))
-	if err != nil || len(bounded.Warnings) != 0 || len(bounded.Diagnostics) == 0 {
+	if err != nil || len(bounded.Diagnostics) == 0 {
 		t.Fatalf("bounded diagnostics = %#v, %v", bounded.Diagnostics, err)
 	}
 }

internal/modules/dnd/normalize/locationregistry/normalizer.go

@@ -148,23 +148,23 @@ func (n *Normalizer) Normalize(ctx context.Context, req contracts.TypedNormalize
 	return retryResult(recordList(applied), findings, reconciliation)
 }
 
-func (n *Normalizer) invalidStructuredResult(value dnd.LocationRegistry, findings []contracts.Warning) (contracts.TypedNormalizeResult[dnd.LocationRegistry], error) {
+func (n *Normalizer) invalidStructuredResult(value dnd.LocationRegistry, findings []diagnostics.Finding) (contracts.TypedNormalizeResult[dnd.LocationRegistry], error) {
 	return retryResultWithFallback(value, findings, nil, "semantic proposal requires retry: invalid structured output", semanticFallbackFinding(-1))
 }
 
-func retryResult(value dnd.LocationRegistry, findings []contracts.Warning, reconciliation semanticreconcile.Result) (contracts.TypedNormalizeResult[dnd.LocationRegistry], error) {
+func retryResult(value dnd.LocationRegistry, findings []diagnostics.Finding, reconciliation semanticreconcile.Result) (contracts.TypedNormalizeResult[dnd.LocationRegistry], error) {
 	return retryResultWithFallback(value, findings, reconciliation.ModelCandidate(), diagnostics.Aggregate("semantic proposal requires retry", semanticreconcile.IssueDetails(reconciliation.Issues())), semanticFallbackFinding(reconciliation.DiscardedGroupCount()))
 }
 
-func semanticFallbackFinding(discarded int) contracts.Warning {
+func semanticFallbackFinding(discarded int) diagnostics.Finding {
 	message := "semantic proposal could not be applied"
 	if discarded >= 0 {
 		message = fmt.Sprintf("%d proposal group(s) omitted after semantic proposal retry exhaustion", discarded)
 	}
-	return contracts.Warning{Scope: "locations", ReasonCode: ReasonCodeLocationSemanticReconciliationExhausted, Message: message}
+	return diagnostics.Finding{Scope: "locations", ReasonCode: ReasonCodeLocationSemanticReconciliationExhausted, Message: message}
 }
 
-func normalizationResult(value dnd.LocationRegistry, findings []contracts.Warning, candidate *contracts.ModelCandidate) (contracts.TypedNormalizeResult[dnd.LocationRegistry], error) {
+func normalizationResult(value dnd.LocationRegistry, findings []diagnostics.Finding, candidate *contracts.ModelCandidate) (contracts.TypedNormalizeResult[dnd.LocationRegistry], error) {
 	diagnosticGroups, err := diagnostics.Collect(findings, contracts.DiagnosticDispositionObservation, contracts.DiagnosticCategoryNormalization)
 	if err != nil {
 		return contracts.TypedNormalizeResult[dnd.LocationRegistry]{}, normalizerErrorf("collect normalization diagnostics: %w", err)
@@ -172,12 +172,12 @@ func normalizationResult(value dnd.LocationRegistry, findings []contracts.Warnin
 	return contracts.TypedNormalizeResult[dnd.LocationRegistry]{Value: value, Diagnostics: diagnosticGroups, ModelCandidate: candidate}, nil
 }
 
-func fallbackResult(value dnd.LocationRegistry, findings []contracts.Warning, fallback contracts.Warning) (contracts.TypedNormalizeResult[dnd.LocationRegistry], error) {
+func fallbackResult(value dnd.LocationRegistry, findings []diagnostics.Finding, fallback diagnostics.Finding) (contracts.TypedNormalizeResult[dnd.LocationRegistry], error) {
 	result, err := normalizationResult(value, findings, nil)
 	if err != nil {
 		return contracts.TypedNormalizeResult[dnd.LocationRegistry]{}, err
 	}
-	fallbackGroups, err := diagnostics.Collect([]contracts.Warning{fallback}, contracts.DiagnosticDispositionWarning, contracts.DiagnosticCategoryFallback)
+	fallbackGroups, err := diagnostics.Collect([]diagnostics.Finding{fallback}, contracts.DiagnosticDispositionWarning, contracts.DiagnosticCategoryFallback)
 	if err != nil {
 		return contracts.TypedNormalizeResult[dnd.LocationRegistry]{}, normalizerErrorf("collect fallback diagnostic: %w", err)
 	}
@@ -185,12 +185,12 @@ func fallbackResult(value dnd.LocationRegistry, findings []contracts.Warning, fa
 	return result, nil
 }
 
-func retryResultWithFallback(value dnd.LocationRegistry, findings []contracts.Warning, candidate *contracts.ModelCandidate, message string, fallback contracts.Warning) (contracts.TypedNormalizeResult[dnd.LocationRegistry], error) {
+func retryResultWithFallback(value dnd.LocationRegistry, findings []diagnostics.Finding, candidate *contracts.ModelCandidate, message string, fallback diagnostics.Finding) (contracts.TypedNormalizeResult[dnd.LocationRegistry], error) {
 	result, err := normalizationResult(value, findings, candidate)
 	if err != nil {
 		return contracts.TypedNormalizeResult[dnd.LocationRegistry]{}, err
 	}
-	fallbackGroups, err := diagnostics.Collect([]contracts.Warning{fallback}, contracts.DiagnosticDispositionWarning, contracts.DiagnosticCategoryFallback)
+	fallbackGroups, err := diagnostics.Collect([]diagnostics.Finding{fallback}, contracts.DiagnosticDispositionWarning, contracts.DiagnosticCategoryFallback)
 	if err != nil {
 		return contracts.TypedNormalizeResult[dnd.LocationRegistry]{}, normalizerErrorf("collect fallback diagnostic: %w", err)
 	}
@@ -204,23 +204,23 @@ type normalizedRecord struct {
 	earliest     int
 }
 
-func preprocessRecords(input dnd.LocationRegistry, order shared.SourceRefOrder) ([]normalizedRecord, []contracts.Warning) {
+func preprocessRecords(input dnd.LocationRegistry, order shared.SourceRefOrder) ([]normalizedRecord, []diagnostics.Finding) {
 	if input.Locations == nil {
 		return nil, nil
 	}
 	records := make([]normalizedRecord, len(input.Locations))
-	warnings := make([]contracts.Warning, 0)
+	warnings := make([]diagnostics.Finding, 0)
 	for index, inputLocation := range input.Locations {
 		location, fieldsChanged, refsChanged := normalizeRecord(inputLocation, order)
 		records[index] = normalizedRecord{location: location, inputIndexes: []int{index}, earliest: index}
 		if fieldsChanged {
-			warnings = append(warnings, contracts.Warning{Scope: locationScope(index), ReasonCode: ReasonCodeLocationFieldsNormalized, Message: fmt.Sprintf("input index %d: location name normalized for %s", index, diagnostics.Quote(inputLocation.Name))})
+			warnings = append(warnings, diagnostics.Finding{Scope: locationScope(index), ReasonCode: ReasonCodeLocationFieldsNormalized, Message: fmt.Sprintf("input index %d: location name normalized for %s", index, diagnostics.Quote(inputLocation.Name))})
 		}
 		if refsChanged {
-			warnings = append(warnings, contracts.Warning{Scope: locationScope(index), ReasonCode: ReasonCodeSourceReferencesNormalized, Message: fmt.Sprintf("input index %d: source references normalized (original count %d, final count %d)", index, len(inputLocation.SourceRefs), len(location.SourceRefs))})
+			warnings = append(warnings, diagnostics.Finding{Scope: locationScope(index), ReasonCode: ReasonCodeSourceReferencesNormalized, Message: fmt.Sprintf("input index %d: source references normalized (original count %d, final count %d)", index, len(inputLocation.SourceRefs), len(location.SourceRefs))})
 		}
 		if inputLocation.ID != location.ID {
-			warnings = append(warnings, contracts.Warning{Scope: locationScope(index), ReasonCode: ReasonCodeLocationIDRecomputed, Message: fmt.Sprintf("input index %d: location ID recomputed from %s", index, diagnostics.Quote(location.Name))})
+			warnings = append(warnings, diagnostics.Finding{Scope: locationScope(index), ReasonCode: ReasonCodeLocationIDRecomputed, Message: fmt.Sprintf("input index %d: location ID recomputed from %s", index, diagnostics.Quote(location.Name))})
 		}
 	}
 	groups := exactDuplicateGroups(records)
@@ -342,7 +342,7 @@ func recordList(records []normalizedRecord) dnd.LocationRegistry {
 	return dnd.LocationRegistry{Locations: recordValues(records)}
 }
 
-func duplicateWarning(retainedIndex int, removed []int) contracts.Warning {
+func duplicateWarning(retainedIndex int, removed []int) diagnostics.Finding {
 	const maxDisplayedIndices = 20
 	displayed := removed
 	if len(displayed) > maxDisplayedIndices {
@@ -356,7 +356,7 @@ func duplicateWarning(retainedIndex int, removed []int) contracts.Warning {
 	if omitted := len(removed) - len(displayed); omitted > 0 {
 		message += fmt.Sprintf("; %d additional removed input indices omitted", omitted)
 	}
-	return contracts.Warning{Scope: locationScope(retainedIndex), ReasonCode: ReasonCodeDuplicateLocationCollapsed, Message: message}
+	return diagnostics.Finding{Scope: locationScope(retainedIndex), ReasonCode: ReasonCodeDuplicateLocationCollapsed, Message: message}
 }
 func locationScope(index int) string { return fmt.Sprintf("locations[%d]", index) }
 

internal/modules/dnd/normalize/locationregistry/reconciliation.go

@@ -3,7 +3,6 @@ package locationregistry
 import (
 	"fmt"
 
-	"gitea.maximumdirect.net/eric/notarius/internal/framework/contracts"
 	"gitea.maximumdirect.net/eric/notarius/internal/framework/semanticreconcile"
 	"gitea.maximumdirect.net/eric/notarius/internal/modules/dnd"
 	"gitea.maximumdirect.net/eric/notarius/internal/modules/dnd/locations/identity"
@@ -28,7 +27,7 @@ func reconciliationInputs(records []normalizedRecord) ([]semanticreconcile.Candi
 	return candidates, envelopes, nil
 }
 
-func applyReconciliationPlan(plan semanticreconcile.Plan, records []normalizedRecord, envelopes []semanticreconcile.Record[dnd.Location], order shared.SourceRefOrder) ([]normalizedRecord, []contracts.Warning, error) {
+func applyReconciliationPlan(plan semanticreconcile.Plan, records []normalizedRecord, envelopes []semanticreconcile.Record[dnd.Location], order shared.SourceRefOrder) ([]normalizedRecord, []diagnostics.Finding, error) {
 	application, err := semanticreconcile.ApplyPlan(plan, envelopes, semanticreconcile.ApplicationPolicy[dnd.Location]{
 		CloneValue: cloneLocation,
 		ConsolidateGroup: func(members []dnd.Location, canonical dnd.Location) (dnd.Location, error) {
@@ -55,7 +54,7 @@ func applyReconciliationPlan(plan semanticreconcile.Plan, records []normalizedRe
 			earliest:     record.EarliestInputPosition(),
 		}
 	}
-	warnings := make([]contracts.Warning, 0, len(application.AppliedGroups()))
+	warnings := make([]diagnostics.Finding, 0, len(application.AppliedGroups()))
 	for _, event := range application.AppliedGroups() {
 		provenance := event.Provenance()
 		warnings = append(warnings, semanticDuplicateWarning(provenance, records[provenance.CanonicalPosition()]))
@@ -63,7 +62,7 @@ func applyReconciliationPlan(plan semanticreconcile.Plan, records []normalizedRe
 	return output, warnings, nil
 }
 
-func semanticDuplicateWarning(provenance semanticreconcile.GroupProvenance, canonical normalizedRecord) contracts.Warning {
+func semanticDuplicateWarning(provenance semanticreconcile.GroupProvenance, canonical normalizedRecord) diagnostics.Finding {
 	inputIndexes := provenance.OriginalInputIndexes()
 	details := make([]string, 0, len(inputIndexes)+1)
 	for _, inputIndex := range inputIndexes {
@@ -72,7 +71,7 @@ func semanticDuplicateWarning(provenance semanticreconcile.GroupProvenance, cano
 	if canonical.earliest != provenance.EarliestInputPosition() {
 		details = append(details, fmt.Sprintf("canonical display name from input index %d", canonical.earliest))
 	}
-	return contracts.Warning{
+	return diagnostics.Finding{
 		Scope:      locationScope(provenance.EarliestInputPosition()),
 		ReasonCode: ReasonCodeDuplicateLocationCollapsed,
 		Message:    diagnostics.Aggregate("semantic duplicate consolidation", details),

internal/modules/dnd/normalize/npcoccurrences/normalizer.go

@@ -124,13 +124,13 @@ type normalizedRecord struct {
 	inputIndex int
 }
 
-func normalizeList(input dnd.NPCOccurrenceList, documentIndex source.DocumentIndex, order shared.SourceRefOrder, registry *npcregistry.Registry) (dnd.NPCOccurrenceList, []contracts.Warning, error) {
+func normalizeList(input dnd.NPCOccurrenceList, documentIndex source.DocumentIndex, order shared.SourceRefOrder, registry *npcregistry.Registry) (dnd.NPCOccurrenceList, []diagnostics.Finding, error) {
 	if input.Occurrences == nil {
 		return dnd.NPCOccurrenceList{}, nil, nil
 	}
 
 	records := make([]normalizedRecord, len(input.Occurrences))
-	warnings := make([]contracts.Warning, 0)
+	warnings := make([]diagnostics.Finding, 0)
 	for index, inputOccurrence := range input.Occurrences {
 		occurrence, refsChanged, err := normalizeOccurrence(inputOccurrence, order, registry)
 		if err != nil {
@@ -138,7 +138,7 @@ func normalizeList(input dnd.NPCOccurrenceList, documentIndex source.DocumentInd
 		}
 		records[index] = normalizedRecord{occurrence: occurrence, inputIndex: index}
 		if refsChanged {
-			warnings = append(warnings, contracts.Warning{
+			warnings = append(warnings, diagnostics.Finding{
 				Scope:      occurrenceScope(index),
 				ReasonCode: ReasonCodeSourceRefsNormalized,
 				Message: fmt.Sprintf("input index %d: source references normalized (original count %d, final count %d)",
@@ -154,7 +154,7 @@ func normalizeList(input dnd.NPCOccurrenceList, documentIndex source.DocumentInd
 		if position == record.inputIndex {
 			continue
 		}
-		warnings = append(warnings, contracts.Warning{
+		warnings = append(warnings, diagnostics.Finding{
 			Scope:      occurrenceScope(record.inputIndex),
 			ReasonCode: ReasonCodeOccurrencesReordered,
 			Message:    fmt.Sprintf("input index %d moved to normalized position %d by source chronology", record.inputIndex, position),
@@ -192,7 +192,7 @@ type duplicateGroup struct {
 	removed       []int
 }
 
-func collapseDuplicates(records []normalizedRecord, documentIndex source.DocumentIndex) ([]dnd.NPCOccurrence, []contracts.Warning) {
+func collapseDuplicates(records []normalizedRecord, documentIndex source.DocumentIndex) ([]dnd.NPCOccurrence, []diagnostics.Finding) {
 	if len(records) == 0 {
 		return make([]dnd.NPCOccurrence, 0), nil
 	}
@@ -220,7 +220,7 @@ func collapseDuplicates(records []normalizedRecord, documentIndex source.Documen
 			output = append(output, cloneOccurrence(record.occurrence))
 		}
 	}
-	warnings := make([]contracts.Warning, 0)
+	warnings := make([]diagnostics.Finding, 0)
 	for _, group := range groups {
 		if len(group.removed) != 0 {
 			warnings = append(warnings, duplicateWarning(group.retainedIndex, group.removed))
@@ -229,12 +229,12 @@ func collapseDuplicates(records []normalizedRecord, documentIndex source.Documen
 	return output, warnings
 }
 
-func duplicateWarning(retainedIndex int, removed []int) contracts.Warning {
+func duplicateWarning(retainedIndex int, removed []int) diagnostics.Finding {
 	issues := make([]string, len(removed))
 	for index, removedIndex := range removed {
 		issues[index] = fmt.Sprintf("removed input index %d", removedIndex)
 	}
-	return contracts.Warning{
+	return diagnostics.Finding{
 		Scope:      occurrenceScope(retainedIndex),
 		ReasonCode: ReasonCodeDuplicateCollapsed,
 		Message: diagnostics.Aggregate(

internal/modules/dnd/normalize/npcoccurrences/normalizer_test.go

@@ -11,7 +11,6 @@ import (
 	"gitea.maximumdirect.net/eric/notarius/internal/modules/dnd"
 	npccodec "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/diagnostics"
 )
 
 func TestNormalizeValidatesPairsAndClones(t *testing.T) {
@@ -141,7 +140,7 @@ func TestNormalizerContractAndDeterministicWarnings(t *testing.T) {
 }
 
 func TestNormalizeBoundsWarnings(t *testing.T) {
-	count := diagnostics.MaxWarnings + 5
+	count := contracts.MaxDiagnosticSamples + 5
 	doc := &source.SourceDocument{ID: "session", Units: make([]source.SourceUnit, count)}
 	input := dnd.NPCOccurrenceList{Occurrences: make([]dnd.NPCOccurrence, count)}
 	for index := range doc.Units {
@@ -163,7 +162,7 @@ func TestNormalizeBoundsWarnings(t *testing.T) {
 	if err != nil {
 		t.Fatal(err)
 	}
-	if len(result.Warnings) != 0 || len(result.Diagnostics) == 0 || result.Diagnostics[0].Disposition != contracts.DiagnosticDispositionObservation {
+	if len(result.Diagnostics) == 0 || result.Diagnostics[0].Disposition != contracts.DiagnosticDispositionObservation {
 		t.Fatalf("diagnostics = %#v", result.Diagnostics)
 	}
 }

internal/modules/dnd/normalize/npcregistry/normalizer.go

@@ -147,23 +147,23 @@ func (n *Normalizer) Normalize(ctx context.Context, req contracts.TypedNormalize
 	return retryResult(recordList(applied), findings, reconciliation)
 }
 
-func (n *Normalizer) invalidStructuredResult(value dnd.NPCRegistry, findings []contracts.Warning) (contracts.TypedNormalizeResult[dnd.NPCRegistry], error) {
+func (n *Normalizer) invalidStructuredResult(value dnd.NPCRegistry, findings []diagnostics.Finding) (contracts.TypedNormalizeResult[dnd.NPCRegistry], error) {
 	return retryResultWithFallback(value, findings, nil, "semantic proposal requires retry: invalid structured output", semanticFallbackFinding(-1))
 }
 
-func retryResult(value dnd.NPCRegistry, findings []contracts.Warning, reconciliation semanticreconcile.Result) (contracts.TypedNormalizeResult[dnd.NPCRegistry], error) {
+func retryResult(value dnd.NPCRegistry, findings []diagnostics.Finding, reconciliation semanticreconcile.Result) (contracts.TypedNormalizeResult[dnd.NPCRegistry], error) {
 	return retryResultWithFallback(value, findings, reconciliation.ModelCandidate(), diagnostics.Aggregate("semantic proposal requires retry", semanticreconcile.IssueDetails(reconciliation.Issues())), semanticFallbackFinding(reconciliation.DiscardedGroupCount()))
 }
 
-func semanticFallbackFinding(discardedGroups int) contracts.Warning {
+func semanticFallbackFinding(discardedGroups int) diagnostics.Finding {
 	message := "semantic proposal could not be applied"
 	if discardedGroups >= 0 {
 		message = fmt.Sprintf("%d proposal group(s) omitted after semantic proposal retry exhaustion", discardedGroups)
 	}
-	return contracts.Warning{Scope: "npcs", ReasonCode: ReasonCodeNPCSemanticReconciliationExhausted, Message: message}
+	return diagnostics.Finding{Scope: "npcs", ReasonCode: ReasonCodeNPCSemanticReconciliationExhausted, Message: message}
 }
 
-func normalizationResult(value dnd.NPCRegistry, findings []contracts.Warning, candidate *contracts.ModelCandidate) (contracts.TypedNormalizeResult[dnd.NPCRegistry], error) {
+func normalizationResult(value dnd.NPCRegistry, findings []diagnostics.Finding, candidate *contracts.ModelCandidate) (contracts.TypedNormalizeResult[dnd.NPCRegistry], error) {
 	diagnosticGroups, err := diagnostics.Collect(findings, contracts.DiagnosticDispositionObservation, contracts.DiagnosticCategoryNormalization)
 	if err != nil {
 		return contracts.TypedNormalizeResult[dnd.NPCRegistry]{}, normalizerErrorf("collect normalization diagnostics: %w", err)
@@ -171,12 +171,12 @@ func normalizationResult(value dnd.NPCRegistry, findings []contracts.Warning, ca
 	return contracts.TypedNormalizeResult[dnd.NPCRegistry]{Value: value, Diagnostics: diagnosticGroups, ModelCandidate: candidate}, nil
 }
 
-func fallbackResult(value dnd.NPCRegistry, findings []contracts.Warning, fallback contracts.Warning) (contracts.TypedNormalizeResult[dnd.NPCRegistry], error) {
+func fallbackResult(value dnd.NPCRegistry, findings []diagnostics.Finding, fallback diagnostics.Finding) (contracts.TypedNormalizeResult[dnd.NPCRegistry], error) {
 	result, err := normalizationResult(value, findings, nil)
 	if err != nil {
 		return contracts.TypedNormalizeResult[dnd.NPCRegistry]{}, err
 	}
-	fallbackGroups, err := diagnostics.Collect([]contracts.Warning{fallback}, contracts.DiagnosticDispositionWarning, contracts.DiagnosticCategoryFallback)
+	fallbackGroups, err := diagnostics.Collect([]diagnostics.Finding{fallback}, contracts.DiagnosticDispositionWarning, contracts.DiagnosticCategoryFallback)
 	if err != nil {
 		return contracts.TypedNormalizeResult[dnd.NPCRegistry]{}, normalizerErrorf("collect fallback diagnostic: %w", err)
 	}
@@ -184,12 +184,12 @@ func fallbackResult(value dnd.NPCRegistry, findings []contracts.Warning, fallbac
 	return result, nil
 }
 
-func retryResultWithFallback(value dnd.NPCRegistry, findings []contracts.Warning, candidate *contracts.ModelCandidate, message string, fallback contracts.Warning) (contracts.TypedNormalizeResult[dnd.NPCRegistry], error) {
+func retryResultWithFallback(value dnd.NPCRegistry, findings []diagnostics.Finding, candidate *contracts.ModelCandidate, message string, fallback diagnostics.Finding) (contracts.TypedNormalizeResult[dnd.NPCRegistry], error) {
 	result, err := normalizationResult(value, findings, candidate)
 	if err != nil {
 		return contracts.TypedNormalizeResult[dnd.NPCRegistry]{}, err
 	}
-	fallbackGroups, err := diagnostics.Collect([]contracts.Warning{fallback}, contracts.DiagnosticDispositionWarning, contracts.DiagnosticCategoryFallback)
+	fallbackGroups, err := diagnostics.Collect([]diagnostics.Finding{fallback}, contracts.DiagnosticDispositionWarning, contracts.DiagnosticCategoryFallback)
 	if err != nil {
 		return contracts.TypedNormalizeResult[dnd.NPCRegistry]{}, normalizerErrorf("collect fallback diagnostic: %w", err)
 	}
@@ -203,23 +203,23 @@ type normalizedRecord struct {
 	earliest     int
 }
 
-func preprocessRecords(input dnd.NPCRegistry, order shared.SourceRefOrder) ([]normalizedRecord, []contracts.Warning) {
+func preprocessRecords(input dnd.NPCRegistry, order shared.SourceRefOrder) ([]normalizedRecord, []diagnostics.Finding) {
 	if input.NPCs == nil {
 		return nil, nil
 	}
 	records := make([]normalizedRecord, len(input.NPCs))
-	warnings := make([]contracts.Warning, 0)
+	warnings := 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 {
-			warnings = append(warnings, contracts.Warning{Scope: npcScope(index), ReasonCode: ReasonCodeNPCFieldsNormalized, Message: fmt.Sprintf("input index %d: NPC name normalized for %s", index, diagnostics.Quote(inputNPC.Name))})
+			warnings = append(warnings, 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 {
-			warnings = append(warnings, contracts.Warning{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))})
+			warnings = append(warnings, 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 {
-			warnings = append(warnings, contracts.Warning{Scope: npcScope(index), ReasonCode: ReasonCodeNPCIDRecomputed, Message: fmt.Sprintf("input index %d: NPC ID recomputed from %s", index, diagnostics.Quote(npc.Name))})
+			warnings = append(warnings, diagnostics.Finding{Scope: npcScope(index), ReasonCode: ReasonCodeNPCIDRecomputed, Message: fmt.Sprintf("input index %d: NPC ID recomputed from %s", index, diagnostics.Quote(npc.Name))})
 		}
 	}
 
@@ -230,7 +230,7 @@ func preprocessRecords(input dnd.NPCRegistry, order shared.SourceRefOrder) ([]no
 		output = append(output, consolidated)
 		retainedIndex := consolidated.earliest
 		if referencesChanged {
-			warnings = append(warnings, contracts.Warning{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))})
+			warnings = append(warnings, 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 {
 			warnings = append(warnings, duplicateWarning(retainedIndex, memberInputIndexes(records, members[1:])))
@@ -340,7 +340,7 @@ func cloneSourceRefs(input []source.SourceRef) []source.SourceRef {
 	return append([]source.SourceRef(nil), input...)
 }
 
-func duplicateWarning(retainedIndex int, removed []int) contracts.Warning {
+func duplicateWarning(retainedIndex int, removed []int) diagnostics.Finding {
 	const maxDisplayedIndices = 20
 	displayed := removed
 	if len(displayed) > maxDisplayedIndices {
@@ -354,7 +354,7 @@ func duplicateWarning(retainedIndex int, removed []int) contracts.Warning {
 	if omitted := len(removed) - len(displayed); omitted > 0 {
 		message += fmt.Sprintf("; %d additional removed input indices omitted", omitted)
 	}
-	return contracts.Warning{Scope: npcScope(retainedIndex), ReasonCode: ReasonCodeDuplicateNPCCollapsed, Message: message}
+	return diagnostics.Finding{Scope: npcScope(retainedIndex), ReasonCode: ReasonCodeDuplicateNPCCollapsed, Message: message}
 }
 
 func npcScope(index int) string { return fmt.Sprintf("npcs[%d]", index) }

internal/modules/dnd/normalize/npcregistry/reconciliation.go

@@ -3,7 +3,6 @@ package npcregistry
 import (
 	"fmt"
 
-	"gitea.maximumdirect.net/eric/notarius/internal/framework/contracts"
 	"gitea.maximumdirect.net/eric/notarius/internal/framework/semanticreconcile"
 	"gitea.maximumdirect.net/eric/notarius/internal/modules/dnd"
 	"gitea.maximumdirect.net/eric/notarius/internal/modules/dnd/npcs/identity"
@@ -28,7 +27,7 @@ func reconciliationInputs(records []normalizedRecord) ([]semanticreconcile.Candi
 	return candidates, envelopes, nil
 }
 
-func applyReconciliationPlan(plan semanticreconcile.Plan, records []normalizedRecord, envelopes []semanticreconcile.Record[dnd.NPC], order shared.SourceRefOrder) ([]normalizedRecord, []contracts.Warning, error) {
+func applyReconciliationPlan(plan semanticreconcile.Plan, records []normalizedRecord, envelopes []semanticreconcile.Record[dnd.NPC], order shared.SourceRefOrder) ([]normalizedRecord, []diagnostics.Finding, error) {
 	application, err := semanticreconcile.ApplyPlan(plan, envelopes, semanticreconcile.ApplicationPolicy[dnd.NPC]{
 		CloneValue: cloneNPC,
 		ConsolidateGroup: func(members []dnd.NPC, canonical dnd.NPC) (dnd.NPC, error) {
@@ -55,7 +54,7 @@ func applyReconciliationPlan(plan semanticreconcile.Plan, records []normalizedRe
 			earliest:     record.EarliestInputPosition(),
 		}
 	}
-	warnings := make([]contracts.Warning, 0, len(application.AppliedGroups()))
+	warnings := make([]diagnostics.Finding, 0, len(application.AppliedGroups()))
 	for _, event := range application.AppliedGroups() {
 		provenance := event.Provenance()
 		warnings = append(warnings, semanticDuplicateWarning(provenance, records[provenance.CanonicalPosition()]))
@@ -63,7 +62,7 @@ func applyReconciliationPlan(plan semanticreconcile.Plan, records []normalizedRe
 	return output, warnings, nil
 }
 
-func semanticDuplicateWarning(provenance semanticreconcile.GroupProvenance, canonical normalizedRecord) contracts.Warning {
+func semanticDuplicateWarning(provenance semanticreconcile.GroupProvenance, canonical normalizedRecord) diagnostics.Finding {
 	inputIndexes := provenance.OriginalInputIndexes()
 	details := make([]string, 0, len(inputIndexes)+1)
 	for _, inputIndex := range inputIndexes {
@@ -72,7 +71,7 @@ func semanticDuplicateWarning(provenance semanticreconcile.GroupProvenance, cano
 	if canonical.earliest != provenance.EarliestInputPosition() {
 		details = append(details, fmt.Sprintf("canonical display name from input index %d", canonical.earliest))
 	}
-	return contracts.Warning{
+	return diagnostics.Finding{
 		Scope:      npcScope(provenance.EarliestInputPosition()),
 		ReasonCode: ReasonCodeDuplicateNPCCollapsed,
 		Message:    diagnostics.Aggregate("semantic duplicate consolidation", details),

internal/modules/dnd/normalize/scenedescriptions/normalizer.go

@@ -79,7 +79,7 @@ type normalizedScene struct {
 	inputIndex int
 }
 
-func normalizeList(input dnd.SceneDescriptionList, doc *source.SourceDocument) (dnd.SceneDescriptionList, []contracts.Warning, error) {
+func normalizeList(input dnd.SceneDescriptionList, doc *source.SourceDocument) (dnd.SceneDescriptionList, []diagnostics.Finding, error) {
 	if doc == nil {
 		return dnd.SceneDescriptionList{}, nil, fmt.Errorf("source document must not be nil")
 	}
@@ -92,7 +92,7 @@ func normalizeList(input dnd.SceneDescriptionList, doc *source.SourceDocument) (
 
 	documentIndex := source.NewDocumentIndex(doc)
 	records := make([]normalizedScene, len(input.Scenes))
-	warnings := make([]contracts.Warning, 0)
+	warnings := make([]diagnostics.Finding, 0)
 	for sceneIndex, scene := range input.Scenes {
 		originalTitle, originalSummary := scene.Title, scene.Summary
 		scene.Title = strings.TrimSpace(scene.Title)
@@ -104,7 +104,7 @@ func normalizeList(input dnd.SceneDescriptionList, doc *source.SourceDocument) (
 			return dnd.SceneDescriptionList{}, nil, fmt.Errorf("scenes[%d].source_ref: %s", sceneIndex, diagnostics.Truncate(err.Error()))
 		}
 		if originalTitle != scene.Title || originalSummary != scene.Summary {
-			warnings = append(warnings, contracts.Warning{
+			warnings = append(warnings, diagnostics.Finding{
 				Scope:      sceneScope(sceneIndex),
 				ReasonCode: ReasonCodeProseNormalized,
 				Message:    fmt.Sprintf("input index %d: title and/or summary whitespace normalized", sceneIndex),
@@ -125,7 +125,7 @@ func normalizeList(input dnd.SceneDescriptionList, doc *source.SourceDocument) (
 		if position == record.inputIndex {
 			continue
 		}
-		warnings = append(warnings, contracts.Warning{
+		warnings = append(warnings, diagnostics.Finding{
 			Scope:      sceneScope(record.inputIndex),
 			ReasonCode: ReasonCodeOrderNormalized,
 			Message: fmt.Sprintf("input index %d moved to normalized position %d by canonical scene order",
@@ -146,7 +146,7 @@ func normalizeList(input dnd.SceneDescriptionList, doc *source.SourceDocument) (
 			return dnd.SceneDescriptionList{}, nil, fmt.Errorf("source range %s has conflicting records", sourceRefLabel(scene.SourceRef))
 		}
 		if retainedIndex, ok := seen[scene]; ok {
-			warnings = append(warnings, contracts.Warning{
+			warnings = append(warnings, diagnostics.Finding{
 				Scope:      sceneScope(record.inputIndex),
 				ReasonCode: ReasonCodeDuplicateCollapsed,
 				Message: fmt.Sprintf("input index %d: exact duplicate scene collapsed; retained input index %d",

internal/modules/dnd/normalize/scenedescriptions/normalizer_test.go

@@ -11,7 +11,6 @@ import (
 	"gitea.maximumdirect.net/eric/notarius/internal/framework/contracts"
 	"gitea.maximumdirect.net/eric/notarius/internal/framework/pipeline"
 	"gitea.maximumdirect.net/eric/notarius/internal/modules/dnd"
-	"gitea.maximumdirect.net/eric/notarius/internal/modules/dnd/shared/diagnostics"
 )
 
 func TestNormalizeTrimsOrdersDeduplicatesAndOwnsOutput(t *testing.T) {
@@ -35,7 +34,7 @@ func TestNormalizeTrimsOrdersDeduplicatesAndOwnsOutput(t *testing.T) {
 	if !reflect.DeepEqual(result.Value.Scenes, want) {
 		t.Fatalf("scenes = %#v, want %#v", result.Value.Scenes, want)
 	}
-	if len(result.Warnings) != 0 || len(result.Diagnostics) != 3 || result.Diagnostics[0].ReasonCode != ReasonCodeProseNormalized || result.Diagnostics[0].OccurrenceCount != 4 || result.Diagnostics[1].ReasonCode != ReasonCodeOrderNormalized || result.Diagnostics[1].OccurrenceCount != 2 || result.Diagnostics[2].ReasonCode != ReasonCodeDuplicateCollapsed || result.Diagnostics[2].OccurrenceCount != 1 {
+	if len(result.Diagnostics) != 3 || result.Diagnostics[0].ReasonCode != ReasonCodeProseNormalized || result.Diagnostics[0].OccurrenceCount != 4 || result.Diagnostics[1].ReasonCode != ReasonCodeOrderNormalized || result.Diagnostics[1].OccurrenceCount != 2 || result.Diagnostics[2].ReasonCode != ReasonCodeDuplicateCollapsed || result.Diagnostics[2].OccurrenceCount != 1 {
 		t.Fatalf("diagnostics = %#v, want grouped prose, order, and duplicate observations", result.Diagnostics)
 	}
 	if !reflect.DeepEqual(input, before) {
@@ -55,7 +54,7 @@ func TestNormalizeTrimsOrdersDeduplicatesAndOwnsOutput(t *testing.T) {
 }
 
 func TestNormalizeLimitsCombinedSceneMutationWarnings(t *testing.T) {
-	count := diagnostics.MaxWarnings - 8
+	count := contracts.MaxDiagnosticSamples + 1
 	doc := &source.SourceDocument{ID: "session", Units: make([]source.SourceUnit, count)}
 	input := dnd.SceneDescriptionList{Scenes: make([]dnd.SceneDescription, count)}
 	for index := range input.Scenes {
@@ -70,7 +69,7 @@ func TestNormalizeLimitsCombinedSceneMutationWarnings(t *testing.T) {
 	if len(result.Value.Scenes) != count || result.Value.Scenes[0].SourceRef.StartUnitID != 1 {
 		t.Fatalf("normalized scenes = %#v, want unchanged canonical values", result.Value.Scenes)
 	}
-	if len(result.Warnings) != 0 || len(result.Diagnostics) != 2 || result.Diagnostics[0].ReasonCode != ReasonCodeProseNormalized || result.Diagnostics[0].Disposition != contracts.DiagnosticDispositionObservation || result.Diagnostics[0].OccurrenceCount != count || len(result.Diagnostics[0].Samples) != contracts.MaxDiagnosticSamples || result.Diagnostics[1].ReasonCode != ReasonCodeOrderNormalized || result.Diagnostics[1].OccurrenceCount != count {
+	if len(result.Diagnostics) != 2 || result.Diagnostics[0].ReasonCode != ReasonCodeProseNormalized || result.Diagnostics[0].Disposition != contracts.DiagnosticDispositionObservation || result.Diagnostics[0].OccurrenceCount != count || len(result.Diagnostics[0].Samples) != contracts.MaxDiagnosticSamples || result.Diagnostics[1].ReasonCode != ReasonCodeOrderNormalized || result.Diagnostics[1].OccurrenceCount != count {
 		t.Fatalf("diagnostics = %#v", result.Diagnostics)
 	}
 }

internal/modules/dnd/normalize/spells/normalizer.go

@@ -110,8 +110,8 @@ func (n *Normalizer) Normalize(ctx context.Context, req contracts.TypedNormalize
 	return contracts.TypedNormalizeResult[dnd.SpellList]{Value: value, Diagnostics: diagnosticGroups}, nil
 }
 
-func normalizeSpellList(input dnd.SpellList, catalog spellcatalog.EffectiveCatalog, order shared.SourceRefOrder) (dnd.SpellList, []contracts.Warning) {
-	var warnings []contracts.Warning
+func normalizeSpellList(input dnd.SpellList, catalog spellcatalog.EffectiveCatalog, order shared.SourceRefOrder) (dnd.SpellList, []diagnostics.Finding) {
+	var warnings []diagnostics.Finding
 	if input.SpellCasts == nil {
 		return dnd.SpellList{}, nil
 	}
@@ -121,7 +121,7 @@ func normalizeSpellList(input dnd.SpellList, catalog spellcatalog.EffectiveCatal
 		cast := cloneSpellCast(inputCast)
 		if canonicalName, ok := catalog.Lookup(inputCast.Spell); ok {
 			if inputCast.Spell != canonicalName {
-				warnings = append(warnings, contracts.Warning{
+				warnings = append(warnings, diagnostics.Finding{
 					Scope:      spellCastScope(index),
 					ReasonCode: ReasonCodeSpellNameCanonicalized,
 					Message: fmt.Sprintf("input index %d: spell name canonicalized from %q to %q",
@@ -130,7 +130,7 @@ func normalizeSpellList(input dnd.SpellList, catalog spellcatalog.EffectiveCatal
 			}
 			cast.Spell = canonicalName
 		} else {
-			warnings = append(warnings, contracts.Warning{
+			warnings = append(warnings, diagnostics.Finding{
 				Scope:      spellCastScope(index),
 				ReasonCode: ReasonCodeSpellNameUnresolved,
 				Message: fmt.Sprintf("input index %d: spell name %q could not be resolved in the effective catalog",
@@ -141,7 +141,7 @@ func normalizeSpellList(input dnd.SpellList, catalog spellcatalog.EffectiveCatal
 		canonicalRefs, orderChanged, duplicateCount := canonicalizeSourceRefs(order, inputCast.SourceRefs)
 		cast.SourceRefs = canonicalRefs
 		if orderChanged || duplicateCount > 0 {
-			warnings = append(warnings, contracts.Warning{
+			warnings = append(warnings, diagnostics.Finding{
 				Scope:      spellCastScope(index),
 				ReasonCode: ReasonCodeSourceReferencesNormalized,
 				Message: fmt.Sprintf("input index %d: source references normalized (original count %d, final count %d, order changed %t, duplicates removed %d)",
@@ -179,7 +179,7 @@ type duplicateGroup struct {
 	removed       []int
 }
 
-func collapseDuplicateSpellCasts(input dnd.SpellList, documentIndex source.DocumentIndex, catalog spellcatalog.EffectiveCatalog) (dnd.SpellList, []contracts.Warning) {
+func collapseDuplicateSpellCasts(input dnd.SpellList, documentIndex source.DocumentIndex, catalog spellcatalog.EffectiveCatalog) (dnd.SpellList, []diagnostics.Finding) {
 	if len(input.SpellCasts) == 0 {
 		return input, nil
 	}
@@ -221,7 +221,7 @@ func collapseDuplicateSpellCasts(input dnd.SpellList, documentIndex source.Docum
 		}
 	}
 
-	warnings := make([]contracts.Warning, 0)
+	warnings := make([]diagnostics.Finding, 0)
 	for _, group := range groups {
 		if len(group.removed) == 0 {
 			continue
@@ -264,7 +264,7 @@ func writeKeyInt(builder *strings.Builder, value int) {
 	builder.WriteByte(';')
 }
 
-func duplicateWarning(retainedIndex int, removed []int) contracts.Warning {
+func duplicateWarning(retainedIndex int, removed []int) diagnostics.Finding {
 	const maxDisplayedIndices = 20
 	displayed := removed
 	if len(displayed) > maxDisplayedIndices {
@@ -279,7 +279,7 @@ func duplicateWarning(retainedIndex int, removed []int) contracts.Warning {
 	if omitted := len(removed) - len(displayed); omitted > 0 {
 		message += fmt.Sprintf("; %d additional removed input indices omitted", omitted)
 	}
-	return contracts.Warning{
+	return diagnostics.Finding{
 		Scope:      spellCastScope(retainedIndex),
 		ReasonCode: ReasonCodeDuplicateSpellCastCollapsed,
 		Message:    message,

internal/modules/dnd/normalize/spells/normalizer_test.go

@@ -12,7 +12,6 @@ import (
 	"gitea.maximumdirect.net/eric/notarius/internal/framework/contracts"
 	"gitea.maximumdirect.net/eric/notarius/internal/framework/pipeline"
 	"gitea.maximumdirect.net/eric/notarius/internal/modules/dnd"
-	"gitea.maximumdirect.net/eric/notarius/internal/modules/dnd/shared/diagnostics"
 	spellcatalog "gitea.maximumdirect.net/eric/notarius/internal/modules/dnd/spells/catalog"
 )
 
@@ -151,13 +150,13 @@ func TestNormalizeCanonicalizesNamesAndReportsUnresolvedNames(t *testing.T) {
 	}
 	canonicalized := diagnosticByReason(result.Diagnostics, ReasonCodeSpellNameCanonicalized)
 	unresolved := diagnosticByReason(result.Diagnostics, ReasonCodeSpellNameUnresolved)
-	if len(result.Warnings) != 0 || canonicalized == nil || canonicalized.Disposition != contracts.DiagnosticDispositionObservation || canonicalized.OccurrenceCount != 3 || unresolved == nil || unresolved.Disposition != contracts.DiagnosticDispositionAdvisory || unresolved.OccurrenceCount != 1 || unresolved.Samples[0].Scope != "spell_casts[3]" || strings.Contains(unresolved.Samples[0].Message, "Mystery\nSpell") || !strings.Contains(unresolved.Samples[0].Message, `Mystery\nSpell\tName`) {
+	if canonicalized == nil || canonicalized.Disposition != contracts.DiagnosticDispositionObservation || canonicalized.OccurrenceCount != 3 || unresolved == nil || unresolved.Disposition != contracts.DiagnosticDispositionAdvisory || unresolved.OccurrenceCount != 1 || unresolved.Samples[0].Scope != "spell_casts[3]" || strings.Contains(unresolved.Samples[0].Message, "Mystery\nSpell") || !strings.Contains(unresolved.Samples[0].Message, `Mystery\nSpell\tName`) {
 		t.Fatalf("diagnostics = %#v, want grouped canonicalization and unresolved-quality diagnostics", result.Diagnostics)
 	}
 }
 
 func TestNormalizeLimitsWarningsWithoutChangingSpellValues(t *testing.T) {
-	input := dnd.SpellList{SpellCasts: make([]dnd.SpellCast, diagnostics.MaxWarnings+1)}
+	input := dnd.SpellList{SpellCasts: make([]dnd.SpellCast, contracts.MaxDiagnosticSamples+1)}
 	for index := range input.SpellCasts {
 		input.SpellCasts[index].Spell = fmt.Sprintf("Unknown Spell %d", index)
 	}
@@ -168,7 +167,7 @@ func TestNormalizeLimitsWarningsWithoutChangingSpellValues(t *testing.T) {
 	if !reflect.DeepEqual(result.Value, input) {
 		t.Fatalf("normalized value = %#v, want unresolved spell values preserved", result.Value)
 	}
-	if len(result.Warnings) != 0 || len(result.Diagnostics) != 1 || result.Diagnostics[0].ReasonCode != ReasonCodeSpellNameUnresolved || result.Diagnostics[0].Disposition != contracts.DiagnosticDispositionAdvisory || result.Diagnostics[0].OccurrenceCount != len(input.SpellCasts) || len(result.Diagnostics[0].Samples) != contracts.MaxDiagnosticSamples {
+	if len(result.Diagnostics) != 1 || result.Diagnostics[0].ReasonCode != ReasonCodeSpellNameUnresolved || result.Diagnostics[0].Disposition != contracts.DiagnosticDispositionAdvisory || result.Diagnostics[0].OccurrenceCount != len(input.SpellCasts) || len(result.Diagnostics[0].Samples) != contracts.MaxDiagnosticSamples {
 		t.Fatalf("diagnostics = %#v", result.Diagnostics)
 	}
 }
@@ -350,7 +349,7 @@ func TestNormalizeCollapsesDuplicateGroupsAfterCanonicalization(t *testing.T) {
 	canonicalized := diagnosticByReason(result.Diagnostics, ReasonCodeSpellNameCanonicalized)
 	refsNormalized := diagnosticByReason(result.Diagnostics, ReasonCodeSourceReferencesNormalized)
 	collapsed := diagnosticByReason(result.Diagnostics, ReasonCodeDuplicateSpellCastCollapsed)
-	if len(result.Warnings) != 0 || canonicalized == nil || canonicalized.OccurrenceCount != 3 || refsNormalized == nil || refsNormalized.OccurrenceCount != 1 || collapsed == nil || collapsed.OccurrenceCount != 2 || !strings.Contains(collapsed.Samples[0].Message, "retained input index 0") {
+	if canonicalized == nil || canonicalized.OccurrenceCount != 3 || refsNormalized == nil || refsNormalized.OccurrenceCount != 1 || collapsed == nil || collapsed.OccurrenceCount != 2 || !strings.Contains(collapsed.Samples[0].Message, "retained input index 0") {
 		t.Fatalf("diagnostics = %#v, want grouped normalization observations", result.Diagnostics)
 	}
 }
@@ -380,10 +379,8 @@ func TestNormalizeKeepsDistinctAndIneligibleCastsSeparate(t *testing.T) {
 			if len(result.Value.SpellCasts) != 2 {
 				t.Fatalf("normalized casts = %#v, want both casts retained", result.Value.SpellCasts)
 			}
-			for _, warning := range result.Warnings {
-				if warning.ReasonCode == ReasonCodeDuplicateSpellCastCollapsed {
-					t.Fatalf("warnings = %#v, want no duplicate collapse", result.Warnings)
-				}
+			if diagnosticByReason(result.Diagnostics, ReasonCodeDuplicateSpellCastCollapsed) != nil {
+				t.Fatalf("diagnostics = %#v, want no duplicate collapse", result.Diagnostics)
 			}
 		})
 	}
@@ -404,10 +401,8 @@ func TestNormalizeDoesNotCollapseAdjacentOrOverlappingEvidence(t *testing.T) {
 	if len(result.Value.SpellCasts) != len(input.SpellCasts) {
 		t.Fatalf("normalized casts = %#v, want adjacent and overlapping evidence retained", result.Value.SpellCasts)
 	}
-	for _, warning := range result.Warnings {
-		if warning.ReasonCode == ReasonCodeDuplicateSpellCastCollapsed {
-			t.Fatalf("warnings = %#v, want no duplicate collapse", result.Warnings)
-		}
+	if diagnosticByReason(result.Diagnostics, ReasonCodeDuplicateSpellCastCollapsed) != nil {
+		t.Fatalf("diagnostics = %#v, want no duplicate collapse", result.Diagnostics)
 	}
 }
 
@@ -448,8 +443,8 @@ func TestNormalizeIsIdempotentForAlreadyNormalizedInput(t *testing.T) {
 	if err != nil {
 		t.Fatalf("second Normalize() error = %v, want nil", err)
 	}
-	if !reflect.DeepEqual(second.Value, first.Value) || len(first.Warnings) != 0 || len(second.Warnings) != 0 {
-		t.Fatalf("first = %#v/%#v, second = %#v/%#v, want identical artifacts without mutation warnings", first.Value, first.Warnings, second.Value, second.Warnings)
+	if !reflect.DeepEqual(second.Value, first.Value) {
+		t.Fatalf("first = %#v, second = %#v, want identical artifacts", first.Value, second.Value)
 	}
 }