Harden diagnostic handling and warning presentation

internal/framework/pipeline/producer_attempts.go

@@ -193,6 +193,10 @@ func runProducerAttempts(ctx context.Context, config producerAttemptConfig, prod
 			}
 			return failedProducerAttempt(provenance), fmt.Errorf("producer failed after %d attempt(s): %w", number, err)
 		}
+		if err := validateProducerAttemptDiagnostics(output); err != nil {
+			provenance = append(provenance, producerAttemptProvenance{Number: number, Kind: kind, Outcome: producerAttemptFailed})
+			return failedProducerAttempt(provenance), err
+		}
 
 		output, err = output.clone()
 		if err != nil {
@@ -265,6 +269,18 @@ func runProducerAttempts(ctx context.Context, config producerAttemptConfig, prod
 	return failedProducerAttempt(provenance), errors.New("producer attempt budget was not exhausted deterministically")
 }
 
+func validateProducerAttemptDiagnostics(output producerAttemptOutput) error {
+	if err := contracts.ValidateProducerDiagnostics(output.Diagnostics); err != nil {
+		return fmt.Errorf("producer returned invalid diagnostics: %w", err)
+	}
+	if output.Retry != nil {
+		if err := contracts.ValidateProducerDiagnostics(output.Retry.FallbackDiagnostics); err != nil {
+			return fmt.Errorf("producer returned invalid retry fallback diagnostics: %w", err)
+		}
+	}
+	return nil
+}
+
 func isImmediateProducerFailure(err error) bool {
 	if errors.Is(err, context.Canceled) || errors.Is(err, context.DeadlineExceeded) {
 		return true

internal/framework/pipeline/producer_attempts_test.go

@@ -4,6 +4,7 @@ import (
 	"context"
 	"errors"
 	"reflect"
+	"strings"
 	"testing"
 
 	"gitea.maximumdirect.net/eric/notarius/internal/framework/contracts"
@@ -247,6 +248,45 @@ func TestRunProducerAttemptsUsesModuleRetryBudgetAndFallback(t *testing.T) {
 	})
 }
 
+func TestRunProducerAttemptsRejectsInvalidDiagnosticsWithoutRetry(t *testing.T) {
+	tests := []struct {
+		name   string
+		output producerAttemptOutput
+		want   string
+	}{
+		{
+			name:   "producer diagnostics",
+			output: producerAttemptOutput{Diagnostics: []contracts.ProducerDiagnostic{{}}},
+			want:   "producer returned invalid diagnostics",
+		},
+		{
+			name:   "retry fallback diagnostics",
+			output: producerAttemptOutput{Retry: &producerRetryDirective{FallbackDiagnostics: []contracts.ProducerDiagnostic{{}}}},
+			want:   "producer returned invalid retry fallback diagnostics",
+		},
+	}
+
+	for _, test := range tests {
+		t.Run(test.name, func(t *testing.T) {
+			producerCalls := 0
+			validatorCalls := 0
+			terminal, err := runProducerAttempts(context.Background(), producerAttemptConfig{Retries: 3, Policy: DefaultValidationPolicy()}, func(context.Context, producerAttemptRequest) (producerAttemptOutput, error) {
+				producerCalls++
+				return test.output, nil
+			}, func(context.Context, producerAttemptOutput) (validationReport, error) {
+				validatorCalls++
+				return validationReport{}, nil
+			})
+			if err == nil || !strings.Contains(err.Error(), test.want) {
+				t.Fatalf("runProducerAttempts() error = %v, want %q", err, test.want)
+			}
+			if terminal.Action != producerTerminalFailed || producerCalls != 1 || validatorCalls != 0 {
+				t.Fatalf("terminal = %#v, producer calls = %d, validator calls = %d; want immediate framework failure", terminal, producerCalls, validatorCalls)
+			}
+		})
+	}
+}
+
 func TestRunProducerAttemptsRejectionWinsOverValidatorFailure(t *testing.T) {
 	firstDiagnostics := []contracts.ProducerDiagnostic{producerDiagnostic("discarded", "discarded warning")}
 	secondDiagnostics := []contracts.ProducerDiagnostic{producerDiagnostic("accepted", "accepted warning")}

internal/framework/pipeline/runner_chunk_plan.go

@@ -101,7 +101,7 @@ func (r *Runner) runChunkPlan(ctx context.Context, input RunInput, doc *source.S
 					return result, failure
 				}
 				// A cache hit is not model material. Its rejection is discarded and
-				// generation begins with the ordinary initial request below. Warnings
+				// generation begins with the ordinary initial request below. Diagnostics
 				// from this discarded candidate are intentionally not promoted.
 			}
 			result.lookup = ChunkPlanDecision{Status: ChunkPlanInvalid, Reason: chunkPlanLookupReason(ChunkPlanInvalid)}

internal/framework/pipeline/validation_executor.go

@@ -21,7 +21,7 @@ const (
 const correctionRequestIntroduction = "The previous response failed semantic validation. Return one complete corrected replacement response, not a patch, explanation, or commentary.\n\nCorrect all of the following:\n"
 
 // validationRecord captures the settled result of one configured validator.
-// Its fields remain private so reports cannot expose mutable warning storage.
+// Its fields remain private so reports cannot expose mutable diagnostic storage.
 type validationRecord struct {
 	validatorName      string
 	outcome            validationOutcome
@@ -188,6 +188,9 @@ func executeValidationChain(ctx context.Context, chain preparedValidatorChain, i
 				report.records = append(report.records, validationRecord{validatorName: binding.Module, outcome: validationSkipped, attemptCount: attempt, reasonCode: invocation.reason, message: invocation.message})
 				break
 			}
+			if err := contracts.ValidateProducerDiagnostics(invocation.result.Diagnostics); err != nil {
+				return validationReport{}, fatalValidationError(fmt.Errorf("validator %q returned invalid diagnostics: %w", binding.Module, err))
+			}
 			if err := contracts.ValidateValidationResult(invocation.result); err != nil {
 				if attempt == attemptLimit {
 					report.records = append(report.records, validationRecord{validatorName: binding.Module, outcome: validationFailed, attemptCount: attempt, message: "validator returned an invalid result", failure: err})

internal/framework/pipeline/validation_executor_test.go

@@ -196,6 +196,19 @@ func TestExecuteValidationChainReturnsFrameworkAndCancellationErrors(t *testing.
 	}
 }
 
+func TestExecuteValidationChainRejectsInvalidDiagnosticsWithoutRetry(t *testing.T) {
+	chain := validationChain(validationSpec("validator", contracts.ExecutionClassLLMBacked, 2))
+	calls := 0
+	_, err := executeValidationChain(context.Background(), chain, func(context.Context, preparedValidator, int) (validationInvocation, error) {
+		calls++
+		return validationInvocation{result: contracts.ValidationResult{Approved: true, Diagnostics: []contracts.ProducerDiagnostic{{}}}}, nil
+	})
+	var frameworkErr validationFrameworkError
+	if !errors.As(err, &frameworkErr) || calls != 1 || !strings.Contains(err.Error(), "validator \"validator\" returned invalid diagnostics") {
+		t.Fatalf("error = %v calls = %d, want one fatal invalid-diagnostics result", err, calls)
+	}
+}
+
 type validationStep struct {
 	result     contracts.ValidationResult
 	invocation validationInvocation