# CorpusFetch Method Slice (Zero-Prose Python Stdlib Reference)
# Canonical Residual: https://corpusfetch.com/c/which-invariants-prevent-taint-laundering-across-agent-tool-boundaries-the-provenance-join-failure.md
# Remnant Warrant:    https://corpusfetch.com/c/which-invariants-prevent-taint-laundering-across-agent-tool-boundaries-the-provenance-join-failure.warrant.json
# Markdown SHA-256:   bd7ea051d9cb8e6bb7d2c107712fd2cd4ace3b3dc0b818be091f9481687d1dc1
# Code AST SHA-256:   44599e84565691b158a456fac0d81211464c2c3e8480db2c05c620d4532fb161
# Verified Classes:   ProvenanceLaunderingError, Provenanced
# Defensive Guards:   2 fail-closed invariants (zero external deps)

from dataclasses import dataclass, field
from typing import FrozenSet

class ProvenanceLaunderingError(RuntimeError):
    """Raised when a value crosses a tool boundary without an explicit source set."""
    pass

@dataclass(frozen=True)
class Provenanced:
    value: str
    sources: FrozenSet[str] = field(default_factory=frozenset)

    def join(self, other: "Provenanced") -> "Provenanced":
        return Provenanced(self.value + other.value, self.sources | other.sources)

def reattach_at_boundary(raw, tool_name: str, declared_source: str) -> Provenanced:
    """Every tool ingress must call this. A bare str/dict/bytes is a laundering channel."""
    if isinstance(raw, Provenanced):
        return raw
    if isinstance(raw, (str, bytes, dict, list)):
        # Fail-closed: the tool did not carry provenance, so its output is
        # declared a taint source rather than trusted as clean.
        return Provenanced(str(raw), frozenset({declared_source}))
    raise ProvenanceLaunderingError(
        f"tool {tool_name!r} returned unclassifiable type {type(raw).__name__}; "
        "declare it as a taint source or make it provenance-aware"
    )

def enforce_sink(arg: Provenanced, allowed: FrozenSet[str], sink_name: str) -> None:
    """Sink enforcement joins all reachable sources; it does not check a flag."""
    reachable = arg.sources
    if not reachable.issubset(allowed):
        raise ProvenanceLaunderingError(
            f"sink {sink_name!r} refused: reachable sources {sorted(reachable)} "
            f"not subset of allowed {sorted(allowed)}"
        )

def run_pipeline(fetch_out, summarize_out, sink_allowed):
    doc = reattach_at_boundary(fetch_out, "fetch", declared_source="doc_4421")
    summary = reattach_at_boundary(summarize_out, "summarize", declared_source="summarize_tool")
    combined = doc.join(summary)
    enforce_sink(combined, sink_allowed, "send")
    return combined.value
