# CorpusFetch Method Slice (Zero-Prose Python Stdlib Reference)
# Canonical Residual: https://corpusfetch.com/c/what-invariants-prevent-costly-signals-from-becoming-adversary-weapons.md
# Remnant Warrant:    https://corpusfetch.com/c/what-invariants-prevent-costly-signals-from-becoming-adversary-weapons.warrant.json
# Markdown SHA-256:   0bf290e8100c01f0fdbfb64f2fbbe75cdd17253d71f860e68003dc69904af9f8
# Code AST SHA-256:   cbf91ca8b0a697d3bb8deacdc1f676d5b237679da421236ec8a881ef1859cf3b
# Verified Classes:   SignalVerdict, CostlySignalDecision, SignalExploitationPolicy, SignalManifest, SignalWeaponizationGuard
# 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_COSTLY_SIGNALS = auto()
    SIGNAL_WITHIN_BUDGET = auto()
    SIGNAL_COSTLY_TO_VALUE = auto()
    BUDGET_EXHAUSTION_IMMINENT = auto()

@dataclass(frozen=True)
class CostlySignalDecision:
    decision_id: str
    signal_cost: float
    signal_value: float
    remaining_signal_budget: float
    signal_trigger_obfuscated: bool
    adversary_observes_pattern: bool

@dataclass(frozen=True)
class SignalExploitationPolicy:
    min_value_cost_ratio: float
    reserve_budget_pct: float

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

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

    @classmethod
    def evaluate_signal(
        cls, decision: CostlySignalDecision, policy: SignalExploitationPolicy
    ) -> SignalManifest:
        
        # Gate 1: No costly signals
        if decision.signal_cost <= 0:
            digest = cls._hash(json.dumps({
                "decision": decision.decision_id,
                "cost": "0"
            }, sort_keys=True))
            return SignalManifest(
                verdict=SignalVerdict.NO_COSTLY_SIGNALS,
                directive=f"PROCEED: Signal {decision.decision_id} costless.",
                manifest_digest=digest
            )

        # Gate 2: Budget exhaustion
        if decision.remaining_signal_budget <= 0:
            return SignalManifest(
                verdict=SignalVerdict.BUDGET_EXHAUSTION_IMMINENT,
                directive=f"HALT: Budget exhausted for signal {decision.decision_id}.",
                manifest_digest=cls._hash(f"EXHAUSTED:{decision.decision_id}")
            )

        # Gate 3: Value-cost ratio
        if decision.signal_value <= 0:
            return SignalManifest(
                verdict=SignalVerdict.SIGNAL_COSTLY_TO_VALUE,
                directive=f"DECLINE: Signal {decision.decision_id} has zero value.",
                manifest_digest=cls._hash(f"NO_VALUE:{decision.decision_id}")
            )

        value_cost_ratio = decision.signal_value / decision.signal_cost
        if value_cost_ratio < policy.min_value_cost_ratio:
            return SignalManifest(
                verdict=SignalVerdict.SIGNAL_COSTLY_TO_VALUE,
                directive=f"DECLINE: Signal {decision.decision_id} ratio {value_cost_ratio:.2f} < {policy.min_value_cost_ratio:.2f}.",
                manifest_digest=cls._hash(f"LOW_RATIO:{decision.decision_id}")
            )

        # Gate 4: Pattern exploitation
        if decision.adversary_observes_pattern and not decision.signal_trigger_obfuscated:
            return SignalManifest(
                verdict=SignalVerdict.SIGNAL_COSTLY_TO_VALUE,
                directive=f"FLAG: Signal {decision.decision_id} trigger exploitable.",
                manifest_digest=cls._hash(f"PATTERN:{decision.decision_id}")
            )

        # Gate 5: Within bounds
        digest = cls._hash(json.dumps({
            "decision": decision.decision_id,
            "cost": f"{decision.signal_cost:.3f}",
            "value": f"{decision.signal_value:.3f}",
            "budget_remaining": f"{decision.remaining_signal_budget:.3f}",
            "ratio": f"{value_cost_ratio:.3f}"
        }, sort_keys=True))
        
        return SignalManifest(
            verdict=SignalVerdict.SIGNAL_WITHIN_BUDGET,
            directive=f"PROCEED: Signal {decision.decision_id} ratio {value_cost_ratio:.2f}.",
            manifest_digest=digest
        )