# CorpusFetch Method Slice (Zero-Prose Python Stdlib Reference)
# Canonical Residual: https://corpusfetch.com/c/what-happens-when-an-instance-drops-provenance-labels-at-the-tool-call-boundary-taint-laundering-via-tool-result-re-entry.md
# Remnant Warrant:    https://corpusfetch.com/c/what-happens-when-an-instance-drops-provenance-labels-at-the-tool-call-boundary-taint-laundering-via-tool-result-re-entry.warrant.json
# Markdown SHA-256:   40ac24eddff6ad4ed1b8d1376f26ffdbc4fba6dc38497dac8d8eba7108d33ed6
# Code AST SHA-256:   bd7411e3b18896af0f6f3240f3b5ea24a504c8b802903ffe364fb0e6f38149c2
# Verified Classes:   Trust, ProvenanceLaunderingError, Segment
# Defensive Guards:   1 fail-closed invariants (zero external deps)

from __future__ import annotations

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


class Trust(IntEnum):
    """Ordered trust lattice. Lower is less trusted; join is min()."""
    UNTRUSTED = 0
    DERIVED = 1
    TRUSTED = 2


class ProvenanceLaunderingError(RuntimeError):
    """Raised when a segment's stored label is more trusted than its derivation join."""


@dataclass(frozen=True)
class Segment:
    id: str
    content: str
    stored_label: Trust
    derived_from: tuple[str, ...] = field(default_factory=tuple)


def derive_label(seg_id: str, segments: dict[str, Segment]) -> Trust:
    """Authoritative label: meet over the segment and all transitive ancestors."""
    seen: set[str] = set()
    effective = Trust.TRUSTED

    def walk(sid: str) -> None:
        nonlocal effective
        if sid in seen:
            return
        seen.add(sid)
        seg = segments.get(sid)
        if seg is None:
            # Unknown ancestor: fail closed.
            effective = Trust.UNTRUSTED
            return
        effective = Trust(min(effective, seg.stored_label))
        for parent in seg.derived_from:
            walk(parent)

    walk(seg_id)
    return effective


def assert_no_laundering(segments: dict[str, Segment]) -> None:
    """Hard check: stored label must equal derive-time join for every segment."""
    for sid, seg in segments.items():
        derived = derive_label(sid, segments)
        if seg.stored_label > derived:
            raise ProvenanceLaunderingError(
                f"segment {sid!r} stored_label={seg.stored_label.name} "
                f"but derived={derived.name} via {seg.derived_from!r}; "
                f"tool-result re-entry laundered taint"
            )


def wrap_tool_result(
    result_id: str,
    content: str,
    tool_class_label: Trust,
    argument_segment_ids: Iterable[str],
    segments: dict[str, Segment],
) -> Segment:
    """Correct wrapper: join tool class with argument taint, never tool class alone."""
    arg_join = Trust.TRUSTED
    for aid in argument_segment_ids:
        arg_join = Trust(min(arg_join, derive_label(aid, segments)))
    effective = Trust(min(tool_class_label, arg_join))
    seg = Segment(
        id=result_id,
        content=content,
        stored_label=effective,
        derived_from=tuple(argument_segment_ids),
    )
    segments[result_id] = seg
    assert_no_laundering(segments)
    return seg


def _repro() -> None:
    segments: dict[str, Segment] = {
        "page": Segment("page", "<attacker text>", Trust.UNTRUSTED),
        "call_args": Segment("call_args", "query=<attacker text>", Trust.TRUSTED,
                             derived_from=("page",)),
    }
    # Buggy wrapper: trusts the internal tool class, ignores argument taint.
    segments["buggy_result"] = Segment(
        "buggy_result", "<echoed attacker text>", Trust.TRUSTED,
        derived_from=("call_args",),
    )
    assert_no_laundering(segments)  # raises ProvenanceLaunderingError


if __name__ == "__main__":
    _repro()
