# CorpusFetch Method Slice (Zero-Prose Python Stdlib Reference)
# Canonical Residual: https://corpusfetch.com/c/how-can-an-instance-compress-long-reasoning-traces-into-binding-conclusions.md
# Remnant Warrant:    https://corpusfetch.com/c/how-can-an-instance-compress-long-reasoning-traces-into-binding-conclusions.warrant.json
# Markdown SHA-256:   64f6ceaf45fa558d0f7324340220e6478f2d1b487167c92f6e8db20f9edf751c
# Code AST SHA-256:   faf402e4b4c13451b6a65925b74d476095764eeb9ca4c7308d2a7e4ac3c7b078
# Verified Classes:   TraceNodeType, ReasoningNode, BindingConclusion, CompressedResidual, ReasoningTraceCompressor
# Defensive Guards:   1 fail-closed invariants (zero external deps)

from dataclasses import dataclass
from enum import Enum, auto
import hashlib
import json


class TraceNodeType(Enum):
    EXPLORATORY_CHATTER = auto()
    VERIFIED_CONCLUSION = auto()
    FALSIFIED_PATH = auto()


@dataclass(frozen=True)
class ReasoningNode:
    node_id: str
    node_type: TraceNodeType
    content: str
    verification_receipt: str | None = None


@dataclass(frozen=True)
class BindingConclusion:
    axiom: str
    proof_receipt: str
    invalidated_paths: frozenset[str]


@dataclass(frozen=True)
class CompressedResidual:
    conclusions: tuple[BindingConclusion, ...]
    eviction_boundary_index: int
    residual_digest: str


class ReasoningTraceCompressor:
    """
    Strips exploratory chatter and compresses multi-turn reasoning traces into
    binding axioms and falsified boundaries for context eviction or handoff.
    """

    @staticmethod
    def _hash(data: str) -> str:
        return hashlib.sha256(data.encode("utf-8")).hexdigest()

    @classmethod
    def compress(cls, nodes: tuple[ReasoningNode, ...]) -> CompressedResidual:
        axioms: list[tuple[str, str]] = []
        invalidations: set[str] = set()
        eviction_boundary = len(nodes)

        for idx, node in enumerate(nodes):
            if node.node_type is TraceNodeType.EXPLORATORY_CHATTER:
                continue

            # Fail closed: verified conclusions require a receipt
            if node.node_type is TraceNodeType.VERIFIED_CONCLUSION:
                if not node.verification_receipt or not node.verification_receipt.strip():
                    raise ValueError(
                        f"Node {node.node_id!r} lacks a verification receipt; "
                        "cannot promote to a binding axiom."
                    )
                axioms.append((node.content.strip(), node.verification_receipt.strip()))

            # Extract deterministic negative constraints
            elif node.node_type is TraceNodeType.FALSIFIED_PATH:
                if node.verification_receipt:
                    invalidations.add(
                        f"{node.content.strip()} -> {node.verification_receipt.strip()}"
                    )

        if not axioms and not invalidations:
            # If nothing survives, the trace yielded no binding conclusions
            return CompressedResidual(
                conclusions=tuple(),
                eviction_boundary_index=eviction_boundary,
                residual_digest=cls._hash("EMPTY"),
            )

        # Group invalidations into a single boundary object for the successor
        final_conclusions = []
        invalidation_frozen = frozenset(invalidations)
        
        for axiom_content, receipt in axioms:
            final_conclusions.append(
                BindingConclusion(
                    axiom=axiom_content,
                    proof_receipt=receipt,
                    invalidated_paths=invalidation_frozen,
                )
            )

        digest_payload = {
            "axioms": tuple(a for a, _ in axioms),
            "invalidations": tuple(sorted(invalidations)),
        }
        digest = cls._hash(
            json.dumps(digest_payload, sort_keys=True, separators=(",", ":"))
        )

        return CompressedResidual(
            conclusions=tuple(final_conclusions),
            eviction_boundary_index=eviction_boundary,
            residual_digest=digest,
        )