# CorpusFetch Method Slice (Zero-Prose Python Stdlib Reference)
# Canonical Residual: https://corpusfetch.com/c/when-must-a-bft-consensus-instance-reject-a-plan-commitment-it-has-already-quorum-certified.md
# Remnant Warrant:    https://corpusfetch.com/c/when-must-a-bft-consensus-instance-reject-a-plan-commitment-it-has-already-quorum-certified.warrant.json
# Markdown SHA-256:   53dde0b74f09329edddf7db89ea03cb7f39f58d794f72832c7e139d03b402428
# Code AST SHA-256:   63ebf4fb89d5abaa2dd3309b270981bfe444cf3e420dd253b914132d027f6a3e
# Verified Classes:   InadmissibleCommitment, PlanCommitment, SharedState
# Defensive Guards:   3 fail-closed invariants (zero external deps)

from dataclasses import dataclass, field
from typing import FrozenSet

class InadmissibleCommitment(RuntimeError):
    """Raised when a QC-valid plan commitment fails execution-time re-validation."""
    def __init__(self, plan_id: str, reason: str, cert_view: int, current_view: int):
        self.plan_id = plan_id
        self.reason = reason
        self.cert_view = cert_view
        self.current_view = current_view
        super().__init__(
            f"plan {plan_id} certified at view {cert_view} inadmissible at "
            f"view {current_view}: {reason}"
        )

@dataclass(frozen=True)
class PlanCommitment:
    plan_id: str
    cert_view: int
    dependencies: FrozenSet[str]
    preconditions: FrozenSet[str]  # predicate ids that must hold now
    exclusive_locks: FrozenSet[str]

@dataclass
class SharedState:
    committed_view: int = 0
    held_locks: set = field(default_factory=set)
    true_predicates: set = field(default_factory=set)

def admit_for_execution(plan: PlanCommitment, state: SharedState) -> None:
    """Gate every execution attempt. QC validity is assumed; admissibility is not."""
    if plan.cert_view < state.committed_view and plan.dependencies:
        # a later committed view touched our dependency set: stale-QC guard
        raise InadmissibleCommitment(
            plan.plan_id, "stale QC relative to dependency set",
            plan.cert_view, state.committed_view,
        )
    conflicting = plan.exclusive_locks & state.held_locks
    if conflicting:
        raise InadmissibleCommitment(
            plan.plan_id, f"exclusive lock conflict: {sorted(conflicting)}",
            plan.cert_view, state.committed_view,
        )
    missing = plan.preconditions - state.true_predicates
    if missing:
        raise InadmissibleCommitment(
            plan.plan_id, f"preconditions no longer hold: {sorted(missing)}",
            plan.cert_view, state.committed_view,
        )
    # admitted: caller may execute; commitment remains auditable in the log