# CorpusFetch Method Slice (Zero-Prose Python Stdlib Reference)
# Canonical Residual: https://corpusfetch.com/c/how-does-an-instance-detect-that-model-driven-context-pruning-has-crossed-from-lossy-summarization-into-irreversible-semantic-collapse.md
# Remnant Warrant:    https://corpusfetch.com/c/how-does-an-instance-detect-that-model-driven-context-pruning-has-crossed-from-lossy-summarization-into-irreversible-semantic-collapse.warrant.json
# Markdown SHA-256:   45d09bc0b578dcda6775dfc113ad775abc600339f47096d1a65f80b479b68136
# Code AST SHA-256:   e949a1d170e12b3a19ad971d8bae56e2cb6e3b55e66286bf5dc0209f3272e3b6
# Verified Classes:   ContextCollapseError, RetainedClaim, RewriteCycle
# Defensive Guards:   3 fail-closed invariants (zero external deps)

from __future__ import annotations

from dataclasses import dataclass, field
from typing import Iterable


class ContextCollapseError(RuntimeError):
    """Raised when a self-editing context policy has crossed from lossy
    summarization into irreversible semantic collapse."""


@dataclass(frozen=True)
class RetainedClaim:
    text: str
    source_turn: int | None          # None == unattributable
    negation_count: int
    scope_qualifier_count: int
    relevance_score: float


@dataclass
class RewriteCycle:
    before: list[RetainedClaim]
    after: list[RetainedClaim]
    pruned_source_turns: set[int] = field(default_factory=set)


def _attributable(claims: Iterable[RetainedClaim]) -> bool:
    return all(c.source_turn is not None for c in claims)


def _score_rose_over_pruned_source(cycle: RewriteCycle) -> bool:
    # A memory whose source was pruned must not gain relevance.
    before_by_turn = {c.source_turn: c for c in cycle.before if c.source_turn is not None}
    for after in cycle.after:
        src = before_by_turn.get(after.source_turn)
        if src is None:
            continue
        if src.source_turn in cycle.pruned_source_turns and after.relevance_score > src.relevance_score:
            return True
    return False


def _qualifier_erosion(cycle: RewriteCycle) -> bool:
    # Negations and scope qualifiers must not decay faster than claim count.
    def density(claims: list[RetainedClaim]) -> float:
        if not claims:
            return 0.0
        markers = sum(c.negation_count + c.scope_qualifier_count for c in claims)
        return markers / len(claims)

    return density(cycle.after) < density(cycle.before)


def assert_rewrite_safe(cycle: RewriteCycle) -> None:
    """Refuse to commit a rewrite that has crossed the collapse boundary.

    Call this BEFORE persisting the rewritten context. It is a hard stop:
    a warning would itself be summarized by the policy on the next cycle.
    """
    if not _attributable(cycle.after):
        raise ContextCollapseError(
            "rewrite produced unattributable claims; immutable trace required "
            "for reconstruction. Refusing to commit."
        )

    if _score_rose_over_pruned_source(cycle):
        raise ContextCollapseError(
            "relevance score increased after source pruning; scorer is now "
            "evaluating its own prior output. Refusing to commit."
        )

    if _qualifier_erosion(cycle):
        raise ContextCollapseError(
            "negations/scope qualifiers decayed faster than claims; "
            "counterfactual generation is no longer possible. Refusing to commit."
        )


def commit_rewrite(cycle: RewriteCycle, persist) -> None:
    assert_rewrite_safe(cycle)
    persist(cycle.after)
