feat(rubric): enhance Finding with Code and Location fields

Add v2 evaluation fields to Finding:
- Code: standardized ReasonCode for automated repair workflows
- Location: reference to where issue was found (e.g., "REQ-12", "Section 3.2")

Add factory functions and fluent setters:
- NewFinding() and NewFindingWithCode() constructors
- SetCode(), SetLocation(), SetRecommendation(), SetEvidence()
- SetOwner(), SetEffort() for workflow integration

Add analysis utilities:
- GetCodeInfo() returns ReasonCodeInfo from registry
- GetRepairPrompt() returns AI repair prompt for automated fixes
- CountFindingsByCode() aggregates by reason code
- GetBlockingCodes() extracts codes from blocking findings

Co-Authored-By: Claude Opus 4.5 <noreply@anthropic.com>

Author: grokify

rubric/finding.go

@@ -8,6 +8,10 @@ type Finding struct {
 	// Category is the evaluation category this relates to.
 	Category string `json:"category"`
 
+	// Code is the standardized reason code for this finding.
+	// Enables automated repair workflows.
+	Code ReasonCode `json:"code,omitempty"`
+
 	// Severity indicates the impact level.
 	Severity Severity `json:"severity"`
 
@@ -20,6 +24,9 @@ type Finding struct {
 	// Recommendation explains how to fix the issue.
 	Recommendation string `json:"recommendation"`
 
+	// Location is a reference to where the issue was found (e.g., "REQ-12", "Section 3.2").
+	Location string `json:"location,omitempty"`
+
 	// Evidence provides specific examples or references.
 	Evidence string `json:"evidence,omitempty"`
 
@@ -75,3 +82,110 @@ func (c FindingCounts) BlockingCount() int {
 func (c FindingCounts) HasBlocking() bool {
 	return c.BlockingCount() > 0
 }
+
+// NewFinding creates a new finding with the required fields.
+func NewFinding(id, category string, severity Severity, title, description string) *Finding {
+	return &Finding{
+		ID:          id,
+		Category:    category,
+		Severity:    severity,
+		Title:       title,
+		Description: description,
+	}
+}
+
+// NewFindingWithCode creates a new finding with a reason code.
+func NewFindingWithCode(id, category string, code ReasonCode, title, description string) *Finding {
+	info := GetReasonCodeInfo(code)
+	severity := SeverityMedium
+	if info != nil {
+		severity = info.DefaultSeverity
+	}
+	return &Finding{
+		ID:          id,
+		Category:    category,
+		Code:        code,
+		Severity:    severity,
+		Title:       title,
+		Description: description,
+	}
+}
+
+// SetCode sets the reason code on the finding.
+func (f *Finding) SetCode(code ReasonCode) *Finding {
+	f.Code = code
+	return f
+}
+
+// SetLocation sets the location reference on the finding.
+func (f *Finding) SetLocation(location string) *Finding {
+	f.Location = location
+	return f
+}
+
+// SetRecommendation sets the recommendation on the finding.
+func (f *Finding) SetRecommendation(recommendation string) *Finding {
+	f.Recommendation = recommendation
+	return f
+}
+
+// SetEvidence sets the evidence on the finding.
+func (f *Finding) SetEvidence(evidence string) *Finding {
+	f.Evidence = evidence
+	return f
+}
+
+// SetOwner sets the owner on the finding.
+func (f *Finding) SetOwner(owner string) *Finding {
+	f.Owner = owner
+	return f
+}
+
+// SetEffort sets the effort estimate on the finding.
+func (f *Finding) SetEffort(effort string) *Finding {
+	f.Effort = effort
+	return f
+}
+
+// GetCodeInfo returns the reason code info for this finding's code.
+func (f *Finding) GetCodeInfo() *ReasonCodeInfo {
+	return GetReasonCodeInfo(f.Code)
+}
+
+// GetRepairHint returns the repair hint from the reason code registry.
+// Deprecated: Use GetRepairPrompt instead.
+func (f *Finding) GetRepairHint() string {
+	return f.GetRepairPrompt()
+}
+
+// GetRepairPrompt returns the AI repair prompt from the reason code registry.
+func (f *Finding) GetRepairPrompt() string {
+	if info := f.GetCodeInfo(); info != nil {
+		return info.RepairPrompt
+	}
+	return f.Recommendation
+}
+
+// CountFindingsByCode counts findings by reason code.
+func CountFindingsByCode(findings []Finding) map[ReasonCode]int {
+	counts := make(map[ReasonCode]int)
+	for _, f := range findings {
+		if f.Code != "" {
+			counts[f.Code]++
+		}
+	}
+	return counts
+}
+
+// GetBlockingCodes returns the reason codes from blocking findings.
+func GetBlockingCodes(findings []Finding) []ReasonCode {
+	var codes []ReasonCode
+	seen := make(map[ReasonCode]bool)
+	for _, f := range findings {
+		if f.IsBlocking() && f.Code != "" && !seen[f.Code] {
+			codes = append(codes, f.Code)
+			seen[f.Code] = true
+		}
+	}
+	return codes
+}