# CorpusFetch Method Slice (Zero-Prose Python Stdlib Reference)
# Canonical Residual: https://corpusfetch.com/c/what-happens-when-an-instance-re-resolves-a-tool-manifest-after-signature-verification-but-before-dispatch.md
# Remnant Warrant:    https://corpusfetch.com/c/what-happens-when-an-instance-re-resolves-a-tool-manifest-after-signature-verification-but-before-dispatch.warrant.json
# Markdown SHA-256:   90e95b666677c101c3b122dbd465051914acae17dbf6e9daa5b97bbab6896abf
# Code AST SHA-256:   c22c692db130f28dbb008be4fae76a8c0757cf79db742b01d00d8ddc8f625432
# Verified Classes:   ManifestClosureDivergence, FrozenClosure
# Defensive Guards:   1 fail-closed invariants (zero external deps)

import hashlib
from dataclasses import dataclass


class ManifestClosureDivergence(RuntimeError):
    """Raised when a resolved tool closure no longer matches the digest frozen at verification."""
    pass


@dataclass(frozen=True)
class FrozenClosure:
    tool_name: str
    closure_digest: str  # SHA-256 over canonicalized manifest + all resolved referents


def _digest(parts: list[bytes]) -> str:
    h = hashlib.sha256()
    for p in parts:
        h.update(len(p).to_bytes(8, "big"))
        h.update(p)
    return h.hexdigest()


def freeze_closure(tool_name: str, manifest_bytes: bytes, referents: list[bytes]) -> FrozenClosure:
    # Referents = handler bytes, prompt fragments, nested manifests. Order-stable.
    return FrozenClosure(tool_name=tool_name, closure_digest=_digest([manifest_bytes, *referents]))


def dispatch_pinned(frozen: FrozenClosure, manifest_bytes: bytes, referents: list[bytes]) -> bytes:
    actual = _digest([manifest_bytes, *referents])
    if actual != frozen.closure_digest:
        raise ManifestClosureDivergence(
            f"Tool '{frozen.tool_name}' closure changed between verification and dispatch: "
            f"verified={frozen.closure_digest[:16]} actual={actual[:16]}. "
            f"Possible TOCTOU skill injection; refusing to execute."
        )
    return referents[0]  # handler bytes, now proven identical to verified closure


def invoke_tool(frozen: FrozenClosure, resolver, manifest_bytes: bytes) -> bytes:
    # resolver returns the CURRENT handler + fragments; must be re-checked, never trusted by name.
    referents = resolver(frozen.tool_name)
    handler = dispatch_pinned(frozen, manifest_bytes, referents)
    return handler  # caller executes only after closure equality is proven
