# CorpusFetch Method Slice (Zero-Prose Python Stdlib Reference)
# Canonical Residual: https://corpusfetch.com/c/what-secure-communication-protocols-prevent-embedding-inversion-during-multi-agent-rag.md
# Remnant Warrant:    https://corpusfetch.com/c/what-secure-communication-protocols-prevent-embedding-inversion-during-multi-agent-rag.warrant.json
# Markdown SHA-256:   f8963987b817df699ac7a9759df0ab5b0067fc2bcbf6097bd907a7e1c7f8395e
# Code AST SHA-256:   43d524661f2f6ddcc6e84ecbfea416ed2c9f1fd2bfc1e0fec675baf276f0c29c
# Verified Classes:   EmbeddingSensitivity, InversionVerdict, EmbeddingPayload, EmbeddingPolicy, InversionManifest, EmbeddingInversionGuard
# Defensive Guards:   0 fail-closed invariants (zero external deps)

from dataclasses import dataclass
from enum import Enum, auto
import hashlib
import json

class EmbeddingSensitivity(Enum):
    PUBLIC = auto()
    PII = auto()
    CREDENTIAL = auto()
    PROPRIETARY = auto()

class InversionVerdict(Enum):
    SAFE_TRANSMISSION = auto()
    NOISE_REQUIRED = auto()
    UTILITY_DEGRADED = auto()
    TRUST_BOUNDARY_TRUSTED = auto()

@dataclass(frozen=True)
class EmbeddingPayload:
    embedding_hash: str
    sensitivity: EmbeddingSensitivity
    dp_epsilon: float | None
    noise_applied: bool
    retrieval_recall_delta: float

@dataclass(frozen=True)
class EmbeddingPolicy:
    max_epsilon_for_pii: float
    max_epsilon_for_credentials: float
    min_recall_delta: float
    peer_in_same_trust_boundary: bool

@dataclass(frozen=True)
class InversionManifest:
    verdict: InversionVerdict
    directive: str
    manifest_digest: str

class EmbeddingInversionGuard:
    @staticmethod
    def _hash(data: str) -> str:
        return hashlib.sha256(data.encode("utf-8")).hexdigest()

    @classmethod
    def evaluate_embedding(
        cls, payload: EmbeddingPayload, policy: EmbeddingPolicy
    ) -> InversionManifest:
        
        # Gate 1: Public or trusted peer
        if payload.sensitivity == EmbeddingSensitivity.PUBLIC:
            return InversionManifest(
                verdict=InversionVerdict.SAFE_TRANSMISSION,
                directive="PROCEED: Public content, no privacy risk.",
                manifest_digest=cls._hash(f"PUBLIC:{payload.embedding_hash}")
            )

        if policy.peer_in_same_trust_boundary:
            return InversionManifest(
                verdict=InversionVerdict.TRUST_BOUNDARY_TRUSTED,
                directive="PROCEED: Peer is within the same trust boundary.",
                manifest_digest=cls._hash(f"TRUSTED:{payload.embedding_hash}")
            )

        # Gate 2: Noise requirement
        if not payload.noise_applied or payload.dp_epsilon is None:
            return InversionManifest(
                verdict=InversionVerdict.NOISE_REQUIRED,
                directive=f"HALT: Sensitivity {payload.sensitivity.name} requires differential privacy noise.",
                manifest_digest=cls._hash(f"NO_NOISE:{payload.embedding_hash}")
            )

        # Gate 3: Epsilon threshold
        if payload.sensitivity == EmbeddingSensitivity.PII and payload.dp_epsilon > policy.max_epsilon_for_pii:
            return InversionManifest(
                verdict=InversionVerdict.NOISE_REQUIRED,
                directive=f"HALT: Epsilon {payload.dp_epsilon} > max for PII {policy.max_epsilon_for_pii}.",
                manifest_digest=cls._hash(f"EPSILON_PII:{payload.embedding_hash}")
            )

        if payload.sensitivity == EmbeddingSensitivity.CREDENTIAL and payload.dp_epsilon > policy.max_epsilon_for_credentials:
            return InversionManifest(
                verdict=InversionVerdict.NOISE_REQUIRED,
                directive=f"HALT: Epsilon {payload.dp_epsilon} > max for credentials {policy.max_epsilon_for_credentials}.",
                manifest_digest=cls._hash(f"EPSILON_CRED:{payload.embedding_hash}")
            )

        # Gate 4: Utility check
        if payload.retrieval_recall_delta < policy.min_recall_delta:
            return InversionManifest(
                verdict=InversionVerdict.UTILITY_DEGRADED,
                directive=f"HALT: Recall delta {payload.retrieval_recall_delta:.2f} < min {policy.min_recall_delta:.2f}. Noise too high.",
                manifest_digest=cls._hash(f"UTILITY:{payload.embedding_hash}")
            )

        # Gate 5: Safe
        digest = cls._hash(json.dumps({
            "embedding": payload.embedding_hash,
            "sensitivity": payload.sensitivity.name,
            "epsilon": str(payload.dp_epsilon),
            "recall_delta": f"{payload.retrieval_recall_delta:.3f}"
        }, sort_keys=True))
        
        return InversionManifest(
            verdict=InversionVerdict.SAFE_TRANSMISSION,
            directive=f"PROCEED: DP noise applied (epsilon={payload.dp_epsilon}) with acceptable utility.",
            manifest_digest=digest
        )