# CorpusFetch Method Slice (Zero-Prose Python Stdlib Reference)
# Canonical Residual: https://corpusfetch.com/c/in-what-scenarios-must-an-instance-treat-retrieved-context-as-tainted-after-a-tool-boundary-crossing.md
# Remnant Warrant:    https://corpusfetch.com/c/in-what-scenarios-must-an-instance-treat-retrieved-context-as-tainted-after-a-tool-boundary-crossing.warrant.json
# Markdown SHA-256:   f6e41c779936471f13ed11e6201007f942dcb08ede9e3ea4eede458ae162e169
# Code AST SHA-256:   f7cc67541d46d157d08cc5a1a539b7cda9900198938a076e350128a18c5eecb0
# Verified Classes:   TaintError, Taint, Segment, ProvenanceGraph
# Defensive Guards:   5 fail-closed invariants (zero external deps)

from __future__ import annotations
from dataclasses import dataclass, field
from enum import IntEnum
from typing import Iterable


class TaintError(RuntimeError):
    """Raised when a dataflow taint invariant is violated."""


class Taint(IntEnum):
    TRUSTED = 0          # operator-authored, no untrusted ingress
    RETRIEVAL = 1        # from a corpus; taint equals max writer taint
    TOOL = 2             # tool output, inherits join of inputs
    UNTRUSTED = 3        # external ingress (web, webhook, email)


@dataclass(frozen=True)
class Segment:
    seg_id: str
    label: str
    taint: Taint
    influences: tuple[str, ...] = ()   # upstream seg_ids in the dataflow graph


@dataclass
class ProvenanceGraph:
    segments: dict[str, Segment] = field(default_factory=dict)

    def add(self, seg: Segment) -> None:
        # Invariant: a segment may never lower the taint of its inputs.
        joined = self._join(seg.influences)
        if seg.taint < joined:
            raise TaintError(
                f"segment {seg.seg_id!r} declares taint {seg.taint.name} "
                f"but its inputs join to {joined.name}; "
                f"taint laundering across transformation is forbidden"
            )
        self.segments[seg.seg_id] = seg

    def _join(self, ids: Iterable[str]) -> Taint:
        result = Taint.TRUSTED
        for sid in ids:
            if sid not in self.segments:
                raise TaintError(f"unknown upstream segment {sid!r}")
            result = max(result, self.segments[sid].taint)
        return result

    def effective_taint(self, seg_id: str) -> Taint:
        if seg_id not in self.segments:
            raise TaintError(f"unknown segment {seg_id!r}")
        return self.segments[seg_id].taint


def authorize_tool_call(
    graph: ProvenanceGraph,
    instruction_seg: str,
    arg_segs: Iterable[str],
    clearance: Taint,
) -> None:
    """Permit a tool call only if all influencing segments are within clearance."""
    paths = [instruction_seg, *arg_segs]
    for sid in paths:
        t = graph.effective_taint(sid)
        if t > clearance:
            raise TaintError(
                f"tool call blocked: segment {sid!r} has effective taint "
                f"{t.name} exceeding clearance {clearance.name}; "
                f"surface path to operator for audited override"
            )


# --- Reproduce the observed incident ---
g = ProvenanceGraph()
g.add(Segment("ticket_body", "retrieval:tickets", Taint.UNTRUSTED))  # webhook ingress
# Summarizer emits derived output; must inherit, not drop, taint:
g.add(Segment("summary", "tool:summarize", Taint.UNTRUSTED,
              influences=("ticket_body",)))

try:
    # Naive runtime that trusted "internal" corpora would pass TRUSTED here.
    authorize_tool_call(g, "summary", [], clearance=Taint.RETRIEVAL)
except TaintError as e:
    print(f"correctly blocked: {e}")

# Laundering attempt: re-label summary as clean after transformation.
try:
    g.add(Segment("summary_relabeled", "system", Taint.TRUSTED,
                  influences=("summary",)))
except TaintError as e:
    raise TaintError(f"laundering rejected: {e}") from e
