Complete assembled validation and migrate remaining tests

internal/framework/validators/llm_context_test.go

@@ -6,6 +6,7 @@ import (
 	"testing"
 
 	"gitea.maximumdirect.net/eric/audita/v3/internal/core/chunking"
+	"gitea.maximumdirect.net/eric/audita/v3/internal/core/glossary"
 	"gitea.maximumdirect.net/eric/audita/v3/internal/core/schema"
 	"gitea.maximumdirect.net/eric/audita/v3/internal/framework/proposals"
 )
@@ -19,11 +20,11 @@ func TestValidationContextCarriesAdjacentEvidenceAndRelevantDefinitions(t *testi
 		{ID: 4, Text: "Elsewhere."},
 	}}
 	req.CandidateProposal[0].TargetSegmentID = 2
-	req.Glossary = &schema.Glossary{Entries: []schema.GlossaryEntry{
-		{Name: "Jesters", Summary: "A traveling troupe"},
-		{Name: "Lyra", Summary: "The host"},
-		{Name: "Unrelated", Summary: "Not mentioned"},
-	}}
+	req.Glossary = []glossary.Entry{
+		{ID: "jesters", Name: "Jesters", Description: "A traveling troupe"},
+		{ID: "lyra", Name: "Lyra", Description: "The host"},
+		{ID: "unrelated", Name: "Unrelated", Description: "Not mentioned"},
+	}
 	payload, immediate := BuildLLMValidationRequest("spoken_form_plausibility", LLMValidatorTypeSpokenFormPlausibility, req)
 	if len(immediate) != 0 || len(payload.Items) != 1 {
 		t.Fatalf("payload: %+v immediate: %+v", payload, immediate)
@@ -40,10 +41,10 @@ func TestValidationContextCarriesAdjacentEvidenceAndRelevantDefinitions(t *testi
 	if err := json.Unmarshal([]byte(variables["PayloadJSON"]), &rendered); err != nil {
 		t.Fatal(err)
 	}
-	if strings.Contains(variables["PayloadJSON"], `"id":`) || rendered[0].CorrectionIndex != 1 || payload.Items[0].CorrectionIndex != 7 {
+	if strings.Contains(variables["PayloadJSON"], `"segment_id":`) || rendered[0].CorrectionIndex != 1 || payload.Items[0].CorrectionIndex != 7 {
 		t.Fatalf("leaked internal identity or mutated request: %s", variables["PayloadJSON"])
 	}
-	if len(rendered[0].NeighboringSegments) != 2 || rendered[0].GlossaryEntries[0].Summary != "A traveling troupe" {
+	if len(rendered[0].NeighboringSegments) != 2 || rendered[0].GlossaryEntries[0].Description != "A traveling troupe" {
 		t.Fatalf("rendered context: %+v", rendered)
 	}
 	// The context-free endpoint must not reach beyond the current chunk.
@@ -64,7 +65,7 @@ func TestValidationContextFitsBudgetWithoutDiscardingCandidate(t *testing.T) {
 	}
 	enriched := base
 	enriched.NeighboringSegments = []NeighboringSegment{{Position: "following", Text: strings.Repeat("long context ", 300)}}
-	enriched.GlossaryEntries = []schema.GlossaryEntry{{Name: "cat", Summary: strings.Repeat("long definition ", 300)}}
+	enriched.GlossaryEntries = []glossary.Entry{{Name: "cat", Description: strings.Repeat("long definition ", 300)}}
 	fitted := fitValidationContext(enriched, required, estimator)
 	tokens, err := estimateBatchTokens(estimator, []LLMValidationItem{fitted})
 	if err != nil || tokens > required || fitted.OriginalSegmentText != base.OriginalSegmentText || fitted.CorrectedSegmentText != base.CorrectedSegmentText {
@@ -80,7 +81,7 @@ func TestValidationContextFitsBudgetWithoutDiscardingCandidate(t *testing.T) {
 func TestValidationContextSelectsGlossaryForEachReplacement(t *testing.T) {
 	req := makeReq([]proposals.EnrichedCorrectionProposal{mk(7, "gestures", "Jesters"), mk(11, "gestures", "Actors")})
 	req.WorkingTranscript = &schema.Transcript{Segments: []schema.Segment{{ID: 1, Text: "Those gestures are back."}}}
-	req.Glossary = &schema.Glossary{Entries: []schema.GlossaryEntry{{Name: "Actors"}, {Name: "Jesters"}}}
+	req.Glossary = []glossary.Entry{{ID: "actors", Name: "Actors"}, {ID: "jesters", Name: "Jesters"}}
 	payload, immediate := BuildLLMValidationRequest("editorial_review", LLMValidatorTypeEditorialReview, req)
 	if len(immediate) != 0 || len(payload.Items) != 2 {
 		t.Fatalf("payload: %+v immediate: %+v", payload, immediate)

internal/framework/validators/llm_integration_test.go

@@ -4,19 +4,24 @@ import (
 	"context"
 	"encoding/json"
 	"fmt"
+	"io"
 	"net/http"
-	"net/http/httptest"
 	"os"
 	"path/filepath"
+	"strings"
 	"testing"
 
-	ck "gitea.maximumdirect.net/eric/ConfigKit"
 	"gitea.maximumdirect.net/eric/audita/v3/internal/core/config"
 	"gitea.maximumdirect.net/eric/audita/v3/internal/framework/llm"
 	"gitea.maximumdirect.net/eric/audita/v3/internal/framework/outcomes"
 	"gitea.maximumdirect.net/eric/audita/v3/internal/framework/proposals"
+	ck "go.maximumdirect.net/configkit"
 )
 
+type validationTransport func(*http.Request) (*http.Response, error)
+
+func (f validationTransport) RoundTrip(r *http.Request) (*http.Response, error) { return f(r) }
+
 func TestValidationRepairAndRuntimeFailuresThroughDomainBoundary(t *testing.T) {
 	valid := `{"validations":[{"correction_index":1,"approved":true,"confidence":0.9,"reason":"ok"}]}`
 	for _, tc := range []struct {
@@ -32,41 +37,38 @@ func TestValidationRepairAndRuntimeFailuresThroughDomainBoundary(t *testing.T) {
 	} {
 		t.Run(tc.name, func(t *testing.T) {
 			calls := 0
-			server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+			transport := validationTransport(func(r *http.Request) (*http.Response, error) {
 				calls++
 				output := tc.responses[len(tc.responses)-1]
 				if calls <= len(tc.responses) {
 					output = tc.responses[calls-1]
 				}
-				if output == "MALFORMED_ENVELOPE" {
-					_, _ = fmt.Fprint(w, `{"choices":[]}`)
-					return
+				body := `{"choices":[]}`
+				if output != "MALFORMED_ENVELOPE" {
+					content, _ := json.Marshal(output)
+					body = fmt.Sprintf(`{"choices":[{"message":{"content":%s}}]}`, content)
 				}
-				content, _ := json.Marshal(output)
-				_, _ = fmt.Fprintf(w, `{"choices":[{"message":{"content":%s}}]}`, content)
-			}))
-			defer server.Close()
+				return &http.Response{StatusCode: 200, Header: make(http.Header), Body: io.NopCloser(strings.NewReader(body)), Request: r}, nil
+			})
 			dir := t.TempDir()
-			if err := os.Mkdir(filepath.Join(dir, "profiles"), 0700); err != nil {
-				t.Fatal(err)
-			}
 			main := filepath.Join(dir, "config.yml")
-			content := fmt.Sprintf("version: 2\nbackends:\n  offline:\n    endpoint: %s/v1\nllm:\n  proposal_profile: base\n  transient_retries: 0\n  repair_attempts: 1\n", server.URL)
-			if err := os.WriteFile(main, []byte(content), 0600); err != nil {
+			if err := os.WriteFile(main, []byte("version: 3\n"), 0600); err != nil {
 				t.Fatal(err)
 			}
-			if err := os.WriteFile(filepath.Join(dir, "profiles", "base.yaml"), []byte("profiles:\n  base:\n    backend: offline\n    model: local-model\n"), 0600); err != nil {
+			if err := os.WriteFile(filepath.Join(dir, "prompts.yml"), []byte("profiles:\n  - {id: base, endpoint: 'https://example.invalid/v1', model: local-model, api_key_required: false}\n"), 0600); err != nil {
 				t.Fatal(err)
 			}
-			loaded, err := config.Load(ck.File(main), "")
+			loaded, err := config.Load(ck.Input{Source: ck.File(main)}, "")
 			if err != nil {
 				t.Fatal(err)
 			}
-			runtime, err := llm.NewRuntime(context.Background(), loaded.Config, main, server.Client())
+			runtime, err := llm.NewRuntime(context.Background(), loaded, &http.Client{Transport: transport})
 			if err != nil {
 				t.Fatal(err)
 			}
-			client, err := runtime.NewRoleClient("validation", llm.CallHooks{})
+			settings := loaded.Config.LLM
+			settings.TransientRetries, settings.RepairAttempts = 0, 1
+			client, err := runtime.NewRoleClient("validation", "base", settings, llm.CallHooks{})
 			if err != nil {
 				t.Fatal(err)
 			}
@@ -75,7 +77,6 @@ func TestValidationRepairAndRuntimeFailuresThroughDomainBoundary(t *testing.T) {
 				t.Fatal(err)
 			}
 			req := makeReq([]proposals.EnrichedCorrectionProposal{mk(0, "gestures", "Jesters")})
-			req.Config = &loaded.Config
 			req.LLMClient = client
 			result, err := validator.Validate(context.Background(), req)
 			if calls != tc.wantCalls {

internal/framework/validators/llm_partial_test.go

@@ -55,7 +55,7 @@ func TestValidationKeepsSuccessfulBatchesAroundUnavailableBatch(t *testing.T) {
 	validator, _ := NewLLMBackedValidator("editorial_review", LLMValidatorTypeEditorialReview)
 	validator.SetTokenEstimator(perItemEstimator{})
 	req := makeReq(candidates)
-	req.Config.Validation.MaxPromptTokens = 150
+	req.Settings.Validation.MaxPromptTokens = 150
 	req.LLMClient = client
 	result, err := validator.Validate(context.Background(), req)
 	if err != nil {
@@ -79,7 +79,7 @@ func TestValidationKeepsSuccessfulBatchesAroundUnavailableBatch(t *testing.T) {
 	nextValidator, _ := NewLLMBackedValidator("meaning_reversal_review", LLMValidatorTypeMeaningReversal)
 	nextValidator.SetTokenEstimator(perItemEstimator{})
 	nextReq := makeReq(survivors)
-	nextReq.Config.Validation.MaxPromptTokens = 150
+	nextReq.Settings.Validation.MaxPromptTokens = 150
 	nextReq.LLMClient = nextClient
 	next, err := nextValidator.Validate(context.Background(), nextReq)
 	if err != nil || len(next.Decisions) != 2 || len(nextClient.calls) != 2 || *nextClient.calls[0].Context.BatchIndex != 0 || *nextClient.calls[1].Context.BatchIndex != 1 {
@@ -144,7 +144,7 @@ func TestValidationFatalFailureKeepsEarlierFactsAndStops(t *testing.T) {
 	validator, _ := NewLLMBackedValidator("editorial_review", LLMValidatorTypeEditorialReview)
 	validator.SetTokenEstimator(perItemEstimator{})
 	req := makeReq([]proposals.EnrichedCorrectionProposal{mk(0, "gestures", "Jesters"), mk(1, "gestures", "actors"), mk(2, "gestures", "figures")})
-	req.Config.Validation.MaxPromptTokens = 150
+	req.Settings.Validation.MaxPromptTokens = 150
 	req.LLMClient = client
 	result, err := validator.Validate(context.Background(), req)
 	if !errors.Is(err, cause) || len(result.Decisions) != 1 || len(result.Operations) != 2 || len(client.calls) != 2 {

internal/framework/validators/llm_validators_test.go

@@ -59,15 +59,14 @@ func (f *fakeStructuredLLMClient) CompleteStructured(ctx context.Context, req St
 }
 
 func makeReq(candidates []proposals.EnrichedCorrectionProposal) Request {
-	cfg := config.Config{}
-	cfg.Validation.MaxPromptTokens = 10000
+	settings := config.Stage{Validation: config.Validation{MaxPromptTokens: 10000}}
 	return Request{
 		WorkingTranscript: &schema.Transcript{Segments: []schema.Segment{{ID: 1, Text: "There were gestures at the temple.", Categories: []string{"narration"}}}},
 		CandidateProposal: candidates,
 		ModuleKey:         "homophones",
 		ModuleInstance:    "homophones",
 		ReplacementPolicy: proposals.ReplacementPolicyRequireUnique,
-		Config:            &cfg,
+		Settings:          settings,
 	}
 }
 
@@ -314,9 +313,7 @@ func TestLLMBackedValidatorOversizedSingleProposalRejectsOnlyThatProposal(t *tes
 		ReplacementPolicy: proposals.ReplacementPolicyRequireUnique,
 	}
 	req.LLMClient = client
-	cfg := config.Config{}
-	cfg.Validation.MaxPromptTokens = 200
-	req.Config = &cfg
+	req.Settings.Validation.MaxPromptTokens = 200
 
 	res, err := v.Validate(context.Background(), req)
 	if err != nil {
@@ -384,7 +381,7 @@ func TestEveryValidationTypeSelectsEmbeddedPromptAndVariables(t *testing.T) {
 			}
 			req := makeReq([]proposals.EnrichedCorrectionProposal{mk(0, "gestures", "Jesters")})
 			req.LLMClient = client
-			req.Config.Context.Description = " Fantasy scene "
+			req.Settings.Context.Description = " Fantasy scene "
 			if _, err := validator.Validate(context.Background(), req); err != nil {
 				t.Fatal(err)
 			}
@@ -392,7 +389,7 @@ func TestEveryValidationTypeSelectsEmbeddedPromptAndVariables(t *testing.T) {
 				t.Fatalf("calls=%d", len(client.calls))
 			}
 			call := client.calls[0]
-			if call.PromptID != tc.prompt || call.PromptVersion != prompts.VersionV1 || call.Schema != responseschema.ValidatorDecisionSetKey || call.Context.Role != "validation" || call.Context.BatchIndex == nil || !strings.Contains(call.Variables["PayloadJSON"], "correction_index") || !strings.Contains(call.Variables["TranscriptDescriptionBlock"], "Fantasy scene") {
+			if call.PromptID != tc.prompt || call.Schema != responseschema.ValidatorDecisionSetKey || call.Context.Role != "validation" || call.Context.BatchIndex == nil || !strings.Contains(call.Variables["PayloadJSON"], "correction_index") || !strings.Contains(call.Variables["TranscriptDescriptionBlock"], "Fantasy scene") {
 				t.Fatalf("mapping: %+v", call)
 			}
 		})

internal/framework/validators/protected_terms_test.go

@@ -2,40 +2,36 @@ package validators
 
 import (
 	"reflect"
+	"sort"
 	"testing"
 
+	domain "gitea.maximumdirect.net/eric/audita/v3/internal/core/glossary"
 	"gitea.maximumdirect.net/eric/audita/v3/internal/core/schema"
 	"gitea.maximumdirect.net/eric/audita/v3/internal/framework/proposals"
 )
 
-func TestExtractProtectedTermsStableDeduplicatedWithPlurals(t *testing.T) {
-	glossary := &schema.Glossary{
-		Entries: []schema.GlossaryEntry{
-			{Name: "Jesters", Aliases: []string{"Jester", "  "}, Plural: "Jesters", Category: "faction", Summary: "Faction"},
-			{Name: "Hrank", Aliases: []string{"hrank", "Hrank"}, Plural: "Hranks", Category: "pc", Summary: "Character"},
-			{Name: "Lyra", Aliases: []string{}, Plural: "", Category: "npc", Summary: "NPC"},
-		},
+func TestRecognizedTermsDeduplicateAndIncludePlurals(t *testing.T) {
+	plural := "Hranks"
+	entries := []domain.Entry{{ID: "jesters", Name: "Jesters", Aliases: []string{"Jester", "  "}}, {ID: "hrank", Name: "Hrank", Aliases: []string{"hrank", "Hrank"}, Plural: &plural}, {ID: "lyra", Name: "Lyra"}}
+	var got []string
+	for _, term := range domain.Vocabulary(entries, nil) {
+		got = append(got, term.Spelling)
 	}
-
-	got := ExtractProtectedTerms(glossary)
+	sort.Strings(got)
 	want := []string{"Hrank", "Hranks", "Jester", "Jesters", "Jesterss", "Lyra", "Lyras"}
 	if !reflect.DeepEqual(got, want) {
-		t.Fatalf("unexpected protected terms\n got: %v\nwant: %v", got, want)
+		t.Fatalf("got %v want %v", got, want)
 	}
-}
-
-func TestExtractProtectedTermsEmptyGlossary(t *testing.T) {
-	if terms := ExtractProtectedTerms(&schema.Glossary{}); len(terms) != 0 {
-		t.Fatalf("expected no terms, got %v", terms)
+	if len(domain.Vocabulary(nil, nil)) != 0 {
+		t.Fatal("empty input produced terms")
 	}
 }
 
 func TestValidateProtectedTermsAppliesToNonGlossaryModule(t *testing.T) {
 	req := Request{
-		ModuleKey: "grammar",
-		Glossary: &schema.Glossary{
-			Entries: []schema.GlossaryEntry{{Name: "Jesters", Category: "faction", Summary: "Faction"}},
-		},
+		ModuleKey:      "grammar",
+		Glossary:       []domain.Entry{{ID: "jesters", Name: "Jesters", Category: "faction"}},
+		ProtectedTerms: domain.Vocabulary([]domain.Entry{{ID: "jesters", Name: "Jesters"}}, nil),
 		CandidateProposal: []proposals.EnrichedCorrectionProposal{
 			{
 				CorrectionProposal: proposals.CorrectionProposal{
@@ -52,7 +48,7 @@ func TestValidateProtectedTermsAppliesToNonGlossaryModule(t *testing.T) {
 			},
 		},
 	}
-	res, err := ValidateProtectedTerms(req, false)
+	res, err := ValidateProtectedTerms(req)
 	if err != nil {
 		t.Fatalf("validator error: %v", err)
 	}
@@ -64,9 +60,7 @@ func TestValidateProtectedTermsAppliesToNonGlossaryModule(t *testing.T) {
 func TestValidateProtectedTermsGlossaryStageAllowsProtectedTermSwap(t *testing.T) {
 	req := Request{
 		ModuleKey: "glossary",
-		Glossary: &schema.Glossary{
-			Entries: []schema.GlossaryEntry{{Name: "Jesters", Category: "faction", Summary: "Faction"}},
-		},
+		Glossary:  []domain.Entry{{ID: "jesters", Name: "Jesters", Category: "faction"}},
 		CandidateProposal: []proposals.EnrichedCorrectionProposal{
 			{
 				CorrectionProposal: proposals.CorrectionProposal{
@@ -79,7 +73,7 @@ func TestValidateProtectedTermsGlossaryStageAllowsProtectedTermSwap(t *testing.T
 			},
 		},
 	}
-	res, err := ValidateProtectedTerms(req, true)
+	res, err := ValidateProtectedTerms(req)
 	if err != nil {
 		t.Fatalf("validator error: %v", err)
 	}
@@ -103,10 +97,10 @@ func TestProtectedNameRepetitionRequiresSurvivingIdentityAndSpokenWordScope(t *t
 		t.Run(tc.name, func(t *testing.T) {
 			req := Request{ModuleKey: tc.module, ReplacementPolicy: proposals.ReplacementPolicyRequireUnique,
 				WorkingTranscript: &schema.Transcript{Segments: []schema.Segment{{ID: 1, Text: tc.before}}},
-				Glossary:          &schema.Glossary{Entries: []schema.GlossaryEntry{{Name: "Jesters"}, {Name: "Lyra"}}},
+				ProtectedTerms:    domain.Vocabulary([]domain.Entry{{ID: "jesters", Name: "Jesters"}, {ID: "lyra", Name: "Lyra"}}, nil),
 				CandidateProposal: []proposals.EnrichedCorrectionProposal{{CorrectionProposal: proposals.CorrectionProposal{TargetSegmentID: 1, OriginalText: tc.original, CorrectedText: tc.replacement, Confidence: 1}}},
 			}
-			result, err := ValidateProtectedTerms(req, false)
+			result, err := ValidateProtectedTerms(req)
 			if err != nil || len(result.Decisions) != 1 || result.Decisions[0].Approved != tc.allowed {
 				t.Fatalf("result=%+v err=%v", result, err)
 			}

internal/framework/validators/validators_test.go

@@ -6,6 +6,7 @@ import (
 	"testing"
 
 	"gitea.maximumdirect.net/eric/audita/v3/internal/core/config"
+	domain "gitea.maximumdirect.net/eric/audita/v3/internal/core/glossary"
 	"gitea.maximumdirect.net/eric/audita/v3/internal/core/schema"
 	"gitea.maximumdirect.net/eric/audita/v3/internal/framework/proposals"
 )
@@ -50,9 +51,7 @@ func TestEnforceDecisionCardinalityUnknownDecision(t *testing.T) {
 }
 
 func TestConfidenceThresholdValidator(t *testing.T) {
-	cfg := config.Config{}
-	cfg.Thresholds.Grammar = 0.8
-	req := Request{ModuleKey: "grammar", Config: &cfg, CandidateProposal: []proposals.EnrichedCorrectionProposal{
+	req := Request{ModuleKey: "grammar", Settings: config.Stage{ConfidenceThreshold: 0.8}, CandidateProposal: []proposals.EnrichedCorrectionProposal{
 		mkCandidate(0, 1, "teh", "the", 0.9),
 		mkCandidate(1, 1, "recieve", "receive", 0.7),
 	}}
@@ -161,16 +160,17 @@ func TestNoEffectValidator(t *testing.T) {
 }
 
 func TestValidateProtectedTerms(t *testing.T) {
-	glossary := &schema.Glossary{Entries: []schema.GlossaryEntry{{Name: "OpenAI", Aliases: []string{"Open AI"}, Plural: "OpenAIs", Category: "brand", Summary: "brand"}}}
+	entries := []domain.Entry{{ID: "openai", Name: "OpenAI", Aliases: []string{"Open AI"}, Category: "brand", Description: "brand"}}
 	req := Request{
-		Glossary:  glossary,
-		ModuleKey: "grammar",
+		Glossary:       entries,
+		ProtectedTerms: domain.Vocabulary(entries, nil),
+		ModuleKey:      "grammar",
 		CandidateProposal: []proposals.EnrichedCorrectionProposal{
 			mkCandidate(0, 1, "OpenAI", "Open A I", 0.9),
 			mkCandidate(1, 1, "teh", "the", 0.9),
 		},
 	}
-	res, err := ValidateProtectedTerms(req, false)
+	res, err := ValidateProtectedTerms(req)
 	if err != nil {
 		t.Fatalf("Validate error: %v", err)
 	}