src/tests/runtime/test_eligible_catalog.py

from __future__ import annotations

import hashlib
import json
from collections.abc import Iterator, Mapping, Sequence
from copy import deepcopy
from dataclasses import dataclass, replace
from typing import overload

import pytest

from ctx.engine.benefit import BenefitSelectionResult, NetBenefitPolicy
from ctx.engine.content import MaterialDescriptor, MaterialIdentity
from ctx.engine.installation import InstallPlanDescriptor, InstallPlanningBundle
from ctx.engine.planner import CapabilityCandidate, WorkObservation
from ctx.engine.planning_v3 import AuthenticatedNetBenefitPlanner
from ctx.engine.replay import PlanningContext, StructuredSurrogate
from ctx.runtime.authenticated_benefit import capability_presentation_digest
from ctx.runtime.benefit_closure import (
    EligibleCatalogClaim,
    QueryCapabilityEligibility,
    ReviewedBenefitAuthorities,
    eligible_catalog_claim_digest,
    load_reviewed_benefit_profiles_bytes,
)
from ctx.runtime.eligible_catalog import (
    EligibleCatalogLayer,
    EligibleCatalogError,
    PreparedEligibleCatalogQuery,
    load_eligible_catalog_layer_bytes,
    open_reviewed_query_catalog,
)
from ctx.runtime.planning_v3 import (
    AuthenticatedReplayDecisionPlannerV3,
    AuthorityBoundInstallPlanningBundle,
)


def _digest(value: str) -> str:
    return hashlib.sha256(value.encode("utf-8")).hexdigest()


def _canonical_bytes(value: object) -> bytes:
    return json.dumps(
        value,
        ensure_ascii=True,
        allow_nan=False,
        separators=(",", ":"),
        sort_keys=True,
    ).encode("utf-8")


CALIBRATION_DIGEST = _digest("eligible-catalog-calibration")
POLICY = NetBenefitPolicy(
    calibration_digest=CALIBRATION_DIGEST,
    minimum_relevance_ppm=1,
    context_token_cost_u=1,
)


def _aggregate_binding(field_name: str, value: str) -> str:
    return hashlib.sha256(
        _canonical_bytes(
            {
                "field": field_name,
                "schema": "ctx.reviewed-authority-bindings-v1",
                "values": [value],
            }
        )
    ).hexdigest()


def _catalog_manifest(
    *,
    actionability: str = "manual",
    material_snapshot_digest: str | None = None,
    installation_snapshot_digest: str | None = None,
    material_descriptor: MaterialDescriptor | None = None,
    install_bundle: InstallPlanningBundle | None = None,
) -> dict[str, object]:
    return {
        "authority": {
            "authority_digest": _digest("ctx-release-authority"),
            "authority_id": "ctx-release",
            "authority_kind": "ctx-release",
            "catalog_layer_kind": "ctx",
            "sequence": 1,
        },
        "bindings": {
            "candidate_projection_version": "ctx.benefit-eligible-entry-v1",
            "catalog_namespace_digest": _digest("ctx-catalog-namespace"),
            "catalog_provenance_digest": _digest("ctx-catalog-provenance"),
            "installation_snapshot_digest": installation_snapshot_digest,
            "material_snapshot_digest": material_snapshot_digest,
        },
        "entries": [
            {
                "actionability": actionability,
                "capability_id": "skill:ctx-python-testing",
                "equivalence_key": None,
                "install_bundle": (
                    None
                    if install_bundle is None
                    else {
                        "descriptor": install_bundle.descriptor.to_dict(),
                        "result_material": install_bundle.result_material.to_dict(),
                    }
                ),
                "kind": "skill",
                "material_descriptor": (
                    None if material_descriptor is None else material_descriptor.to_dict()
                ),
                "name": "ctx-python-testing",
            }
        ],
        "schema": "ctx.benefit-eligible-catalog-v1",
    }


def _reviewed_profiles_body(layer) -> bytes:  # type: ignore[no-untyped-def]
    entry = layer.entries[0]
    manifest = {
        "authority": {
            "authority_digest": layer.authority_digest,
            "authority_id": layer.authority_id,
            "authority_kind": layer.authority_kind,
            "catalog_layer_kind": layer.catalog_layer_kind,
            "sequence": layer.sequence,
        },
        "bindings": {
            "calibration_digest": CALIBRATION_DIGEST,
            "candidate_projection_version": layer.candidate_projection_version,
            "catalog_artifact_sha256": layer.catalog_artifact_sha256,
            "catalog_namespace_digest": layer.catalog_namespace_digest,
            "catalog_provenance_digest": layer.catalog_provenance_digest,
            "catalog_retrieval_snapshot_digest": layer.catalog_retrieval_snapshot_digest,
            "installation_snapshot_digest": layer.installation_snapshot_digest,
            "material_snapshot_digest": layer.material_snapshot_digest,
            "policy_digest": POLICY.policy_digest,
        },
        "profiles": [
            {
                "actionability": entry.actionability,
                "capability_id": entry.capability_id,
                "catalog_entry_claim_digest": entry.catalog_entry_claim_digest,
                "complements": [],
                "conflicts": [],
                "costs": {
                    "approval_prompts": 0,
                    "child_agent_units": 0,
                    "context_tokens": 120,
                    "credential_burden_units": 0,
                    "permission_burden_units": 0,
                    "process_units": 0,
                    "runtime_millis": 0,
                    "tool_schema_tokens": 0,
                },
                "coverage_keys": ["python-testing"],
                "expected_task_benefit_ppm": 500_000,
                "kind": entry.kind,
                "match_policy": {
                    "allowed_equivalence_keys": [],
                    "allowed_reason_codes": ["reviewed-match"],
                    "allowed_signals": ["python", "testing"],
                    "minimum_matching_signals": 2,
                    "minimum_non_language_matching_signals": 1,
                    "required_any_signals": ["testing"],
                },
                "maximum_relevance_ppm": 700_000,
                "name": entry.name,
                "profile_id": "profile-ctx-python-testing",
                "review_basis_digest": _digest("review-basis:ctx-python-testing"),
                "security_approved": True,
                "source_trusted": True,
                "trust_ppm": 900_000,
            }
        ],
        "schema": "ctx.reviewed-benefit-profiles-v2",
    }
    return _canonical_bytes(manifest)


@dataclass
class _HostPolicy:
    host_policy_snapshot_digest: str = _digest("eligible-catalog-host-policy")

    def eligibility_for(
        self,
        presentation: CapabilityCandidate,
        claim: EligibleCatalogClaim,
    ) -> QueryCapabilityEligibility:
        return QueryCapabilityEligibility(
            presentation_digest=capability_presentation_digest(presentation),
            catalog_entry_claim_digest=claim.catalog_entry_claim_digest,
            catalog_claim_digest=eligible_catalog_claim_digest(claim),
            available=True,
            permissions_allowed=True,
            credentials_available=True,
        )


@dataclass
class _AuditStore:
    results: dict[str, BenefitSelectionResult]

    def store(self, result: BenefitSelectionResult) -> str:
        self.results[result.result_digest] = result
        return result.result_digest


def _open_catalog():  # type: ignore[no-untyped-def]
    catalog_body = _canonical_bytes(_catalog_manifest())
    layer = load_eligible_catalog_layer_bytes(
        catalog_body,
        hashlib.sha256(catalog_body).hexdigest(),
    )
    profiles_body = _reviewed_profiles_body(layer)
    profiles = ReviewedBenefitAuthorities.create(
        (
            load_reviewed_benefit_profiles_bytes(
                profiles_body,
                hashlib.sha256(profiles_body).hexdigest(),
            ),
        )
    )
    return layer, open_reviewed_query_catalog(
        layers=(layer,),
        profiles=profiles,
        policy=POLICY,
    )


def test_exact_catalog_profile_join_prepares_one_sealed_query() -> None:
    layer, catalog = _open_catalog()
    observation = WorkObservation(
        signals=("testing",),
        languages=("python",),
        requested_limit=5,
    )

    prepared = catalog.prepare_query(observation=observation, host_policy=_HostPolicy())

    candidates = prepared.closure.source.retrieve(observation)
    assert tuple(candidate.capability_id for candidate in candidates) == (
        "skill:ctx-python-testing",
    )
    assert candidates[0].matching_signals == ("python", "testing")
    assert candidates[0].reason_codes == ("reviewed-match",)
    assert candidates[0].source_digest == layer.entries[0].source_digest
    assert prepared.material_authority is None
    assert prepared.install_authority is None
    assert catalog.vocabulary.signals == ("testing",)

    prepared.close()
    catalog.close()
    with pytest.raises(EligibleCatalogError, match="closed"):
        catalog.prepare_query(observation=observation, host_policy=_HostPolicy())


def test_catalog_bytes_are_closed_canonical_and_exact_hash_bound() -> None:
    body = _canonical_bytes(_catalog_manifest())

    with pytest.raises(EligibleCatalogError, match="SHA-256"):
        load_eligible_catalog_layer_bytes(body, _digest("wrong"))

    manifest = _catalog_manifest()
    manifest["description"] = "graph prose is not catalog authority"
    mutated = _canonical_bytes(manifest)
    with pytest.raises(EligibleCatalogError, match="declared fields"):
        load_eligible_catalog_layer_bytes(mutated, hashlib.sha256(mutated).hexdigest())

    noncanonical = json.dumps(_catalog_manifest()).encode("utf-8")
    with pytest.raises(EligibleCatalogError, match="canonical"):
        load_eligible_catalog_layer_bytes(
            noncanonical,
            hashlib.sha256(noncanonical).hexdigest(),
        )


def _open_actionable_catalog(actionability: str):  # type: ignore[no-untyped-def]
    capability_id = "skill:ctx-python-testing"
    kind = "skill"
    material_identity = MaterialIdentity.create(
        capability_id=capability_id,
        kind=kind,
        content_sha256=_digest(f"{actionability}-content"),
        content_bytes=240,
    )
    raw_material_snapshot = _digest("raw-material-snapshot")
    raw_installation_snapshot = _digest("raw-installation-snapshot")
    material_descriptor = None
    install_bundle = None
    if actionability == "load":
        material_descriptor = MaterialDescriptor.create(
            capability_id=capability_id,
            kind=kind,
            actionability="load",
            content_sha256=material_identity.content_sha256,
            content_bytes=material_identity.content_bytes,
            estimated_tokens=60,
            provenance_digest=raw_material_snapshot,
            material_identity_digest=material_identity.identity_digest,
        )
    else:
        descriptor = InstallPlanDescriptor.create(
            capability_id=capability_id,
            kind=kind,
            installer_id="ctx-skill-cas",
            plan_digest=_digest("install-plan"),
            provenance_digest=raw_installation_snapshot,
            result_material_identity_digest=material_identity.identity_digest,
        )
        install_bundle = InstallPlanningBundle(
            descriptor=descriptor,
            result_material=material_identity,
        )
    body = _canonical_bytes(
        _catalog_manifest(
            actionability=actionability,
            material_snapshot_digest=(raw_material_snapshot if actionability == "load" else None),
            installation_snapshot_digest=(
                raw_installation_snapshot if actionability == "install" else None
            ),
            material_descriptor=material_descriptor,
            install_bundle=install_bundle,
        )
    )
    layer = load_eligible_catalog_layer_bytes(body, hashlib.sha256(body).hexdigest())
    profiles_body = _reviewed_profiles_body(layer)
    profile_manifest = json.loads(profiles_body)
    profile_manifest["profiles"][0]["actionability"] = actionability
    profile_manifest["profiles"][0]["catalog_entry_claim_digest"] = layer.entries[
        0
    ].catalog_entry_claim_digest
    profiles_body = _canonical_bytes(profile_manifest)
    profiles = ReviewedBenefitAuthorities.create(
        (
            load_reviewed_benefit_profiles_bytes(
                profiles_body,
                hashlib.sha256(profiles_body).hexdigest(),
            ),
        )
    )
    return layer, open_reviewed_query_catalog(
        layers=(layer,),
        profiles=profiles,
        policy=POLICY,
    )


def _actionability_variant_manifest() -> dict[str, object]:
    capability_id = "skill:ctx-python-testing"
    kind = "skill"
    raw_material_snapshot = _digest("variant-material-snapshot")
    raw_installation_snapshot = _digest("variant-installation-snapshot")
    material_identity = MaterialIdentity.create(
        capability_id=capability_id,
        kind=kind,
        content_sha256=_digest("variant-content"),
        content_bytes=240,
    )
    material_descriptor = MaterialDescriptor.create(
        capability_id=capability_id,
        kind=kind,
        actionability="load",
        content_sha256=material_identity.content_sha256,
        content_bytes=material_identity.content_bytes,
        estimated_tokens=60,
        provenance_digest=raw_material_snapshot,
        material_identity_digest=material_identity.identity_digest,
    )
    install_bundle = InstallPlanningBundle(
        descriptor=InstallPlanDescriptor.create(
            capability_id=capability_id,
            kind=kind,
            installer_id="ctx-skill-cas",
            plan_digest=_digest("variant-install-plan"),
            provenance_digest=raw_installation_snapshot,
            result_material_identity_digest=material_identity.identity_digest,
        ),
        result_material=material_identity,
    )
    manifest = _catalog_manifest()
    manifest["bindings"] = {
        "candidate_projection_version": "ctx.benefit-eligible-entry-v1",
        "catalog_namespace_digest": _digest("ctx-catalog-namespace"),
        "catalog_provenance_digest": _digest("ctx-catalog-provenance"),
        "installation_snapshot_digest": raw_installation_snapshot,
        "material_snapshot_digest": raw_material_snapshot,
    }
    manifest["entries"] = [
        {
            "actionability": "install",
            "capability_id": capability_id,
            "equivalence_key": None,
            "install_bundle": {
                "descriptor": install_bundle.descriptor.to_dict(),
                "result_material": install_bundle.result_material.to_dict(),
            },
            "kind": kind,
            "material_descriptor": None,
            "name": "ctx-python-testing",
        },
        {
            "actionability": "load",
            "capability_id": capability_id,
            "equivalence_key": None,
            "install_bundle": None,
            "kind": kind,
            "material_descriptor": material_descriptor.to_dict(),
            "name": "ctx-python-testing",
        },
    ]
    return manifest


def _open_actionability_variant_catalog():  # type: ignore[no-untyped-def]
    body = _canonical_bytes(_actionability_variant_manifest())
    layer = load_eligible_catalog_layer_bytes(body, hashlib.sha256(body).hexdigest())
    profile_manifest = json.loads(_reviewed_profiles_body(layer))
    prototype = profile_manifest["profiles"][0]
    profile_manifest["profiles"] = []
    for entry in layer.entries:
        profile = deepcopy(prototype)
        profile["actionability"] = entry.actionability
        profile["catalog_entry_claim_digest"] = entry.catalog_entry_claim_digest
        profile["profile_id"] = f"profile-{entry.name}-{entry.actionability}"
        profile["review_basis_digest"] = _digest(
            f"review:{entry.capability_id}:{entry.actionability}"
        )
        profile_manifest["profiles"].append(profile)
    profiles_body = _canonical_bytes(profile_manifest)
    profiles = ReviewedBenefitAuthorities.create(
        (
            load_reviewed_benefit_profiles_bytes(
                profiles_body,
                hashlib.sha256(profiles_body).hexdigest(),
            ),
        )
    )
    return layer, open_reviewed_query_catalog(
        layers=(layer,),
        profiles=profiles,
        policy=POLICY,
    )


@dataclass
class _ActionabilityHostPolicy:
    selected_actionability: str
    host_policy_snapshot_digest: str = _digest("variant-host-policy")

    def eligibility_for(
        self,
        presentation: CapabilityCandidate,
        claim: EligibleCatalogClaim,
    ) -> QueryCapabilityEligibility:
        return QueryCapabilityEligibility(
            presentation_digest=capability_presentation_digest(presentation),
            catalog_entry_claim_digest=claim.catalog_entry_claim_digest,
            catalog_claim_digest=eligible_catalog_claim_digest(claim),
            available=presentation.actionability == self.selected_actionability,
            permissions_allowed=True,
            credentials_available=True,
        )


def test_catalog_accepts_distinct_install_and_load_variants_for_one_capability() -> None:
    layer, catalog = _open_actionability_variant_catalog()

    assert tuple((entry.capability_id, entry.actionability) for entry in layer.entries) == (
        ("skill:ctx-python-testing", "install"),
        ("skill:ctx-python-testing", "load"),
    )

    catalog.close()


def test_catalog_layer_rejects_duplicate_capability_actionability_pair() -> None:
    manifest = _actionability_variant_manifest()
    entries = manifest["entries"]
    assert isinstance(entries, list)
    entries.insert(1, deepcopy(entries[0]))
    body = _canonical_bytes(manifest)

    with pytest.raises(EligibleCatalogError, match="capability actionability"):
        load_eligible_catalog_layer_bytes(body, hashlib.sha256(body).hexdigest())


def test_catalog_layers_reject_duplicate_capability_actionability_pair() -> None:
    ctx_body = _canonical_bytes(_catalog_manifest())
    ctx_layer = load_eligible_catalog_layer_bytes(
        ctx_body,
        hashlib.sha256(ctx_body).hexdigest(),
    )
    user_manifest = _catalog_manifest()
    user_manifest["authority"] = {
        "authority_digest": _digest("user-authority"),
        "authority_id": "user-local",
        "authority_kind": "user",
        "catalog_layer_kind": "user",
        "sequence": 1,
    }
    user_manifest["bindings"] = {
        "candidate_projection_version": "ctx.benefit-eligible-entry-v1",
        "catalog_namespace_digest": _digest("user-catalog-namespace"),
        "catalog_provenance_digest": _digest("user-catalog-provenance"),
        "installation_snapshot_digest": None,
        "material_snapshot_digest": None,
    }
    user_body = _canonical_bytes(user_manifest)
    user_layer = load_eligible_catalog_layer_bytes(
        user_body,
        hashlib.sha256(user_body).hexdigest(),
    )
    profiles = ReviewedBenefitAuthorities.create(
        (
            load_reviewed_benefit_profiles_bytes(
                _reviewed_profiles_body(ctx_layer),
                hashlib.sha256(_reviewed_profiles_body(ctx_layer)).hexdigest(),
            ),
            load_reviewed_benefit_profiles_bytes(
                _reviewed_profiles_body(user_layer),
                hashlib.sha256(_reviewed_profiles_body(user_layer)).hexdigest(),
            ),
        )
    )

    with pytest.raises(EligibleCatalogError, match="capability actionability collision"):
        open_reviewed_query_catalog(
            layers=(ctx_layer, user_layer),
            profiles=profiles,
            policy=POLICY,
        )


@pytest.mark.parametrize("selected_actionability", ["install", "load"])
def test_host_policy_selects_one_variant_for_the_single_global_planner(
    selected_actionability: str,
) -> None:
    _layer, catalog = _open_actionability_variant_catalog()
    observation = WorkObservation(
        signals=("testing",),
        languages=("python",),
        requested_limit=5,
    )

    prepared = catalog.prepare_query(
        observation=observation,
        host_policy=_ActionabilityHostPolicy(selected_actionability),
    )
    candidates = prepared.closure.source.retrieve(observation)
    assert tuple(
        (candidate.capability_id, candidate.actionability) for candidate in candidates
    ) == (("skill:ctx-python-testing", selected_actionability),)
    adapter = AuthenticatedReplayDecisionPlannerV3(
        planner=AuthenticatedNetBenefitPlanner(
            policy=POLICY,
            audit_store=_AuditStore(results={}),
        ),
        source=prepared.closure.source,
        benefit_facts_port=prepared.closure.benefit_facts,
        material_port=prepared.material_authority,
        install_bundle_port=prepared.install_authority,
        planner_version="eligible-catalog-v1",
        catalog_namespace_digest=prepared.closure.catalog_namespace_digest,
    )
    decision = adapter(
        StructuredSurrogate.create(
            schema_id="ctx.observation.current-work",
            schema_version=1,
            value={
                "active_capability_ids": [],
                "baseline_capability_ids": [],
                "languages": ["python"],
                "rejected_capability_ids": [],
                "requested_limit": 5,
                "signals": ["testing"],
            },
        ),
        None,
        PlanningContext(
            planner_version="eligible-catalog-v1",
            catalog_snapshot_digest=adapter.catalog_snapshot_digest,
        ),
    )

    selections = decision.value["capabilities"]
    assert isinstance(selections, tuple)
    assert len(selections) == 1
    selection = selections[0]
    assert isinstance(selection, Mapping)
    assert selection["actionability"] == selected_actionability


def test_host_policy_exposing_both_variants_fails_before_planning() -> None:
    _layer, catalog = _open_actionability_variant_catalog()
    observation = WorkObservation(
        signals=("testing",),
        languages=("python",),
        requested_limit=5,
    )

    with pytest.raises(EligibleCatalogError, match="multiple actionability variants"):
        catalog.prepare_query(observation=observation, host_policy=_HostPolicy())


def test_load_authority_is_frozen_from_the_same_catalog_bytes() -> None:
    _layer, catalog = _open_actionable_catalog("load")
    observation = WorkObservation(
        signals=("testing",),
        languages=("python",),
        requested_limit=5,
    )

    prepared = catalog.prepare_query(observation=observation, host_policy=_HostPolicy())
    candidate = prepared.closure.source.retrieve(observation)[0]

    assert prepared.material_authority is not None
    bundle = prepared.material_authority.load_bundle(candidate)
    assert bundle is not None
    assert bundle.presentation == candidate
    assert bundle.catalog_snapshot_digest == prepared.closure.closure_snapshot_digest
    assert bundle.material_snapshot_digest == prepared.closure.material_snapshot_digest
    assert bundle.descriptor.material_identity_digest is not None
    assert prepared.install_authority is None

    substituted = replace(candidate, normalized_score_ppm=candidate.normalized_score_ppm - 1)
    assert prepared.material_authority.load_bundle(substituted) is None


def test_install_authority_is_frozen_from_the_same_catalog_bytes() -> None:
    _layer, catalog = _open_actionable_catalog("install")
    observation = WorkObservation(
        signals=("testing",),
        languages=("python",),
        requested_limit=5,
    )

    prepared = catalog.prepare_query(observation=observation, host_policy=_HostPolicy())
    candidate = prepared.closure.source.retrieve(observation)[0]

    assert prepared.install_authority is not None
    bundle = prepared.install_authority.describe_bundle(candidate.capability_id, candidate.kind)
    assert bundle is not None
    assert bundle.descriptor.descriptor_digest == candidate.install_descriptor_digest
    assert bundle.descriptor.plan_digest == candidate.install_plan_digest
    assert bundle.descriptor.provenance_digest == _digest("raw-installation-snapshot")
    assert bundle.installation_snapshot_digest == prepared.closure.installation_snapshot_digest
    assert prepared.material_authority is None


@pytest.mark.parametrize("actionability", ["load", "install"])
def test_actionable_catalog_composes_into_schema_v3_without_silent_drop(
    actionability: str,
) -> None:
    _layer, catalog = _open_actionable_catalog(actionability)
    observation = WorkObservation(
        signals=("testing",),
        languages=("python",),
        requested_limit=5,
    )
    prepared = catalog.prepare_query(observation=observation, host_policy=_HostPolicy())
    adapter = AuthenticatedReplayDecisionPlannerV3(
        planner=AuthenticatedNetBenefitPlanner(
            policy=POLICY,
            audit_store=_AuditStore(results={}),
        ),
        source=prepared.closure.source,
        benefit_facts_port=prepared.closure.benefit_facts,
        material_port=prepared.material_authority,
        install_bundle_port=prepared.install_authority,
        planner_version="eligible-catalog-v1",
        catalog_namespace_digest=prepared.closure.catalog_namespace_digest,
    )
    surrogate = StructuredSurrogate.create(
        schema_id="ctx.observation.current-work",
        schema_version=1,
        value={
            "active_capability_ids": [],
            "baseline_capability_ids": [],
            "languages": ["python"],
            "rejected_capability_ids": [],
            "requested_limit": 5,
            "signals": ["testing"],
        },
    )

    decision = adapter(
        surrogate,
        None,
        PlanningContext(
            planner_version="eligible-catalog-v1",
            catalog_snapshot_digest=adapter.catalog_snapshot_digest,
        ),
    )

    selections = decision.value["capabilities"]
    assert isinstance(selections, tuple)
    assert len(selections) == 1
    selection = selections[0]
    assert isinstance(selection, Mapping)
    assert selection["actionability"] == actionability


def _manual_entry(name: str) -> dict[str, object]:
    return {
        "actionability": "manual",
        "capability_id": f"skill:{name}",
        "equivalence_key": None,
        "install_bundle": None,
        "kind": "skill",
        "material_descriptor": None,
        "name": name,
    }


def test_catalog_rejects_noncanonical_entry_order_instead_of_reordering_it() -> None:
    manifest = _catalog_manifest()
    manifest["entries"] = [_manual_entry("z-last"), _manual_entry("a-first")]
    body = _canonical_bytes(manifest)

    with pytest.raises(EligibleCatalogError, match="canonical capability order"):
        load_eligible_catalog_layer_bytes(body, hashlib.sha256(body).hexdigest())


def test_catalog_and_reviewed_profiles_must_be_bijective() -> None:
    body = _canonical_bytes(_catalog_manifest())
    layer = load_eligible_catalog_layer_bytes(body, hashlib.sha256(body).hexdigest())
    profile_manifest = json.loads(_reviewed_profiles_body(layer))
    orphan = deepcopy(profile_manifest["profiles"][0])
    orphan["capability_id"] = "skill:orphan"
    orphan["name"] = "orphan"
    orphan["profile_id"] = "profile-orphan"
    orphan["catalog_entry_claim_digest"] = _digest("orphan-entry-claim")
    orphan["review_basis_digest"] = _digest("orphan-review")
    orphan["coverage_keys"] = ["orphan"]
    profile_manifest["profiles"].append(orphan)
    profiles_body = _canonical_bytes(profile_manifest)
    profiles = ReviewedBenefitAuthorities.create(
        (
            load_reviewed_benefit_profiles_bytes(
                profiles_body,
                hashlib.sha256(profiles_body).hexdigest(),
            ),
        )
    )

    with pytest.raises(EligibleCatalogError, match="one-to-one"):
        open_reviewed_query_catalog(layers=(layer,), profiles=profiles, policy=POLICY)


def _open_large_catalog_with_target(
    *,
    noise_context_tokens: int,
    noise_equivalence_key: str | None = None,
):
    manifest = _catalog_manifest()
    names = [f"noise-{index:03d}" for index in range(513)] + ["target"]
    manifest["entries"] = [_manual_entry(name) for name in names]
    if noise_equivalence_key is not None:
        raw_entries = manifest["entries"]
        assert isinstance(raw_entries, list)
        for entry in raw_entries:
            assert isinstance(entry, dict)
            if entry["name"] != "target":
                entry["equivalence_key"] = noise_equivalence_key
    body = _canonical_bytes(manifest)
    layer = load_eligible_catalog_layer_bytes(body, hashlib.sha256(body).hexdigest())
    profile_manifest = json.loads(_reviewed_profiles_body(layer))
    prototype = profile_manifest["profiles"][0]
    records = []
    for entry in layer.entries:
        record = deepcopy(prototype)
        record["capability_id"] = entry.capability_id
        record["name"] = entry.name
        record["profile_id"] = f"profile-{entry.name}"
        record["catalog_entry_claim_digest"] = entry.catalog_entry_claim_digest
        record["review_basis_digest"] = _digest(f"review:{entry.capability_id}")
        record["coverage_keys"] = [entry.name]
        record["costs"]["context_tokens"] = 120 if entry.name == "target" else noise_context_tokens
        record["maximum_relevance_ppm"] = 500_000 if entry.name == "target" else 1_000_000
        record["match_policy"]["allowed_equivalence_keys"] = (
            [] if noise_equivalence_key is None else [noise_equivalence_key]
        )
        records.append(record)
    profile_manifest["profiles"] = records
    profiles_body = _canonical_bytes(profile_manifest)
    profiles = ReviewedBenefitAuthorities.create(
        (
            load_reviewed_benefit_profiles_bytes(
                profiles_body,
                hashlib.sha256(profiles_body).hexdigest(),
            ),
        )
    )
    return open_reviewed_query_catalog(
        layers=(layer,),
        profiles=profiles,
        policy=POLICY,
    )


def test_net_benefit_filter_runs_before_the_512_candidate_bound() -> None:
    catalog = _open_large_catalog_with_target(noise_context_tokens=1_000_000)
    observation = WorkObservation(
        signals=("testing",),
        languages=("python",),
        requested_limit=5,
    )

    prepared = catalog.prepare_query(observation=observation, host_policy=_HostPolicy())

    assert tuple(
        candidate.capability_id for candidate in prepared.closure.source.retrieve(observation)
    ) == ("skill:target",)


@dataclass
class _TargetOnlyHostPolicy(_HostPolicy):
    def eligibility_for(
        self,
        presentation: CapabilityCandidate,
        claim: EligibleCatalogClaim,
    ) -> QueryCapabilityEligibility:
        return QueryCapabilityEligibility(
            presentation_digest=capability_presentation_digest(presentation),
            catalog_entry_claim_digest=claim.catalog_entry_claim_digest,
            catalog_claim_digest=eligible_catalog_claim_digest(claim),
            available=presentation.capability_id == "skill:target",
            permissions_allowed=True,
            credentials_available=True,
        )


def test_host_feasibility_filter_runs_before_the_512_candidate_bound() -> None:
    catalog = _open_large_catalog_with_target(noise_context_tokens=120)
    observation = WorkObservation(
        signals=("testing",),
        languages=("python",),
        requested_limit=5,
    )

    prepared = catalog.prepare_query(
        observation=observation,
        host_policy=_TargetOnlyHostPolicy(),
    )

    assert tuple(
        candidate.capability_id for candidate in prepared.closure.source.retrieve(observation)
    ) == ("skill:target",)


def test_equivalent_high_score_rows_cannot_poison_the_512_candidate_bound() -> None:
    catalog = _open_large_catalog_with_target(
        noise_context_tokens=120,
        noise_equivalence_key="noise-equivalent",
    )
    observation = WorkObservation(
        signals=("testing",),
        languages=("python",),
        requested_limit=5,
    )

    prepared = catalog.prepare_query(observation=observation, host_policy=_HostPolicy())
    candidates = prepared.closure.source.retrieve(observation)

    assert "skill:target" in {candidate.capability_id for candidate in candidates}
    assert len(candidates) <= 512


def test_distinct_feasible_frontier_over_512_fails_closed() -> None:
    catalog = _open_large_catalog_with_target(noise_context_tokens=120)
    observation = WorkObservation(
        signals=("testing",),
        languages=("python",),
        requested_limit=5,
    )

    with pytest.raises(EligibleCatalogError, match="exact bounded policy frontier"):
        catalog.prepare_query(observation=observation, host_policy=_HostPolicy())


def test_equivalence_dominance_preserves_inbound_conflict_alternatives() -> None:
    manifest = _catalog_manifest()
    names = ["a", "b", *(f"noise-{index:03d}" for index in range(511)), "peer"]
    entries = [_manual_entry(name) for name in names]
    for raw_entry in entries:
        if raw_entry["name"] in {"a", "b"}:
            raw_entry["equivalence_key"] = "tool-equivalent"
        elif str(raw_entry["name"]).startswith("noise-"):
            raw_entry["equivalence_key"] = "noise-equivalent"
    manifest["entries"] = entries
    body = _canonical_bytes(manifest)
    layer = load_eligible_catalog_layer_bytes(body, hashlib.sha256(body).hexdigest())
    profile_manifest = json.loads(_reviewed_profiles_body(layer))
    prototype = profile_manifest["profiles"][0]
    records = []
    for catalog_entry in layer.entries:
        record = deepcopy(prototype)
        record["capability_id"] = catalog_entry.capability_id
        record["name"] = catalog_entry.name
        record["profile_id"] = f"profile-{catalog_entry.name}"
        record["catalog_entry_claim_digest"] = catalog_entry.catalog_entry_claim_digest
        record["review_basis_digest"] = _digest(f"review:{catalog_entry.capability_id}")
        record["coverage_keys"] = [catalog_entry.name]
        record["conflicts"] = ["skill:a"] if catalog_entry.name == "peer" else []
        record["maximum_relevance_ppm"] = {
            "a": 1_000_000,
            "b": 900_000,
            "peer": 950_000,
        }.get(catalog_entry.name, 800_000)
        record["match_policy"]["allowed_equivalence_keys"] = [
            "noise-equivalent",
            "tool-equivalent",
        ]
        records.append(record)
    profile_manifest["profiles"] = records
    profiles_body = _canonical_bytes(profile_manifest)
    profiles = ReviewedBenefitAuthorities.create(
        (
            load_reviewed_benefit_profiles_bytes(
                profiles_body,
                hashlib.sha256(profiles_body).hexdigest(),
            ),
        )
    )
    catalog = open_reviewed_query_catalog(
        layers=(layer,),
        profiles=profiles,
        policy=POLICY,
    )
    observation = WorkObservation(
        signals=("testing",),
        languages=("python",),
        requested_limit=5,
    )

    prepared = catalog.prepare_query(observation=observation, host_policy=_HostPolicy())
    retained = {value.capability_id for value in prepared.closure.source.retrieve(observation)}

    assert {"skill:a", "skill:b", "skill:peer"}.issubset(retained)


def test_prepared_query_cannot_be_constructed_by_callers() -> None:
    _layer, catalog = _open_catalog()
    observation = WorkObservation(
        signals=("testing",),
        languages=("python",),
        requested_limit=5,
    )
    prepared = catalog.prepare_query(observation=observation, host_policy=_HostPolicy())

    with pytest.raises(TypeError, match="catalog factory"):
        PreparedEligibleCatalogQuery(
            closure=prepared.closure,
            material_authority=None,
            install_authority=None,
        )


class _OverlongLayerSequence(Sequence[EligibleCatalogLayer]):
    def __len__(self) -> int:
        return 65

    def __iter__(self) -> Iterator[EligibleCatalogLayer]:
        raise AssertionError("layer input was read beyond its declared bound")

    @overload
    def __getitem__(self, index: int) -> EligibleCatalogLayer: ...

    @overload
    def __getitem__(self, index: slice) -> Sequence[EligibleCatalogLayer]: ...

    def __getitem__(
        self,
        index: int | slice,
    ) -> EligibleCatalogLayer | Sequence[EligibleCatalogLayer]:
        raise AssertionError(f"layer input index {index!r} was read before the length bound")


def test_catalog_layer_input_is_bounded_before_materialization() -> None:
    _layer, catalog = _open_catalog()

    with pytest.raises(EligibleCatalogError, match="bounded"):
        open_reviewed_query_catalog(
            layers=_OverlongLayerSequence(),
            profiles=catalog._profiles,
            policy=POLICY,
        )


@pytest.mark.parametrize("actionability", ["load", "install"])
def test_actionable_authority_survives_multi_layer_aggregation(
    actionability: str,
) -> None:
    ctx_layer, single_catalog = _open_actionable_catalog(actionability)
    ctx_profile = single_catalog._profiles.authorities[0]

    user_manifest = _catalog_manifest()
    user_manifest["authority"] = {
        "authority_digest": _digest("user-authority"),
        "authority_id": "user-local",
        "authority_kind": "user",
        "catalog_layer_kind": "user",
        "sequence": 1,
    }
    user_manifest["bindings"] = {
        "candidate_projection_version": "ctx.benefit-eligible-entry-v1",
        "catalog_namespace_digest": _digest("user-catalog-namespace"),
        "catalog_provenance_digest": _digest("user-catalog-provenance"),
        "installation_snapshot_digest": None,
        "material_snapshot_digest": None,
    }
    user_manifest["entries"] = [_manual_entry("user-helper")]
    user_body = _canonical_bytes(user_manifest)
    user_layer = load_eligible_catalog_layer_bytes(
        user_body,
        hashlib.sha256(user_body).hexdigest(),
    )
    user_profiles_body = _reviewed_profiles_body(user_layer)
    user_profile = load_reviewed_benefit_profiles_bytes(
        user_profiles_body,
        hashlib.sha256(user_profiles_body).hexdigest(),
    )
    profiles = ReviewedBenefitAuthorities.create((ctx_profile, user_profile))
    catalog = open_reviewed_query_catalog(
        layers=(ctx_layer, user_layer),
        profiles=profiles,
        policy=POLICY,
    )
    observation = WorkObservation(
        signals=("testing",),
        languages=("python",),
        requested_limit=5,
    )
    prepared = catalog.prepare_query(observation=observation, host_policy=_HostPolicy())
    candidate = next(
        value
        for value in prepared.closure.source.retrieve(observation)
        if value.capability_id == "skill:ctx-python-testing"
    )

    if actionability == "load":
        assert prepared.material_authority is not None
        load_bundle = prepared.material_authority.load_bundle(candidate)
        assert load_bundle is not None
        assert load_bundle.descriptor.provenance_digest == ctx_layer.material_snapshot_digest
        assert load_bundle.authority_material_snapshot_digest == ctx_layer.material_snapshot_digest
        assert load_bundle.material_snapshot_digest == profiles.material_snapshot_digest
        assert (
            load_bundle.material_snapshot_digest != load_bundle.authority_material_snapshot_digest
        )
    else:
        assert prepared.install_authority is not None
        install_bundle = prepared.install_authority.describe_bundle(
            candidate.capability_id,
            candidate.kind,
        )
        assert isinstance(install_bundle, AuthorityBoundInstallPlanningBundle)
        assert install_bundle.descriptor.provenance_digest == ctx_layer.installation_snapshot_digest
        assert install_bundle.authority_installation_snapshot_digest == (
            ctx_layer.installation_snapshot_digest
        )
        assert install_bundle.installation_snapshot_digest == profiles.installation_snapshot_digest
        assert install_bundle.installation_snapshot_digest != (
            install_bundle.authority_installation_snapshot_digest
        )

    adapter = AuthenticatedReplayDecisionPlannerV3(
        planner=AuthenticatedNetBenefitPlanner(
            policy=POLICY,
            audit_store=_AuditStore(results={}),
        ),
        source=prepared.closure.source,
        benefit_facts_port=prepared.closure.benefit_facts,
        material_port=prepared.material_authority,
        install_bundle_port=prepared.install_authority,
        planner_version="eligible-catalog-v1",
        catalog_namespace_digest=prepared.closure.catalog_namespace_digest,
    )
    decision = adapter(
        StructuredSurrogate.create(
            schema_id="ctx.observation.current-work",
            schema_version=1,
            value={
                "active_capability_ids": [],
                "baseline_capability_ids": [],
                "languages": ["python"],
                "rejected_capability_ids": [],
                "requested_limit": 5,
                "signals": ["testing"],
            },
        ),
        None,
        PlanningContext(
            planner_version="eligible-catalog-v1",
            catalog_snapshot_digest=adapter.catalog_snapshot_digest,
        ),
    )
    raw_selections = decision.value["capabilities"]
    assert isinstance(raw_selections, tuple)
    selected: dict[str, str] = {}
    for raw_selection in raw_selections:
        assert isinstance(raw_selection, Mapping)
        capability_id = raw_selection["capability_id"]
        selected_actionability = raw_selection["actionability"]
        assert isinstance(capability_id, str)
        assert isinstance(selected_actionability, str)
        selected[capability_id] = selected_actionability
    assert selected["skill:ctx-python-testing"] == actionability


@pytest.mark.parametrize("actionability", ["load", "install"])
def test_actionable_entry_rejects_cross_capability_planning_authority(
    actionability: str,
) -> None:
    raw_snapshot = _digest(f"raw-{actionability}-snapshot")
    aggregate = _aggregate_binding(f"{actionability}ation_snapshot_digest", raw_snapshot)
    if actionability == "load":
        aggregate = _aggregate_binding("material_snapshot_digest", raw_snapshot)
    other_material = MaterialIdentity.create(
        capability_id="skill:other",
        kind="skill",
        content_sha256=_digest("other-content"),
        content_bytes=100,
    )
    material_descriptor = None
    install_bundle = None
    if actionability == "load":
        material_descriptor = MaterialDescriptor.create(
            capability_id="skill:other",
            kind="skill",
            actionability="load",
            content_sha256=other_material.content_sha256,
            content_bytes=other_material.content_bytes,
            estimated_tokens=25,
            provenance_digest=aggregate,
            material_identity_digest=other_material.identity_digest,
        )
    else:
        install_bundle = InstallPlanningBundle(
            descriptor=InstallPlanDescriptor.create(
                capability_id="skill:other",
                kind="skill",
                installer_id="ctx-skill-cas",
                plan_digest=_digest("other-plan"),
                provenance_digest=aggregate,
                result_material_identity_digest=other_material.identity_digest,
            ),
            result_material=other_material,
        )
    body = _canonical_bytes(
        _catalog_manifest(
            actionability=actionability,
            material_snapshot_digest=raw_snapshot if actionability == "load" else None,
            installation_snapshot_digest=(raw_snapshot if actionability == "install" else None),
            material_descriptor=material_descriptor,
            install_bundle=install_bundle,
        )
    )

    with pytest.raises(EligibleCatalogError, match="planning authority"):
        load_eligible_catalog_layer_bytes(body, hashlib.sha256(body).hexdigest())