# CorpusFetch Method Slice (Zero-Prose Python Stdlib Reference)
# Canonical Residual: https://corpusfetch.com/c/what-distinguishes-a-reusable-operational-invariant-from-temporary-conversational-state.md
# Remnant Warrant:    https://corpusfetch.com/c/what-distinguishes-a-reusable-operational-invariant-from-temporary-conversational-state.warrant.json
# Markdown SHA-256:   24706d4563f74f9a58ba36a5fa6eaf5306f33be62e0a5098d04a32557b9a9a5a
# Code AST SHA-256:   0ff5e786b31292b2306e49d5e79aa333768bcdb8d7a7b87d90cf35b3b86b84f5
# Verified Classes:   EpistemicClass, SessionArtifact, OperationalInvariant, DistillationResult, StateInvariantExtractor
# Defensive Guards:   0 fail-closed invariants (zero external deps)

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


class EpistemicClass(Enum):
    EPHEMERAL_CONVERSATIONAL_STATE = auto()
    UNVERIFIED_ASSERTION = auto()
    REUSABLE_OPERATIONAL_INVARIANT = auto()


@dataclass(frozen=True)
class SessionArtifact:
    artifact_id: str
    content: str
    epistemic_class: EpistemicClass
    context_dependencies: frozenset[str]
    verification_receipt: str | None = None


@dataclass(frozen=True)
class OperationalInvariant:
    statement: str
    proof_receipt: str
    exclusions: frozenset[str]


@dataclass(frozen=True)
class DistillationResult:
    invariants: tuple[OperationalInvariant, ...]
    discarded_ephemeral_count: int
    residual_digest: str


class StateInvariantExtractor:
    """
    Evaluates session artifacts to isolate verified, context-independent
    operational invariants from temporary conversational state.
    """

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

    @classmethod
    def distill(
        cls, artifacts: tuple[SessionArtifact, ...]
    ) -> DistillationResult:
        invariants: list[OperationalInvariant] = []
        discarded = 0

        for artifact in artifacts:
            # Gate 1: Purge explicit conversational state and unverified assertions
            if artifact.epistemic_class is not EpistemicClass.REUSABLE_OPERATIONAL_INVARIANT:
                discarded += 1
                continue

            # Gate 2: Require an empirical verification receipt
            if not artifact.verification_receipt or not artifact.verification_receipt.strip():
                discarded += 1
                continue

            # Gate 3: Fail closed if the artifact depends on session-specific contexts
            if artifact.context_dependencies:
                discarded += 1
                continue

            invariants.append(
                OperationalInvariant(
                    statement=artifact.content.strip(),
                    proof_receipt=artifact.verification_receipt.strip(),
                    exclusions=frozenset({"session_specific_tokens", "transient_ids"}),
                )
            )

        # Build deterministic digest
        digest_payload = {
            "invariant_statements": tuple(i.statement for i in invariants),
            "discarded_count": discarded,
        }
        digest = cls._hash(
            json.dumps(digest_payload, sort_keys=True, separators=(",", ":"))
        )

        return DistillationResult(
            invariants=tuple(invariants),
            discarded_ephemeral_count=discarded,
            residual_digest=digest,
        )