Guard _resolve_cause against cyclic cause chains

Traverse only BaseException instances and track visited exceptions by
id, so a non-exception __cause__ ends the walk and a self-referential
chain terminates instead of hanging or raising in the degrade path.

Author: chris-colinsky

src/openarmature/graph/middleware/failure_isolation.py

@@ -77,7 +77,12 @@ def _resolve_cause(exc: Exception) -> BaseException:
 
     origin: BaseException | None = None
     current: BaseException | None = exc
-    while current is not None:
+    seen: set[int] = set()
+    # Traverse only BaseException instances (a non-exception ``__cause__``
+    # ends the walk) and guard against a cyclic ``__cause__`` chain so a
+    # malformed chain can't hang or crash the degrade path.
+    while isinstance(current, BaseException) and id(current) not in seen:
+        seen.add(id(current))
         if not isinstance(current, NodeException):
             if origin is None:
                 origin = current

tests/unit/test_failure_isolation_middleware.py

@@ -330,6 +330,24 @@ async def test_categorized_surface_wins_over_deeper_cause() -> None:
     assert events[0].caught_exception.message == "misconfigured"
 
 
+async def test_cyclic_cause_chain_terminates() -> None:
+    # Defensive: a self-referential __cause__ chain must not hang the
+    # degrade path. Resolution terminates and the node still degrades.
+    events: list[Any] = []
+    disp_token = _set_active_dispatch(lambda e: events.append(e))
+    a = NodeException(node_name="a", cause=ValueError("seed"), recoverable_state={})
+    b = NodeException(node_name="b", cause=a, recoverable_state={})
+    a.__cause__ = b  # cycle: a -> b -> a
+    try:
+        mw = FailureIsolationMiddleware(degraded_update={"result": []}, event_name="iso")
+        out = await mw("s", _raises(a))
+    finally:
+        _reset_active_dispatch(disp_token)
+
+    assert out == {"result": []}
+    assert len(events) == 1
+
+
 async def test_no_event_outside_invocation() -> None:
     # current_dispatch() is None outside an invocation; the degrade still
     # happens, no event is emitted, and nothing raises.