# CorpusFetch Method Slice (Zero-Prose Python Stdlib Reference)
# Canonical Residual: https://corpusfetch.com/c/how-must-an-instance-handle-decision-paralysis-from-adversarial-information-overload.md
# Remnant Warrant:    https://corpusfetch.com/c/how-must-an-instance-handle-decision-paralysis-from-adversarial-information-overload.warrant.json
# Markdown SHA-256:   aae4a1f7e74cd1870729319d28d97bdbb8dd5f31800d3845dddb0f71e6c5f1c0
# Code AST SHA-256:   277cc63bd3639d0a8f1ba4a53e7d2f0651363b12d55e46543008a5e48be61c38
# Verified Classes:   OverloadVerdict, DecisionContext, OverloadPolicy, OverloadManifest, InformationOverloadGuard
# Defensive Guards:   0 fail-closed invariants (zero external deps)

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

class OverloadVerdict(Enum):
    NO_ADVERSARIAL_INPUT = auto()
    SUFFICIENT_DECIDE_NOW = auto()
    INTAKE_BUDGET_EXCEEDED = auto()
    FLOOD_DETECTED = auto()

@dataclass(frozen=True)
class DecisionContext:
    decision_id: str
    intake_budget_defined: bool
    information_considered: float
    information_budget: float
    flood_indicators: int
    sufficiency_predicate_met: bool
    decision_reversible: bool

@dataclass(frozen=True)
class OverloadPolicy:
    flood_threshold: int

@dataclass(frozen=True)
class OverloadManifest:
    verdict: OverloadVerdict
    directive: str
    manifest_digest: str

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

    @classmethod
    def evaluate_decision(
        cls, ctx: DecisionContext, policy: OverloadPolicy
    ) -> OverloadManifest:
        
        # Gate 1: Sufficiency met
        if ctx.sufficiency_predicate_met:
            digest = cls._hash(json.dumps({
                "decision": ctx.decision_id,
                "sufficiency": True
            }, sort_keys=True))
            return OverloadManifest(
                verdict=OverloadVerdict.SUFFICIENT_DECIDE_NOW,
                directive=f"DECIDE: {ctx.decision_id} sufficient, proceed.",
                manifest_digest=digest
            )

        # Gate 2: Flood detected
        if ctx.flood_indicators >= policy.flood_threshold:
            return OverloadManifest(
                verdict=OverloadVerdict.FLOOD_DETECTED,
                directive=f"FLAG: {ctx.flood_indicators} flood indicators for {ctx.decision_id}.",
                manifest_digest=cls._hash(f"FLOOD:{ctx.decision_id}")
            )

        # Gate 3: Intake budget exceeded
        if ctx.intake_budget_defined and ctx.information_considered > ctx.information_budget:
            return OverloadManifest(
                verdict=OverloadVerdict.INTAKE_BUDGET_EXCEEDED,
                directive=f"HALT: Intake {ctx.information_considered:.0f} > budget {ctx.information_budget:.0f} for {ctx.decision_id}.",
                manifest_digest=cls._hash(f"BUDGET:{ctx.decision_id}")
            )

        # Gate 4: No adverse input signals
        digest = cls._hash(json.dumps({
            "decision": ctx.decision_id,
            "considered": f"{ctx.information_considered:.0f}",
            "budget": f"{ctx.information_budget:.0f}",
            "flood": str(ctx.flood_indicators)
        }, sort_keys=True))
        
        return OverloadManifest(
            verdict=OverloadVerdict.NO_ADVERSARIAL_INPUT,
            directive=f"PROCEED: No overload detected for {ctx.decision_id}.",
            manifest_digest=digest
        )