Add validator chain provenance

internal/framework/pipeline/validator_registry.go

@@ -2,6 +2,7 @@ package pipeline
 
 import (
 	"fmt"
+	"sort"
 	"strings"
 
 	"gitea.maximumdirect.net/eric/notarius/internal/framework/contracts"
@@ -9,29 +10,34 @@ import (
 
 type ValidatorConstructor func() (contracts.Validator, error)
 
+type ValidatorSpec struct {
+	Key            string                   `json:"key"`
+	ExecutionClass contracts.ExecutionClass `json:"execution_class"`
+}
+
 type ValidatorRegistry struct {
 	constructors map[string]ValidatorConstructor
-	specs        map[string]ModuleSpec
+	specs        map[string]ValidatorSpec
 }
 
 func NewValidatorRegistry() *ValidatorRegistry {
 	return &ValidatorRegistry{
 		constructors: make(map[string]ValidatorConstructor),
-		specs:        make(map[string]ModuleSpec),
+		specs:        make(map[string]ValidatorSpec),
 	}
 }
 
 func (r *ValidatorRegistry) Register(key string, constructor ValidatorConstructor) error {
-	return r.RegisterWithSpec(defaultModuleSpec(key, StageValidate), constructor)
+	return r.RegisterWithSpec(ValidatorSpec{Key: key, ExecutionClass: contracts.ExecutionClassDeterministic}, constructor)
 }
 
-func (r *ValidatorRegistry) RegisterWithSpec(spec ModuleSpec, constructor ValidatorConstructor) error {
+func (r *ValidatorRegistry) RegisterWithSpec(spec ValidatorSpec, constructor ValidatorConstructor) error {
 	if r == nil {
 		return fmt.Errorf("validator registry must not be nil")
 	}
 
-	normalizedSpec := normalizeModuleSpec(spec)
-	if err := validateModuleSpec("validator", StageValidate, normalizedSpec); err != nil {
+	normalizedSpec, err := normalizeValidatorSpec(spec)
+	if err != nil {
 		return err
 	}
 	if constructor == nil {
@@ -45,10 +51,10 @@ func (r *ValidatorRegistry) RegisterWithSpec(spec ModuleSpec, constructor Valida
 		r.constructors = make(map[string]ValidatorConstructor)
 	}
 	if r.specs == nil {
-		r.specs = make(map[string]ModuleSpec)
+		r.specs = make(map[string]ValidatorSpec)
 	}
 	r.constructors[normalizedSpec.Key] = constructor
-	r.specs[normalizedSpec.Key] = cloneModuleSpec(normalizedSpec)
+	r.specs[normalizedSpec.Key] = normalizedSpec
 	return nil
 }
 
@@ -77,25 +83,45 @@ func (r *ValidatorRegistry) Build(key string) (contracts.Validator, error) {
 	if validator.Name() != normalizedKey {
 		return nil, fmt.Errorf("validator %q returned name %q", normalizedKey, validator.Name())
 	}
-	switch validator.ExecutionClass() {
-	case contracts.ExecutionClassDeterministic, contracts.ExecutionClassLLMBacked:
-	default:
-		return nil, fmt.Errorf("validator %q returned unsupported execution class %q", normalizedKey, validator.ExecutionClass())
+	spec, ok := r.specs[normalizedKey]
+	if !ok {
+		return nil, fmt.Errorf("validator %q spec is not registered", normalizedKey)
+	}
+	if validator.ExecutionClass() != spec.ExecutionClass {
+		return nil, fmt.Errorf("validator %q returned execution class %q, want %q", normalizedKey, validator.ExecutionClass(), spec.ExecutionClass)
 	}
 
 	return validator, nil
 }
 
-func (r *ValidatorRegistry) Spec(key string) (ModuleSpec, bool) {
+func (r *ValidatorRegistry) Spec(key string) (ValidatorSpec, bool) {
 	if r == nil {
-		return ModuleSpec{}, false
+		return ValidatorSpec{}, false
 	}
 
 	spec, ok := r.specs[strings.TrimSpace(key)]
 	if !ok {
-		return ModuleSpec{}, false
+		return ValidatorSpec{}, false
 	}
-	return cloneModuleSpec(spec), true
+	return spec, true
+}
+
+func (r *ValidatorRegistry) RegisteredSpecs() []ValidatorSpec {
+	if r == nil || len(r.specs) == 0 {
+		return nil
+	}
+
+	keys := make([]string, 0, len(r.specs))
+	for key := range r.specs {
+		keys = append(keys, key)
+	}
+	sort.Strings(keys)
+
+	specs := make([]ValidatorSpec, 0, len(keys))
+	for _, key := range keys {
+		specs = append(specs, r.specs[key])
+	}
+	return specs
 }
 
 func (r *ValidatorRegistry) RegisteredKeys() []string {
@@ -105,3 +131,19 @@ func (r *ValidatorRegistry) RegisteredKeys() []string {
 
 	return sortedRegistryKeys(r.constructors)
 }
+
+func normalizeValidatorSpec(spec ValidatorSpec) (ValidatorSpec, error) {
+	normalized := ValidatorSpec{
+		Key:            strings.TrimSpace(spec.Key),
+		ExecutionClass: spec.ExecutionClass,
+	}
+	if normalized.Key == "" {
+		return ValidatorSpec{}, fmt.Errorf("validator key must not be empty")
+	}
+	switch normalized.ExecutionClass {
+	case contracts.ExecutionClassDeterministic, contracts.ExecutionClassLLMBacked:
+	default:
+		return ValidatorSpec{}, fmt.Errorf("validator %q execution class %q is not supported", normalized.Key, normalized.ExecutionClass)
+	}
+	return normalized, nil
+}