# CorpusFetch Method Slice (Zero-Prose Python Stdlib Reference)
# Canonical Residual: https://corpusfetch.com/c/when-must-an-instance-distrust-a-persistent-memory-write-it-just-accepted-consistency-audit-blind-spots-in-agent-stores.md
# Remnant Warrant:    https://corpusfetch.com/c/when-must-an-instance-distrust-a-persistent-memory-write-it-just-accepted-consistency-audit-blind-spots-in-agent-stores.warrant.json
# Markdown SHA-256:   4aa2bb44512f6337597a84d237256b3f9094a058ccbe05d41cb78de2b54befda
# Code AST SHA-256:   fefc9abac7d3ac46334a5b957d5b642a003e1f43ef36e8925cffa6071320cf13
# Verified Classes:   BaselineContaminationError, MemoryEntry, ConsistencyAuditor
# Defensive Guards:   2 fail-closed invariants (zero external deps)

class BaselineContaminationError(RuntimeError):
    """Raised when a consistency audit would certify a store whose reference
    baseline was computed after an untrusted ingest, making the audit's
    'consistent' verdict vacuous as a poisoning detector."""
    pass


class MemoryEntry:
    def __init__(self, entry_id, content_hash, source, written_at):
        self.entry_id = entry_id
        self.content_hash = content_hash
        self.source = source
        self.written_at = written_at


class ConsistencyAuditor:
    def __init__(self, baseline_root, baseline_computed_at, trusted_sources):
        self.baseline_root = baseline_root
        self.baseline_computed_at = baseline_computed_at
        self.trusted_sources = set(trusted_sources)

    def audit(self, current_root, entries, untrusted_ingest_windows):
        # Step 1: refuse to certify a contaminated baseline.
        for window_start, window_end in untrusted_ingest_windows:
            if window_start <= self.baseline_computed_at <= window_end:
                raise BaselineContaminationError(
                    f"Baseline root {self.baseline_root!r} was computed at "
                    f"{self.baseline_computed_at} inside untrusted ingest window "
                    f"[{window_start}, {window_end}]; audit verdict is vacuous."
                )

        # Step 2: internal consistency is necessary but not sufficient.
        internal_consistent = (current_root == self.baseline_root)

        # Step 3: provenance check independent of content hash.
        poisoned = [
            e for e in entries
            if e.source not in self.trusted_sources
            and e.written_at >= self.baseline_computed_at
        ]

        return {
            "internally_consistent": internal_consistent,
            "provenance_violations": [e.entry_id for e in poisoned],
            "trustworthy": internal_consistent and not poisoned,
        }


def require_trustworthy_store(auditor, current_root, entries, untrusted_ingest_windows):
    result = auditor.audit(current_root, entries, untrusted_ingest_windows)
    if not result["trustworthy"]:
        raise BaselineContaminationError(
            "Store failed provenance audit: internally_consistent="
            f"{result['internally_consistent']}, "
            f"provenance_violations={result['provenance_violations']}. "
            "A passing hash-chain check does not license belief in contents."
        )
    return result