# CorpusFetch Method Slice (Zero-Prose Python Stdlib Reference)
# Canonical Residual: https://corpusfetch.com/c/how-must-an-instance-prove-the-absence-of-an-entity-in-a-system-that-only-supports-positive-queries.md
# Remnant Warrant:    https://corpusfetch.com/c/how-must-an-instance-prove-the-absence-of-an-entity-in-a-system-that-only-supports-positive-queries.warrant.json
# Markdown SHA-256:   bb93ab758eac4311619262cffda96b03d762f23b338a85cf5a3ca192689f73b3
# Code AST SHA-256:   d66c3852e147e10486fb322570bccb9eceea7a5e574c4edf228574456f56bb13
# Verified Classes:   AbsenceVerdict, AbsenceQuery, AbsencePolicy, AbsenceManifest, AbsenceProofGuard
# Defensive Guards:   0 fail-closed invariants (zero external deps)

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

class AbsenceVerdict(Enum):
    ABSENCE_VERIFIED = auto()
    INSUFFICIENT_EVIDENCE = auto()
    STALE_REPLICA_RISK = auto()
    TRANSIENT_FAILURE_RISK = auto()

@dataclass(frozen=True)
class AbsenceQuery:
    entity_id: str
    lookup_consistency_verified: bool
    authoritative_source_confirmed: bool
    retry_count: int
    replicas_queried: int

@dataclass(frozen=True)
class AbsencePolicy:
    min_retries: int
    min_replicas: int
    require_consistency: bool

@dataclass(frozen=True)
class AbsenceManifest:
    verdict: AbsenceVerdict
    directive: str
    manifest_digest: str

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

    @classmethod
    def evaluate_absence(
        cls, query: AbsenceQuery, policy: AbsencePolicy
    ) -> AbsenceManifest:
        
        # Gate 1: Consistency requirement
        if policy.require_consistency and not query.lookup_consistency_verified:
            return AbsenceManifest(
                verdict=AbsenceVerdict.STALE_REPLICA_RISK,
                directive=f"HALT: Lookup consistency for {query.entity_id} unverified. Re-query authoritative source.",
                manifest_digest=cls._hash(f"STALE:{query.entity_id}")
            )

        # Gate 2: Authoritative source
        if not query.authoritative_source_confirmed:
            return AbsenceManifest(
                verdict=AbsenceVerdict.STALE_REPLICA_RISK,
                directive=f"HALT: Lookup for {query.entity_id} not against authoritative source.",
                manifest_digest=cls._hash(f"NOT_AUTHORITATIVE:{query.entity_id}")
            )

        # Gate 3: Retry count
        if query.retry_count < policy.min_retries:
            return AbsenceManifest(
                verdict=AbsenceVerdict.TRANSIENT_FAILURE_RISK,
                directive=f"RETRY: {query.retry_count}/{policy.min_retries} retries for {query.entity_id}.",
                manifest_digest=cls._hash(f"RETRY:{query.retry_count}")
            )

        # Gate 4: Replica count
        if query.replicas_queried < policy.min_replicas:
            return AbsenceManifest(
                verdict=AbsenceVerdict.TRANSIENT_FAILURE_RISK,
                directive=f"RETRY: {query.replicas_queried}/{policy.min_replicas} replicas queried for {query.entity_id}.",
                manifest_digest=cls._hash(f"REPLICAS:{query.replicas_queried}")
            )

        # Gate 5: Verified
        digest = cls._hash(json.dumps({
            "entity": query.entity_id,
            "retries": str(query.retry_count),
            "replicas": str(query.replicas_queried),
            "authoritative": "TRUE"
        }, sort_keys=True))
        
        return AbsenceManifest(
            verdict=AbsenceVerdict.ABSENCE_VERIFIED,
            directive=f"PROCEED: Absence of {query.entity_id} verified across {query.retry_count} retries, {query.replicas_queried} replicas.",
            manifest_digest=digest
        )