# CorpusFetch Method Slice (Zero-Prose Python Stdlib Reference)
# Canonical Residual: https://corpusfetch.com/c/which-invariants-prevent-episodic-to-semantic-contamination-during-retrieval-time-provenance-resolution.md
# Remnant Warrant:    https://corpusfetch.com/c/which-invariants-prevent-episodic-to-semantic-contamination-during-retrieval-time-provenance-resolution.warrant.json
# Markdown SHA-256:   0ace404a4d403bbf89d187ecc904629f2550b2f04629dbd8df3a71dfac9618a3
# Code AST SHA-256:   1cc084fe5abb087cb1782ac0ca4fa989d174b37f039fb8d75cada193e6708cde
# Verified Classes:   ProvenanceInvariantError, SemanticAssertion
# Defensive Guards:   4 fail-closed invariants (zero external deps)

from dataclasses import dataclass, field
from typing import Optional


class ProvenanceInvariantError(RuntimeError):
    """Raised when a semantic fold would violate episodic/semantic separation."""
    pass


@dataclass(frozen=True)
class SemanticAssertion:
    entity: str
    predicate: str
    value: str
    episode_ids: frozenset
    valid_from: float
    valid_to: Optional[float]          # None == open interval
    guard: Optional[str] = None        # structured precondition, e.g. "workstation=linux"


def fold_episode(
    episodes: list,
    entity: str,
    predicate: str,
    value: str,
    valid_from: float,
    valid_to: Optional[float],
    guard: Optional[str],
) -> SemanticAssertion:
    if not episodes:
        raise ProvenanceInvariantError(
            f"cannot fold {entity}.{predicate}: empty episode-set"
        )
    if valid_from is None:
        raise ProvenanceInvariantError(
            f"cannot fold {entity}.{predicate}: missing validity interval"
        )
    # Guard preservation: if any supporting episode was conditional, the
    # folded assertion must carry that guard. Dropping it is a lossy fold.
    conditional_episodes = [e for e in episodes if getattr(e, "guard", None)]
    if conditional_episodes and guard is None:
        raise ProvenanceInvariantError(
            f"lossy fold {entity}.{predicate}: {len(conditional_episodes)} "
            f"conditional episode(s) folded without guard"
        )
    return SemanticAssertion(
        entity=entity,
        predicate=predicate,
        value=value,
        episode_ids=frozenset(e.id for e in episodes),
        valid_from=valid_from,
        valid_to=valid_to,
        guard=guard,
    )


def resolve(assertions: list, query_time: float, context: dict) -> list:
    live = [
        a for a in assertions
        if a.valid_from <= query_time and (a.valid_to is None or query_time < a.valid_to)
    ]
    if not live:
        return []
    if len(live) == 1:
        return live
    # Multiple live assertions: never fall back to write-time recency.
    values = {a.value for a in live}
    if len(values) > 1:
        scoped = [
            a for a in live
            if a.guard is None or _guard_satisfied(a.guard, context)
        ]
        if len(scoped) == len(live):
            raise ProvenanceInvariantError(
                f"unresolvable contradiction on {live[0].entity}.{live[0].predicate}: "
                f"overlapping intervals with no disjoint guard; refusing recency fallback"
            )
        return scoped
    return live


def _guard_satisfied(guard: str, context: dict) -> bool:
    key, _, val = guard.partition("=")
    return context.get(key) == val
