src/tests/engine/test_benefit.py

from __future__ import annotations

import hashlib
import time
from dataclasses import replace
from itertools import permutations

import pytest

from ctx import engine as engine_api
from ctx.engine.benefit import (
    MAX_CANDIDATES,
    BenefitCandidate,
    BenefitSelectionResult,
    EvidenceSummary,
    NetBenefitPolicy,
    ResourceCosts,
)


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


def _evidence(
    capability_id: str,
    *,
    source_digest: str | None = None,
    evidence_window_digest: str | None = None,
    opportunity_observable: bool = False,
    **counts: object,
) -> EvidenceSummary:
    return EvidenceSummary(
        capability_id=capability_id,
        kind=capability_id.split(":", 1)[0],
        source_digest=source_digest or _digest(capability_id),
        evidence_window_digest=evidence_window_digest
        or _digest(f"evidence-window:{capability_id}"),
        opportunity_observable=opportunity_observable,
        **counts,  # type: ignore[arg-type]
    )


def _policy(**overrides: object) -> NetBenefitPolicy:
    values: dict[str, object] = {
        "calibration_digest": _digest("calibration-v1"),
        "minimum_relevance_ppm": 1,
    }
    values.update(overrides)
    return NetBenefitPolicy(**values)  # type: ignore[arg-type]


def _candidate(
    capability_id: str,
    *,
    availability: str = "executable",
    expected_task_benefit_ppm: int = 600_000,
    relevance_ppm: int = 1_000_000,
    trust_ppm: int = 1_000_000,
    costs: ResourceCosts | None = None,
    source_trusted: bool = True,
    security_approved: bool = True,
    permissions_allowed: bool = True,
    credentials_available: bool = True,
    coverage_keys: tuple[str, ...] = (),
    equivalence_key: str | None = None,
    complements: tuple[str, ...] = (),
    conflicts: tuple[str, ...] = (),
    evidence: EvidenceSummary | None = None,
) -> BenefitCandidate:
    source_digest = _digest(capability_id)
    return BenefitCandidate(
        capability_id=capability_id,
        source_digest=source_digest,
        resource_profile_digest=_digest(f"resource-profile:{capability_id}"),
        availability=availability,
        expected_task_benefit_ppm=expected_task_benefit_ppm,
        relevance_ppm=relevance_ppm,
        trust_ppm=trust_ppm,
        costs=ResourceCosts() if costs is None else costs,
        source_trusted=source_trusted,
        security_approved=security_approved,
        permissions_allowed=permissions_allowed,
        credentials_available=credentials_available,
        coverage_keys=coverage_keys,
        equivalence_key=equivalence_key,
        complements=complements,
        conflicts=conflicts,
        evidence=(
            _evidence(capability_id, source_digest=source_digest) if evidence is None else evidence
        ),
    )


def test_benefit_values_are_available_from_the_stable_engine_surface() -> None:
    assert engine_api.BenefitCandidate is BenefitCandidate
    assert engine_api.EvidenceSummary is EvidenceSummary
    assert engine_api.NetBenefitPolicy is NetBenefitPolicy
    assert engine_api.ResourceCosts is ResourceCosts


def test_advisory_candidate_cannot_displace_positive_executable_value() -> None:
    executable = _candidate(
        "skill:local",
        expected_task_benefit_ppm=100_000,
    )
    advisory = _candidate(
        "skill:manual",
        availability="advisory",
        expected_task_benefit_ppm=1_000_000,
    )
    policy = _policy()

    one = policy.select((advisory, executable), requested_limit=1)
    two = policy.select((advisory, executable), requested_limit=2)

    assert [item.capability_id for item in one.selections] == ["skill:local"]
    assert [item.capability_id for item in two.selections] == [
        "skill:local",
        "skill:manual",
    ]
    assert [item.tier for item in two.selections] == ["executable", "advisory"]


def test_selector_stops_at_positive_marginal_value_and_never_exceeds_five() -> None:
    candidates = tuple(
        _candidate(
            f"skill:positive-{index}",
            expected_task_benefit_ppm=900_000 - index,
        )
        for index in range(6)
    ) + (
        _candidate("skill:zero", expected_task_benefit_ppm=0),
        _candidate(
            "skill:negative",
            expected_task_benefit_ppm=100_000,
            costs=ResourceCosts(context_tokens=2_000),
        ),
    )
    policy = _policy(context_token_cost_u=100)

    result = policy.select(candidates, requested_limit=5)

    assert len(result.selections) == 5
    assert all(item.marginal_net_benefit_u > 0 for item in result.selections)
    assert "skill:zero" not in {item.capability_id for item in result.selections}
    assert "skill:negative" not in {item.capability_id for item in result.selections}


def test_selector_abstains_instead_of_filling_when_every_marginal_is_nonpositive() -> None:
    policy = _policy(context_token_cost_u=100)
    candidates = (
        _candidate("skill:zero", expected_task_benefit_ppm=0),
        _candidate(
            "skill:costly",
            expected_task_benefit_ppm=100_000,
            costs=ResourceCosts(context_tokens=2_000),
        ),
    )

    result = policy.select(candidates)

    assert result.selections == ()
    assert result.abstention_code == "below-net-benefit"


def test_marginal_overlap_stops_at_the_smallest_useful_set() -> None:
    stronger = _candidate(
        "skill:stronger",
        expected_task_benefit_ppm=600_000,
        coverage_keys=("testing",),
    )
    redundant = _candidate(
        "agent:redundant",
        expected_task_benefit_ppm=300_000,
        coverage_keys=("testing",),
    )
    policy = _policy(overlap_penalty_u_per_key=300_000)

    result = policy.select((redundant, stronger))

    assert [item.capability_id for item in result.selections] == ["skill:stronger"]


@pytest.mark.parametrize(
    ("candidate", "reason"),
    [
        (_candidate("skill:unsupported", availability="unsupported"), "host-unsupported"),
        (_candidate("skill:untrusted", source_trusted=False), "source-untrusted"),
        (_candidate("skill:unsafe", security_approved=False), "security-blocked"),
        (_candidate("skill:permission", permissions_allowed=False), "permission-blocked"),
        (
            _candidate("skill:credential", credentials_available=False),
            "credential-unavailable",
        ),
    ],
)
def test_hard_gates_cannot_be_outscored(candidate: BenefitCandidate, reason: str) -> None:
    result = _policy().select((candidate,))

    assert result.selections == ()
    assert result.abstention_code == "no-feasible-capability"
    assert result.assessments[0].tier == "ineligible"
    assert reason in result.assessments[0].reason_codes


def test_unknown_resource_cost_fails_closed() -> None:
    candidate = _candidate("skill:unknown")
    candidate = BenefitCandidate(
        capability_id=candidate.capability_id,
        source_digest=candidate.source_digest,
        availability=candidate.availability,
        expected_task_benefit_ppm=candidate.expected_task_benefit_ppm,
        relevance_ppm=candidate.relevance_ppm,
        trust_ppm=candidate.trust_ppm,
        costs=None,
        evidence=candidate.evidence,
        resource_profile_digest=candidate.resource_profile_digest,
        source_trusted=True,
        security_approved=True,
        permissions_allowed=True,
        credentials_available=True,
    )

    result = _policy().select((candidate,))

    assert result.selections == ()
    assert result.assessments[0].tier == "ineligible"
    assert "resource-cost-unknown" in result.assessments[0].reason_codes


def test_every_resource_quantity_uses_the_frozen_policy_conversion() -> None:
    candidate = _candidate(
        "agent:costed",
        expected_task_benefit_ppm=1_000_000,
        costs=ResourceCosts(
            context_tokens=1,
            tool_schema_tokens=1,
            runtime_millis=1,
            permission_burden_units=1,
            credential_burden_units=1,
            approval_prompts=1,
            process_units=1,
            child_agent_units=1,
        ),
    )
    policy = _policy(
        context_token_cost_u=1,
        tool_schema_token_cost_u=2,
        runtime_millisecond_cost_u=3,
        permission_burden_cost_u=4,
        credential_burden_cost_u=5,
        approval_prompt_cost_u=6,
        process_unit_cost_u=7,
        child_agent_unit_cost_u=8,
    )

    assessment = policy.assess(candidate)

    assert assessment.expected_benefit_u == 1_000_000
    assert assessment.expected_cost_u == 36
    assert assessment.individual_net_benefit_u == 999_964


def test_trust_threshold_is_a_hard_gate_not_a_soft_cost() -> None:
    result = _policy(minimum_trust_ppm=500_000).select(
        (_candidate("skill:low-trust", trust_ppm=499_999),)
    )

    assert result.selections == ()
    assert "trust-below-threshold" in result.assessments[0].reason_codes


def test_selection_and_ties_are_invariant_to_candidate_permutation() -> None:
    candidates = (
        _candidate("skill:b"),
        _candidate("agent:a"),
        _candidate("mcp-server:c"),
    )
    policy = _policy()

    results = tuple(policy.select(order) for order in permutations(candidates))
    observed = {tuple(item.capability_id for item in result.selections) for result in results}

    assert observed == {("agent:a", "mcp-server:c", "skill:b")}
    assert len({result.result_digest for result in results}) == 1
    assert len({result.search_evaluation_count for result in results}) == 1


def test_equivalence_collapses_unless_exact_candidates_are_complementary() -> None:
    lower = _candidate(
        "skill:lower",
        expected_task_benefit_ppm=400_000,
        equivalence_key="python-testing",
    )
    higher = _candidate(
        "agent:higher",
        expected_task_benefit_ppm=700_000,
        equivalence_key="python-testing",
    )
    collapsed = _policy().select((lower, higher))

    complementary_left = _candidate(
        "skill:implementation",
        equivalence_key="python-quality",
        complements=("agent:review",),
    )
    complementary_right = _candidate(
        "agent:review",
        equivalence_key="python-quality",
        complements=("skill:implementation",),
    )
    complementary = _policy(complementarity_bonus_u=10_000).select(
        (complementary_right, complementary_left)
    )

    assert [item.capability_id for item in collapsed.selections] == ["agent:higher"]
    assert {item.capability_id for item in complementary.selections} == {
        "skill:implementation",
        "agent:review",
    }


def test_conflict_is_a_hard_set_gate() -> None:
    preferred = _candidate(
        "skill:preferred",
        expected_task_benefit_ppm=800_000,
        conflicts=("agent:conflicting",),
    )
    conflicting = _candidate(
        "agent:conflicting",
        expected_task_benefit_ppm=700_000,
    )

    result = _policy().select((conflicting, preferred))

    assert [item.capability_id for item in result.selections] == ["skill:preferred"]


@pytest.mark.parametrize(
    "factory",
    [
        lambda: ResourceCosts(context_tokens=True),
        lambda: ResourceCosts(runtime_millis=1.5),  # type: ignore[arg-type]
        lambda: ResourceCosts(context_tokens=1_000_001),
        lambda: _evidence("skill:bad-evidence", exposed_count=True),
        lambda: _evidence("skill:bad-evidence", exposed_count=1_000_001),
        lambda: _candidate(
            "skill:bad-score",
            expected_task_benefit_ppm=True,  # type: ignore[arg-type]
        ),
        lambda: _candidate(
            "skill:bad-score",
            relevance_ppm=0.5,  # type: ignore[arg-type]
        ),
        lambda: _policy(context_token_cost_u=True),
        lambda: _policy(context_token_cost_u=1_000_001),
    ],
)
def test_numeric_contract_rejects_bool_float_and_unbounded_values(factory: object) -> None:
    with pytest.raises((TypeError, ValueError)):
        factory()  # type: ignore[operator]


def test_candidate_and_relationship_identities_use_declared_capability_kinds() -> None:
    with pytest.raises(ValueError, match="capability_id"):
        _candidate("plugin:unknown")
    with pytest.raises(ValueError, match="complements"):
        _candidate("skill:known", complements=("plugin:unknown",))


def test_requested_limit_is_a_strict_zero_to_five_integer() -> None:
    policy = _policy()
    candidate = _candidate("skill:one")

    assert policy.select((candidate,), requested_limit=0).selections == ()
    with pytest.raises(ValueError, match="requested_limit"):
        policy.select((candidate,), requested_limit=6)
    with pytest.raises(ValueError, match="requested_limit"):
        policy.select((candidate,), requested_limit=True)


def test_exposure_has_zero_adjustment_and_outcome_evidence_is_ordered() -> None:
    policy = _policy(evidence_prior_observations=1)

    def assessed(evidence: EvidenceSummary) -> tuple[int, int]:
        value = policy.assess(_candidate("skill:evidence", evidence=evidence))
        return value.evidence_adjustment_ppm, value.expected_benefit_u

    none = assessed(_evidence("skill:evidence"))
    exposed = assessed(_evidence("skill:evidence", opportunities_observed=10, exposed_count=10))
    succeeded = assessed(
        _evidence(
            "skill:evidence",
            opportunities_observed=1,
            successful_invocations=1,
        )
    )
    effective = assessed(
        _evidence(
            "skill:evidence",
            opportunities_observed=1,
            exposed_count=1,
            effective_outcomes=1,
        )
    )
    validated = assessed(
        _evidence(
            "skill:evidence",
            opportunities_observed=1,
            exposed_count=1,
            effective_outcomes=1,
            validated_outcomes=1,
        )
    )
    failed = assessed(
        _evidence(
            "skill:evidence",
            opportunities_observed=1,
            failed_invocations=1,
        )
    )
    harmful = assessed(
        _evidence(
            "skill:evidence",
            opportunities_observed=1,
            exposed_count=1,
            harmful_outcomes=1,
        )
    )

    assert exposed == none
    assert harmful < failed < none < succeeded < effective < validated


def test_nonuse_is_negative_only_when_opportunity_is_declared_observable() -> None:
    policy = _policy(evidence_prior_observations=1)
    hidden = policy.assess(
        _candidate(
            "skill:hidden-opportunity",
            evidence=_evidence("skill:hidden-opportunity", opportunities_observed=5),
        )
    )
    observable = policy.assess(
        _candidate(
            "skill:observable-opportunity",
            evidence=_evidence(
                "skill:observable-opportunity",
                opportunities_observed=5,
                opportunity_observable=True,
            ),
        )
    )

    assert hidden.evidence_adjustment_ppm == 0
    assert observable.evidence_adjustment_ppm < 0


def test_candidate_requires_explicit_authenticated_gate_cost_and_evidence_facts() -> None:
    capability_id = "skill:explicit"
    source_digest = _digest(capability_id)
    values: dict[str, object] = {
        "capability_id": capability_id,
        "source_digest": source_digest,
        "resource_profile_digest": _digest("explicit-resource-profile"),
        "availability": "executable",
        "expected_task_benefit_ppm": 500_000,
        "relevance_ppm": 500_000,
        "trust_ppm": 500_000,
        "costs": ResourceCosts(),
        "evidence": _evidence(capability_id, source_digest=source_digest),
        "source_trusted": True,
        "security_approved": True,
        "permissions_allowed": True,
        "credentials_available": True,
    }

    for omitted in (
        "resource_profile_digest",
        "evidence",
        "source_trusted",
        "security_approved",
        "permissions_allowed",
        "credentials_available",
    ):
        incomplete = dict(values)
        incomplete.pop(omitted)
        with pytest.raises(TypeError):
            BenefitCandidate(**incomplete)  # type: ignore[arg-type]

    with pytest.raises(TypeError):
        NetBenefitPolicy(minimum_relevance_ppm=1)  # type: ignore[call-arg]


def test_candidate_rejects_evidence_bound_to_another_identity_or_source() -> None:
    with pytest.raises(ValueError, match="evidence"):
        _candidate(
            "skill:bound",
            evidence=_evidence("skill:other"),
        )
    with pytest.raises(ValueError, match="evidence"):
        _candidate(
            "skill:bound",
            evidence=_evidence("skill:bound", source_digest=_digest("other-source")),
        )


@pytest.mark.parametrize(
    "factory",
    [
        lambda: _evidence(
            "skill:orphan-validation",
            opportunities_observed=1,
            exposed_count=1,
            effective_outcomes=0,
            validated_outcomes=1,
        ),
        lambda: _evidence(
            "skill:orphan-effect",
            opportunities_observed=1,
            effective_outcomes=1,
        ),
        lambda: _evidence(
            "agent:orphan-effect",
            opportunities_observed=1,
            exposed_count=1,
            effective_outcomes=1,
        ),
        lambda: _evidence(
            "mcp-server:orphan-effect",
            opportunities_observed=1,
            effective_outcomes=1,
        ),
        lambda: _evidence(
            "harness:orphan-effect",
            opportunities_observed=1,
            effective_outcomes=1,
        ),
        lambda: _evidence(
            "skill:orphan-harm",
            opportunities_observed=1,
            harmful_outcomes=1,
        ),
    ],
)
def test_outcome_evidence_requires_attributable_prior_observation(factory: object) -> None:
    with pytest.raises(ValueError, match="validated|effective|harmful|attributable|invocation"):
        factory()  # type: ignore[operator]


@pytest.mark.parametrize(
    "factory",
    [
        lambda: _evidence("skill:no-opportunity", exposed_count=1),
        lambda: _evidence(
            "skill:too-many-exposures",
            opportunities_observed=1,
            exposed_count=2,
        ),
        lambda: _evidence(
            "agent:too-many-attempts",
            opportunities_observed=1,
            successful_invocations=1,
            failed_invocations=1,
        ),
        lambda: _evidence(
            "skill:effect-without-exposure",
            opportunities_observed=1,
            successful_invocations=1,
            effective_outcomes=1,
        ),
        lambda: _evidence(
            "agent:too-many-effects",
            opportunities_observed=2,
            successful_invocations=1,
            effective_outcomes=2,
        ),
        lambda: _evidence(
            "skill:too-many-harms",
            opportunities_observed=2,
            exposed_count=1,
            harmful_outcomes=2,
        ),
        lambda: _evidence(
            "skill:outcomes-exceed-window",
            opportunities_observed=1,
            exposed_count=1,
            effective_outcomes=1,
            harmful_outcomes=1,
        ),
    ],
)
def test_evidence_counts_obey_one_strict_observation_window(factory: object) -> None:
    with pytest.raises(ValueError, match="opportunit|expos|attempt|effective|harmful|window"):
        factory()  # type: ignore[operator]


def test_evidence_window_digest_is_required_and_candidate_bound_evidence_is_explicit() -> None:
    with pytest.raises(TypeError):
        EvidenceSummary(  # type: ignore[call-arg]
            capability_id="skill:window",
            kind="skill",
            source_digest=_digest("skill:window"),
            opportunity_observable=False,
        )


def test_minimum_relevance_is_a_hard_gate() -> None:
    result = _policy(minimum_relevance_ppm=500_000).select(
        (_candidate("skill:low-relevance", relevance_ppm=499_999),)
    )

    assert result.selections == ()
    assert result.assessments[0].tier == "ineligible"
    assert "relevance-below-threshold" in result.assessments[0].reason_codes


def test_complementarity_must_be_reciprocal_and_cannot_contradict_conflict() -> None:
    unilateral = _candidate(
        "skill:unilateral",
        expected_task_benefit_ppm=600_000,
        equivalence_key="same-need",
        complements=("agent:stronger",),
    )
    stronger = _candidate(
        "agent:stronger",
        expected_task_benefit_ppm=700_000,
        equivalence_key="same-need",
    )

    result = _policy(complementarity_bonus_u=1_000_000).select((unilateral, stronger))

    assert [item.capability_id for item in result.selections] == ["agent:stronger"]
    with pytest.raises(ValueError, match="complement|conflict"):
        _candidate(
            "skill:contradictory",
            complements=("agent:peer",),
            conflicts=("agent:peer",),
        )


def test_multistart_search_exchanges_one_conflicting_candidate_for_better_pair() -> None:
    single = _candidate(
        "skill:single",
        expected_task_benefit_ppm=600_000,
        conflicts=("agent:left", "mcp-server:right"),
    )
    left = _candidate("agent:left", expected_task_benefit_ppm=400_000)
    right = _candidate("mcp-server:right", expected_task_benefit_ppm=400_000)

    observed = {
        tuple(item.capability_id for item in _policy().select(order).selections)
        for order in permutations((single, left, right))
    }

    assert observed == {("agent:left", "mcp-server:right")}


def test_direct_marginal_admits_zero_individual_value_with_new_coverage() -> None:
    candidate = _candidate(
        "skill:coverage-only",
        expected_task_benefit_ppm=0,
        coverage_keys=("uncovered-need",),
    )

    result = _policy(new_coverage_bonus_u_per_key=10).select((candidate,))

    assert [item.capability_id for item in result.selections] == ["skill:coverage-only"]
    assert result.selections[0].individual_net_benefit_u == 0
    assert result.selections[0].marginal_net_benefit_u == 10


def test_advisory_negative_individual_value_can_help_frozen_executable_via_complement() -> None:
    executable = _candidate(
        "skill:implementation",
        complements=("agent:review",),
    )
    advisory = _candidate(
        "agent:review",
        availability="advisory",
        expected_task_benefit_ppm=0,
        costs=ResourceCosts(context_tokens=1),
        complements=("skill:implementation",),
    )

    result = _policy(
        context_token_cost_u=10,
        complementarity_bonus_u=20,
    ).select((advisory, executable))

    assert [item.capability_id for item in result.selections] == [
        "skill:implementation",
        "agent:review",
    ]
    assert result.selections[1].individual_net_benefit_u == -10
    assert result.selections[1].marginal_net_benefit_u == 10


def test_advisory_admission_cannot_invalidate_frozen_value_and_hide_valid_refill() -> None:
    executable = _candidate(
        "skill:frozen",
        expected_task_benefit_ppm=10,
        coverage_keys=("x",),
    )
    high_but_invalid = _candidate(
        "agent:invalid-overlap",
        availability="advisory",
        expected_task_benefit_ppm=100,
        coverage_keys=("x",),
    )
    lower_valid = _candidate(
        "mcp-server:valid-distinct",
        availability="advisory",
        expected_task_benefit_ppm=50,
        coverage_keys=("y",),
    )
    policy = _policy(overlap_penalty_u_per_key=20)

    results = tuple(
        policy.select(order, requested_limit=2)
        for order in permutations((executable, high_but_invalid, lower_valid))
    )

    assert {tuple(item.capability_id for item in result.selections) for result in results} == {
        ("skill:frozen", "mcp-server:valid-distinct")
    }
    assert len({result.result_digest for result in results}) == 1
    for result in results:
        policy.validate_result(result)
        assert all(item.marginal_net_benefit_u >= 1 for item in result.selections)


def test_two_mutually_nonpositive_unselected_candidates_cannot_rescue_each_other() -> None:
    left = _candidate(
        "skill:left-negative",
        expected_task_benefit_ppm=0,
        costs=ResourceCosts(context_tokens=1),
        complements=("agent:right-negative",),
    )
    right = _candidate(
        "agent:right-negative",
        expected_task_benefit_ppm=0,
        costs=ResourceCosts(context_tokens=1),
        complements=("skill:left-negative",),
    )

    result = _policy(
        context_token_cost_u=10,
        complementarity_bonus_u=1_000,
    ).select((left, right))

    assert result.selections == ()
    assert result.abstention_code == "below-net-benefit"


def test_policy_digest_binds_schema_algorithm_and_calibration() -> None:
    first = _policy()
    changed = _policy(calibration_digest=_digest("calibration-v2"))
    changed_weight = _policy(context_token_cost_u=1)

    assert first.policy_schema_id == "ctx.net-benefit-policy-v3"
    assert first.selection_algorithm_id == "ctx.greedy-bounded-subset-exchange-v1"
    assert first.policy_digest != changed.policy_digest
    assert first.policy_digest != changed_weight.policy_digest


def test_selection_result_rejects_duplicates_and_nonmatching_assessment_projection() -> None:
    result = _policy().select((_candidate("skill:projection"),))
    selection = result.selections[0]

    with pytest.raises(ValueError, match="duplicate"):
        BenefitSelectionResult(
            selections=(selection, selection),
            assessments=result.assessments,
            abstention_code=None,
            policy_digest=result.policy_digest,
            requested_limit=result.requested_limit,
            candidate_pool_count=result.candidate_pool_count,
            search_evaluation_count=result.search_evaluation_count,
            result_digest=_digest("forged-result"),
        )
    with pytest.raises(ValueError, match="assessment"):
        replace(
            result,
            selections=(replace(selection, source_digest=_digest("substituted-source")),),
        )


def test_result_digest_metadata_and_policy_revalidation_reject_consistent_tamper() -> None:
    policy = _policy()
    result = policy.select(
        (_candidate("skill:a-result"), _candidate("agent:b-result")),
        requested_limit=1,
    )

    assert result.result_schema_id == "ctx.benefit-selection-result-v1"
    assert result.requested_limit == 1
    assert result.candidate_pool_count == 2
    assert result.search_evaluation_count > 0
    assert result.recomputed_result_digest == result.result_digest
    policy.validate_result(result)
    with pytest.raises(ValueError, match="result_digest"):
        replace(result, result_digest=_digest("tampered-result-digest"))

    selection = result.selections[0]
    tampered = BenefitSelectionResult._create(
        selections=(
            replace(
                selection,
                marginal_net_benefit_u=selection.marginal_net_benefit_u + 1,
            ),
        ),
        assessments=result.assessments,
        abstention_code=result.abstention_code,
        policy_digest=result.policy_digest,
        requested_limit=result.requested_limit,
        candidate_pool_count=result.candidate_pool_count,
        search_evaluation_count=result.search_evaluation_count,
    )
    with pytest.raises(ValueError, match="revalidation|match"):
        policy.validate_result(tampered)

    changed_assessment = replace(
        result.assessments[-1],
        individual_net_benefit_u=result.assessments[-1].individual_net_benefit_u - 1,
    )
    tampered_assessment = BenefitSelectionResult._create(
        selections=result.selections,
        assessments=(*result.assessments[:-1], changed_assessment),
        abstention_code=result.abstention_code,
        policy_digest=result.policy_digest,
        requested_limit=result.requested_limit,
        candidate_pool_count=result.candidate_pool_count,
        search_evaluation_count=result.search_evaluation_count,
    )
    with pytest.raises(ValueError, match="revalidation|assessment"):
        policy.validate_result(tampered_assessment)


def test_result_enforces_canonical_order_and_exact_abstention_semantics() -> None:
    policy = _policy()
    selected = policy.select(
        (_candidate("skill:z-order"), _candidate("agent:a-order")),
        requested_limit=2,
    )
    with pytest.raises(ValueError, match="canonical"):
        BenefitSelectionResult._create(
            selections=tuple(reversed(selected.selections)),
            assessments=selected.assessments,
            abstention_code=None,
            policy_digest=selected.policy_digest,
            requested_limit=selected.requested_limit,
            candidate_pool_count=selected.candidate_pool_count,
            search_evaluation_count=selected.search_evaluation_count,
        )

    limit_zero = policy.select((_candidate("skill:limit-zero"),), requested_limit=0)
    no_candidates = policy.select(())
    below = policy.select((_candidate("skill:zero-benefit", expected_task_benefit_ppm=0),))
    assert (limit_zero.abstention_code, limit_zero.search_evaluation_count) == (
        "limit-zero",
        0,
    )
    assert no_candidates.abstention_code == "no-feasible-capability"
    assert below.abstention_code == "below-net-benefit"

    with pytest.raises(ValueError, match="abstention"):
        BenefitSelectionResult._create(
            selections=(),
            assessments=below.assessments,
            abstention_code="no-feasible-capability",
            policy_digest=below.policy_digest,
            requested_limit=below.requested_limit,
            candidate_pool_count=below.candidate_pool_count,
            search_evaluation_count=below.search_evaluation_count,
        )


def test_candidate_pool_accepts_exact_bound_and_rejects_one_more() -> None:
    coverage_keys = tuple(f"need-{index:02d}" for index in range(64))
    candidates = tuple(
        _candidate(
            f"skill:bounded-{index:03d}",
            coverage_keys=coverage_keys,
        )
        for index in range(MAX_CANDIDATES + 1)
    )

    # Bound algorithmic CPU cost without charging this worker for scheduler
    # starvation while the full suite is running under xdist. The bound catches
    # a pathological blowup, not a slow machine: the real algorithmic guard is
    # search_evaluation_count below. Calibrated on a laptop it read under 5s and
    # measured 14.6s on a shared GitHub runner, so it is set where only a
    # genuine regression can trip it.
    started = time.process_time()
    accepted = _policy().select(candidates[:-1], requested_limit=5)
    elapsed = time.process_time() - started

    assert len(accepted.assessments) == MAX_CANDIDATES
    assert len(accepted.selections) == 5
    assert accepted.search_evaluation_count < 100_000
    assert elapsed < 60.0
    with pytest.raises(ValueError, match="bounded limit"):
        _policy().select(candidates, requested_limit=1)


def test_pool_rejects_cross_record_complement_conflict_contradiction() -> None:
    complementing = _candidate(
        "skill:complementing",
        complements=("agent:conflicting",),
    )
    conflicting = _candidate(
        "agent:conflicting",
        conflicts=("skill:complementing",),
    )

    with pytest.raises(ValueError, match="complement|conflict"):
        _policy().select((complementing, conflicting))