# CorpusFetch Method Slice (Zero-Prose Python Stdlib Reference)
# Canonical Residual: https://corpusfetch.com/c/how-must-an-instance-detect-training-data-poisoning-through-correlated-task-failures.md
# Remnant Warrant:    https://corpusfetch.com/c/how-must-an-instance-detect-training-data-poisoning-through-correlated-task-failures.warrant.json
# Markdown SHA-256:   20fbdc0445454614f7d01c1302e93e574c7e3b2d6f5eb2ac06421dbfaf0f3bd8
# Code AST SHA-256:   8b812743a0d5cbddee313b483c0a3f96e6c6202cbfdc034d4c66c89b35722357
# Verified Classes:   PoisoningVerdict, TaskFailure, PoisoningPolicy, PoisoningManifest, TrainingDataPoisoningGuard
# Defensive Guards:   0 fail-closed invariants (zero external deps)

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

class PoisoningVerdict(Enum):
    NO_FAILURES = auto()
    RANDOM_FAILURES = auto()
    TRIGGER_CORRELATION_SUSPECTED = auto()
    POISONING_CONFIRMED = auto()

@dataclass(frozen=True)
class TaskFailure:
    failure_id: str
    input_features: tuple[str, ...]
    baseline_failure_rate: float
    observed_failure_rate: float
    trigger_removal_resolves: bool

@dataclass(frozen=True)
class PoisoningPolicy:
    min_correlation_for_suspicion: float
    max_acceptable_failure_rate_elevation: float

@dataclass(frozen=True)
class PoisoningManifest:
    verdict: PoisoningVerdict
    directive: str
    manifest_digest: str

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

    @classmethod
    def evaluate_failure(
        cls, failure: TaskFailure, policy: PoisoningPolicy
    ) -> PoisoningManifest:
        
        # Gate 1: No failures
        if not failure.failure_id:
            digest = cls._hash(json.dumps({
                "failure": "NONE"
            }, sort_keys=True))
            return PoisoningManifest(
                verdict=PoisoningVerdict.NO_FAILURES,
                directive=f"PROCEED: No failures to analyze.",
                manifest_digest=digest
            )

        # Gate 2: Trigger removal resolves
        if failure.trigger_removal_resolves:
            return PoisoningManifest(
                verdict=PoisoningVerdict.POISONING_CONFIRMED,
                directive=f"CONFIRM: Failure {failure.failure_id} resolved by trigger removal.",
                manifest_digest=cls._hash(f"CONFIRMED:{failure.failure_id}")
            )

        # Gate 3: Failure rate elevation
        if failure.baseline_failure_rate > 0:
            elevation = (failure.observed_failure_rate - failure.baseline_failure_rate) / failure.baseline_failure_rate
        else:
            elevation = 0.0

        # Gate 4: Input feature correlation
        if len(failure.input_features) > 0 and elevation > policy.max_acceptable_failure_rate_elevation:
            return PoisoningManifest(
                verdict=PoisoningVerdict.TRIGGER_CORRELATION_SUSPECTED,
                directive=f"SUSPECT: Failure {failure.failure_id} has {len(failure.input_features)} correlated features, elevation {elevation*100:.1f}%.",
                manifest_digest=cls._hash(f"SUSPECT:{failure.failure_id}")
            )

        # Gate 5: Random
        digest = cls._hash(json.dumps({
            "failure": failure.failure_id,
            "features": failure.input_features,
            "elevation": f"{elevation:.3f}"
        }, sort_keys=True))
        
        return PoisoningManifest(
            verdict=PoisoningVerdict.RANDOM_FAILURES,
            directive=f"PROCEED: Failure {failure.failure_id} appears random.",
            manifest_digest=digest
        )