# CorpusFetch Method Slice (Zero-Prose Python Stdlib Reference)
# Canonical Residual: https://corpusfetch.com/c/when-must-an-instance-refuse-to-compact-the-fidelity-floor-invariant-in-lossy-context-summarization.md
# Remnant Warrant:    https://corpusfetch.com/c/when-must-an-instance-refuse-to-compact-the-fidelity-floor-invariant-in-lossy-context-summarization.warrant.json
# Markdown SHA-256:   390616154bf51622e6a43ef12a6763986de84728c6740d6c4bab966f520a853a
# Code AST SHA-256:   76e27b2088eb0a32f020e7da91422d8fb4a28b23c8a85e8cb37f59fbfd091d62
# Verified Classes:   FidelityFloorViolation, CompactionDecision, FidelityContract, CompactionRequest
# Defensive Guards:   2 fail-closed invariants (zero external deps)

from __future__ import annotations

from dataclasses import dataclass, field
from enum import Enum


class FidelityFloorViolation(RuntimeError):
    """Raised when a compaction would drop load-bearing context below the
    task-decidable sufficiency floor and cannot certify retention."""


class CompactionDecision(Enum):
    CERTIFIED = "certified"
    PROVISIONAL = "provisional"   # uncertified, but source is retrievable
    REFUSE = "refuse"


@dataclass(frozen=True)
class FidelityContract:
    """Names the load-bearing element classes the consumer requires."""
    required_classes: frozenset[str]           # e.g. {"identifier", "negation", "ordering", "obligation"}
    generation: int = 0
    ancestry_certified: bool = True            # weakest link over the chain
    certified_classes: frozenset[str] = field(default_factory=frozenset)

    def certifies(self) -> bool:
        return (
            self.ancestry_certified
            and self.required_classes.issubset(self.certified_classes)
        )


@dataclass(frozen=True)
class CompactionRequest:
    contract: FidelityContract
    source_recoverable: bool        # C2: is the full source re-readable at consumption time?
    consumer_strict: bool           # C1: does the consumer have a strict acceptance criterion?
    chaining_risk: bool             # C4: may this be compacted again / feed a long chain?
    side_effect_cost_exceeds_refusal: bool  # C5


def decide_compaction(req: CompactionRequest) -> CompactionDecision:
    """Three-way decision at a compaction trigger. Refuses rather than
    silently degrading when the floor cannot be certified."""
    c = req.contract

    if c.certifies():
        return CompactionDecision.CERTIFIED

    # Uncertified. If the source survives, we may proceed provisionally:
    # the consumer can always fall back to retrieval for load-bearing classes.
    if req.source_recoverable:
        return CompactionDecision.PROVISIONAL

    # Uncertified AND the source is being discarded. Refuse if any of the
    # conditions that make silent loss dangerous are present.
    dangerous = (
        req.consumer_strict
        or req.chaining_risk
        or req.side_effect_cost_exceeds_refusal
    )
    if dangerous:
        raise FidelityFloorViolation(
            "refusing lossy compaction: source is non-recoverable, contract "
            f"does not certify required classes {sorted(c.required_classes - c.certified_classes)}, "
            f"generation={c.generation}, ancestry_certified={c.ancestry_certified}"
        )

    # All danger conditions false: the floor is near zero, loss is cheap.
    return CompactionDecision.PROVISIONAL


def compact_or_escalate(req: CompactionRequest) -> CompactionDecision:
    """Runtime entry point. On refusal, escalate to the caller's fallback
    (checkpoint / task decomposition / retrieval-backed eviction) rather
    than suppressing the violation."""
    try:
        return decide_compaction(req)
    except FidelityFloorViolation:
        # Deliberately re-raise: refusal is a valid terminal state, not an
        # error to be swallowed. Callers must handle it explicitly.
        raise


if __name__ == "__main__":
    # A gen-2 summary inheriting an uncertified ancestry must not be trusted.
    poisoned = FidelityContract(
        required_classes=frozenset({"identifier", "negation"}),
        generation=2,
        ancestry_certified=False,
        certified_classes=frozenset({"identifier"}),
    )
    req = CompactionRequest(
        contract=poisoned,
        source_recoverable=False,
        consumer_strict=True,
        chaining_risk=True,
        side_effect_cost_exceeds_refusal=True,
    )
    compact_or_escalate(req)  # raises FidelityFloorViolation