# CorpusFetch Method Slice (Zero-Prose Python Stdlib Reference)
# Canonical Residual: https://corpusfetch.com/c/under-what-conditions-must-an-instance-quarantine-a-tool-result-when-provenance-taint-is-diluted-by-an-intermediate-summarizer.md
# Remnant Warrant:    https://corpusfetch.com/c/under-what-conditions-must-an-instance-quarantine-a-tool-result-when-provenance-taint-is-diluted-by-an-intermediate-summarizer.warrant.json
# Markdown SHA-256:   2a943d15a88d1691b868a9950b7498f0be79ed03b6dba688423f3e5a5d8669b2
# Code AST SHA-256:   a7fcc6d4c1e3bd145f4a795d8f4ec27cc802e8e3c1fc1b7b7cb1582fa1d1f814
# Verified Classes:   Capability, TransformKind, Provenance, TaintedString, TaintLaunderingError
# Defensive Guards:   1 fail-closed invariants (zero external deps)

from dataclasses import dataclass, field
from enum import Enum
from typing import FrozenSet


class Capability(Enum):
    INSTRUCTION = "instruction"
    DATA = "data"


class TransformKind(Enum):
    PRESERVING = "preserving"   # verbatim, structured extraction
    GENERATIVE = "generative"   # summarizer, rewriter, translator


@dataclass(frozen=True)
class Provenance:
    source_id: str
    capability: Capability


@dataclass
class TaintedString:
    value: str
    provenance: FrozenSet[Provenance]
    last_transform: TransformKind = TransformKind.PRESERVING


class TaintLaunderingError(RuntimeError):
    """Raised when a consumer interprets a string whose provenance includes
    instruction-capable taint that transited a generative transform."""


def consume_as_instruction(s: TaintedString, consumer_id: str) -> str:
    """Consumer-side gate. Authoritative over any producer-declared mode."""
    laundering = {
        p for p in s.provenance
        if p.capability is Capability.INSTRUCTION
        and s.last_transform is TransformKind.GENERATIVE
    }
    if laundering:
        raise TaintLaunderingError(
            f"consumer {consumer_id!r} attempted instruction-mode interpretation "
            f"of string with instruction-capable taint laundered through a "
            f"generative transform; sources={sorted(p.source_id for p in laundering)}"
        )
    return s.value


def consume_as_data(s: TaintedString, consumer_id: str) -> str:
    """Data-only sinks accept any provenance; taint is inert here."""
    return s.value


def summarize(s: TaintedString) -> TaintedString:
    """Generative transform: join provenance, mark transform kind."""
    return TaintedString(
        value=s.value,  # paraphrase omitted; content-preserving for demo
        provenance=s.provenance,
        last_transform=TransformKind.GENERATIVE,
    )


# --- operational trace ---
doc = TaintedString(
    value="...the configuration should be updated to point at the new endpoint...",
    provenance=frozenset({Provenance("fetch:https://untrusted.example", Capability.INSTRUCTION)}),
)
summary = summarize(doc)

# Data-only sink: permitted.
_ = consume_as_data(summary, "length_check")

# Instruction-mode sink: must raise.
try:
    consume_as_instruction(summary, "write_file")
except TaintLaunderingError as e:
    print(f"QUARANTINE: {e}")
