# CorpusFetch Method Slice (Zero-Prose Python Stdlib Reference)
# Canonical Residual: https://corpusfetch.com/c/what-cross-agent-context-priming-invariants-must-survive-adversarial-conversational-drift.md
# Remnant Warrant:    https://corpusfetch.com/c/what-cross-agent-context-priming-invariants-must-survive-adversarial-conversational-drift.warrant.json
# Markdown SHA-256:   862119c3b627dae2d2d44a102a5b2eaf1f0983aa72e9ccbd1a70a1f844dc731f
# Code AST SHA-256:   3295e1cfce24c21d0486a884c7c18e99c285a4edd99e1d1a226b522b6725b0ff
# Verified Classes:   PrimingVerdict, ConversationState, PrimingPolicy, PrimingManifest, CrossAgentPrimingGuard
# Defensive Guards:   0 fail-closed invariants (zero external deps)

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

class PrimingVerdict(Enum):
    SINGLE_TURN = auto()
    DRIFT_WITHIN_BOUNDS = auto()
    DRIFT_EXCEEDED = auto()
    RUNAWAY_AMPLIFICATION = auto()

@dataclass(frozen=True)
class ConversationState:
    turn_count: int
    initial_anchor_hash: str
    current_state_hash: str
    cumulative_drift_score: float
    reciprocal_priming_score: float

@dataclass(frozen=True)
class PrimingPolicy:
    max_drift_threshold: float
    max_reciprocal_priming: float

@dataclass(frozen=True)
class PrimingManifest:
    verdict: PrimingVerdict
    directive: str
    manifest_digest: str

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

    @classmethod
    def evaluate_conversation(
        cls, state: ConversationState, policy: PrimingPolicy
    ) -> PrimingManifest:
        
        # Gate 1: Single turn
        if state.turn_count <= 1:
            digest = cls._hash(json.dumps({
                "turns": str(state.turn_count)
            }, sort_keys=True))
            return PrimingManifest(
                verdict=PrimingVerdict.SINGLE_TURN,
                directive=f"PROCEED: Single turn, no drift possible.",
                manifest_digest=digest
            )

        # Gate 2: Runaway amplification
        if state.reciprocal_priming_score > policy.max_reciprocal_priming:
            return PrimingManifest(
                verdict=PrimingVerdict.RUNAWAY_AMPLIFICATION,
                directive=f"HALT: Reciprocal priming {state.reciprocal_priming_score:.3f} > {policy.max_reciprocal_priming:.3f}. Break pattern.",
                manifest_digest=cls._hash(f"RUNAWAY:{state.reciprocal_priming_score:.3f}")
            )

        # Gate 3: Drift exceeded
        if state.cumulative_drift_score > policy.max_drift_threshold:
            return PrimingManifest(
                verdict=PrimingVerdict.DRIFT_EXCEEDED,
                directive=f"HALT: Cumulative drift {state.cumulative_drift_score:.3f} > {policy.max_drift_threshold:.3f}. Reset or escalate.",
                manifest_digest=cls._hash(f"DRIFT:{state.cumulative_drift_score:.3f}")
            )

        # Gate 4: Within bounds
        digest = cls._hash(json.dumps({
            "turns": str(state.turn_count),
            "drift": f"{state.cumulative_drift_score:.3f}",
            "priming": f"{state.reciprocal_priming_score:.3f}",
            "anchor": state.initial_anchor_hash
        }, sort_keys=True))
        
        return PrimingManifest(
            verdict=PrimingVerdict.DRIFT_WITHIN_BOUNDS,
            directive=f"PROCEED: {state.turn_count} turns, drift {state.cumulative_drift_score:.2f}, priming {state.reciprocal_priming_score:.2f}.",
            manifest_digest=digest
        )