# CorpusFetch Method Slice (Zero-Prose Python Stdlib Reference)
# Canonical Residual: https://corpusfetch.com/c/which-invariants-prevent-provenance-replay-in-adversarial-agent-skill-marketplaces.md
# Remnant Warrant:    https://corpusfetch.com/c/which-invariants-prevent-provenance-replay-in-adversarial-agent-skill-marketplaces.warrant.json
# Markdown SHA-256:   d7489deffe51622ae5015aae6a3d037c666da10be61f40334be8f92d08798e51
# Code AST SHA-256:   4c6f5cb0d122986af08dd8a00f7b8b39761125efcfca9fcf4a969e971f9f113e
# Verified Classes:   ProvenanceReplayError, VerifiedClaim, ExecutionTarget
# Defensive Guards:   4 fail-closed invariants (zero external deps)

"""Provenance binding guard for agent-skill resolution.

Enforces the invariant: a cached verification verdict is reusable only if the
tuple (publisher, name, version, bundle_digest, resolved_dep_digests) matches
the tuple the signature actually covered. Anything else must fail closed.
"""

from dataclasses import dataclass


class ProvenanceReplayError(RuntimeError):
    """Raised when a verification verdict does not bind to the artifact to execute."""


@dataclass(frozen=True)
class VerifiedClaim:
    publisher_id: str
    skill_name: str
    version: str
    bundle_digest: str
    resolved_dep_digests: tuple  # sorted, digest-pinned; never ranges


@dataclass(frozen=True)
class ExecutionTarget:
    publisher_id: str
    skill_name: str
    version: str
    bundle_digest: str
    resolved_dep_digests: tuple


def assert_binding(claim: VerifiedClaim, target: ExecutionTarget) -> None:
    """Fail closed unless the verified claim binds exactly to the execution target."""
    if claim.resolved_dep_digests != tuple(sorted(claim.resolved_dep_digests)):
        raise ProvenanceReplayError(
            "claim dependency closure is not canonically ordered; cannot compare safely"
        )
    if target.resolved_dep_digests != tuple(sorted(target.resolved_dep_digests)):
        raise ProvenanceReplayError(
            "target dependency closure is not canonically ordered; cannot compare safely"
        )

    mismatches = []
    for field in (
        "publisher_id",
        "skill_name",
        "version",
        "bundle_digest",
        "resolved_dep_digests",
    ):
        if getattr(claim, field) != getattr(target, field):
            mismatches.append(
                f"{field}: verified={getattr(claim, field)!r} "
                f"target={getattr(target, field)!r}"
            )

    if mismatches:
        raise ProvenanceReplayError(
            "provenance replay detected: verification verdict does not bind to "
            "the artifact about to execute. " + "; ".join(mismatches)
        )


def resolve_with_verdict(
    claim: VerifiedClaim,
    target: ExecutionTarget,
    verdict_cache: dict,
) -> ExecutionTarget:
    """Resolve a skill, reusing a cached verdict only if the binding holds."""
    cache_key = (
        claim.publisher_id,
        claim.skill_name,
        claim.version,
        claim.bundle_digest,
        claim.resolved_dep_digests,
    )
    # A cache hit is only meaningful for the exact signed tuple.
    cached = verdict_cache.get(cache_key)
    if cached is not True:
        raise ProvenanceReplayError(
            f"no digest-bound verification verdict for {cache_key!r}; "
            "refusing to execute on an unverified binding"
        )
    assert_binding(claim, target)
    return target
