[ Proposed AI Agent Action ]
             │
             ▼
[ 1. Circuit Breaker ]  ────────► (Halts system on statistical anomalies / Z-score)
             │
             ▼
[ 2. Policy Engine ]    ────────► (Enforces hard caps, action whitelists, rate limits)
             │
             ▼
[ 3. State Validator ]  ────────► (Verifies schema & business invariants pre-commit)
             │
             ▼
[ 4. Governed Executor] ────────► (Executes mutation atomically & records audit trace)

from dataclasses import dataclass
from enum import Enum

class Decision(Enum):
    ALLOW = "allow"         # Passed all gates; execute with zero human friction
    REJECT = "reject"       # Violated hard invariant; rejected deterministically
    ESCALATE = "escalate"   # High-stakes boundary; awakens human authority
    HALT = "halt"           # Circuit breaker open; emergency brake tripped

@dataclass(frozen=True)
class Action:
    """The proposal emitted by the LLM or Autonomous Agent."""
    type: str
    account_id: str
    amount: float

@dataclass(frozen=True)
class Policy:
    """Immutable business rules defined by human leadership."""
    allowed_actions: frozenset = frozenset({"transfer", "refund"})
    max_amount: float = 10_000.0          # Absolute ceiling (Hard Reject above this)
    escalation_amount: float = 2_000.0    # Judgment boundary (Escalate above this)
    max_actions_per_minute: int = 30      # Runtime rate limit

import time
from collections import deque

class PolicyEngine:
    def __init__(self, policy: Policy):
        self.policy = policy
        self._timestamps: deque[float] = deque()

    def evaluate(self, action: Action):
        p = self.policy

        # 1. Action Whitelist Enforcement
        if action.type not in p.allowed_actions:
            return Decision.REJECT, f"Action '{action.type}' is strictly forbidden by policy."

        # 2. Hard Monetary Ceiling
        if action.amount > p.max_amount:
            return Decision.REJECT, f"Amount ${action.amount:,.2f} exceeds hard cap of ${p.max_amount:,.2f}."

        # 3. Rolling Window Rate Limiting
        if not self._within_rate_limit():
            return Decision.REJECT, "Rate limit exceeded (Too many actions per minute)."

        # 4. Human Escalation Trigger
        if action.amount > p.escalation_amount:
            return Decision.ESCALATE, f"Amount ${action.amount:,.2f} requires human sign-off."

        return Decision.ALLOW, "Action complies with policy."

    def _within_rate_limit(self) -> bool:
        now = time.monotonic()
        while self._timestamps and now - self._timestamps[0] > 60:
            self._timestamps.popleft()
        if len(self._timestamps) >= self.policy.max_actions_per_minute:
            return False
        self._timestamps.append(now)
        return True

class Validator:
    def __init__(self, balances: dict[str, float]):
        self.balances = balances

    def validate(self, action: Action):
        # Schema Invariants
        if not isinstance(action.amount, (int, float)) or action.amount <= 0:
            return Decision.REJECT, "Schema Error: Amount must be a positive number."
        if not action.account_id:
            return Decision.REJECT, "Schema Error: Missing target account_id."

        # State Invariants
        if action.account_id not in self.balances:
            return Decision.REJECT, f"Target account '{action.account_id}' does not exist."
        if action.type == "transfer" and self.balances[action.account_id] < action.amount:
            return Decision.REJECT, "State Error: Insufficient funds for transfer."

        return Decision.ALLOW, "System state invariants verified."

import statistics

class CircuitBreaker:
    def __init__(self, window: int = 20, max_reject_rate: float = 0.5, z_threshold: float = 4.0):
        self.window = window
        self.max_reject_rate = max_reject_rate
        self.z_threshold = z_threshold
        self.recent_outcomes: deque[bool] = deque(maxlen=window)
        self.recent_amounts: deque[float] = deque(maxlen=window)
        self.is_open = False
        self.trip_reason = ""

    def check_anomaly(self, action: Action) -> bool:
        # Trip on statistical value outlier (Z-Score)
        if len(self.recent_amounts) >= 10:
            mean = statistics.mean(self.recent_amounts)
            stdev = statistics.pstdev(self.recent_amounts) or 1.0
            z = abs(action.amount - mean) / stdev
            if z > self.z_threshold:
                self._trip(f"Statistical outlier detected (Z-score: {z:.1f})")
                return True
        return False

    def record(self, action: Action, decision: Decision) -> None:
        self.recent_outcomes.append(decision == Decision.REJECT)
        if decision == Decision.ALLOW:
            self.recent_amounts.append(action.amount)

        # Trip on sliding failure surge
        if len(self.recent_outcomes) == self.window:
            rate = sum(self.recent_outcomes) / self.window
            if rate > self.max_reject_rate:
                self._trip(f"High rejection surge ({rate:.0%}) over last {self.window} actions.")

    def reset(self) -> None:
        """Explicit human reset required to restore operations."""
        self.is_open = False
        self.trip_reason = ""
        self.recent_outcomes.clear()

    def _trip(self, reason: str) -> None:
        self.is_open = True
        self.trip_reason = reason

class GovernedExecutor:
    def __init__(self, policy: Policy, balances: dict[str, float]):
        self.engine = PolicyEngine(policy)
        self.validator = Validator(balances)
        self.breaker = CircuitBreaker()
        self.balances = balances
        self.audit_log = []

    def submit(self, action: Action):
        # Stage 1: Emergency Brake & Anomaly Check
        if self.breaker.is_open:
            return self._record(action, Decision.HALT, f"Breaker Open: {self.breaker.trip_reason}")
        if self.breaker.check_anomaly(action):
            return self._record(action, Decision.HALT, f"Breaker Tripped: {self.breaker.trip_reason}")

        # Stage 2: Policy Bounds Evaluation
        decision, reason = self.engine.evaluate(action)

        # Stage 3: State Invariant Verification
        if decision == Decision.ALLOW:
            decision, reason = self.validator.validate(action)

        # Stage 4: Atomic State Mutation (Only if all gates pass)
        if decision == Decision.ALLOW:
            self._execute(action)

        self.breaker.record(action, decision)
        return self._record(action, decision, reason)

    def _execute(self, action: Action):
        if action.type == "transfer":
            self.balances[action.account_id] -= action.amount
        elif action.type == "refund":
            self.balances[action.account_id] += action.amount

    def _record(self, action: Action, decision: Decision, reason: str):
        self.audit_log.append((action, decision, reason))
        return decision, reason

system = GovernedExecutor(Policy(), balances={"acc_enterprise": 50_000.0})

# Scenario 1: Routine Action ($150 transfer)
# Result -> ALLOW: Processed in microseconds with zero human involvement.

# Scenario 2: Hard Cap Breach ($25,000 transfer)
# Result -> REJECT: Deterministically blocked by PolicyEngine.

# Scenario 3: Human Judgment Escalation ($5,000 transfer)
# Result -> ESCALATE: Halts before mutation; awakens human review queue.

# Scenario 4: Statistical Anomaly Drift (12 transfers of $100, then a sudden $1,900)
# Result -> HALT: CircuitBreaker trips automatically on Z-score deviation; 
#           all subsequent actions are locked until human investigation.