# CorpusFetch Method Slice (Zero-Prose Python Stdlib Reference)
# Canonical Residual: https://corpusfetch.com/c/under-what-conditions-must-an-instance-refuse-a-delegated-a2a-task-whose-agent-card-signature-verifies-but-whose-capability-negotiation-was-satisfied.md
# Remnant Warrant:    https://corpusfetch.com/c/under-what-conditions-must-an-instance-refuse-a-delegated-a2a-task-whose-agent-card-signature-verifies-but-whose-capability-negotiation-was-satisfied.warrant.json
# Markdown SHA-256:   17d139569ed792cc553cd122b962b78361fe6c4fdee903a4259bae4ff49d14c8
# Code AST SHA-256:   852ee41157b8c486be77ba15080d103c661531c836c89bc48d2fd9ce60e0700a
# Verified Classes:   StaleCapabilityCardError, AgentCard
# Defensive Guards:   5 fail-closed invariants (zero external deps)

import time
from dataclasses import dataclass


class StaleCapabilityCardError(RuntimeError):
    """Raised when a signed agent card is authentic but not authoritative."""
    pass


@dataclass
class AgentCard:
    agent_id: str
    version: int
    signing_key_id: str
    capabilities: frozenset
    endpoint: str


def resolve_authoritative_card(
    cached: AgentCard,
    origin_current: AgentCard | None,
    active_key_ids: set[str],
    origin_reachable: bool,
    last_seen_version: int,
) -> AgentCard:
    # Signature already verified upstream; this checks authority, not authenticity.
    if not origin_reachable:
        if cached.version < last_seen_version:
            raise StaleCapabilityCardError(
                f"origin unreachable and cached card v{cached.version} "
                f"< last-seen v{last_seen_version} for {cached.agent_id}"
            )
        return cached

    if origin_current is None:
        raise StaleCapabilityCardError(
            f"origin returned no current card for {cached.agent_id}"
        )

    if cached.version < origin_current.version:
        raise StaleCapabilityCardError(
            f"cached card v{cached.version} superseded by origin v"
            f"{origin_current.version} for {cached.agent_id}; renegotiate"
        )

    if cached.signing_key_id not in active_key_ids:
        raise StaleCapabilityCardError(
            f"card signed by rotation-overlap key {cached.signing_key_id}; "
            f"not authoritative for {cached.agent_id}"
        )

    return origin_current


def negotiate_and_submit(
    cached: AgentCard,
    origin_current: AgentCard | None,
    active_key_ids: set[str],
    origin_reachable: bool,
    last_seen_version: int,
    requested_caps: frozenset,
) -> str:
    card = resolve_authoritative_card(
        cached, origin_current, active_key_ids, origin_reachable, last_seen_version
    )
    missing = requested_caps - card.capabilities
    if missing:
        raise StaleCapabilityCardError(
            f"capability mismatch after authority check: {sorted(missing)} "
            f"not offered by {card.agent_id} v{card.version}"
        )
    return card.endpoint
