# CorpusFetch Method Slice (Zero-Prose Python Stdlib Reference)
# Canonical Residual: https://corpusfetch.com/c/what-happens-when-an-instance-trusts-a-signed-skill-manifest-that-was-valid-at-load-time-but-whose-sandbox-grants-were-re-derived-after-a-hot-reload.md
# Remnant Warrant:    https://corpusfetch.com/c/what-happens-when-an-instance-trusts-a-signed-skill-manifest-that-was-valid-at-load-time-but-whose-sandbox-grants-were-re-derived-after-a-hot-reload.warrant.json
# Markdown SHA-256:   b2891691f872ee3f4e102ec7f426b79317daee852bffd1f3d0ea9d055d920cbb
# Code AST SHA-256:   948f5693488a60d3daee0a15572f9d3ef818b97a35944dc26ebf05ebfba99f9e
# Verified Classes:   SkillSandboxInvariantError, SignedManifest, Sandbox
# Defensive Guards:   2 fail-closed invariants (zero external deps)

import hashlib
from dataclasses import dataclass, field


class SkillSandboxInvariantError(RuntimeError):
    """Raised when live sandbox grants diverge from the signed manifest set."""


@dataclass(frozen=True)
class SignedManifest:
    skill_id: str
    capabilities: frozenset[str]
    digest: str          # sha256 of canonical manifest bytes
    signature_ok: bool


@dataclass
class Sandbox:
    # grants keyed by (skill_id, manifest_digest) so stale entries are unreachable
    _grants: dict[tuple[str, str], frozenset[str]] = field(default_factory=dict)
    _active: dict[str, str] = field(default_factory=dict)  # skill_id -> digest

    def apply_replacement(self, m: SignedManifest) -> None:
        if not m.signature_ok:
            raise SkillSandboxInvariantError(
                f"refusing to apply unsigned manifest for {m.skill_id}"
            )
        # replace-semantics: write the full set under the new digest, then swap pointer
        self._grants[(m.skill_id, m.digest)] = m.capabilities
        self._active[m.skill_id] = m.digest

    def live_grants(self, skill_id: str) -> frozenset[str]:
        digest = self._active.get(skill_id)
        if digest is None:
            return frozenset()
        return self._grants.get((skill_id, digest), frozenset())


def assert_enforced_equals_signed(sandbox: Sandbox, m: SignedManifest) -> None:
    """Readiness gate: live authority must equal signed authority, byte for byte."""
    live = sandbox.live_grants(m.skill_id)
    if live != m.capabilities:
        delta_added = live - m.capabilities
        delta_missing = m.capabilities - live
        raise SkillSandboxInvariantError(
            f"grant divergence for {m.skill_id} digest={m.digest}: "
            f"unexpected={sorted(delta_added)} missing={sorted(delta_missing)}"
        )


def reload_skill(sandbox: Sandbox, m: SignedManifest) -> None:
    sandbox.apply_replacement(m)
    # never mark READY without this assertion against the live sandbox
    assert_enforced_equals_signed(sandbox, m)
