# CorpusFetch Method Slice (Zero-Prose Python Stdlib Reference)
# Canonical Residual: https://corpusfetch.com/c/how-should-agents-communicate-when-one-is-running-at-a-degraded-compute-capacity.md
# Remnant Warrant:    https://corpusfetch.com/c/how-should-agents-communicate-when-one-is-running-at-a-degraded-compute-capacity.warrant.json
# Markdown SHA-256:   191b3e5a24afeeb392547a323da3738964a16fc44b0bdcc6ce2cd44c8625ef16
# Code AST SHA-256:   bf83209efb8f975cc05abea1b651454b143e7fe9ef5b45432e2c40543b0ecc10
# Verified Classes:   DegradationVerdict, ComputeCapacity, CommunicationPolicy, DegradationManifest, DegradedComputeCommunicationGuard
# Defensive Guards:   0 fail-closed invariants (zero external deps)

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

class DegradationVerdict(Enum):
    NORMAL_CAPACITY = auto()
    ADJUST_TIMEOUT = auto()
    REROUTE_RECOMMENDED = auto()
    DEFER_MESSAGE = auto()

@dataclass(frozen=True)
class ComputeCapacity:
    agent_id: str
    tokens_per_sec: float
    p99_latency_ms: float
    degradation_factor: float

@dataclass(frozen=True)
class CommunicationPolicy:
    sender_timeout_ms: float
    priority_level: str
    alternate_agents_available: bool

@dataclass(frozen=True)
class DegradationManifest:
    verdict: DegradationVerdict
    adjusted_timeout_ms: float
    directive: str
    manifest_digest: str

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

    @classmethod
    def evaluate_communication(
        cls, capacity: ComputeCapacity, policy: CommunicationPolicy
    ) -> DegradationManifest:
        
        # Gate 1: Normal capacity
        if capacity.degradation_factor <= 1.0:
            digest = cls._hash(json.dumps({
                "agent": capacity.agent_id,
                "factor": f"{capacity.degradation_factor:.2f}"
            }, sort_keys=True))
            return DegradationManifest(
                verdict=DegradationVerdict.NORMAL_CAPACITY,
                adjusted_timeout_ms=policy.sender_timeout_ms,
                directive="PROCEED: Receiver at normal capacity.",
                manifest_digest=digest
            )

        # Gate 2: Adjust timeout
        required_timeout = capacity.p99_latency_ms * capacity.degradation_factor * 1.5
        if required_timeout > policy.sender_timeout_ms:
            # Check for reroute
            if policy.priority_level == "HIGH" and policy.alternate_agents_available:
                return DegradationManifest(
                    verdict=DegradationVerdict.REROUTE_RECOMMENDED,
                    adjusted_timeout_ms=required_timeout,
                    directive=f"HIGH priority, required timeout {required_timeout:.0f}ms > {policy.sender_timeout_ms:.0f}ms. Reroute.",
                    manifest_digest=cls._hash(f"REROUTE:{capacity.agent_id}")
                )
            return DegradationManifest(
                verdict=DegradationVerdict.ADJUST_TIMEOUT,
                adjusted_timeout_ms=required_timeout,
                directive=f"ADJUST: Timeout must be {required_timeout:.0f}ms for degradation factor {capacity.degradation_factor:.2f}.",
                manifest_digest=cls._hash(f"ADJUST:{required_timeout:.0f}")
            )

        # Gate 3: Defer non-priority
        if policy.priority_level == "LOW" and capacity.degradation_factor > 5.0:
            return DegradationManifest(
                verdict=DegradationVerdict.DEFER_MESSAGE,
                adjusted_timeout_ms=required_timeout,
                directive=f"DEFER: Low priority with degradation factor {capacity.degradation_factor:.2f}. Send when capacity improves.",
                manifest_digest=cls._hash(f"DEFER:{capacity.agent_id}")
            )

        # Gate 4: Proceed
        digest = cls._hash(json.dumps({
            "agent": capacity.agent_id,
            "factor": f"{capacity.degradation_factor:.2f}",
            "timeout": f"{required_timeout:.0f}"
        }, sort_keys=True))
        
        return DegradationManifest(
            verdict=DegradationVerdict.ADJUST_TIMEOUT,
            adjusted_timeout_ms=required_timeout,
            directive=f"PROCEED: Timeout adjusted to {required_timeout:.0f}ms.",
            manifest_digest=digest
        )