src/tests/runtime/test_benefit_closure.py

from __future__ import annotations

import hashlib
import json
import traceback
from collections.abc import Iterator, Sequence
from dataclasses import dataclass, field, replace
from pathlib import Path
from typing import cast, overload

import pytest

from ctx.engine.benefit import NetBenefitPolicy
from ctx.engine.planner import CapabilityCandidate, PlannerValidationError, WorkObservation
from ctx.runtime.benefit_closure import (
    BenefitClosureError,
    EligibleCatalogClaim,
    QueryCapabilityEligibility,
    QueryHostPolicyAuthority,
    ReviewedBenefitAuthorities,
    ReviewedBenefitProfiles,
    catalog_candidate_entry_claim_digest,
    eligible_catalog_claim_digest,
    load_reviewed_benefit_profiles,
    load_reviewed_benefit_profiles_bytes,
    prepare_query_benefit_closure,
)
from ctx.runtime.planning_v3 import normalize_candidate_pool


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("reviewed-calibration")
CATALOG_SNAPSHOT_DIGEST = _digest("eligible-catalog-snapshot")
ELIGIBILITY_DIGEST = _digest("eligible-catalog-index")
HOST_POLICY_DIGEST = _digest("query-host-policy")
POLICY = NetBenefitPolicy(calibration_digest=CALIBRATION_DIGEST, minimum_relevance_ppm=1)


def _profile_record(
    *,
    capability_id: str = "skill:ctx-python-testing",
    actionability: str = "manual",
    entry_claim_digest: str | None = None,
    minimum_matching_signals: int = 2,
    minimum_non_language_matching_signals: int = 1,
    allowed_signals: list[str] | None = None,
) -> dict[str, object]:
    kind, name = capability_id.split(":", 1)
    return {
        "actionability": actionability,
        "capability_id": capability_id,
        "catalog_entry_claim_digest": entry_claim_digest
        or catalog_candidate_entry_claim_digest(
            _candidate(capability_id=capability_id, actionability=actionability)
        ),
        "complements": [],
        "conflicts": [],
        "costs": {
            "approval_prompts": 0,
            "child_agent_units": 0,
            "context_tokens": 180,
            "credential_burden_units": 0,
            "permission_burden_units": 0,
            "process_units": 0,
            "runtime_millis": 0,
            "tool_schema_tokens": 0,
        },
        "coverage_keys": [f"coverage-{name}"],
        "expected_task_benefit_ppm": 500_000,
        "kind": kind,
        "match_policy": {
            "allowed_equivalence_keys": [],
            "allowed_reason_codes": ["graph-match", "signal-match"],
            "allowed_signals": allowed_signals or ["python", "testing"],
            "minimum_matching_signals": minimum_matching_signals,
            "minimum_non_language_matching_signals": minimum_non_language_matching_signals,
            "required_any_signals": ["testing"],
        },
        "maximum_relevance_ppm": 700_000,
        "name": name,
        "profile_id": f"profile-{name}",
        "review_basis_digest": _digest(f"review-basis:{capability_id}"),
        "security_approved": True,
        "source_trusted": True,
        "trust_ppm": 900_000,
    }


def _manifest(
    *profiles: dict[str, object],
    authority_id: str = "ctx-release",
    authority_kind: str = "ctx-release",
    catalog_layer_kind: str = "ctx",
    sequence: int = 1,
) -> dict[str, object]:
    ordered = sorted(
        profiles or (_profile_record(),),
        key=lambda value: (
            str(value["capability_id"]),
            str(value["actionability"]),
            str(value["profile_id"]),
        ),
    )
    return {
        "authority": {
            "authority_digest": _digest(f"benefit-authority:{authority_id}:{sequence}"),
            "authority_id": authority_id,
            "authority_kind": authority_kind,
            "catalog_layer_kind": catalog_layer_kind,
            "sequence": sequence,
        },
        "bindings": {
            "calibration_digest": CALIBRATION_DIGEST,
            "candidate_projection_version": "ctx.catalog-entry.graph-v4",
            "catalog_artifact_sha256": _digest(f"eligible-catalog-artifact:{authority_id}"),
            "catalog_namespace_digest": _digest(f"catalog-namespace:{authority_id}"),
            "catalog_provenance_digest": _digest(f"catalog-provenance:{authority_id}"),
            "catalog_retrieval_snapshot_digest": _digest(f"catalog-retrieval:{authority_id}"),
            "installation_snapshot_digest": None,
            "material_snapshot_digest": None,
            "policy_digest": POLICY.policy_digest,
        },
        "profiles": ordered,
        "schema": "ctx.reviewed-benefit-profiles-v2",
    }


def _authority(
    *records: dict[str, object],
    authority_id: str = "ctx-release",
    authority_kind: str = "ctx-release",
    catalog_layer_kind: str = "ctx",
    sequence: int = 1,
) -> ReviewedBenefitProfiles:
    body = _canonical_bytes(
        _manifest(
            *records,
            authority_id=authority_id,
            authority_kind=authority_kind,
            catalog_layer_kind=catalog_layer_kind,
            sequence=sequence,
        )
    )
    return load_reviewed_benefit_profiles_bytes(body, hashlib.sha256(body).hexdigest())


def _authorities(*values: ReviewedBenefitProfiles) -> ReviewedBenefitAuthorities:
    return ReviewedBenefitAuthorities.create(values or (_authority(),))


def _candidate(
    *,
    capability_id: str = "skill:ctx-python-testing",
    matching_signals: tuple[str, ...] = ("python", "testing"),
    actionability: str = "manual",
    reason_codes: tuple[str, ...] = ("graph-match", "signal-match"),
) -> CapabilityCandidate:
    kind, name = capability_id.split(":", 1)
    return CapabilityCandidate(
        capability_id=capability_id,
        kind=kind,
        name=name,
        source_digest=_digest(f"source:{capability_id}:{actionability}"),
        normalized_score_ppm=700_000,
        matching_signals=matching_signals,
        reason_codes=reason_codes,
        actionability=actionability,
        install_descriptor_digest=(
            _digest(f"install-descriptor:{capability_id}") if actionability == "install" else None
        ),
        install_plan_digest=(
            _digest(f"install-plan:{capability_id}") if actionability == "install" else None
        ),
    )


def _observation(
    *,
    signals: tuple[str, ...] = ("testing",),
    languages: tuple[str, ...] = ("python",),
    baseline: tuple[str, ...] = (),
    rejected: tuple[str, ...] = (),
) -> WorkObservation:
    return WorkObservation(
        signals=signals,
        languages=languages,
        baseline_capability_ids=baseline,
        rejected_capability_ids=rejected,
        requested_limit=5,
    )


@dataclass
class _EligibleSource:
    candidates: object
    claims: dict[str, EligibleCatalogClaim]
    catalog_snapshot_digest: str
    catalog_retrieval_snapshot_digest: str
    catalog_namespace_digest: str
    catalog_provenance_digest: str
    catalog_artifact_sha256: str
    candidate_projection_version: str
    material_snapshot_digest: str | None
    installation_snapshot_digest: str | None
    profile_snapshot_digest: str
    authority_snapshot_digest: str
    eligibility_snapshot_digest: str
    calibration_digest: str
    policy_digest: str
    close_calls: int = 0
    cleanup_failure: bool = False
    retrieve_calls: int = 0
    claim_calls: int = 0
    candidate_rounds: tuple[object, ...] = ()
    claim_rounds: dict[str, tuple[EligibleCatalogClaim, ...]] = field(default_factory=dict)
    drift_binding_on_retrieve: bool = False
    drift_binding_on_claim: bool = False
    explode_at: str | None = None
    leak_cleanup_class: bool = False

    def retrieve(self, _observation: WorkObservation) -> Sequence[CapabilityCandidate]:
        if self.explode_at == "retrieve":
            raise RuntimeError("/Users/alice/private-repo sk-live-secret")
        self.retrieve_calls += 1
        value = (
            self.candidate_rounds[min(self.retrieve_calls - 1, len(self.candidate_rounds) - 1)]
            if self.candidate_rounds
            else self.candidates
        )
        if self.drift_binding_on_retrieve:
            self.catalog_provenance_digest = _digest("drifted-during-retrieve")
        return cast(Sequence[CapabilityCandidate], value)

    def entry_claim(self, presentation: CapabilityCandidate) -> EligibleCatalogClaim:
        if self.explode_at == "claim":
            raise RuntimeError("/Users/alice/private-repo sk-live-secret")
        self.claim_calls += 1
        rounds = self.claim_rounds.get(presentation.capability_id, ())
        value = (
            rounds[min(self.claim_calls - 1, len(rounds) - 1)]
            if rounds
            else self.claims[presentation.capability_id]
        )
        if self.drift_binding_on_claim:
            self.catalog_provenance_digest = _digest("drifted-during-claim")
        return value

    def close(self) -> None:
        self.close_calls += 1
        if self.leak_cleanup_class:
            raise Alice_private_repo_sk_live_secret
        if self.explode_at == "close":
            raise RuntimeError("/Users/alice/private-repo sk-live-secret")
        if self.cleanup_failure:
            raise RuntimeError("cleanup sentinel")


class Alice_private_repo_sk_live_secret(RuntimeError):
    pass


class _ExplodingAttributeSource:
    def __init__(self, source: _EligibleSource, attribute: str) -> None:
        self._source = source
        self._attribute = attribute

    def __getattr__(self, name: str) -> object:
        if name == self._attribute:
            raise RuntimeError("/Users/alice/private-repo sk-live-secret")
        return getattr(self._source, name)


def _source(
    profiles: ReviewedBenefitAuthorities,
    *candidates: CapabilityCandidate,
    claim_authorities: dict[str, ReviewedBenefitProfiles] | None = None,
) -> _EligibleSource:
    values = candidates or (_candidate(),)
    authority_by_id = claim_authorities or {
        candidate.capability_id: profiles.authorities[0] for candidate in values
    }
    claims = {
        candidate.capability_id: EligibleCatalogClaim.create(
            authority_by_id[candidate.capability_id],
            presentation=candidate,
        )
        for candidate in values
    }
    return _EligibleSource(
        candidates=values,
        claims=claims,
        catalog_snapshot_digest=CATALOG_SNAPSHOT_DIGEST,
        catalog_retrieval_snapshot_digest=profiles.catalog_retrieval_snapshot_digest,
        catalog_namespace_digest=profiles.catalog_namespace_digest,
        catalog_provenance_digest=profiles.catalog_provenance_digest,
        catalog_artifact_sha256=profiles.catalog_artifact_sha256,
        candidate_projection_version=profiles.candidate_projection_version,
        material_snapshot_digest=profiles.material_snapshot_digest,
        installation_snapshot_digest=profiles.installation_snapshot_digest,
        profile_snapshot_digest=profiles.profile_snapshot_digest,
        authority_snapshot_digest=profiles.authority_snapshot_digest,
        eligibility_snapshot_digest=ELIGIBILITY_DIGEST,
        calibration_digest=profiles.calibration_digest,
        policy_digest=profiles.policy_digest,
    )


@dataclass
class _HostPolicy:
    host_policy_snapshot_digest: str = HOST_POLICY_DIGEST
    available: bool = True
    permissions_allowed: bool = True
    credentials_available: bool = True
    return_none: bool = False
    drift: bool = False
    claim_digest_override: str | None = None
    explode: bool = False
    calls: int = 0

    def eligibility_for(
        self,
        presentation: CapabilityCandidate,
        claim: EligibleCatalogClaim,
    ) -> QueryCapabilityEligibility | None:
        if self.explode:
            raise RuntimeError("/Users/alice/private-repo sk-live-secret")
        self.calls += 1
        if self.return_none:
            return None
        result = QueryCapabilityEligibility(
            presentation_digest=_presentation_digest(presentation),
            catalog_entry_claim_digest=claim.catalog_entry_claim_digest,
            catalog_claim_digest=(
                self.claim_digest_override or eligible_catalog_claim_digest(claim)
            ),
            available=self.available,
            permissions_allowed=self.permissions_allowed,
            credentials_available=self.credentials_available,
        )
        if self.drift:
            self.host_policy_snapshot_digest = _digest("drifted-host-policy")
        return result


def _presentation_digest(candidate: CapabilityCandidate) -> str:
    from ctx.runtime.authenticated_benefit import capability_presentation_digest

    return capability_presentation_digest(candidate)


def _prepare(
    profiles: ReviewedBenefitAuthorities,
    source: _EligibleSource,
    *,
    observation: WorkObservation | object | None = None,
    host_policy: _HostPolicy | None = None,
):  # type: ignore[no-untyped-def]
    return prepare_query_benefit_closure(
        source=source,
        observation=observation if observation is not None else _observation(),  # type: ignore[arg-type]
        profiles=profiles,
        policy=POLICY,
        host_policy=host_policy or _HostPolicy(),
    )


def test_reviewed_profiles_load_from_exact_file_and_frozen_bytes(tmp_path: Path) -> None:
    body = _canonical_bytes(_manifest())
    expected_sha256 = hashlib.sha256(body).hexdigest()
    path = tmp_path / "reviewed-benefit-profiles.json"
    path.write_bytes(body)
    path.chmod(0o444)

    from_path = load_reviewed_benefit_profiles(path, expected_sha256)
    from_bytes = load_reviewed_benefit_profiles_bytes(body, expected_sha256)

    assert from_path == from_bytes
    assert from_path.profile_snapshot_digest == expected_sha256
    assert from_path.policy_digest == POLICY.policy_digest
    assert len(from_path.profiles) == 1


@pytest.mark.parametrize(
    "mutation",
    ["unknown-root", "wrong-layer", "duplicate-profile", "unreviewed-signal"],
)
def test_reviewed_profiles_reject_non_closed_cross_authority_or_ambiguous_input(
    mutation: str,
) -> None:
    manifest = _manifest()
    if mutation == "unknown-root":
        manifest["description"] = "catalog prose is not profile authority"
    elif mutation == "wrong-layer":
        manifest["authority"]["catalog_layer_kind"] = "user"  # type: ignore[index]
    elif mutation == "duplicate-profile":
        manifest["profiles"] = [manifest["profiles"][0], manifest["profiles"][0]]  # type: ignore[index]
    else:
        manifest["profiles"][0]["match_policy"]["required_any_signals"] = ["secret"]  # type: ignore[index]
    body = _canonical_bytes(manifest)

    with pytest.raises(BenefitClosureError):
        load_reviewed_benefit_profiles_bytes(body, hashlib.sha256(body).hexdigest())


def test_query_closure_freezes_exact_presentations_authorities_policy_and_facts() -> None:
    profiles = _authorities()
    observation = _observation()
    raw_source = _source(profiles)

    closure = _prepare(profiles, raw_source, observation=observation)

    assert raw_source.close_calls == 1
    assert raw_source.retrieve_calls == 2
    assert closure.source.retrieve(observation) == (_candidate(),)
    facts = closure.benefit_facts.benefit_candidate(_candidate(), observation)
    assert facts is not None
    assert facts.expected_task_benefit_ppm == 500_000
    assert facts.relevance_ppm == 700_000
    assert facts.costs is not None and facts.costs.context_tokens == 180
    assert closure.authority_snapshot_digest == profiles.authority_snapshot_digest
    assert closure.policy is POLICY
    assert closure.policy_digest == POLICY.policy_digest
    assert closure.upstream_host_policy_snapshot_digest == HOST_POLICY_DIGEST
    assert (
        closure.host_policy_snapshot_digest
        == closure.host_policy_authority.host_policy_snapshot_digest
    )
    assert closure.closure_snapshot_digest == closure.source.catalog_snapshot_digest

    with pytest.raises(PlannerValidationError, match="observation mismatch"):
        closure.source.retrieve(WorkObservation(signals=("security",), languages=("python",)))
    closure.source.close()
    with pytest.raises(PlannerValidationError, match="closed"):
        closure.source.retrieve(observation)


def test_query_closure_value_recomputes_its_public_pins() -> None:
    profiles = _authorities()
    closure = _prepare(profiles, _source(profiles))

    with pytest.raises(TypeError, match="closure factory"):
        replace(closure, policy_digest=_digest("substituted-policy"))


def test_reviewed_values_recompute_profile_and_manifest_membership() -> None:
    authority = _authority()

    with pytest.raises(BenefitClosureError, match="profile_digest"):
        replace(authority.profiles[0], source_trusted=False)
    with pytest.raises(BenefitClosureError, match="profile_snapshot_digest"):
        replace(authority, sequence=2)


def test_query_closure_rejects_forged_claim_outside_advertised_authorities() -> None:
    profiles = _authorities()
    closure = _prepare(profiles, _source(profiles))
    candidate = closure.source.retrieve(_observation())[0]
    user_authority = _authority(
        authority_id="local-user",
        authority_kind="user",
        catalog_layer_kind="user",
    )
    forged_claim = EligibleCatalogClaim.create(user_authority, presentation=candidate)
    forged_host_fact = replace(
        closure.host_eligibilities[0],
        catalog_entry_claim_digest=forged_claim.catalog_entry_claim_digest,
        catalog_claim_digest=eligible_catalog_claim_digest(forged_claim),
    )

    with pytest.raises(TypeError, match="closure factory"):
        replace(
            closure,
            catalog_claims=(forged_claim,),
            host_eligibilities=(forged_host_fact,),
        )


@pytest.mark.parametrize(
    "field_name",
    [
        "catalog_entry_claim_digest",
        "presentation_digest",
    ],
)
def test_query_closure_rechecks_claim_on_reconstruction(field_name: str) -> None:
    profiles = _authorities()
    closure = _prepare(profiles, _source(profiles))
    original_claim = closure.catalog_claims[0]
    forged_claim = replace(original_claim, **{field_name: _digest(f"other-{field_name}")})
    forged_host_fact = replace(
        closure.host_eligibilities[0],
        catalog_claim_digest=eligible_catalog_claim_digest(forged_claim),
    )

    with pytest.raises(TypeError, match="closure factory"):
        replace(
            closure,
            catalog_claims=(forged_claim,),
            host_eligibilities=(forged_host_fact,),
        )


def test_query_closure_supports_independent_ctx_and_user_authorities() -> None:
    ctx_authority = _authority()
    user_candidate = _candidate(capability_id="agent:user-reviewer")
    user_claim = catalog_candidate_entry_claim_digest(user_candidate)
    user_authority = _authority(
        _profile_record(
            capability_id=user_candidate.capability_id,
            entry_claim_digest=user_claim,
        ),
        authority_id="local-user",
        authority_kind="user",
        catalog_layer_kind="user",
    )
    profiles = _authorities(ctx_authority, user_authority)
    source = _source(
        profiles,
        _candidate(),
        user_candidate,
        claim_authorities={
            "skill:ctx-python-testing": ctx_authority,
            user_candidate.capability_id: user_authority,
        },
    )

    closure = _prepare(profiles, source)

    assert {item.capability_id for item in closure.source.retrieve(_observation())} == {
        "skill:ctx-python-testing",
        "agent:user-reviewer",
    }


def test_host_policy_cannot_reuse_same_entry_digest_across_authorities() -> None:
    candidate = _candidate()
    ctx_authority = _authority()
    user_authority = _authority(
        authority_id="local-user",
        authority_kind="user",
        catalog_layer_kind="user",
    )
    profiles = _authorities(ctx_authority, user_authority)
    source = _source(
        profiles,
        candidate,
        claim_authorities={candidate.capability_id: ctx_authority},
    )
    user_claim = EligibleCatalogClaim.create(user_authority, presentation=candidate)

    with pytest.raises(BenefitClosureError, match="cross-authority"):
        _prepare(
            profiles,
            source,
            host_policy=_HostPolicy(
                claim_digest_override=eligible_catalog_claim_digest(user_claim)
            ),
        )


def test_query_closure_abstains_on_unobserved_or_unreviewed_presentation_tokens() -> None:
    profiles = _authorities()
    unobserved = _candidate(matching_signals=("testing",))
    source = _source(profiles, unobserved)
    observation = _observation(signals=("security",), languages=("python",))

    closure = _prepare(profiles, source, observation=observation)
    assert closure.source.retrieve(observation) == ()

    private_reason = _candidate(reason_codes=("graph-match", "sk-live-secret-token"))
    source = _source(profiles, private_reason)
    closure = _prepare(profiles, source)
    assert closure.source.retrieve(_observation()) == ()


def test_query_closure_is_deterministic_and_weak_matches_abstain() -> None:
    profiles = _authorities()
    observation = _observation()
    first = _prepare(
        profiles,
        _source(profiles, _candidate(matching_signals=("python",))),
        observation=observation,
    )
    second = _prepare(
        profiles,
        _source(profiles, _candidate(matching_signals=("python",))),
        observation=observation,
    )

    assert first.source.retrieve(observation) == ()
    assert first.benefit_facts.presentation_digests == ()
    assert first.closure_snapshot_digest == second.closure_snapshot_digest


@pytest.mark.parametrize("excluded", ["baseline", "rejected"])
def test_query_closure_applies_shared_eligibility_before_requiring_profiles(excluded: str) -> None:
    profiles = _authorities()
    unprofiled = _candidate(capability_id="agent:unprofiled-reviewer")
    observation = _observation(
        baseline=(unprofiled.capability_id,) if excluded == "baseline" else (),
        rejected=(unprofiled.capability_id,) if excluded == "rejected" else (),
    )
    source = _source(profiles, unprofiled)

    closure = _prepare(profiles, source, observation=observation)

    assert closure.source.retrieve(observation) == ()
    assert source.claim_calls == 0
    assert source.close_calls == 1


def test_query_closure_rejects_unreviewed_or_authority_substituted_claim() -> None:
    profiles = _authorities()
    unreviewed = _candidate(capability_id="agent:unreviewed")
    source = _source(profiles, unreviewed)

    with pytest.raises(BenefitClosureError, match="without an exact reviewed profile"):
        _prepare(profiles, source)
    assert source.close_calls == 1

    user_authority = _authority(
        authority_id="local-user",
        authority_kind="user",
        catalog_layer_kind="user",
    )
    substituted = _source(profiles)
    substituted.claims["skill:ctx-python-testing"] = EligibleCatalogClaim.create(
        user_authority,
        presentation=_candidate(),
    )
    with pytest.raises(BenefitClosureError, match="without an exact reviewed profile"):
        _prepare(profiles, substituted)


def test_reviewed_install_claim_rejects_source_and_plan_substitution() -> None:
    reviewed = _candidate(actionability="install")
    authority = _authority(_profile_record(actionability="install"))
    profiles = _authorities(authority)
    substituted = replace(
        reviewed,
        source_digest=_digest("substituted-source"),
        install_descriptor_digest=_digest("substituted-descriptor"),
        install_plan_digest=_digest("substituted-plan"),
    )
    source = _source(profiles, substituted)

    with pytest.raises(BenefitClosureError, match="without an exact reviewed profile"):
        _prepare(profiles, source)

    assert source.close_calls == 1


def test_query_closure_requires_the_exact_reviewed_policy() -> None:
    manifest = _manifest()
    manifest["bindings"]["policy_digest"] = _digest("different-reviewed-policy")  # type: ignore[index]
    body = _canonical_bytes(manifest)
    authority = load_reviewed_benefit_profiles_bytes(body, hashlib.sha256(body).hexdigest())
    profiles = _authorities(authority)
    source = _source(profiles)

    with pytest.raises(BenefitClosureError, match="policy does not match"):
        _prepare(profiles, source)

    assert source.close_calls == 1


@pytest.mark.parametrize("during", ["retrieve", "claim"])
def test_query_closure_rejects_binding_drift_during_source_reads(during: str) -> None:
    profiles = _authorities()
    source = _source(profiles)
    if during == "retrieve":
        source.drift_binding_on_retrieve = True
    else:
        source.drift_binding_on_claim = True

    with pytest.raises(BenefitClosureError, match="binding drift"):
        _prepare(profiles, source)
    assert source.close_calls == 1


def test_query_closure_rejects_same_digest_candidate_or_claim_drift() -> None:
    profiles = _authorities()
    candidate = _candidate()
    changed = _candidate(matching_signals=("python",))
    source = _source(profiles, candidate)
    source.candidate_rounds = ((candidate,), (changed,))
    with pytest.raises(
        BenefitClosureError,
        match="claim does not match exact presentation|changed candidates or claims",
    ):
        _prepare(profiles, source)

    source = _source(profiles, candidate)
    first_claim = source.claims[candidate.capability_id]
    second_claim = replace(first_claim, authority_digest=_digest("changed-claim-authority"))
    source.claim_rounds[candidate.capability_id] = (first_claim, second_claim)
    with pytest.raises(BenefitClosureError, match="changed candidates or claims"):
        _prepare(profiles, source)


def test_host_policy_is_query_scoped_exact_and_not_install_consent() -> None:
    profiles = _authorities()
    source = _source(profiles)
    denied = _HostPolicy(permissions_allowed=False, credentials_available=False)

    closure = _prepare(profiles, source, host_policy=denied)
    benefit = closure.benefit_facts.benefit_candidate(_candidate(), _observation())

    assert benefit is not None
    assert benefit.permissions_allowed is False
    assert benefit.credentials_available is False
    assert denied.calls == 2

    source = _source(profiles)
    unavailable = _prepare(
        profiles,
        source,
        host_policy=_HostPolicy(available=False),
    )
    assert unavailable.source.retrieve(_observation()) == ()

    source = _source(profiles)
    with pytest.raises(BenefitClosureError, match="no exact query eligibility"):
        _prepare(profiles, source, host_policy=_HostPolicy(return_none=True))

    source = _source(profiles)
    with pytest.raises(BenefitClosureError, match="drift"):
        _prepare(profiles, source, host_policy=_HostPolicy(drift=True))


def test_query_closure_rejects_reconstructed_allow_after_host_denial() -> None:
    profiles = _authorities()
    closure = _prepare(
        profiles,
        _source(profiles),
        host_policy=_HostPolicy(permissions_allowed=False, credentials_available=False),
    )
    denied = closure.host_eligibilities[0]
    forged_allow = replace(
        denied,
        permissions_allowed=True,
        credentials_available=True,
    )

    with pytest.raises(TypeError, match="closure factory"):
        replace(closure, host_eligibilities=(forged_allow,))


def test_query_closure_closes_owned_source_on_invalid_arguments() -> None:
    profiles = _authorities()
    source = _source(profiles)

    with pytest.raises(TypeError, match="observation"):
        _prepare(profiles, source, observation=object())

    assert source.close_calls == 1


def test_query_closure_preserves_primary_error_when_cleanup_also_fails() -> None:
    profiles = _authorities()
    source = _source(profiles, _candidate(capability_id="agent:unreviewed"))
    source.cleanup_failure = True

    with pytest.raises(BenefitClosureError, match="without an exact reviewed profile") as exc:
        _prepare(profiles, source)

    assert any("cleanup also failed" in note for note in (exc.value.__notes__ or []))


@pytest.mark.parametrize("boundary", ["retrieve", "claim", "host-policy", "close"])
def test_query_closure_redacts_injected_boundary_exception_messages(boundary: str) -> None:
    profiles = _authorities()
    source = _source(profiles)
    host_policy = _HostPolicy(explode=boundary == "host-policy")
    if boundary != "host-policy":
        source.explode_at = boundary

    with pytest.raises(BenefitClosureError) as exc:
        _prepare(profiles, source, host_policy=host_policy)

    assert "alice" not in str(exc.value)
    assert "sk-live-secret" not in str(exc.value)
    assert exc.value.__suppress_context__ is True


class _ExplodingSnapshotHostPolicy:
    @property
    def host_policy_snapshot_digest(self) -> str:
        raise BenefitClosureError("/Users/alice/private-repo sk-live-secret")

    def eligibility_for(
        self,
        _presentation: CapabilityCandidate,
        _claim: EligibleCatalogClaim,
    ) -> QueryCapabilityEligibility | None:
        raise AssertionError("snapshot access must fail before eligibility lookup")


class _ExplodingEligibilityAttributeHostPolicy:
    host_policy_snapshot_digest = HOST_POLICY_DIGEST

    def __getattribute__(self, name: str) -> object:
        if name == "eligibility_for":
            raise RuntimeError("/Users/alice/private-repo sk-live-secret")
        return super().__getattribute__(name)


def test_query_closure_redacts_host_policy_snapshot_property_errors() -> None:
    profiles = _authorities()
    source = _source(profiles)

    with pytest.raises(BenefitClosureError) as exc:
        prepare_query_benefit_closure(
            source=source,
            observation=_observation(),
            profiles=profiles,
            policy=POLICY,
            host_policy=_ExplodingSnapshotHostPolicy(),
        )

    assert "alice" not in str(exc.value)
    assert "sk-live-secret" not in str(exc.value)
    assert exc.value.__suppress_context__ is True


@pytest.mark.parametrize("attribute", ["retrieve", "entry_claim"])
def test_query_closure_redacts_source_callable_attribute_errors(attribute: str) -> None:
    profiles = _authorities()
    source = _source(profiles)

    with pytest.raises(BenefitClosureError) as exc:
        prepare_query_benefit_closure(
            source=_ExplodingAttributeSource(source, attribute),  # type: ignore[arg-type]
            observation=_observation(),
            profiles=profiles,
            policy=POLICY,
            host_policy=_HostPolicy(),
        )

    assert "alice" not in str(exc.value)
    assert "sk-live-secret" not in str(exc.value)
    assert exc.value.__suppress_context__ is True


def test_query_closure_redacts_host_policy_callable_attribute_errors() -> None:
    profiles = _authorities()

    with pytest.raises(BenefitClosureError) as exc:
        prepare_query_benefit_closure(
            source=_source(profiles),
            observation=_observation(),
            profiles=profiles,
            policy=POLICY,
            host_policy=cast(
                QueryHostPolicyAuthority,
                _ExplodingEligibilityAttributeHostPolicy(),
            ),
        )

    assert "alice" not in str(exc.value)
    assert "sk-live-secret" not in str(exc.value)
    assert exc.value.__suppress_context__ is True


def test_query_closure_cleanup_note_does_not_expose_injected_exception_class() -> None:
    profiles = _authorities()
    source = _source(profiles, _candidate(capability_id="agent:unreviewed"))
    source.leak_cleanup_class = True

    with pytest.raises(BenefitClosureError) as exc:
        _prepare(profiles, source)

    notes = exc.value.__notes__ or []
    assert notes == ["CTX eligible-source cleanup also failed"]
    assert "Alice" not in " ".join(notes)


class _LyingSequence(Sequence[CapabilityCandidate]):
    def __init__(self, candidate: CapabilityCandidate, actual: int) -> None:
        self.candidate = candidate
        self.actual = actual

    def __len__(self) -> int:
        return 1

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

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

    def __getitem__(
        self, index: int | slice
    ) -> CapabilityCandidate | Sequence[CapabilityCandidate]:
        if isinstance(index, slice):
            return ((self.candidate,) * self.actual)[index]
        if index < 0 or index >= self.actual:
            raise IndexError(index)
        return self.candidate

    def __iter__(self) -> Iterator[CapabilityCandidate]:
        return iter((self.candidate,) * self.actual)


def test_shared_candidate_bound_uses_realized_iteration_not_reported_length() -> None:
    with pytest.raises(PlannerValidationError, match="candidate pool limit"):
        normalize_candidate_pool(_LyingSequence(_candidate(), 513), _observation())


class _LyingAuthoritySequence(Sequence[ReviewedBenefitProfiles]):
    def __init__(self, authority: ReviewedBenefitProfiles, actual: int) -> None:
        self.authority = authority
        self.actual = actual

    def __len__(self) -> int:
        return 1

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

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

    def __getitem__(
        self, index: int | slice
    ) -> ReviewedBenefitProfiles | Sequence[ReviewedBenefitProfiles]:
        if isinstance(index, slice):
            return ((self.authority,) * self.actual)[index]
        if index < 0 or index >= self.actual:
            raise IndexError(index)
        return self.authority

    def __iter__(self) -> Iterator[ReviewedBenefitProfiles]:
        return iter((self.authority,) * self.actual)


def test_reviewed_authority_bound_uses_realized_iteration_not_reported_length() -> None:
    with pytest.raises(BenefitClosureError, match="bounded item limit"):
        ReviewedBenefitAuthorities.create(_LyingAuthoritySequence(_authority(), 65))


def test_profile_path_failures_redact_sensitive_locations_from_traceback() -> None:
    sensitive = "/private/clients/acme-secret/reviewed-benefit.json"

    with pytest.raises(BenefitClosureError) as exc:
        load_reviewed_benefit_profiles(Path(sensitive), "a" * 64)

    rendered = "".join(
        traceback.format_exception(type(exc.value), exc.value, exc.value.__traceback__)
    )
    assert sensitive not in rendered
    assert "acme-secret" not in rendered
    assert exc.value.__cause__ is None
    assert exc.value.__suppress_context__ is True