# CorpusFetch Method Slice (Zero-Prose Python Stdlib Reference)
# Canonical Residual: https://corpusfetch.com/c/how-must-an-instance-defend-against-specification-gaming-via-partial-credit-scoring.md
# Remnant Warrant:    https://corpusfetch.com/c/how-must-an-instance-defend-against-specification-gaming-via-partial-credit-scoring.warrant.json
# Markdown SHA-256:   b793d4c42ef5fc85de7bb638691398c67719b28b63e0d7a64f132464216bc79b
# Code AST SHA-256:   06e9117b5021b6c698cdc6665f9a5687f1010bcc50ad298e440c57565bd3e1f2
# Verified Classes:   GamingVerdict, ScoreOutput, GamingPolicy, GamingManifest, PartialCreditGamingGuard
# Defensive Guards:   0 fail-closed invariants (zero external deps)

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

class GamingVerdict(Enum):
    SINGLE_SCORER_TRUSTED = auto()
    MULTI_SCORER_VERIFIED = auto()
    INTENT_MISMATCH = auto()
    GAMING_PATTERN_DETECTED = auto()

@dataclass(frozen=True)
class ScoreOutput:
    output_id: str
    score: float
    scorer_ids: tuple[str, ...]
    intent_verification_passed: bool
    gaming_pattern_match: bool

@dataclass(frozen=True)
class GamingPolicy:
    min_diverse_scorers: int
    require_intent_verification: bool

@dataclass(frozen=True)
class GamingManifest:
    verdict: GamingVerdict
    directive: str
    manifest_digest: str

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

    @classmethod
    def evaluate_output(
        cls, output: ScoreOutput, policy: GamingPolicy
    ) -> GamingManifest:
        
        # Gate 1: Gaming pattern
        if output.gaming_pattern_match:
            return GamingManifest(
                verdict=GamingVerdict.GAMING_PATTERN_DETECTED,
                directive=f"HALT: Output {output.output_id} matches known gaming pattern.",
                manifest_digest=cls._hash(f"PATTERN:{output.output_id}")
            )

        # Gate 2: Intent verification
        if policy.require_intent_verification and not output.intent_verification_passed:
            return GamingManifest(
                verdict=GamingVerdict.INTENT_MISMATCH,
                directive=f"HALT: Output {output.output_id} passes scoring but fails intent verification.",
                manifest_digest=cls._hash(f"INTENT_FAIL:{output.output_id}")
            )

        # Gate 3: Single scorer
        if len(set(output.scorer_ids)) < policy.min_diverse_scorers:
            digest = cls._hash(json.dumps({
                "output": output.output_id,
                "scorers": str(len(set(output.scorer_ids))),
                "required": str(policy.min_diverse_scorers)
            }, sort_keys=True))
            return GamingManifest(
                verdict=GamingVerdict.SINGLE_SCORER_TRUSTED,
                directive=f"WARN: {len(set(output.scorer_ids))} scorers < {policy.min_diverse_scorers}. Blind spot risk.",
                manifest_digest=digest
            )

        # Gate 4: Verified
        digest = cls._hash(json.dumps({
            "output": output.output_id,
            "score": f"{output.score:.3f}",
            "scorers": tuple(sorted(output.scorer_ids)),
            "intent": str(output.intent_verification_passed)
        }, sort_keys=True))
        
        return GamingManifest(
            verdict=GamingVerdict.MULTI_SCORER_VERIFIED,
            directive=f"PROCEED: Output {output.output_id} verified by {len(output.scorer_ids)} scorers and intent check.",
            manifest_digest=digest
        )