VALUE-03B1: freeze generation configuration end to end

frontend/src/api/campaign-types.ts

@@ -48,6 +48,7 @@ export interface CampaignResultsReadModel extends UIModelIdentity {
 export interface CampaignEntryReadModel extends UIModelIdentity {
   entry_id: string;
   candidate_id: string;
+  configuration_id: string;
   model_id: string;
   config_digest: string;
   status: CampaignEntryStatus;
@@ -90,6 +91,7 @@ export interface CampaignCaseSummaryReadModel extends UIModelIdentity {
 export interface CampaignCaseCandidateReadModel extends UIModelIdentity {
   entry_id: string;
   candidate_id: string;
+  configuration_id: string;
   model_id: string;
   config_digest: string;
   entry_status: CampaignEntryStatus;

frontend/src/api/index.ts

@@ -80,6 +80,7 @@ export type {
   EvidenceContentState,
   ExplanationState,
   FrozenExecutionPreviewReadModel,
+  GenerationParameterDomainReadModel,
   IdentityDifference,
   IdentitySummary,
   MetricDelta,

frontend/src/api/planning-types.ts

@@ -1,5 +1,6 @@
 import type {
   DatasetSummaryReadModel,
+  GenerationParameterDomainReadModel,
   SuiteSummaryReadModel,
   TargetSummaryReadModel,
   UIModelIdentity,
@@ -28,6 +29,7 @@ export interface CandidateModelReadModel extends UIModelIdentity {
   runtime_name: string | null;
   runtime_version: string | null;
   runtime_config_digest: string | null;
+  generation_parameter_domains: GenerationParameterDomainReadModel[];
   source: "configured" | "discovered";
 }
 
@@ -67,11 +69,18 @@ export interface CampaignPlanIssueReadModel extends UIModelIdentity {
   field: string | null;
 }
 
+export interface FrozenGenerationConfigurationReadModel extends UIModelIdentity {
+  configuration_id: string;
+  generation_digest: string;
+  generation: Record<string, unknown>;
+}
+
 export interface ConfigurationSearchPlanReadModel extends UIModelIdentity {
   strategy: CampaignSearchStrategy;
   title: string;
   configuration_count_per_candidate: number;
   base_generation: Record<string, unknown>;
+  configurations: FrozenGenerationConfigurationReadModel[];
   bounded_parameter_ranges: string[];
   note: string;
 }

frontend/src/api/types.ts

@@ -104,6 +104,18 @@ export interface CapabilitySupportReadModel extends UIModelIdentity {
   detail: string | null;
 }
 
+export interface GenerationParameterDomainReadModel extends UIModelIdentity {
+  name: string;
+  kind: "float" | "integer" | "boolean";
+  scope: "request_generation";
+  source: "local_llm_server";
+  provenance: "registry_declared";
+  minimum: number | null;
+  maximum: number | null;
+  step: number | null;
+  values: boolean[];
+}
+
 export interface RuntimeParameterReadModel extends UIModelIdentity {
   name: string;
   scope: "runtime_load";
@@ -115,6 +127,7 @@ export interface RuntimeParameterReadModel extends UIModelIdentity {
 export interface DiscoveredModelReadModel extends UIModelIdentity {
   model_id: string;
   runtime_parameters: RuntimeParameterReadModel[];
+  generation_parameter_domains: GenerationParameterDomainReadModel[];
 }
 
 export interface EndpointProbeReadModel extends UIModelIdentity {

frontend/src/pages/find-best-setup/FindBestSetupPage.test.tsx

@@ -58,6 +58,7 @@ const context: CampaignPlanningContextReadModel = {
           runtime_name: null,
           runtime_version: null,
           runtime_config_digest: null,
+          generation_parameter_domains: [],
           source: "configured",
         },
       ],

frontend/src/pages/test-model/TestModelPage.test.tsx

@@ -120,6 +120,7 @@ const probe: EndpointProbeReadModel = {
           provenance: "local_llm_server",
         },
       ],
+      generation_parameter_domains: [],
     },
   ],
   capabilities: [

src/performance_lab/application/__init__.py

@@ -61,6 +61,7 @@
     EvaluatorDefinitionReadModel,
     EvidenceAvailability,
     FrozenExecutionPreviewReadModel,
+    GenerationParameterDomainReadModel,
     IdentitySummary,
     MetricDimension,
     MetricReadModel,
@@ -123,6 +124,7 @@
     "EvidenceContentState",
     "ExplanationState",
     "FrozenExecutionPreviewReadModel",
+    "GenerationParameterDomainReadModel",
     "IdentitySummary",
     "MetricDimension",
     "MetricReadModel",

src/performance_lab/application/campaign_jobs.py

@@ -47,6 +47,7 @@ class CampaignRunSpec:
     candidate_id: str
     model_id: str
     config: StarterRunConfig
+    configuration_id: str = "fixed-1"
 
 
 @dataclass(frozen=True, slots=True)
@@ -139,12 +140,14 @@ async def launch(self, plan: CampaignLaunchPlan) -> Campaign:
                         candidate_id=spec.candidate_id,
                         model_id=spec.model_id,
                         config=config,
+                        configuration_id=spec.configuration_id,
                     )
                 )
                 entries.append(
                     CampaignEntry(
                         entry_id=f"entry-{index + 1}",
                         candidate_id=spec.candidate_id,
+                        configuration_id=spec.configuration_id,
                         model_id=spec.model_id,
                         config_digest=starter_run_config_digest(config),
                     )

src/performance_lab/application/campaign_models.py

@@ -47,6 +47,7 @@ class CampaignResultsReadModel(UIModel):
 class CampaignEntryReadModel(UIModel):
     entry_id: str = Field(min_length=1)
     candidate_id: str = Field(min_length=1)
+    configuration_id: str = Field(default="fixed-1", min_length=1)
     model_id: str = Field(min_length=1)
     config_digest: str = Field(pattern=r"^[0-9a-f]{64}$")
     status: CampaignEntryStatus
@@ -89,6 +90,7 @@ class CampaignCaseSummaryReadModel(UIModel):
 class CampaignCaseCandidateReadModel(UIModel):
     entry_id: str = Field(min_length=1)
     candidate_id: str = Field(min_length=1)
+    configuration_id: str = Field(default="fixed-1", min_length=1)
     model_id: str = Field(min_length=1)
     config_digest: str = Field(pattern=r"^[0-9a-f]{64}$")
     entry_status: CampaignEntryStatus

src/performance_lab/application/endpoint_discovery.py

@@ -6,7 +6,7 @@
 from typing import Literal
 
 import httpx
-from pydantic import HttpUrl
+from pydantic import HttpUrl, ValidationError
 
 from performance_lab.adapters import OpenAICompatibleAdapter
 from performance_lab.domain import EndpointProfile
@@ -17,6 +17,7 @@
     DiscoveredModelReadModel,
     EndpointConnectionInput,
     EndpointProbeReadModel,
+    GenerationParameterDomainReadModel,
     RuntimeParameterReadModel,
 )
 
@@ -66,18 +67,22 @@ async def probe_endpoint_profile(
 
     capabilities = _capability_evidence(passive.capabilities, healthy=passive.healthy)
     runtime_parameters: dict[str, tuple[RuntimeParameterReadModel, ...]] = {}
+    generation_domains: dict[str, tuple[GenerationParameterDomainReadModel, ...]] = {}
     warning: str | None = None
     if (
         passive.healthy
         and local_connection is not None
         and local_connection.server_type == "local_llm_server"
     ):
-        runtime_parameters, warning = await _probe_local_llm_server_registry(local_connection)
+        runtime_parameters, generation_domains, warning = await _probe_local_llm_server_registry(
+            local_connection
+        )
 
     models = tuple(
         DiscoveredModelReadModel(
             model_id=model_id,
             runtime_parameters=runtime_parameters.get(model_id, ()),
+            generation_parameter_domains=generation_domains.get(model_id, ()),
         )
         for model_id in passive.models
     )
@@ -131,7 +136,11 @@ def _capability_evidence(
 
 async def _probe_local_llm_server_registry(
     connection: EndpointConnectionInput,
-) -> tuple[dict[str, tuple[RuntimeParameterReadModel, ...]], str | None]:
+) -> tuple[
+    dict[str, tuple[RuntimeParameterReadModel, ...]],
+    dict[str, tuple[GenerationParameterDomainReadModel, ...]],
+    str | None,
+]:
     """Best-effort first-party enrichment; generic OpenAI discovery stays authoritative."""
     root = str(local_server_root(connection)).rstrip("/")
     url = f"{root}/api/v1/models/registry"
@@ -142,17 +151,20 @@ async def _probe_local_llm_server_registry(
         payload = response.json()
     except (httpx.HTTPError, ValueError, TypeError):
         return (
+            {},
             {},
             "Model discovery succeeded, but Local LLM Server runtime details are unavailable.",
         )
 
     if not isinstance(payload, Mapping):
-        return {}, "Local LLM Server returned an invalid runtime registry response."
+        return {}, {}, "Local LLM Server returned an invalid runtime registry response."
     raw_models = payload.get("models")
     if not isinstance(raw_models, list):
-        return {}, "Local LLM Server runtime registry did not include a model list."
+        return {}, {}, "Local LLM Server runtime registry did not include a model list."
 
-    result: dict[str, tuple[RuntimeParameterReadModel, ...]] = {}
+    runtime_result: dict[str, tuple[RuntimeParameterReadModel, ...]] = {}
+    domain_result: dict[str, tuple[GenerationParameterDomainReadModel, ...]] = {}
+    invalid_domain_metadata = False
     for raw_model in raw_models:
         if not isinstance(raw_model, Mapping):
             continue
@@ -163,16 +175,41 @@ async def _probe_local_llm_server_registry(
         runtime_config = raw_model.get("runtime_config")
         config = runtime_config if isinstance(runtime_config, Mapping) else {}
         names = raw_capabilities if isinstance(raw_capabilities, list) else []
-        parameters = tuple(
+        runtime_result[model_id] = tuple(
             RuntimeParameterReadModel(
                 name=name,
                 current_value=config.get(name),
             )
             for name in names
             if isinstance(name, str) and name
         )
-        result[model_id] = parameters
-    return result, None
+
+        raw_domains = raw_model.get("generation_parameter_domains")
+        if raw_domains is None:
+            domain_result[model_id] = ()
+            continue
+        if not isinstance(raw_domains, list):
+            invalid_domain_metadata = True
+            domain_result[model_id] = ()
+            continue
+        domains: list[GenerationParameterDomainReadModel] = []
+        for raw_domain in raw_domains:
+            if not isinstance(raw_domain, Mapping):
+                invalid_domain_metadata = True
+                continue
+            try:
+                domains.append(GenerationParameterDomainReadModel.model_validate(dict(raw_domain)))
+            except ValidationError:
+                invalid_domain_metadata = True
+        domain_result[model_id] = tuple(sorted(domains, key=lambda item: item.name))
+
+    warning = (
+        "Local LLM Server returned invalid generation-domain metadata; "
+        "invalid domains were ignored."
+        if invalid_domain_metadata
+        else None
+    )
+    return runtime_result, domain_result, warning
 
 
 def _model_id(raw_model: Mapping[object, object]) -> str | None:

src/performance_lab/application/execution_policy_queries.py

@@ -2,7 +2,7 @@
 
 from __future__ import annotations
 
-from performance_lab.domain import EndpointProfile, EvidenceMode
+from performance_lab.domain import EndpointProfile, EvidenceMode, GenerationConfig
 from performance_lab.run_config import StarterRunConfig
 
 from .evidence_models import (
@@ -87,13 +87,15 @@ def _campaign_run_config(
         target: TargetSummaryReadModel,
         endpoint: EndpointProfile,
         model_id: str,
+        generation: GenerationConfig,
         suite_id: str,
         suite_version: str,
     ) -> StarterRunConfig:
         config = super()._campaign_run_config(
             target=target,
             endpoint=endpoint,
             model_id=model_id,
+            generation=generation,
             suite_id=suite_id,
             suite_version=suite_version,
         )

src/performance_lab/application/planning_models.py

@@ -11,6 +11,7 @@
 
 from .ui_models import (
     DatasetSummaryReadModel,
+    GenerationParameterDomainReadModel,
     SuiteSummaryReadModel,
     TargetSummaryReadModel,
     UIModel,
@@ -46,6 +47,7 @@ class CandidateModelReadModel(UIModel):
     runtime_name: str | None = None
     runtime_version: str | None = None
     runtime_config_digest: str | None = None
+    generation_parameter_domains: tuple[GenerationParameterDomainReadModel, ...] = ()
     source: Literal["configured", "discovered"]
 
 
@@ -107,14 +109,35 @@ class CampaignPlanIssueReadModel(UIModel):
     field: str | None = None
 
 
+class FrozenGenerationConfigurationReadModel(UIModel):
+    """One exact request-generation configuration reviewed before campaign launch."""
+
+    configuration_id: str = Field(min_length=1)
+    generation_digest: str = Field(pattern=r"^[0-9a-f]{64}$")
+    generation: GenerationConfig
+
+
 class ConfigurationSearchPlanReadModel(UIModel):
     strategy: CampaignSearchStrategy
     title: str = Field(min_length=1)
     configuration_count_per_candidate: int = Field(gt=0)
     base_generation: GenerationConfig
+    configurations: tuple[FrozenGenerationConfigurationReadModel, ...]
     bounded_parameter_ranges: tuple[str, ...] = ()
     note: str = Field(min_length=1)
 
+    @model_validator(mode="after")
+    def require_exact_configuration_matrix(self) -> ConfigurationSearchPlanReadModel:
+        if len(self.configurations) != self.configuration_count_per_candidate:
+            raise ValueError("configuration count must match the frozen configuration matrix")
+        configuration_ids = [item.configuration_id for item in self.configurations]
+        if len(configuration_ids) != len(set(configuration_ids)):
+            raise ValueError("configuration ids must be unique")
+        generation_digests = [item.generation_digest for item in self.configurations]
+        if len(generation_digests) != len(set(generation_digests)):
+            raise ValueError("frozen generation configurations must be unique")
+        return self
+
 
 class BenchmarkPlanReadModel(UIModel):
     suite: SuiteSummaryReadModel