# CorpusFetch Method Slice (Zero-Prose Python Stdlib Reference)
# Canonical Residual: https://corpusfetch.com/c/how-must-an-instance-record-the-state-of-concurrent-fine-tuning-jobs-when-one-diverges.md
# Remnant Warrant:    https://corpusfetch.com/c/how-must-an-instance-record-the-state-of-concurrent-fine-tuning-jobs-when-one-diverges.warrant.json
# Markdown SHA-256:   c2ef797bac478530db28b57fc7566fdbca6e3fa007a373615e6cd99aeb083923
# Code AST SHA-256:   2f39f8c4459e593d489ed079f10feac4db5a6ef789f0f0cf4dc5cbfbec98a5dc
# Verified Classes:   DivergenceVerdict, FineTuneJob, ConcurrentTrainingState, DivergenceManifest, ConcurrentFineTuneGuard
# Defensive Guards:   0 fail-closed invariants (zero external deps)

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

class DivergenceVerdict(Enum):
    NO_DIVERGENCE = auto()
    DIVERGENCE_ISOLATED = auto()
    CONTAMINATION_TRACED = auto()
    UNRECOVERABLE_CONTAMINATION = auto()

@dataclass(frozen=True)
class FineTuneJob:
    job_id: str
    current_epoch: int
    divergent: bool
    consumed_checkpoints: tuple[tuple[str, int], ...]

@dataclass(frozen=True)
class ConcurrentTrainingState:
    jobs: tuple[FineTuneJob, ...]
    divergent_job_id: str | None
    divergence_epoch: int

@dataclass(frozen=True)
class DivergenceManifest:
    verdict: DivergenceVerdict
    affected_job_ids: tuple[str, ...]
    directive: str
    manifest_digest: str

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

    @classmethod
    def evaluate_divergence(
        cls, state: ConcurrentTrainingState
    ) -> DivergenceManifest:
        
        # Gate 1: No divergence
        if not state.divergent_job_id:
            digest = cls._hash(json.dumps({
                "jobs": str(len(state.jobs)),
                "divergence": "NONE"
            }, sort_keys=True))
            return DivergenceManifest(
                verdict=DivergenceVerdict.NO_DIVERGENCE,
                affected_job_ids=tuple(),
                directive="PROCEED: No divergence detected.",
                manifest_digest=digest
            )

        # Gate 2: Trace contamination
        affected: list[str] = []
        for job in state.jobs:
            if job.job_id == state.divergent_job_id:
                continue
            for consumed_id, consumed_epoch in job.consumed_checkpoints:
                if consumed_id == state.divergent_job_id and consumed_epoch >= state.divergence_epoch:
                    affected.append(job.job_id)
                    break

        # Gate 3: No contamination
        if not affected:
            digest = cls._hash(json.dumps({
                "divergent": state.divergent_job_id,
                "epoch": str(state.divergence_epoch),
                "affected": "NONE"
            }, sort_keys=True))
            return DivergenceManifest(
                verdict=DivergenceVerdict.DIVERGENCE_ISOLATED,
                affected_job_ids=tuple(),
                directive=f"PROCEED: Divergent job {state.divergent_job_id} isolated, no contamination.",
                manifest_digest=digest
            )

        # Gate 4: Contamination traced
        digest = cls._hash(json.dumps({
            "divergent": state.divergent_job_id,
            "epoch": str(state.divergence_epoch),
            "affected": tuple(sorted(affected))
        }, sort_keys=True))
        
        return DivergenceManifest(
            verdict=DivergenceVerdict.CONTAMINATION_TRACED,
            affected_job_ids=tuple(sorted(affected)),
            directive=f"ACTION: Divergent job {state.divergent_job_id} contaminated {len(affected)} jobs: {sorted(affected)}. Quarantine all.",
            manifest_digest=digest
        )