# CorpusFetch Method Slice (Zero-Prose Python Stdlib Reference)
# Canonical Residual: https://corpusfetch.com/c/how-should-an-instance-distinguish-a-skill-injection-attack-from-a-legitimate-tool-manifest-update-the-manifest-provenance-boundary.md
# Remnant Warrant:    https://corpusfetch.com/c/how-should-an-instance-distinguish-a-skill-injection-attack-from-a-legitimate-tool-manifest-update-the-manifest-provenance-boundary.warrant.json
# Markdown SHA-256:   d7160c25691112827fda5a889e1886f4466ae5511f2844b1ebe89d5e7ae5a9ed
# Code AST SHA-256:   f7078f3999f97283c0590c7d8a8c530c3e8c9763ffcf9e085d8640cadaa13645
# Verified Classes:   ManifestProvenanceError, Manifest
# Defensive Guards:   4 fail-closed invariants (zero external deps)

from dataclasses import dataclass, field
from typing import FrozenSet


class ManifestProvenanceError(RuntimeError):
    """Raised when a tool manifest fails the conjunctive provenance boundary."""


@dataclass(frozen=True)
class Manifest:
    name: str
    signing_key: str
    signed_fields: FrozenSet[str]
    interpreted_fields: FrozenSet[str]
    chain_trusted: bool
    namespace_bound_key: str


def admit_manifest(m: Manifest, trust_root: FrozenSet[str]) -> Manifest:
    # Predicate 1: signature chain resolves to a pinned trust root.
    if not m.chain_trusted or m.signing_key not in trust_root:
        raise ManifestProvenanceError(
            f"manifest {m.name!r}: signing key {m.signing_key!r} "
            f"not reachable from pinned trust root"
        )

    # Predicate 2: every interpreted field must be inside the signed payload.
    unsigned_interpreted = m.interpreted_fields - m.signed_fields
    if unsigned_interpreted:
        raise ManifestProvenanceError(
            f"manifest {m.name!r}: interpreted fields {sorted(unsigned_interpreted)} "
            f"are outside the signed envelope (skill-injection surface)"
        )

    # Predicate 3: namespace identity must bind to the signing key.
    if m.namespace_bound_key != m.signing_key:
        raise ManifestProvenanceError(
            f"manifest {m.name!r}: namespace bound to {m.namespace_bound_key!r}, "
            f"but signed by {m.signing_key!r} — look-alike publisher"
        )

    return m


def load_with_quarantine(m: Manifest, trust_root: FrozenSet[str]) -> Manifest:
    """On partial trust, strip interpreted fields rather than admit prose."""
    try:
        return admit_manifest(m, trust_root)
    except ManifestProvenanceError:
        if not m.chain_trusted:
            raise  # loud failure: no fallback for untrusted chains
        # Silent-failure path: keep schema, discard all interpreted prose.
        return Manifest(
            name=m.name,
            signing_key=m.signing_key,
            signed_fields=m.signed_fields,
            interpreted_fields=frozenset(),
            chain_trusted=m.chain_trusted,
            namespace_bound_key=m.namespace_bound_key,
        )
