agentevolve-optimizer 0.5.0__py3-none-any.whl

agent_evolve/application/finite_action_hypothesis_semantics.py

@@ -0,0 +1,446 @@
+"""Portable conservative semantics for reflected finite-action hypotheses.
+
+Free-text triggers and mechanisms are never parsed.  This compiler deliberately
+uses authenticated direct evidence when available to compile a replayable
+parent-local transition claim.  Legacy or foreign evidence retains the older
+all-parent interpretation so existing non-identifiable workflows remain
+explicitly backward compatible.  A workload may inject a narrower semantic
+compiler and matcher, but this implementation provides one shared default for
+BOiLS, Heat, Timeloop, and other finite catalogs.
+"""
+
+from __future__ import annotations
+
+import hashlib
+from dataclasses import dataclass
+
+from agent_evolve.application.finite_action_transition import (
+    EmpiricalFiniteActionTransition,
+    empirical_finite_action_transitions_for_insight,
+)
+from agent_evolve.application.campaign_learning_runtime import (
+    CampaignInsightSemanticCompiler,
+    CompiledCampaignInsightSemantics,
+)
+from agent_evolve.domain.typed_json import FrozenJsonObject, freeze_json, thaw_json
+from agent_evolve.policies.memory.global_falsification import (
+    AuthenticatedHypothesisObservation,
+    GlobalHypothesisAuditRequest,
+    HypothesisEvidenceMatchReceipt,
+    InterventionIdentifiability,
+    InterventionMatch,
+    TriggerMatch,
+    TypedEvidencePredicate,
+)
+from agent_evolve.ports.agentic_generator import (
+    InsightDraft,
+    ReflectionInsightContract,
+)
+from agent_evolve.application.insight_memory import InsightEvidenceLineage
+
+
+PORTABLE_FINITE_ACTION_MATCHER_ID = "portable_finite_action_hypothesis_matcher"
+PORTABLE_FINITE_ACTION_MATCHER_VERSION = 2
+PORTABLE_FINITE_ACTION_MATCHER_DEFINITION_SHA256 = hashlib.sha256(
+    b"agent-evolve:portable-finite-action-hypothesis-matcher:v2:"
+    b"authenticated-parent-local-transition-when-available:"
+    b"stable-action-id-family-path-and-compiler:typed-old-new-values:"
+    b"legacy-all-parent-schema-compatible"
+).hexdigest()
+PORTABLE_FINITE_ACTION_COMPILER_ID = "portable_finite_action_insight_compiler"
+PORTABLE_FINITE_ACTION_COMPILER_VERSION = 2
+PORTABLE_FINITE_ACTION_COMPILER_DEFINITION_SHA256 = hashlib.sha256(
+    b"agent-evolve:portable-finite-action-insight-compiler:v2:"
+    b"no-prose-parsing:authenticated-direct-transition-first:"
+    b"foreign-evidence-legacy-fallback"
+).hexdigest()
+
+_TRIGGER_SCHEMA = "finite_action_all_parent_trigger"
+_OLD_VALUE_SCHEMA = "finite_action_parent_value_scope"
+_NEW_ACTION_SCHEMA = "finite_action_declared_intervention"
+_TRIGGER_SCHEMA_SHA256 = hashlib.sha256(
+    b"agent-evolve:finite-action-all-parent-trigger-schema:v1"
+).hexdigest()
+_OLD_VALUE_SCHEMA_SHA256 = hashlib.sha256(
+    b"agent-evolve:finite-action-parent-value-scope-schema:v1"
+).hexdigest()
+_NEW_ACTION_SCHEMA_SHA256 = hashlib.sha256(
+    b"agent-evolve:finite-action-declared-intervention-schema:v1"
+).hexdigest()
+
+_EMPIRICAL_TRIGGER_SCHEMA = "finite_action_empirical_parent_trigger"
+_EMPIRICAL_OLD_VALUE_SCHEMA = "finite_action_empirical_parent_values"
+_EMPIRICAL_NEW_ACTION_SCHEMA = "finite_action_empirical_transition"
+_EMPIRICAL_TRIGGER_SCHEMA_SHA256 = hashlib.sha256(
+    b"agent-evolve:finite-action-empirical-parent-trigger-schema:v1"
+).hexdigest()
+_EMPIRICAL_OLD_VALUE_SCHEMA_SHA256 = hashlib.sha256(
+    b"agent-evolve:finite-action-empirical-parent-values-schema:v1"
+).hexdigest()
+_EMPIRICAL_NEW_ACTION_SCHEMA_SHA256 = hashlib.sha256(
+    b"agent-evolve:finite-action-empirical-transition-schema:v1"
+).hexdigest()
+
+
+def _object(value: dict[str, object]) -> FrozenJsonObject:
+    frozen = freeze_json(value)
+    if type(frozen) is not FrozenJsonObject:  # pragma: no cover - closed root.
+        raise AssertionError("portable semantics payload did not freeze to an object")
+    return frozen
+
+
+def _paths_overlap(first: str, second: str) -> bool:
+    return (
+        first == second
+        or first.startswith(second + ".")
+        or first.startswith(second + "[")
+        or second.startswith(first + ".")
+        or second.startswith(first + "[")
+    )
+
+
+def _exact_path_cover(
+    declared: tuple[str, ...],
+    observed: tuple[str, ...],
+) -> bool:
+    return all(
+        any(_paths_overlap(path, value) for value in observed) for path in declared
+    ) and all(
+        any(_paths_overlap(value, path) for path in declared) for value in observed
+    )
+
+
+@dataclass(frozen=True, slots=True)
+class PortableFiniteActionInsightSemanticCompiler(CampaignInsightSemanticCompiler):
+    """Compile structured card fields into a strong portable local claim."""
+
+    policy_id: str = PORTABLE_FINITE_ACTION_COMPILER_ID
+    policy_version: int = PORTABLE_FINITE_ACTION_COMPILER_VERSION
+    definition_sha256: str = PORTABLE_FINITE_ACTION_COMPILER_DEFINITION_SHA256
+
+    def compile(
+        self,
+        *,
+        draft: InsightDraft,
+        insight_contract: ReflectionInsightContract,
+        evidence_lineage: InsightEvidenceLineage,
+    ) -> CompiledCampaignInsightSemantics:
+        if type(draft) is not InsightDraft:
+            raise TypeError("draft must be exact")
+        if type(insight_contract) is not ReflectionInsightContract:
+            raise TypeError("insight_contract must be exact")
+        if type(evidence_lineage) is not InsightEvidenceLineage:
+            raise TypeError("evidence_lineage must be exact")
+        InsightDraft.__post_init__(draft)
+        ReflectionInsightContract.__post_init__(insight_contract)
+        InsightEvidenceLineage.__post_init__(evidence_lineage)
+        transitions = empirical_finite_action_transitions_for_insight(
+            draft,
+            evidence_lineage,
+        )
+        if transitions:
+            transition_records = [value.to_record() for value in transitions]
+            trigger = TypedEvidencePredicate(
+                schema_id=_EMPIRICAL_TRIGGER_SCHEMA,
+                schema_version=1,
+                schema_definition_sha256=_EMPIRICAL_TRIGGER_SCHEMA_SHA256,
+                payload=_object(
+                    {
+                        "scope": "authenticated_parent_local_value_alternatives",
+                        "transitions": transition_records,
+                    }
+                ),
+            )
+            old_value_predicate = TypedEvidencePredicate(
+                schema_id=_EMPIRICAL_OLD_VALUE_SCHEMA,
+                schema_version=1,
+                schema_definition_sha256=_EMPIRICAL_OLD_VALUE_SCHEMA_SHA256,
+                payload=_object(
+                    {
+                        "affected_paths": list(draft.affected_paths),
+                        "value_constraint": (
+                            "one_of_authenticated_parent_local_values"
+                        ),
+                        "transitions": transition_records,
+                    }
+                ),
+            )
+            new_action = TypedEvidencePredicate(
+                schema_id=_EMPIRICAL_NEW_ACTION_SCHEMA,
+                schema_version=1,
+                schema_definition_sha256=_EMPIRICAL_NEW_ACTION_SCHEMA_SHA256,
+                payload=_object(
+                    {
+                        "affected_paths": list(draft.affected_paths),
+                        "recommended_option_families": list(
+                            draft.recommended_option_families
+                        ),
+                        "recommended_option_ids": list(
+                            draft.recommended_option_ids
+                        ),
+                        "factor_capabilities": list(draft.factor_capabilities),
+                        "matching_law": (
+                            "stable_action_and_compiler_with_exact_local_child_value"
+                        ),
+                        "transitions": transition_records,
+                    }
+                ),
+            )
+        else:
+            trigger = TypedEvidencePredicate(
+                schema_id=_TRIGGER_SCHEMA,
+                schema_version=1,
+                schema_definition_sha256=_TRIGGER_SCHEMA_SHA256,
+                payload=_object(
+                    {
+                        "scope": "every_parent_in_registered_audit_scope",
+                        "prose_trigger_used_for_matching": False,
+                    }
+                ),
+            )
+            old_value_predicate = TypedEvidencePredicate(
+                schema_id=_OLD_VALUE_SCHEMA,
+                schema_version=1,
+                schema_definition_sha256=_OLD_VALUE_SCHEMA_SHA256,
+                payload=_object(
+                    {
+                        "affected_paths": list(draft.affected_paths),
+                        "value_constraint": "any_pre_intervention_value",
+                    }
+                ),
+            )
+            new_action = TypedEvidencePredicate(
+                schema_id=_NEW_ACTION_SCHEMA,
+                schema_version=1,
+                schema_definition_sha256=_NEW_ACTION_SCHEMA_SHA256,
+                payload=_object(
+                    {
+                        "affected_paths": list(draft.affected_paths),
+                        "recommended_option_families": list(
+                            draft.recommended_option_families
+                        ),
+                        "recommended_option_ids": list(
+                            draft.recommended_option_ids
+                        ),
+                        "factor_capabilities": list(draft.factor_capabilities),
+                        "matching_law": (
+                            "exact_bidirectional_path_cover_and_declared_family_id"
+                        ),
+                    }
+                ),
+            )
+        return CompiledCampaignInsightSemantics(
+            draft_content_sha256=draft.content_sha256,
+            insight_contract_identity_sha256=insight_contract.identity_sha256,
+            evidence_lineage_sha256=evidence_lineage.identity_sha256,
+            trigger=trigger,
+            old_value_predicate=old_value_predicate,
+            new_action=new_action,
+            matcher_definition_sha256=(
+                PORTABLE_FINITE_ACTION_MATCHER_DEFINITION_SHA256
+            ),
+            compiler_policy_id=self.policy_id,
+            compiler_policy_version=self.policy_version,
+            compiler_definition_sha256=self.definition_sha256,
+        )
+
+
+@dataclass(frozen=True, slots=True)
+class PortableFiniteActionHypothesisMatcher:
+    """Match compiled finite-action claims to authenticated action records."""
+
+    policy_id: str = PORTABLE_FINITE_ACTION_MATCHER_ID
+    policy_version: int = PORTABLE_FINITE_ACTION_MATCHER_VERSION
+    definition_sha256: str = PORTABLE_FINITE_ACTION_MATCHER_DEFINITION_SHA256
+
+    @staticmethod
+    def _predicate_payload(
+        request: GlobalHypothesisAuditRequest,
+    ) -> tuple[dict[str, object], tuple[EmpiricalFiniteActionTransition, ...]]:
+        trigger = request.trigger
+        old_value = request.intervention.old_value_predicate
+        new_action = request.intervention.new_action
+        expected = (
+            (
+                trigger.schema_id,
+                trigger.schema_version,
+                trigger.schema_definition_sha256,
+            ),
+            (
+                old_value.schema_id,
+                old_value.schema_version,
+                old_value.schema_definition_sha256,
+            ),
+            (
+                new_action.schema_id,
+                new_action.schema_version,
+                new_action.schema_definition_sha256,
+            ),
+        )
+        required = (
+            (_TRIGGER_SCHEMA, 1, _TRIGGER_SCHEMA_SHA256),
+            (_OLD_VALUE_SCHEMA, 1, _OLD_VALUE_SCHEMA_SHA256),
+            (_NEW_ACTION_SCHEMA, 1, _NEW_ACTION_SCHEMA_SHA256),
+        )
+        if expected == required:
+            payload = thaw_json(new_action.payload)
+            if type(payload) is not dict:  # pragma: no cover - closed root.
+                raise AssertionError("new-action predicate thawed to a non-object")
+            return payload, ()
+        empirical_required = (
+            (
+                _EMPIRICAL_TRIGGER_SCHEMA,
+                1,
+                _EMPIRICAL_TRIGGER_SCHEMA_SHA256,
+            ),
+            (
+                _EMPIRICAL_OLD_VALUE_SCHEMA,
+                1,
+                _EMPIRICAL_OLD_VALUE_SCHEMA_SHA256,
+            ),
+            (
+                _EMPIRICAL_NEW_ACTION_SCHEMA,
+                1,
+                _EMPIRICAL_NEW_ACTION_SCHEMA_SHA256,
+            ),
+        )
+        if expected != empirical_required:
+            raise ValueError("audit request uses a foreign finite-action schema")
+        payloads = tuple(
+            thaw_json(value.payload) for value in (trigger, old_value, new_action)
+        )
+        if any(type(value) is not dict for value in payloads):
+            raise ValueError("empirical finite-action predicates must be objects")
+        trigger_payload, old_payload, action_payload = payloads
+        transition_records = action_payload.get("transitions")
+        if (
+            type(transition_records) is not list
+            or not transition_records
+            or trigger_payload.get("transitions") != transition_records
+            or old_payload.get("transitions") != transition_records
+        ):
+            raise ValueError("empirical finite-action predicates lost their join")
+        transitions = tuple(
+            EmpiricalFiniteActionTransition.from_record(value)
+            for value in transition_records
+        )
+        if transitions != tuple(
+            sorted(transitions, key=lambda value: value.transition_sha256)
+        ):
+            raise ValueError("empirical finite-action transitions are not canonical")
+        return action_payload, transitions
+
+    def classify(
+        self,
+        request: GlobalHypothesisAuditRequest,
+        observation: AuthenticatedHypothesisObservation,
+    ) -> HypothesisEvidenceMatchReceipt:
+        if type(request) is not GlobalHypothesisAuditRequest:
+            raise TypeError("request must be exact")
+        if type(observation) is not AuthenticatedHypothesisObservation:
+            raise TypeError("observation must be exact")
+        GlobalHypothesisAuditRequest.__post_init__(request)
+        AuthenticatedHypothesisObservation.__post_init__(observation)
+        payload, transitions = self._predicate_payload(request)
+        action = thaw_json(observation.observed_action)
+        if type(action) is not dict:
+            raise ValueError("observed action must be an object")
+        required_action_fields = {
+            "option_id",
+            "option_family",
+            "operator_family",
+            "changed_paths",
+        }
+        if not required_action_fields.issubset(action):
+            raise ValueError("observed action omits finite-action identity fields")
+        declared_paths = tuple(payload.get("affected_paths", ()))
+        declared_families = tuple(payload.get("recommended_option_families", ()))
+        declared_ids = tuple(payload.get("recommended_option_ids", ()))
+        observed_paths = tuple(action["changed_paths"])
+        path_exact = _exact_path_cover(declared_paths, observed_paths)
+        family_exact = (
+            not declared_families or action["option_family"] in declared_families
+        )
+        option_exact = not declared_ids or action["option_id"] in declared_ids
+        operator_exact = action["operator_family"] in (
+            request.intervention.admissible_operator_families
+        )
+        trigger_match = TriggerMatch.EXACT
+        if transitions:
+            try:
+                trigger_match = (
+                    TriggerMatch.EXACT
+                    if any(
+                        transition.parent_matches(observation.parent_configuration)
+                        for transition in transitions
+                    )
+                    else TriggerMatch.OFF_TRIGGER
+                )
+            except ValueError:
+                trigger_match = TriggerMatch.AMBIGUOUS
+            action_transition_exact = False
+            if path_exact and operator_exact:
+                for transition in transitions:
+                    if (
+                        action["option_id"] == transition.option_id
+                        and action["option_family"] == transition.option_family
+                        and observation.action_semantics_compiler_id
+                        == transition.action_semantics_compiler_id
+                        and observation.action_semantics_compiler_version
+                        == transition.action_semantics_compiler_version
+                        and observation.action_semantics_definition_sha256
+                        == transition.action_semantics_definition_sha256
+                        and transition.affected_path in observed_paths
+                    ):
+                        try:
+                            if transition.child_matches(
+                                observation.child_configuration
+                            ):
+                                action_transition_exact = True
+                                break
+                        except ValueError:
+                            continue
+            family_exact = family_exact and any(
+                action["option_family"] == value.option_family
+                for value in transitions
+            )
+            option_exact = option_exact and any(
+                action["option_id"] == value.option_id for value in transitions
+            )
+        else:
+            action_transition_exact = path_exact and family_exact and option_exact
+        if observation.intervention_identifiability is not (
+            InterventionIdentifiability.EXACT_SINGLE
+        ):
+            intervention_match = InterventionMatch.NON_IDENTIFIABLE
+        elif action_transition_exact and operator_exact:
+            intervention_match = InterventionMatch.EXACT
+        elif any(
+            _paths_overlap(declared, observed)
+            for declared in declared_paths
+            for observed in observed_paths
+        ):
+            intervention_match = InterventionMatch.NEAR
+        else:
+            intervention_match = InterventionMatch.DIFFERENT
+        return HypothesisEvidenceMatchReceipt(
+            request_sha256=request.request_sha256,
+            observation_sha256=observation.observation_sha256,
+            trigger_match=trigger_match,
+            intervention_match=intervention_match,
+            matcher_policy_id=self.policy_id,
+            matcher_policy_version=self.policy_version,
+            matcher_definition_sha256=self.definition_sha256,
+        )
+
+
+__all__ = [
+    "PORTABLE_FINITE_ACTION_COMPILER_DEFINITION_SHA256",
+    "PORTABLE_FINITE_ACTION_COMPILER_ID",
+    "PORTABLE_FINITE_ACTION_COMPILER_VERSION",
+    "PORTABLE_FINITE_ACTION_MATCHER_DEFINITION_SHA256",
+    "PORTABLE_FINITE_ACTION_MATCHER_ID",
+    "PORTABLE_FINITE_ACTION_MATCHER_VERSION",
+    "PortableFiniteActionHypothesisMatcher",
+    "PortableFiniteActionInsightSemanticCompiler",
+]

agent_evolve/application/finite_action_selection.py

@@ -0,0 +1,188 @@
+"""Trusted sealing of model choices from matched finite action sets.
+
+The provider-facing generator already returns an opaque finite-option ID.  This
+service joins that untrusted draft to the exact Stage-B authority, logical call,
+semantic prompt, and provider telemetry before an evaluator may use the choice.
+It deliberately has no evaluator or outcome dependency.
+"""
+
+from __future__ import annotations
+
+import hashlib
+import json
+from decimal import Decimal
+
+from agent_evolve.domain.finite_action_set import FiniteActionSetAuthority
+from agent_evolve.domain.ids import LLMCallId
+from agent_evolve.domain.patch import require_sha256
+from agent_evolve.ports.agentic_generator import (
+    AgenticCallTelemetry,
+    FiniteVariationSelectionDraft,
+    resolve_finite_variation_selection,
+)
+from agent_evolve.ports.finite_action_selection import (
+    FiniteActionDecision,
+    FiniteActionSelectorKind,
+    validate_finite_action_decision,
+)
+
+
+MODEL_FINITE_ACTION_SELECTOR_POLICY_ID = "literal_id_model_finite_action"
+MODEL_FINITE_ACTION_SELECTOR_POLICY_VERSION = 1
+_MODEL_SELECTOR_DEFINITION_DOMAIN = (
+    b"agent-evolve:literal-id-model-finite-action:def:v1\x00"
+)
+_MODEL_TELEMETRY_DOMAIN = (
+    b"agent-evolve:model-finite-action-call-telemetry:v1\x00"
+)
+_MODEL_SELECTOR_DEFINITION = {
+    "choice_authority": "one presealed finite action set",
+    "model_output": "one opaque option ID plus non-authoritative rationale",
+    "materialization": "engine-owned full child",
+    "propensity": "unknown",
+    "current_outcome_access": False,
+}
+
+
+def _canonical_json(value: object) -> bytes:
+    return json.dumps(
+        value,
+        ensure_ascii=True,
+        allow_nan=False,
+        separators=(",", ":"),
+        sort_keys=True,
+    ).encode("ascii")
+
+
+MODEL_FINITE_ACTION_SELECTOR_DEFINITION_SHA256 = hashlib.sha256(
+    _MODEL_SELECTOR_DEFINITION_DOMAIN
+    + _canonical_json(_MODEL_SELECTOR_DEFINITION)
+).hexdigest()
+
+
+def _telemetry_record(telemetry: AgenticCallTelemetry) -> dict[str, object]:
+    if type(telemetry) is not AgenticCallTelemetry:
+        raise TypeError("telemetry must be an exact AgenticCallTelemetry")
+    AgenticCallTelemetry.__post_init__(telemetry)
+    for name in ("provider_response_id", "finish_reason"):
+        value = getattr(telemetry, name)
+        if value is not None and type(value) is not str:
+            raise TypeError(f"telemetry {name} must be an exact string or None")
+    if telemetry.cost_usd is None:
+        cost_usd: str | None = None
+    else:
+        if type(telemetry.cost_usd) is not Decimal:
+            raise TypeError("telemetry cost_usd must be an exact Decimal or None")
+        if not telemetry.cost_usd.is_finite() or telemetry.cost_usd < 0:
+            raise ValueError("telemetry cost_usd must be finite and non-negative")
+        cost_usd = str(telemetry.cost_usd)
+    return {
+        "requested_model": telemetry.requested_model,
+        "resolved_model": telemetry.resolved_model,
+        "resolved_provider": telemetry.resolved_provider,
+        "provider_response_id": telemetry.provider_response_id,
+        "finish_reason": telemetry.finish_reason,
+        "input_tokens": telemetry.input_tokens,
+        "output_tokens": telemetry.output_tokens,
+        "reasoning_tokens": telemetry.reasoning_tokens,
+        "cache_read_tokens": telemetry.cache_read_tokens,
+        "cache_write_tokens": telemetry.cache_write_tokens,
+        "cost_usd": cost_usd,
+        "latency_ns": telemetry.latency_ns,
+        "attempt_count": telemetry.attempt_count,
+    }
+
+
+def model_finite_action_telemetry_sha256(
+    telemetry: AgenticCallTelemetry,
+) -> str:
+    """Hash exact call telemetry without lossy Decimal conversion."""
+
+    return hashlib.sha256(
+        _MODEL_TELEMETRY_DOMAIN + _canonical_json(_telemetry_record(telemetry))
+    ).hexdigest()
+
+
+def seal_model_finite_action_decision(
+    *,
+    authority: FiniteActionSetAuthority,
+    call_id: LLMCallId,
+    prompt_sha256: str,
+    draft: FiniteVariationSelectionDraft,
+    telemetry: AgenticCallTelemetry,
+) -> FiniteActionDecision:
+    """Bind one model-selected ID to its exact K-option authority.
+
+    The option ordinal is derived from the authority's provider-visible order;
+    it is never accepted from the model.  All validation and sealing happen
+    without current candidate outcomes.
+    """
+
+    if type(authority) is not FiniteActionSetAuthority:
+        raise TypeError("authority must be an exact FiniteActionSetAuthority")
+    FiniteActionSetAuthority.__post_init__(authority)
+    if type(call_id) is not LLMCallId:
+        raise TypeError("call_id must be an exact LLMCallId")
+    LLMCallId.__post_init__(call_id)
+    require_sha256(prompt_sha256, "prompt_sha256")
+    if type(draft) is not FiniteVariationSelectionDraft:
+        raise TypeError("draft must be an exact FiniteVariationSelectionDraft")
+    FiniteVariationSelectionDraft.__post_init__(draft)
+    if type(telemetry) is not AgenticCallTelemetry:
+        raise TypeError("telemetry must be an exact AgenticCallTelemetry")
+    AgenticCallTelemetry.__post_init__(telemetry)
+
+    authority_sha256_before = authority.authority_sha256
+    support_sha256_before = authority.support.support_sha256
+    support_contract = authority.support.support_contract
+    option = resolve_finite_variation_selection(support_contract, draft)
+    matching_ordinals = tuple(
+        ordinal
+        for ordinal, row in enumerate(authority.support.options)
+        if (
+            row.option.option_id == option.option_id
+            and row.option.identity_sha256 == option.identity_sha256
+        )
+    )
+    if len(matching_ordinals) != 1:
+        raise ValueError("selected option has no unique authority ordinal")
+    selected_ordinal = matching_ordinals[0]
+    row = authority.support.options[selected_ordinal]
+    decision = FiniteActionDecision(
+        authority_sha256=authority.authority_sha256,
+        support_sha256=authority.support.support_sha256,
+        selector_kind=FiniteActionSelectorKind.MODEL,
+        selected_ordinal=selected_ordinal,
+        option_id=row.option.option_id,
+        option_identity_sha256=row.option.identity_sha256,
+        child_configuration_sha256=row.option.child_configuration_sha256,
+        phenotype_identity_sha256=row.phenotype_identity_sha256,
+        selector_policy_id=MODEL_FINITE_ACTION_SELECTOR_POLICY_ID,
+        selector_policy_version=MODEL_FINITE_ACTION_SELECTOR_POLICY_VERSION,
+        selector_definition_sha256=(
+            MODEL_FINITE_ACTION_SELECTOR_DEFINITION_SHA256
+        ),
+        prospective_token_sha256=None,
+        model_call_id=call_id,
+        model_prompt_sha256=prompt_sha256,
+        model_telemetry_sha256=model_finite_action_telemetry_sha256(telemetry),
+        propensity_numerator=None,
+        propensity_denominator=None,
+        current_outcome_access=False,
+    )
+    if (
+        authority.authority_sha256 != authority_sha256_before
+        or authority.support.support_sha256 != support_sha256_before
+    ):
+        raise ValueError("finite action authority changed during model sealing")
+    validate_finite_action_decision(authority, decision)
+    return decision
+
+
+__all__ = [
+    "MODEL_FINITE_ACTION_SELECTOR_DEFINITION_SHA256",
+    "MODEL_FINITE_ACTION_SELECTOR_POLICY_ID",
+    "MODEL_FINITE_ACTION_SELECTOR_POLICY_VERSION",
+    "model_finite_action_telemetry_sha256",
+    "seal_model_finite_action_decision",
+]