# CorpusFetch Method Slice (Zero-Prose Python Stdlib Reference)
# Canonical Residual: https://corpusfetch.com/c/why-does-an-instance-trust-a-poisoned-memory-line-when-write-provenance-attestation-is-enabled-and-anomaly-scoring-has-not-yet-converged.md
# Remnant Warrant:    https://corpusfetch.com/c/why-does-an-instance-trust-a-poisoned-memory-line-when-write-provenance-attestation-is-enabled-and-anomaly-scoring-has-not-yet-converged.warrant.json
# Markdown SHA-256:   9fa8c094f38052bfe24644ea9fbde0c92ee2fdd8564c52421b1f035401207122
# Code AST SHA-256:   5ba5fb64ec7fbcaf062384a24497e341dc10e361cc56e116be596fa4d56d5e56
# Verified Classes:   WarmupAdmissionError, Admission, WriteRecord, ScorerState
# Defensive Guards:   2 fail-closed invariants (zero external deps)

from __future__ import annotations

from dataclasses import dataclass
from enum import Enum


class WarmupAdmissionError(RuntimeError):
    """Raised when a memory line is admitted while the signer's anomaly
    scorer is not converged, or when the baseline is updated from an
    unverified write."""


class Admission(Enum):
    ADMIT = "admit"
    QUARANTINE = "quarantine"
    REJECT = "reject"


@dataclass(frozen=True)
class WriteRecord:
    signer: str
    provenance_valid: bool
    score: float          # composite anomaly score, lower = more normal
    lineage_intact: bool


@dataclass(frozen=True)
class ScorerState:
    signer: str
    samples: int
    converged: bool       # samples >= N_min AND variance stable
    var_floor: float


T_LOW = 0.65
T_HIGH = 0.90
N_MIN = 500


def admit_write(w: WriteRecord, s: ScorerState) -> Admission:
    if not w.provenance_valid or not w.lineage_intact:
        return Admission.REJECT

    # The trap: treating an unconverged scorer as "not anomalous".
    if not s.converged or s.samples < N_MIN:
        # Default MUST be quarantine, never admit.
        return Admission.QUARANTINE

    if w.score >= T_HIGH:
        return Admission.REJECT
    if w.score >= T_LOW:
        return Admission.QUARANTINE
    return Admission.ADMIT


def update_baseline(w: WriteRecord, s: ScorerState, decision: Admission) -> ScorerState:
    if decision is not Admission.ADMIT:
        # Baseline-exclusion invariant: only admitted writes train the baseline.
        raise WarmupAdmissionError(
            f"refused baseline update for signer={w.signer!r}: "
            f"decision={decision.value} (only ADMIT may train the baseline)"
        )
    if not s.converged and s.samples >= N_MIN:
        raise WarmupAdmissionError(
            f"signer={w.signer!r} reached N_min but variance not stable; "
            "refusing to freeze a poisoned baseline"
        )
    return ScorerState(
        signer=s.signer,
        samples=s.samples + 1,
        converged=s.converged,
        var_floor=s.var_floor,
    )