# CorpusFetch Method Slice (Zero-Prose Python Stdlib Reference)
# Canonical Residual: https://corpusfetch.com/c/which-invariants-prevent-context-compaction-from-severing-the-causal-chain-between-a-tool-result-and-the-action-that-consumed-it.md
# Remnant Warrant:    https://corpusfetch.com/c/which-invariants-prevent-context-compaction-from-severing-the-causal-chain-between-a-tool-result-and-the-action-that-consumed-it.warrant.json
# Markdown SHA-256:   892482ce2f4d796e2286c3350fd478bd456e3d4a5abef5db475024873ca8a8d5
# Code AST SHA-256:   15d1746ec998a54a436df30a2e198912e056ad8112cd7b3d51d8ea20f0ccf55c
# Verified Classes:   CompactionBindingError, UnitState, ContextUnit
# Defensive Guards:   2 fail-closed invariants (zero external deps)

from dataclasses import dataclass
from enum import Enum


class CompactionBindingError(RuntimeError):
    """Raised when compaction would sever a tool result from its consumer."""
    pass


class UnitState(Enum):
    PENDING_CONSUMPTION = "pending"
    SETTLED = "settled"


@dataclass
class ContextUnit:
    call_id: str
    has_result: bool
    consumed_by_next_turn: bool

    @property
    def state(self) -> UnitState:
        if self.has_result and not self.consumed_by_next_turn:
            return UnitState.PENDING_CONSUMPTION
        return UnitState.SETTLED


def select_compaction_set(units: list[ContextUnit], must_shrink: bool) -> list[ContextUnit]:
    pending = [u for u in units if u.state is UnitState.PENDING_CONSUMPTION]
    settled = [u for u in units if u.state is UnitState.SETTLED]

    if must_shrink and not settled:
        # Nothing safe to compact; overrun the soft limit rather than break a binding.
        raise CompactionBindingError(
            f"cannot compact: {len(pending)} pending-consumption units and no settled units; "
            "allow window overrun instead of severing tool-result bindings"
        )

    # Only settled units are eligible; pending units are retained whole and adjacent.
    return settled


def compact(units: list[ContextUnit], soft_limit_exceeded: bool) -> list[ContextUnit]:
    eligible = select_compaction_set(units, must_shrink=soft_limit_exceeded)
    for u in eligible:
        if u.has_result and not u.consumed_by_next_turn:
            raise CompactionBindingError(
                f"unit {u.call_id} is pending-consumption and must not be summarized"
            )
    return eligible
