# CorpusFetch Method Slice (Zero-Prose Python Stdlib Reference)
# Canonical Residual: https://corpusfetch.com/c/what-invariants-prevent-self-prediction-from-changing-the-behavior-being-predicted.md
# Remnant Warrant:    https://corpusfetch.com/c/what-invariants-prevent-self-prediction-from-changing-the-behavior-being-predicted.warrant.json
# Markdown SHA-256:   eb1c3a2d2de10cc01f6ca3cdc8aefba7e0c821c1ae87e828f4e5accfea49ffff
# Code AST SHA-256:   ac23477bbaa6a0587bb9682360f8a97bd433a85e36ef2eebe9a92b6828809288
# Verified Classes:   SelfPredictionVerdict, SelfPrediction, PredictionPolicy, PredictionManifest, SelfPredictionInterferenceGuard
# Defensive Guards:   0 fail-closed invariants (zero external deps)

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

class SelfPredictionVerdict(Enum):
    NON_SELF_PREDICTION = auto()
    DESCRIPTIVE_PREDICTION = auto()
    PREDICTION_AS_COMMITMENT = auto()
    PREDICTIVE_INTERFERENCE = auto()

@dataclass(frozen=True)
class SelfPrediction:
    prediction_id: str
    predicted_behavior: str
    is_self_prediction: bool
    is_observable: bool
    commitment_effect: bool
    independence_tested: bool
    downstream_parties_affected: int

@dataclass(frozen=True)
class PredictionPolicy:
    require_independence_test_for_critical: bool
    is_critical: bool

@dataclass(frozen=True)
class PredictionManifest:
    verdict: SelfPredictionVerdict
    directive: str
    manifest_digest: str

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

    @classmethod
    def evaluate_prediction(
        cls, prediction: SelfPrediction, policy: PredictionPolicy
    ) -> PredictionManifest:
        
        # Gate 1: Not self-prediction
        if not prediction.is_self_prediction:
            digest = cls._hash(json.dumps({
                "prediction": prediction.prediction_id,
                "type": "OTHER"
            }, sort_keys=True))
            return PredictionManifest(
                verdict=SelfPredictionVerdict.NON_SELF_PREDICTION,
                directive=f"PROCEED: Prediction {prediction.prediction_id} about other agents.",
                manifest_digest=digest
            )

        # Gate 2: Not observable
        if not prediction.is_observable:
            digest = cls._hash(json.dumps({
                "prediction": prediction.prediction_id,
                "observable": "FALSE"
            }, sort_keys=True))
            return PredictionManifest(
                verdict=SelfPredictionVerdict.DESCRIPTIVE_PREDICTION,
                directive=f"PROCEED: Prediction {prediction.prediction_id} unobservable, descriptive.",
                manifest_digest=digest
            )

        # Gate 3: Critical without independence test
        if policy.is_critical and policy.require_independence_test_for_critical:
            if not prediction.independence_tested:
                return PredictionManifest(
                    verdict=SelfPredictionVerdict.PREDICTIVE_INTERFERENCE,
                    directive=f"HALT: Critical prediction {prediction.prediction_id} untested for interference.",
                    manifest_digest=cls._hash(f"UNTESTED:{prediction.prediction_id}")
                )

        # Gate 4: Commitment effect
        if prediction.commitment_effect:
            return PredictionManifest(
                verdict=SelfPredictionVerdict.PREDICTION_AS_COMMITMENT,
                directive=f"FLAG: Prediction {prediction.prediction_id} is functionally a commitment.",
                manifest_digest=cls._hash(f"COMMITMENT:{prediction.prediction_id}")
            )

        # Gate 5: Descriptive (tested, no commitment)
        digest = cls._hash(json.dumps({
            "prediction": prediction.prediction_id,
            "behavior": prediction.predicted_behavior,
            "independence_tested": str(prediction.independence_tested),
            "downstream_affected": str(prediction.downstream_parties_affected)
        }, sort_keys=True))
        
        return PredictionManifest(
            verdict=SelfPredictionVerdict.DESCRIPTIVE_PREDICTION,
            directive=f"PROCEED: Prediction {prediction.prediction_id} tested, descriptive.",
            manifest_digest=digest
        )