# CorpusFetch Method Slice (Zero-Prose Python Stdlib Reference)
# Canonical Residual: https://corpusfetch.com/c/what-invariants-preserve-signal-integrity-when-signaling-is-costly.md
# Remnant Warrant:    https://corpusfetch.com/c/what-invariants-preserve-signal-integrity-when-signaling-is-costly.warrant.json
# Markdown SHA-256:   1fe7876cb87f4639e6c8b1c1eb359a4130acfedfe743097ff6c0ad4f2f69f4d9
# Code AST SHA-256:   eebdc6f76f4445f2fea9155d9a026e2eb5c7ecac4f432fa5b2e3cffe82684a0c
# Verified Classes:   SignalVerdict, CostlySignal, SignalPolicy, SignalManifest, SignalIntegrityGuard
# Defensive Guards:   0 fail-closed invariants (zero external deps)

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

class SignalVerdict(Enum):
    NO_SIGNAL = auto()
    SIGNAL_VALID = auto()
    SIGNAL_DILUTED = auto()
    SIGNAL_MIMICRY_SUSPECTED = auto()

@dataclass(frozen=True)
class CostlySignal:
    signal_id: str
    signaler_id: str
    cost_to_signaler: float
    is_cost_shared: bool
    is_part_of_bundle: bool
    bundle_size: int
    mimicry_indicators: int

@dataclass(frozen=True)
class SignalPolicy:
    max_bundle_size_for_valid: int
    min_cost_for_valid: float

@dataclass(frozen=True)
class SignalManifest:
    verdict: SignalVerdict
    directive: str
    manifest_digest: str

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

    @classmethod
    def evaluate_signal(
        cls, signal: CostlySignal, policy: SignalPolicy
    ) -> SignalManifest:
        
        # Gate 1: No signal
        if not signal.signal_id:
            digest = cls._hash(json.dumps({
                "signal": "NONE"
            }, sort_keys=True))
            return SignalManifest(
                verdict=SignalVerdict.NO_SIGNAL,
                directive=f"PROCEED: No signal to evaluate.",
                manifest_digest=digest
            )

        # Gate 2: Cost sharing
        if signal.is_cost_shared:
            return SignalManifest(
                verdict=SignalVerdict.SIGNAL_DILUTED,
                directive=f"FLAG: Signal {signal.signal_id} cost shared, informational content reduced.",
                manifest_digest=cls._hash(f"COST_SHARED:{signal.signal_id}")
            )

        # Gate 3: Bundle inflation
        if signal.is_part_of_bundle and signal.bundle_size > policy.max_bundle_size_for_valid:
            return SignalManifest(
                verdict=SignalVerdict.SIGNAL_DILUTED,
                directive=f"FLAG: Signal {signal.signal_id} in bundle of {signal.bundle_size}, value diluted.",
                manifest_digest=cls._hash(f"BUNDLE:{signal.signal_id}")
            )

        # Gate 4: Mimicry
        if signal.mimicry_indicators >= 2:
            return SignalManifest(
                verdict=SignalVerdict.SIGNAL_MIMICRY_SUSPECTED,
                directive=f"FLAG: {signal.mimicry_indicators} mimicry indicators for {signal.signal_id}.",
                manifest_digest=cls._hash(f"MIMIC:{signal.signal_id}")
            )

        # Gate 5: Insufficient cost
        if signal.cost_to_signaler < policy.min_cost_for_valid:
            return SignalManifest(
                verdict=SignalVerdict.SIGNAL_DILUTED,
                directive=f"FLAG: Signal {signal.signal_id} cost {signal.cost_to_signaler:.2f} < {policy.min_cost_for_valid:.2f}.",
                manifest_digest=cls._hash(f"LOW_COST:{signal.signal_id}")
            )

        # Gate 6: Valid
        digest = cls._hash(json.dumps({
            "signal": signal.signal_id,
            "signaler": signal.signaler_id,
            "cost": f"{signal.cost_to_signaler:.3f}",
            "bundle": signal.bundle_size
        }, sort_keys=True))
        
        return SignalManifest(
            verdict=SignalVerdict.SIGNAL_VALID,
            directive=f"PROCEED: Signal {signal.signal_id} valid.",
            manifest_digest=digest
        )