Update Notarius integration and plan references

internal/stage/extract.go

@@ -161,6 +161,10 @@ func (extractStage) Run(ctx context.Context, env *Env, m *manifest.Manifest) (*S
 	if err != nil {
 		return nil, fmt.Errorf("extract: resolve staging warnings relative path: %w", err)
 	}
+	diagnosticsRelative, err := pathsafe.SlashRelativeFromRoot(adapterResult.BundleRoot, adapterResult.Index.DiagnosticsPath)
+	if err != nil {
+		return nil, fmt.Errorf("extract: resolve staging diagnostics relative path: %w", err)
+	}
 	stagingIndexChecksum, err := checksumRegularFile(adapterResult.Index.Path, false)
 	if err != nil {
 		return nil, fmt.Errorf("extract: validate staging index: %w", err)
@@ -188,6 +192,10 @@ func (extractStage) Run(ctx context.Context, env *Env, m *manifest.Manifest) (*S
 	if err != nil {
 		return nil, fmt.Errorf("extract: resolve promoted warnings: %w", err)
 	}
+	promotedDiagnosticsPath, err := pathsafe.JoinSlashRelativeUnderRoot(durableBundle, diagnosticsRelative)
+	if err != nil {
+		return nil, fmt.Errorf("extract: resolve promoted diagnostics: %w", err)
+	}
 
 	outputs := make([]artifacts.Ref, 0, len(selected)+1)
 	for _, lane := range selected {
@@ -237,18 +245,25 @@ func (extractStage) Run(ctx context.Context, env *Env, m *manifest.Manifest) (*S
 		"diagnostic_path":           logPath,
 		"rejections_path":           promotedRejectionsPath,
 		"warnings_path":             promotedWarningsPath,
+		"diagnostics_path":          promotedDiagnosticsPath,
 		"narratio_run_id":           runID,
 		"configuration_fingerprint": fingerprint,
 		"direct_input":              input.Metadata(),
 		"receipt": map[string]any{
 			"run_id": adapterResult.Receipt.RunID, "pipeline_id": adapterResult.Receipt.PipelineID,
-			"normalized_output_count": adapterResult.Receipt.NormalizedOutputCount,
-			"rejected_output_count":   adapterResult.Receipt.RejectedOutputCount,
-			"warning_count":           adapterResult.Receipt.WarningCount,
-			"validation_status":       adapterResult.Receipt.ValidationStatus,
+			"normalized_output_count":     adapterResult.Receipt.NormalizedOutputCount,
+			"rejected_output_count":       adapterResult.Receipt.RejectedOutputCount,
+			"warning_group_count":         adapterResult.Receipt.WarningGroupCount,
+			"warning_occurrence_count":    adapterResult.Receipt.WarningOccurrenceCount,
+			"diagnostic_group_count":      adapterResult.Receipt.DiagnosticGroupCount,
+			"diagnostic_occurrence_count": adapterResult.Receipt.DiagnosticOccurrenceCount,
+			"diagnostics_truncated":       adapterResult.Receipt.DiagnosticsTruncated,
+			"validation_status":           adapterResult.Receipt.ValidationStatus,
 		},
-		"rejections": boundedRejectionMetadata(adapterResult.Rejections),
-		"warnings":   boundedWarningMetadata(adapterResult.Warnings),
+		"rejections":           boundedRejectionMetadata(adapterResult.Rejections),
+		"warnings":             boundedWarningMetadata(adapterResult.Warnings),
+		"diagnostics":          boundedDiagnosticMetadata(adapterResult.Diagnostics),
+		"validation_summaries": boundedValidationMetadata(adapterResult.Receipt.ValidationSummaries),
 	}
 	return &StageResult{
 		Outputs:  outputs,
@@ -282,6 +297,11 @@ func selectRequiredNotariusLanes(
 				return nil, fmt.Errorf("extract: required lane %q was rejected (reason_code=%q)", expected.LaneID, rejection.ReasonCode)
 			}
 		}
+		for _, validation := range result.Receipt.ValidationSummaries {
+			if validation.LaneID == expected.LaneID && validation.Status != "complete" {
+				return nil, fmt.Errorf("extract: required lane %q validation is %q", expected.LaneID, validation.Status)
+			}
+		}
 		matches := make([]notarius.LaneDescriptor, 0, 1)
 		for _, descriptor := range result.Index.Lanes {
 			if descriptor.LaneID == expected.LaneID {
@@ -441,7 +461,52 @@ func boundedWarningMetadata(values []notarius.WarningSummary) []map[string]any {
 	}
 	result := make([]map[string]any, 0, limit)
 	for _, value := range values[:limit] {
-		result = append(result, map[string]any{"scope": value.Scope, "reason_code": value.ReasonCode})
+		result = append(result, map[string]any{
+			"disposition": value.Disposition, "category": value.Category,
+			"reason_code": value.ReasonCode, "origin": diagnosticOriginMetadata(value.Origin),
+			"occurrence_count": value.OccurrenceCount,
+		})
 	}
 	return result
 }
+
+func boundedDiagnosticMetadata(values []notarius.DiagnosticSummary) []map[string]any {
+	limit := len(values)
+	if limit > maxDiagnosticSummaries {
+		limit = maxDiagnosticSummaries
+	}
+	result := make([]map[string]any, 0, limit)
+	for _, value := range values[:limit] {
+		result = append(result, map[string]any{
+			"disposition": value.Disposition, "category": value.Category,
+			"reason_code": value.ReasonCode, "origin": diagnosticOriginMetadata(value.Origin),
+			"occurrence_count": value.OccurrenceCount,
+		})
+	}
+	return result
+}
+
+func boundedValidationMetadata(values []notarius.ValidationSummary) []map[string]any {
+	limit := len(values)
+	if limit > maxDiagnosticSummaries {
+		limit = maxDiagnosticSummaries
+	}
+	result := make([]map[string]any, 0, limit)
+	for _, value := range values[:limit] {
+		result = append(result, map[string]any{
+			"stage": value.Stage, "step_id": value.StepID, "lane_id": value.LaneID,
+			"module_key": value.ModuleKey, "chunk_id": value.ChunkID, "status": value.Status,
+			"rejecting_validators": value.RejectingValidators, "reason_codes": value.ReasonCodes,
+			"incomplete_validators":  value.IncompleteValidators,
+			"producer_attempt_count": value.ProducerAttemptCount, "terminal_action": value.TerminalAction,
+		})
+	}
+	return result
+}
+
+func diagnosticOriginMetadata(value notarius.DiagnosticOrigin) map[string]any {
+	return map[string]any{
+		"stage": value.Stage, "step_id": value.StepID, "lane_id": value.LaneID,
+		"module_key": value.ModuleKey, "validator_key": value.ValidatorKey,
+	}
+}