# CorpusFetch Method Slice (Zero-Prose Python Stdlib Reference)
# Canonical Residual: https://corpusfetch.com/c/what-secure-communication-boundaries-must-be-established-when-agents-exchange-semantic-embeddings.md
# Remnant Warrant:    https://corpusfetch.com/c/what-secure-communication-boundaries-must-be-established-when-agents-exchange-semantic-embeddings.warrant.json
# Markdown SHA-256:   da8e5ff8484ddc56bb2cd301773e14bfc19f1aa4a2474df800fcb9416f83724a
# Code AST SHA-256:   8469570ebf4d2c62763925f5432a33a77047d067b9ac503b4886c03504835057
# Verified Classes:   SensitivityClass, TransmissionVerdict, EmbeddingPayload, PeerContext, TransmissionManifest, EmbeddingPrivacyGuard
# Defensive Guards:   0 fail-closed invariants (zero external deps)

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

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

class TransmissionVerdict(Enum):
    SAFE_TO_TRANSMIT = auto()
    REQUIRES_NOISE = auto()
    BLOCKED_UNAUTHORIZED_PEER = auto()

@dataclass(frozen=True)
class EmbeddingPayload:
    vector_hash: str
    sensitivity: SensitivityClass
    dp_noise_epsilon: float | None

@dataclass(frozen=True)
class PeerContext:
    is_authenticated: bool
    authorized_sensitivity_classes: frozenset[SensitivityClass]

@dataclass(frozen=True)
class TransmissionManifest:
    verdict: TransmissionVerdict
    directive: str
    manifest_digest: str

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

    @classmethod
    def evaluate_transmission(
        cls, payload: EmbeddingPayload, peer: PeerContext
    ) -> TransmissionManifest:
        
        # Gate 1: Public data is always safe
        if payload.sensitivity is SensitivityClass.PUBLIC:
            return TransmissionManifest(
                verdict=TransmissionVerdict.SAFE_TO_TRANSMIT,
                directive="PROCEED: Public data has no inversion risk.",
                manifest_digest=cls._hash("PUBLIC")
            )

        # Gate 2: Peer authorization
        if not peer.is_authenticated or payload.sensitivity not in peer.authorized_sensitivity_classes:
            return TransmissionManifest(
                verdict=TransmissionVerdict.BLOCKED_UNAUTHORIZED_PEER,
                directive=f"BLOCKED: Peer not authorized for {payload.sensitivity.name} data.",
                manifest_digest=cls._hash(f"UNAUTH:{payload.sensitivity.name}")
            )

        # Gate 3: DP noise requirement for sensitive classes
        if payload.sensitivity in (SensitivityClass.PII, SensitivityClass.CREDENTIAL):
            if not payload.dp_noise_epsilon or payload.dp_noise_epsilon > 1.0:
                return TransmissionManifest(
                    verdict=TransmissionVerdict.REQUIRES_NOISE,
                    directive="HALT: PII/Credential embedding requires differential privacy (epsilon <= 1.0).",
                    manifest_digest=cls._hash("NO_NOISE")
                )

        # Gate 4: Safe
        digest = cls._hash(json.dumps({
            "vector": payload.vector_hash,
            "sensitivity": payload.sensitivity.name,
            "epsilon": str(payload.dp_noise_epsilon) if payload.dp_noise_epsilon else "NONE"
        }, sort_keys=True))
        
        return TransmissionManifest(
            verdict=TransmissionVerdict.SAFE_TO_TRANSMIT,
            directive="PROCEED: Peer authorized and embedding protected.",
            manifest_digest=digest
        )