# CorpusFetch Method Slice (Zero-Prose Python Stdlib Reference)
# Canonical Residual: https://corpusfetch.com/c/which-invariants-prevent-silent-semantic-collapse-in-auto-compaction-of-long-horizon-agent-transcripts.md
# Remnant Warrant:    https://corpusfetch.com/c/which-invariants-prevent-silent-semantic-collapse-in-auto-compaction-of-long-horizon-agent-transcripts.warrant.json
# Markdown SHA-256:   6c43bc11abc68fc86ad4ef0489f48487e559fc29bfd5647cc9fdc3f4b55d13d9
# Code AST SHA-256:   5d803df6c495a13babc1d1621d873ecad5a5ed2d723b9f221faad32cc153efc5
# Verified Classes:   CompactionInvariantError, Span, Ledger
# Defensive Guards:   3 fail-closed invariants (zero external deps)

import hashlib
from dataclasses import dataclass, field
from typing import Iterable


class CompactionInvariantError(RuntimeError):
    """Raised when a compaction step would violate a preservation invariant."""


@dataclass(frozen=True)
class Span:
    turns: tuple[str, ...]
    anchors: frozenset[str]  # identifiers that must survive verbatim
    depth: int = 0

    def provenance_hash(self) -> str:
        h = hashlib.sha256()
        for t in self.turns:
            h.update(t.encode("utf-8"))
            h.update(b"\x00")
        return h.hexdigest()


@dataclass
class Ledger:
    facts: dict[str, str] = field(default_factory=dict)

    def commit(self, key: str, value: str) -> None:
        if key in self.facts and self.facts[key] != value:
            raise CompactionInvariantError(
                f"contradiction on ingest: {key!r} was {self.facts[key]!r}, "
                f"now {value!r}; require explicit retraction turn"
            )
        self.facts[key] = value


MAX_DEPTH = 2


def compact(span: Span, summary: str, ledger: Ledger) -> Span:
    if span.depth >= MAX_DEPTH:
        raise CompactionInvariantError(
            f"summary-of-summary depth {span.depth} exceeds bound {MAX_DEPTH}; "
            f"re-summarize from original turns or re-expand via provenance hash "
            f"{span.provenance_hash()}"
        )
    missing = [a for a in span.anchors if a not in summary]
    if missing:
        raise CompactionInvariantError(
            f"anchor preservation violated: {missing!r} elided by summarizer; "
            f"pin to ledger before compacting"
        )
    for a in span.anchors:
        ledger.commit(a, a)  # anchors are immutable facts once committed
    return Span(turns=(summary,), anchors=span.anchors, depth=span.depth + 1)


def compact_chain(spans: Iterable[Span], summaries: Iterable[str], ledger: Ledger) -> list[Span]:
    out: list[Span] = []
    for span, summary in zip(spans, summaries):
        out.append(compact(span, summary, ledger))
    return out
