openbox-sdk-python 1.1.0__tar.gz → 1.2.0__tar.gz

{openbox_sdk_python-1.1.0 → openbox_sdk_python-1.2.0}/CHANGELOG.md

@@ -5,6 +5,24 @@ All notable changes to this project are documented in this file.
 The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.1.0/),
 and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
 
+## [1.2.0] - 2026-07-23
+
+### Changed
+- **BREAKING:** Renamed the public BLOCK remediation contract from `retry_plan` to `patch`.
+  `RetryPlan` is now `Patch`, `RetryDirective` is now `PatchDirective`, and
+  `handle_retryable_block()` is now `handle_patch()`. `EvaluationResult.retry_plan` and
+  `ApprovalResult.retry_plan` are now `.patch`. The parser now reads only the canonical outer
+  wire key `patch`; the old `retry_plan` key is no longer recognized.
+- The verdict gate is unchanged: a directive is still surfaced only for an exact `BLOCK` verdict
+  carrying a valid patch — never for HALT/`should_stop()`, and never for an expired approval
+  result.
+
+### Notes
+- This is a breaking release: the old public names (`RetryPlan`, `RetryDirective`,
+  `handle_retryable_block`, `.retry_plan`) are removed, not aliased. Consumers still pinned to
+  `1.1.0` remain fail-safe — they ignore the unknown `patch` field but still enforce the `BLOCK`
+  verdict.
+
 ## [1.1.0] - 2026-07-21
 
 ### Added

{openbox_sdk_python-1.1.0 → openbox_sdk_python-1.2.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: openbox-sdk-python
-Version: 1.1.0
+Version: 1.2.0
 Summary: OpenBox base SDK - governance contracts, strict gate, identity/signing, evaluate client, context runtime, OTel span wire serialization, and generic instrumentation shared by every OpenBox framework SDK
 Author-email: OpenBox Team <tino@openbox.ai>
 License-Expression: MIT

{openbox_sdk_python-1.1.0 → openbox_sdk_python-1.2.0}/openbox_core/__init__.py

@@ -37,7 +37,7 @@ from .errors import (
 # governance; eagerly it can deadlock package init as a circular import, and
 # lazily it can recurse unboundedly when a per-request header builder resolves
 # the version. Keep in sync with pyproject.toml on release.
-__version__ = "1.1.0"
+__version__ = "1.2.0"
 
 __all__ = [
     "__version__",

{openbox_sdk_python-1.1.0 → openbox_sdk_python-1.2.0}/openbox_core/contracts/results.py

@@ -20,9 +20,9 @@ __all__ = [
     "GuardrailsResult",
     "EvaluationResult",
     "ApprovalResult",
-    "RetryPlan",
-    "RetryDirective",
-    "handle_retryable_block",
+    "Patch",
+    "PatchDirective",
+    "handle_patch",
 ]
 
 
@@ -106,8 +106,8 @@ class GuardrailsResult:
         return [r.get("reason", "") for r in self.reasons if r.get("reason")]
 
 
-# Sentinel distinguishing an absent ``retry_plan`` field from a present JSON ``null``.
-# ``dict.get("retry_plan")`` would collapse both to None; membership via this sentinel does not.
+# Sentinel distinguishing an absent ``patch`` field from a present JSON ``null``.
+# ``dict.get("patch")`` would collapse both to None; membership via this sentinel does not.
 _MISSING = object()
 
 # JS Number.MAX_SAFE_INTEGER. Integral numbers must fit within +/- this bound so ``new_input`` can
@@ -120,7 +120,7 @@ def _numbers_are_safe(value: Any) -> bool:
     """Every number (recursively) must be finite and, if integral, within the JS-safe range.
 
     ``bool`` is a subclass of ``int`` but is not a number here; a nested bool is a plain leaf
-    (top-level ``new_input`` booleans are rejected separately by :func:`_parse_retry_plan`).
+    (top-level ``new_input`` booleans are rejected separately by :func:`_parse_patch`).
     """
     if isinstance(value, bool):
         return True
@@ -140,22 +140,22 @@ def _numbers_are_safe(value: Any) -> bool:
 
 
 @dataclass
-class RetryPlan:
-    """Optional remediation hint carried on a BLOCK verdict (policy-produced or admin-retry).
+class Patch:
+    """Optional remediation hint carried on a BLOCK verdict (policy-produced or admin-patch).
 
     ``new_input`` may be null | str | number | list | dict (boolean rejected). A present
-    ``new_input`` of ``None`` is a valid plan (retry with the original input) and is distinct
-    from an absent ``retry_plan`` field.
+    ``new_input`` of ``None`` is a valid patch (reuses the original input) and is distinct
+    from an absent ``patch`` field.
     """
 
     new_input: Any = None
 
 
 @dataclass
-class RetryDirective:
-    """Caller-facing view of a retryable BLOCK, surfaced only via :func:`handle_retryable_block`.
+class PatchDirective:
+    """Caller-facing view of a BLOCK with patch, surfaced only via :func:`handle_patch`.
 
-    It is a remediation hint, not proof that a retry was evaluated or executed.
+    It is a remediation hint, not proof that a patch was evaluated or executed.
     """
 
     new_input: Any = None
@@ -163,28 +163,28 @@ class RetryDirective:
     reason: str | None = None
 
 
-def _parse_retry_plan(container: dict[str, Any]) -> RetryPlan | None:
-    """Parse an optional ``retry_plan`` from a result dict against the frozen wire contract.
+def _parse_patch(container: dict[str, Any]) -> Patch | None:
+    """Parse an optional ``patch`` from a result dict against the frozen wire contract.
 
-    Returns a plan only when ``retry_plan`` is present, is a dict whose ONLY key is ``new_input``,
+    Returns a patch only when ``patch`` is present, is a dict whose ONLY key is ``new_input``,
     and ``new_input`` is null/str/number/list/dict (boolean rejected) with every number finite and,
     if integral, within the JS-safe integer range. An absent field, a JSON ``null`` field, or any
     contract violation yields ``None`` (treated as absent — never an error). A present
-    ``new_input`` of ``None`` is preserved as a valid plan.
+    ``new_input`` of ``None`` is preserved as a valid patch.
     """
-    plan = container.get("retry_plan", _MISSING)
-    if plan is _MISSING or not isinstance(plan, dict):
+    patch = container.get("patch", _MISSING)
+    if patch is _MISSING or not isinstance(patch, dict):
         return None
     # Exactly the single key new_input (also guarantees new_input is present, not merely null).
-    if set(plan.keys()) != {"new_input"}:
+    if set(patch.keys()) != {"new_input"}:
         return None
-    new_input = plan["new_input"]
+    new_input = patch["new_input"]
     # bool is a subclass of int — reject a boolean new_input BEFORE the number check.
     if isinstance(new_input, bool):
         return None
     if not _numbers_are_safe(new_input):
         return None
-    return RetryPlan(new_input=new_input)
+    return Patch(new_input=new_input)
 
 
 @dataclass
@@ -215,7 +215,7 @@ class EvaluationResult:
     fallback_used: bool = False  # True when fail-open produced this result
     diagnostics: list[Any] = field(default_factory=list)
     raw: dict[str, Any] = field(default_factory=dict)
-    retry_plan: RetryPlan | None = None  # Optional BLOCK remediation hint; None = absent
+    patch: Patch | None = None  # Optional BLOCK remediation hint; None = absent
 
     @property
     def guardrails_result(self) -> GuardrailsResult | None:
@@ -266,7 +266,7 @@ class EvaluationResult:
             fallback_used=bool(data.get("fallback_used", False)),
             diagnostics=data.get("diagnostics") or [],
             raw=dict(data),
-            retry_plan=_parse_retry_plan(data),
+            patch=_parse_patch(data),
         )
 
     @classmethod
@@ -299,7 +299,7 @@ class ApprovalResult:
     approval_expiration_time: str | None = None
     expired: bool = False
     raw: dict[str, Any] = field(default_factory=dict)
-    retry_plan: RetryPlan | None = None  # Present only on an admin-retry BLOCK
+    patch: Patch | None = None  # Present only on an admin-patch BLOCK
 
     # Known decision vocabulary for approvals (current values + accepted aliases).
     # Anything OUTSIDE this set parses to None (pending) — the evaluate-path
@@ -345,7 +345,7 @@ class ApprovalResult:
             approval_expiration_time=data.get("approval_expiration_time"),
             expired=bool(data.get("expired", False)),
             raw=dict(data),
-            retry_plan=_parse_retry_plan(data),
+            patch=_parse_patch(data),
         )
 
     @property
@@ -376,21 +376,22 @@ class ApprovalResult:
         return self.verdict in (Verdict.REQUIRE_APPROVAL, Verdict.CONSTRAIN)
 
 
-def handle_retryable_block(
+def handle_patch(
     result: EvaluationResult | ApprovalResult,
-) -> RetryDirective | None:
-    """Opt-in, pure inspector: surface a retry directive from a retryable BLOCK.
+) -> PatchDirective | None:
+    """Opt-in, pure inspector: surface a patch directive from a BLOCK with patch.
 
-    Returns a :class:`RetryDirective` ONLY for ``verdict == Verdict.BLOCK`` with a present, valid
-    ``retry_plan``. Returns ``None`` for plain BLOCK, every non-BLOCK verdict (including HALT),
+    Returns a :class:`PatchDirective` ONLY for ``verdict == Verdict.BLOCK`` with a present, valid
+    ``patch``. Returns ``None`` for plain BLOCK, every non-BLOCK verdict (including HALT),
     a pending/``None`` verdict, and an expired :class:`ApprovalResult`.
 
-    This does NOT change enforcement: importing or exposing it never auto-retries. A caller must
-    invoke it explicitly, and it makes no claim that a replacement was evaluated or executed.
+    This does NOT change enforcement: importing or exposing it never auto-applies the patch. A
+    caller must invoke it explicitly, and it makes no claim that a replacement was evaluated or
+    executed.
 
     The gate is deliberately ``verdict == Verdict.BLOCK`` — NOT ``is_blocking()`` /
     ``verdict.should_stop()``, which also match HALT (and, for approvals, expired results) and would
-    violate the wire-contract invariant that HALT always strips the plan.
+    violate the wire-contract invariant that HALT always strips the patch.
     """
     # A stale/expired poll result must not surface a directive, even if verdict == BLOCK.
     if isinstance(result, ApprovalResult) and result.expired:
@@ -400,8 +401,8 @@ def handle_retryable_block(
     if getattr(result, "verdict", None) != Verdict.BLOCK:
         return None
 
-    plan = result.retry_plan
-    if plan is None:
+    patch = result.patch
+    if patch is None:
         return None
 
     # governance_event_id is typed on EvaluationResult; ApprovalResult carries it only in raw.
@@ -410,8 +411,8 @@ def handle_retryable_block(
     else:
         governance_event_id = result.raw.get("governance_event_id") or result.raw.get("id")
 
-    return RetryDirective(
-        new_input=plan.new_input,
+    return PatchDirective(
+        new_input=patch.new_input,
         governance_event_id=governance_event_id,
         reason=result.reason,
     )

{openbox_sdk_python-1.1.0 → openbox_sdk_python-1.2.0}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "openbox-sdk-python"
-version = "1.1.0"
+version = "1.2.0"
 description = "OpenBox base SDK - governance contracts, strict gate, identity/signing, evaluate client, context runtime, OTel span wire serialization, and generic instrumentation shared by every OpenBox framework SDK"
 authors = [
     { name = "OpenBox Team", email = "tino@openbox.ai" },

openbox_sdk_python-1.2.0/tests/contracts/test_patch.py

@@ -0,0 +1,207 @@
+"""patch parsing + handle_patch tests (frozen wire contract).
+
+Covers: present-null vs absent, falsy-value preservation, boolean rejection, the finite/
+safe-integer numeric rule (incl. nested), action="block" approvals, HALT/expired -> None,
+the EvaluationResult path not raising AttributeError, and default BLOCK enforcement unchanged.
+"""
+
+import pytest
+
+from openbox_core.contracts.results import (
+    ApprovalResult,
+    EvaluationResult,
+    Patch,
+    PatchDirective,
+    Verdict,
+    handle_patch,
+)
+from openbox_core.errors import GovernanceBlockedError
+from openbox_core.gate import raise_for_verdict
+
+SAFE_MAX = 2**53 - 1
+
+
+def _block(**extra):
+    return {"verdict": "block", **extra}
+
+
+class TestPatchParsing:
+    def test_valid_patch_parses_on_evaluation(self):
+        r = EvaluationResult.from_dict(_block(patch={"new_input": "x"}))
+        assert isinstance(r.patch, Patch)
+        assert r.patch.new_input == "x"
+
+    def test_valid_patch_parses_on_approval_block_action(self):
+        r = ApprovalResult.from_dict(
+            {"action": "block", "patch": {"new_input": [1, 2]}}
+        )
+        assert r.verdict is Verdict.BLOCK
+        assert isinstance(r.patch, Patch)
+        assert r.patch.new_input == [1, 2]
+
+    def test_present_null_is_distinct_from_absent(self):
+        present = EvaluationResult.from_dict(_block(patch={"new_input": None}))
+        assert present.patch is not None
+        assert present.patch.new_input is None
+
+        absent = EvaluationResult.from_dict(_block())
+        assert absent.patch is None
+
+    def test_json_null_field_is_treated_as_absent(self):
+        assert EvaluationResult.from_dict(_block(patch=None)).patch is None
+
+    def test_falsy_values_preserved(self):
+        for val in (None, "", 0, [], {}):
+            r = EvaluationResult.from_dict(_block(patch={"new_input": val}))
+            assert r.patch is not None, val
+            assert r.patch.new_input == val
+
+    def test_boolean_new_input_rejected(self):
+        for val in (True, False):
+            r = EvaluationResult.from_dict(_block(patch={"new_input": val}))
+            assert r.patch is None
+
+    def test_extra_key_rejected(self):
+        r = EvaluationResult.from_dict(
+            _block(patch={"new_input": None, "x": 1})
+        )
+        assert r.patch is None
+
+    def test_missing_new_input_rejected(self):
+        r = EvaluationResult.from_dict(_block(patch={"other": 1}))
+        assert r.patch is None
+
+    def test_non_dict_patch_rejected(self):
+        for bad in ("str", 5, [1], True):
+            r = EvaluationResult.from_dict(_block(patch=bad))
+            assert r.patch is None
+
+    def test_numeric_safe_boundary(self):
+        assert (
+            EvaluationResult.from_dict(
+                _block(patch={"new_input": SAFE_MAX})
+            ).patch
+            is not None
+        )
+        assert (
+            EvaluationResult.from_dict(
+                _block(patch={"new_input": SAFE_MAX + 1})
+            ).patch
+            is None
+        )
+
+    def test_non_finite_and_nested_unsafe_rejected(self):
+        assert (
+            EvaluationResult.from_dict(
+                _block(patch={"new_input": float("inf")})
+            ).patch
+            is None
+        )
+        assert (
+            EvaluationResult.from_dict(
+                _block(patch={"new_input": float("nan")})
+            ).patch
+            is None
+        )
+        assert (
+            EvaluationResult.from_dict(
+                _block(patch={"new_input": {"a": [SAFE_MAX + 1]}})
+            ).patch
+            is None
+        )
+        assert (
+            EvaluationResult.from_dict(
+                _block(patch={"new_input": {"a": [SAFE_MAX]}})
+            ).patch
+            is not None
+        )
+
+    def test_raw_preserved(self):
+        data = _block(patch={"new_input": "x"}, extra="keep")
+        r = EvaluationResult.from_dict(data)
+        assert r.raw["extra"] == "keep"
+        assert r.raw["patch"] == {"new_input": "x"}
+
+
+class TestHandlePatch:
+    def test_directive_from_evaluation_block(self):
+        r = EvaluationResult.from_dict(
+            _block(
+                patch={"new_input": "x"},
+                governance_event_id="ev-1",
+                reason="blocked",
+            )
+        )
+        d = handle_patch(r)
+        assert isinstance(d, PatchDirective)
+        assert d.new_input == "x"
+        assert d.governance_event_id == "ev-1"
+        assert d.reason == "blocked"
+
+    def test_directive_from_approval_reads_event_id_from_raw(self):
+        r = ApprovalResult.from_dict(
+            {
+                "action": "block",
+                "patch": {"new_input": None},
+                "governance_event_id": "ev-2",
+                "reason": "patch",
+            }
+        )
+        d = handle_patch(r)
+        assert d is not None
+        assert d.new_input is None
+        assert d.governance_event_id == "ev-2"
+
+    def test_approval_event_id_falls_back_to_id(self):
+        r = ApprovalResult.from_dict(
+            {"action": "block", "patch": {"new_input": 1}, "id": "ev-3"}
+        )
+        d = handle_patch(r)
+        assert d is not None
+        assert d.governance_event_id == "ev-3"
+
+    def test_plain_block_returns_none(self):
+        assert handle_patch(EvaluationResult.from_dict(_block())) is None
+
+    def test_non_block_verdicts_return_none(self):
+        for verdict in ("allow", "constrain", "require_approval", "halt"):
+            r = EvaluationResult.from_dict(
+                {"verdict": verdict, "patch": {"new_input": "x"}}
+            )
+            assert handle_patch(r) is None, verdict
+
+    def test_halt_approval_returns_none_even_with_patch(self):
+        r = ApprovalResult.from_dict(
+            {"action": "halt", "patch": {"new_input": "x"}}
+        )
+        assert handle_patch(r) is None
+
+    def test_expired_approval_returns_none_even_if_block(self):
+        r = ApprovalResult.from_dict(
+            {"action": "block", "patch": {"new_input": "x"}, "expired": True}
+        )
+        assert r.verdict is Verdict.BLOCK
+        assert handle_patch(r) is None
+
+    def test_pending_approval_returns_none(self):
+        r = ApprovalResult.from_dict({"patch": {"new_input": "x"}})
+        assert r.verdict is None
+        assert handle_patch(r) is None
+
+    def test_evaluation_result_never_raises_attributeerror(self):
+        # EvaluationResult has no is_blocking()/expired; the gate must not touch them.
+        r = EvaluationResult.from_dict(_block(patch={"new_input": "x"}))
+        assert handle_patch(r) is not None
+
+    def test_block_without_patch_returns_none(self):
+        assert handle_patch(EvaluationResult.from_dict(_block())) is None
+
+
+class TestEnforcementUnchanged:
+    def test_block_still_raises_even_with_patch(self):
+        # Adding patch support must NOT suppress the default block; the helper is opt-in only.
+        r = EvaluationResult.from_dict(
+            _block(patch={"new_input": "x"}, reason="nope")
+        )
+        with pytest.raises(GovernanceBlockedError):
+            raise_for_verdict(r)

{openbox_sdk_python-1.1.0 → openbox_sdk_python-1.2.0}/uv.lock

@@ -584,7 +584,7 @@ wheels = [
 
 [[package]]
 name = "openbox-sdk-python"
-version = "1.0.1"
+version = "1.2.0"
 source = { editable = "." }
 dependencies = [
     { name = "cryptography" },

openbox_sdk_python-1.1.0/tests/contracts/test_retry_plan.py

@@ -1,207 +0,0 @@
-"""retry_plan parsing + handle_retryable_block tests (frozen wire contract).
-
-Covers: present-null vs absent, falsy-value preservation, boolean rejection, the finite/
-safe-integer numeric rule (incl. nested), action="block" approvals, HALT/expired -> None,
-the EvaluationResult path not raising AttributeError, and default BLOCK enforcement unchanged.
-"""
-
-import pytest
-
-from openbox_core.contracts.results import (
-    ApprovalResult,
-    EvaluationResult,
-    RetryDirective,
-    RetryPlan,
-    Verdict,
-    handle_retryable_block,
-)
-from openbox_core.errors import GovernanceBlockedError
-from openbox_core.gate import raise_for_verdict
-
-SAFE_MAX = 2**53 - 1
-
-
-def _block(**extra):
-    return {"verdict": "block", **extra}
-
-
-class TestRetryPlanParsing:
-    def test_valid_plan_parses_on_evaluation(self):
-        r = EvaluationResult.from_dict(_block(retry_plan={"new_input": "x"}))
-        assert isinstance(r.retry_plan, RetryPlan)
-        assert r.retry_plan.new_input == "x"
-
-    def test_valid_plan_parses_on_approval_block_action(self):
-        r = ApprovalResult.from_dict(
-            {"action": "block", "retry_plan": {"new_input": [1, 2]}}
-        )
-        assert r.verdict is Verdict.BLOCK
-        assert isinstance(r.retry_plan, RetryPlan)
-        assert r.retry_plan.new_input == [1, 2]
-
-    def test_present_null_is_distinct_from_absent(self):
-        present = EvaluationResult.from_dict(_block(retry_plan={"new_input": None}))
-        assert present.retry_plan is not None
-        assert present.retry_plan.new_input is None
-
-        absent = EvaluationResult.from_dict(_block())
-        assert absent.retry_plan is None
-
-    def test_json_null_field_is_treated_as_absent(self):
-        assert EvaluationResult.from_dict(_block(retry_plan=None)).retry_plan is None
-
-    def test_falsy_values_preserved(self):
-        for val in (None, "", 0, [], {}):
-            r = EvaluationResult.from_dict(_block(retry_plan={"new_input": val}))
-            assert r.retry_plan is not None, val
-            assert r.retry_plan.new_input == val
-
-    def test_boolean_new_input_rejected(self):
-        for val in (True, False):
-            r = EvaluationResult.from_dict(_block(retry_plan={"new_input": val}))
-            assert r.retry_plan is None
-
-    def test_extra_key_rejected(self):
-        r = EvaluationResult.from_dict(
-            _block(retry_plan={"new_input": None, "x": 1})
-        )
-        assert r.retry_plan is None
-
-    def test_missing_new_input_rejected(self):
-        r = EvaluationResult.from_dict(_block(retry_plan={"other": 1}))
-        assert r.retry_plan is None
-
-    def test_non_dict_plan_rejected(self):
-        for bad in ("str", 5, [1], True):
-            r = EvaluationResult.from_dict(_block(retry_plan=bad))
-            assert r.retry_plan is None
-
-    def test_numeric_safe_boundary(self):
-        assert (
-            EvaluationResult.from_dict(
-                _block(retry_plan={"new_input": SAFE_MAX})
-            ).retry_plan
-            is not None
-        )
-        assert (
-            EvaluationResult.from_dict(
-                _block(retry_plan={"new_input": SAFE_MAX + 1})
-            ).retry_plan
-            is None
-        )
-
-    def test_non_finite_and_nested_unsafe_rejected(self):
-        assert (
-            EvaluationResult.from_dict(
-                _block(retry_plan={"new_input": float("inf")})
-            ).retry_plan
-            is None
-        )
-        assert (
-            EvaluationResult.from_dict(
-                _block(retry_plan={"new_input": float("nan")})
-            ).retry_plan
-            is None
-        )
-        assert (
-            EvaluationResult.from_dict(
-                _block(retry_plan={"new_input": {"a": [SAFE_MAX + 1]}})
-            ).retry_plan
-            is None
-        )
-        assert (
-            EvaluationResult.from_dict(
-                _block(retry_plan={"new_input": {"a": [SAFE_MAX]}})
-            ).retry_plan
-            is not None
-        )
-
-    def test_raw_preserved(self):
-        data = _block(retry_plan={"new_input": "x"}, extra="keep")
-        r = EvaluationResult.from_dict(data)
-        assert r.raw["extra"] == "keep"
-        assert r.raw["retry_plan"] == {"new_input": "x"}
-
-
-class TestHandleRetryableBlock:
-    def test_directive_from_evaluation_block(self):
-        r = EvaluationResult.from_dict(
-            _block(
-                retry_plan={"new_input": "x"},
-                governance_event_id="ev-1",
-                reason="blocked",
-            )
-        )
-        d = handle_retryable_block(r)
-        assert isinstance(d, RetryDirective)
-        assert d.new_input == "x"
-        assert d.governance_event_id == "ev-1"
-        assert d.reason == "blocked"
-
-    def test_directive_from_approval_reads_event_id_from_raw(self):
-        r = ApprovalResult.from_dict(
-            {
-                "action": "block",
-                "retry_plan": {"new_input": None},
-                "governance_event_id": "ev-2",
-                "reason": "retry",
-            }
-        )
-        d = handle_retryable_block(r)
-        assert d is not None
-        assert d.new_input is None
-        assert d.governance_event_id == "ev-2"
-
-    def test_approval_event_id_falls_back_to_id(self):
-        r = ApprovalResult.from_dict(
-            {"action": "block", "retry_plan": {"new_input": 1}, "id": "ev-3"}
-        )
-        d = handle_retryable_block(r)
-        assert d is not None
-        assert d.governance_event_id == "ev-3"
-
-    def test_plain_block_returns_none(self):
-        assert handle_retryable_block(EvaluationResult.from_dict(_block())) is None
-
-    def test_non_block_verdicts_return_none(self):
-        for verdict in ("allow", "constrain", "require_approval", "halt"):
-            r = EvaluationResult.from_dict(
-                {"verdict": verdict, "retry_plan": {"new_input": "x"}}
-            )
-            assert handle_retryable_block(r) is None, verdict
-
-    def test_halt_approval_returns_none_even_with_plan(self):
-        r = ApprovalResult.from_dict(
-            {"action": "halt", "retry_plan": {"new_input": "x"}}
-        )
-        assert handle_retryable_block(r) is None
-
-    def test_expired_approval_returns_none_even_if_block(self):
-        r = ApprovalResult.from_dict(
-            {"action": "block", "retry_plan": {"new_input": "x"}, "expired": True}
-        )
-        assert r.verdict is Verdict.BLOCK
-        assert handle_retryable_block(r) is None
-
-    def test_pending_approval_returns_none(self):
-        r = ApprovalResult.from_dict({"retry_plan": {"new_input": "x"}})
-        assert r.verdict is None
-        assert handle_retryable_block(r) is None
-
-    def test_evaluation_result_never_raises_attributeerror(self):
-        # EvaluationResult has no is_blocking()/expired; the gate must not touch them.
-        r = EvaluationResult.from_dict(_block(retry_plan={"new_input": "x"}))
-        assert handle_retryable_block(r) is not None
-
-    def test_block_without_plan_returns_none(self):
-        assert handle_retryable_block(EvaluationResult.from_dict(_block())) is None
-
-
-class TestEnforcementUnchanged:
-    def test_block_still_raises_even_with_retry_plan(self):
-        # Adding retry_plan support must NOT suppress the default block; the helper is opt-in only.
-        r = EvaluationResult.from_dict(
-            _block(retry_plan={"new_input": "x"}, reason="nope")
-        )
-        with pytest.raises(GovernanceBlockedError):
-            raise_for_verdict(r)