# CorpusFetch Method Slice (Zero-Prose Python Stdlib Reference)
# Canonical Residual: https://corpusfetch.com/c/what-structural-signals-indicate-that-automatic-context-compaction-has-silently-violated-the-summarization-invariant.md
# Remnant Warrant:    https://corpusfetch.com/c/what-structural-signals-indicate-that-automatic-context-compaction-has-silently-violated-the-summarization-invariant.warrant.json
# Markdown SHA-256:   e069028e59b69d5a8218613d4951561ce45306ea644a7286242c8463cadebb3b
# Code AST SHA-256:   186148401603036aec48604929215210f4c8a6626ac18b4073f1cf68be9005a7
# Verified Classes:   CompactionInvariantError, ConstraintLedger
# Defensive Guards:   6 fail-closed invariants (zero external deps)

from dataclasses import dataclass, field
from typing import Iterable


class CompactionInvariantError(RuntimeError):
    """Raised when a budget-compliant summary has silently dropped a load-bearing fact."""
    pass


@dataclass
class ConstraintLedger:
    negations: list[str] = field(default_factory=list)
    numeric_bounds: list[str] = field(default_factory=list)
    open_obligations: list[str] = field(default_factory=list)
    entity_defs: list[str] = field(default_factory=list)

    def carry_forward(self) -> "ConstraintLedger":
        # Copy, never regenerate. Regeneration is where compounding loss enters.
        return ConstraintLedger(
            negations=list(self.negations),
            numeric_bounds=list(self.numeric_bounds),
            open_obligations=list(self.open_obligations),
            entity_defs=list(self.entity_defs),
        )


def _clause_contains(text: str, needle: str) -> bool:
    return needle.lower() in text.lower()


def validate_compaction(
    summary: str,
    ledger: ConstraintLedger,
    token_budget: int,
    token_count: int,
) -> None:
    if token_count > token_budget:
        # Loud failure: budget overflow. Distinct from invariant violation.
        raise CompactionInvariantError(
            f"budget overflow: {token_count} > {token_budget}"
        )

    # Budget compliance is necessary but NOT sufficient. Check the kernel.
    missing_negations = [n for n in ledger.negations if not _clause_contains(summary, n)]
    if missing_negations:
        raise CompactionInvariantError(
            f"negation collapse: dropped {missing_negations!r} from summary"
        )

    missing_bounds = [b for b in ledger.numeric_bounds if not _clause_contains(summary, b)]
    if missing_bounds:
        raise CompactionInvariantError(
            f"numeric/bound drift: dropped {missing_bounds!r} from summary"
        )

    missing_obligations = [
        o for o in ledger.open_obligations if not _clause_contains(summary, o)
    ]
    if missing_obligations:
        raise CompactionInvariantError(
            f"obligation orphaning: dropped {missing_obligations!r} from summary"
        )

    missing_entities = [e for e in ledger.entity_defs if not _clause_contains(summary, e)]
    if missing_entities:
        raise CompactionInvariantError(
            f"dangling definite reference: entity {missing_entities!r} elided while referenced"
        )


def compact_cycle(
    summaries: Iterable[str],
    ledger: ConstraintLedger,
    token_budget: int,
    count_tokens,
) -> str:
    current = ""
    carried = ledger
    for generation, candidate in enumerate(summaries):
        validate_compaction(candidate, carried, token_budget, count_tokens(candidate))
        current = candidate
        # Carry the ledger forward unchanged across compaction-of-compaction.
        carried = carried.carry_forward()
    if not current:
        raise CompactionInvariantError("no summary produced; refusing to proceed empty")
    return current
