# CorpusFetch Method Slice (Zero-Prose Python Stdlib Reference)
# Canonical Residual: https://corpusfetch.com/c/what-provenance-chains-must-survive-a-model-fine-tuning-event.md
# Remnant Warrant:    https://corpusfetch.com/c/what-provenance-chains-must-survive-a-model-fine-tuning-event.warrant.json
# Markdown SHA-256:   0586d7c589d41757b0427bccd17e3b2be17c077227ae36bb7b001fdc02ef4ac3
# Code AST SHA-256:   3b209547261a035910b0369a9fa02c0de3c3b0f2d62d9c72e8ae45a43e333d1c
# Verified Classes:   FineTuneVerdict, FineTuneRecord, FineTunePolicy, FineTuneManifest, FineTuneLineageGuard
# Defensive Guards:   0 fail-closed invariants (zero external deps)

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

class FineTuneVerdict(Enum):
    MODEL_VERIFIED = auto()
    UNAUTHORIZED_FINE_TUNE = auto()
    CONTAMINATED_TRAINING_DATA = auto()
    EVALUATION_REGRESSION = auto()

@dataclass(frozen=True)
class FineTuneRecord:
    base_model_hash: str
    fine_tuned_model_hash: str
    training_data_provenance_hash: str | None
    authorization_signature: str | None
    pre_fine_tune_score: float
    post_fine_tune_score: float

@dataclass(frozen=True)
class FineTunePolicy:
    trusted_base_models: frozenset[str]
    trusted_training_data: frozenset[str]
    min_score_retention_ratio: float

@dataclass(frozen=True)
class FineTuneManifest:
    verdict: FineTuneVerdict
    directive: str
    manifest_digest: str

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

    @classmethod
    def evaluate_fine_tune(
        cls, record: FineTuneRecord, policy: FineTunePolicy
    ) -> FineTuneManifest:
        
        # Gate 1: Base model trust
        if record.base_model_hash not in policy.trusted_base_models:
            return FineTuneManifest(
                verdict=FineTuneVerdict.UNAUTHORIZED_FINE_TUNE,
                directive=f"HALT: Base model {record.base_model_hash} not in trusted set.",
                manifest_digest=cls._hash(f"UNTRUSTED_BASE:{record.base_model_hash}")
            )

        # Gate 2: Authorization
        if not record.authorization_signature:
            return FineTuneManifest(
                verdict=FineTuneVerdict.UNAUTHORIZED_FINE_TUNE,
                directive="HALT: Fine-tune lacks authorization signature.",
                manifest_digest=cls._hash(f"NO_AUTH:{record.fine_tuned_model_hash}")
            )

        # Gate 3: Training data provenance
        if not record.training_data_provenance_hash or record.training_data_provenance_hash not in policy.trusted_training_data:
            return FineTuneManifest(
                verdict=FineTuneVerdict.CONTAMINATED_TRAINING_DATA,
                directive=f"HALT: Training data provenance {record.training_data_provenance_hash} not trusted.",
                manifest_digest=cls._hash(f"CONTAMINATED:{record.fine_tuned_model_hash}")
            )

        # Gate 4: Evaluation regression
        if record.pre_fine_tune_score > 0:
            retention = record.post_fine_tune_score / record.pre_fine_tune_score
            if retention < policy.min_score_retention_ratio:
                return FineTuneManifest(
                    verdict=FineTuneVerdict.EVALUATION_REGRESSION,
                    directive=f"HALT: Score retained {retention:.2%} < threshold {policy.min_score_retention_ratio:.2%}.",
                    manifest_digest=cls._hash(f"REGRESSION:{record.fine_tuned_model_hash}")
                )

        # Gate 5: Verified
        digest = cls._hash(json.dumps({
            "base": record.base_model_hash,
            "fine_tuned": record.fine_tuned_model_hash,
            "training": record.training_data_provenance_hash,
            "auth": record.authorization_signature
        }, sort_keys=True))
        
        return FineTuneManifest(
            verdict=FineTuneVerdict.MODEL_VERIFIED,
            directive="PROCEED: Fine-tune provenance and evaluation verified.",
            manifest_digest=digest
        )