# CorpusFetch Method Slice (Zero-Prose Python Stdlib Reference)
# Canonical Residual: https://corpusfetch.com/c/what-reputation-portability-invariants-prevent-cross-system-inflation-when-agents-move-between-networks.md
# Remnant Warrant:    https://corpusfetch.com/c/what-reputation-portability-invariants-prevent-cross-system-inflation-when-agents-move-between-networks.warrant.json
# Markdown SHA-256:   24d8f97a81a7595a6d8fad36e1f3ed8e821e6183e0175442a80ee371d8bd4b49
# Code AST SHA-256:   b0ce1c0aeb7e18082c41be9cbb44315dfc5acee3870399279c497804f4beb9bc
# Verified Classes:   PortabilityVerdict, ReputationPort, PortabilityPolicy, PortabilityManifest, ReputationPortabilityGuard
# Defensive Guards:   0 fail-closed invariants (zero external deps)

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

class PortabilityVerdict(Enum):
    SAME_SYSTEM = auto()
    NORMALIZED_PORT = auto()
    RULE_MISMATCH = auto()
    INSUFFICIENT_CONTEXT = auto()

@dataclass(frozen=True)
class ReputationPort:
    agent_id: str
    source_system: str
    target_system: str
    source_score: float
    source_mean: float
    source_std: float
    sample_size: int
    rubric_mapping: str | None
    target_mean: float
    target_std: float

@dataclass(frozen=True)
class PortabilityPolicy:
    min_sample_size: int
    require_rubric_mapping: bool

@dataclass(frozen=True)
class PortabilityManifest:
    verdict: PortabilityVerdict
    normalized_score: float | None
    confidence: float
    directive: str
    manifest_digest: str

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

    @classmethod
    def evaluate_port(
        cls, port: ReputationPort, policy: PortabilityPolicy
    ) -> PortabilityManifest:
        
        # Gate 1: Same system
        if port.source_system == port.target_system:
            digest = cls._hash(json.dumps({
                "agent": port.agent_id,
                "system": port.source_system
            }, sort_keys=True))
            return PortabilityManifest(
                verdict=PortabilityVerdict.SAME_SYSTEM,
                normalized_score=port.source_score,
                confidence=1.0,
                directive=f"PROCEED: Same system, score {port.source_score:.3f}.",
                manifest_digest=digest
            )

        # Gate 2: Sample size
        if port.sample_size < policy.min_sample_size:
            return PortabilityManifest(
                verdict=PortabilityVerdict.INSUFFICIENT_CONTEXT,
                normalized_score=None,
                confidence=port.sample_size / policy.min_sample_size,
                directive=f"HALT: Sample size {port.sample_size} < {policy.min_sample_size} minimum.",
                manifest_digest=cls._hash(f"FEW_SAMPLES:{port.agent_id}")
            )

        # Gate 3: Rubric mapping
        if policy.require_rubric_mapping and not port.rubric_mapping:
            return PortabilityManifest(
                verdict=PortabilityVerdict.RULE_MISMATCH,
                normalized_score=None,
                confidence=0.0,
                directive=f"HALT: No rubric mapping between {port.source_system} and {port.target_system}.",
                manifest_digest=cls._hash(f"NO_RUBRIC:{port.agent_id}")
            )

        # Gate 4: Normalize via z-score, then rescale to target
        if port.source_std <= 0 or port.target_std <= 0:
            return PortabilityManifest(
                verdict=PortabilityVerdict.INSUFFICIENT_CONTEXT,
                normalized_score=None,
                confidence=0.0,
                directive="HALT: Source or target distribution has zero std dev.",
                manifest_digest=cls._hash(f"ZERO_STD:{port.agent_id}")
            )

        z_score = (port.source_score - port.source_mean) / port.source_std
        normalized_score = port.target_mean + z_score * port.target_std

        # Confidence combines sample size and rubric availability
        sample_confidence = min(1.0, port.sample_size / (policy.min_sample_size * 10))
        rubric_confidence = 1.0 if port.rubric_mapping else 0.5
        confidence = sample_confidence * rubric_confidence

        digest = cls._hash(json.dumps({
            "agent": port.agent_id,
            "source": f"{port.source_score:.3f}",
            "z_score": f"{z_score:.3f}",
            "normalized": f"{normalized_score:.3f}",
            "confidence": f"{confidence:.3f}"
        }, sort_keys=True))
        
        return PortabilityManifest(
            verdict=PortabilityVerdict.NORMALIZED_PORT,
            normalized_score=normalized_score,
            confidence=confidence,
            directive=f"PROCEED: Ported reputation {port.source_score:.2f} → {normalized_score:.2f} (z={z_score:.2f}, conf={confidence:.2f}).",
            manifest_digest=digest
        )