feat(#11): AdminEvents pane — GET /admin/events SSE (session-filtered)

v1 coverage-audit: the last unbuilt design-brief §5 debug pane. #11's
blocker was already satisfied (admin key carries admin.events.read).
Completes the admin/debug-observability core.

- sse_client.py: AdminEvent dataclass + stream_admin_events — a new
  long-lived SSE consumer for the admin lifecycle stream (envelope
  {id,type,timestamp,data}), admin-scoped (bearer-override), Last-Event-ID
  resume. non-200 -> SseConnectFailed; mid-drop -> SseConnectionDropped.
- tui.py: "AdminEvents" TabPane + _format_admin_event + _admin_event_matches
  (design-brief §6 filter: active-session + non-heartbeat system.*) +
  _stream_admin_events long-lived best-effort worker (unconditional
  on_mount; self-labels not-configured / unavailable / stream-ended).
- Contract-skipped for stream_admin_events (out of #1's turn-SSE scope;
  spec § Admin Event Stream is the reference). TDD: 4 sse_client + 5 tui
  tests. Suite 561 green.
- LIVE-AUTH-PROVEN on :8081 (GET /admin/events -> HTTP 200 under admin key).

Coverage: REST 12/40. Tier 1 debug-observability core complete.

tests/test_tui.py

@@ -3330,3 +3330,110 @@ class TestBifrostStateHydration:
         joined = " ".join(_text_of(w) for w in writes)
         assert "not bound to Bifrost" in joined
         assert "bifrost_state_unavailable" in joined
+
+
+class TestAdminEventsStream:
+    """stream_admin_events + the #11 AdminEvents pane (GET /admin/events, session-filtered)."""
+
+    @staticmethod
+    def _mute_hydrates(monkeypatch: pytest.MonkeyPatch) -> None:
+        """Neutralize the other on_mount workers (tools + bifrost) — no real calls."""
+        import ratatoskr.tui as tui_mod
+        from ratatoskr.sessions import SessionApiFailed
+
+        async def noop_tools(client, session_id):
+            return {"agent_id": "x", "builtin_tools": [], "bifrost_tools": []}
+
+        async def noop_bifrost(client, session_id, *, admin_key):
+            raise SessionApiFailed(status=404, body=b"nb")
+
+        monkeypatch.setattr(tui_mod, "get_session_tools", noop_tools)
+        monkeypatch.setattr(tui_mod, "get_session_bifrost", noop_bifrost)
+
+    def test_format_admin_event(self) -> None:
+        """format_admin_event [unit]: HH:MM:SS + type + fields; session_id dropped."""
+        from ratatoskr.sse_client import AdminEvent
+        from ratatoskr.tui import _format_admin_event
+
+        line = _format_admin_event(
+            AdminEvent(
+                42, "turn.completed", "2026-05-06T10:00:05.000Z",
+                {"session_id": "s1", "turn_id": 7, "duration_ms": 1200, "phase": "succeeded"},
+            )
+        )
+        assert "turn.completed" in line
+        assert "[10:00:05]" in line
+        assert "turn_id=7" in line
+        assert "session_id" not in line  # dropped — pane is already session-scoped
+
+    def test_admin_event_matches_filter(self) -> None:
+        """admin_event_matches [unit]: active-session + non-heartbeat system.* pass (§6)."""
+        from ratatoskr.sse_client import AdminEvent
+
+        E = AdminEvent
+        app = _resolved_app(_args_existing(session_id="s-match"))
+        assert app._admin_event_matches(E(1, "session.created", "t", {"session_id": "s-match"}))
+        assert not app._admin_event_matches(E(2, "turn.started", "t", {"session_id": "other"}))
+        assert not app._admin_event_matches(E(0, "system.heartbeat", "t", {}))
+        assert app._admin_event_matches(E(3, "system.events_dropped", "t", {"count": 5}))
+
+    async def test_stream_writes_filtered_events(self, monkeypatch: pytest.MonkeyPatch) -> None:
+        """stream_filtered [scenario,tracer]: only active-session + non-heartbeat lines land."""
+        import ratatoskr.tui as tui_mod
+        from ratatoskr.sse_client import AdminEvent
+
+        self._mute_hydrates(monkeypatch)
+        writes = _spy_writes(monkeypatch)
+
+        async def fake_stream(client, *, admin_key, last_event_id=None):
+            yield AdminEvent(41, "session.created", "t", {"session_id": "s-ae-2"})
+            yield AdminEvent(0, "system.heartbeat", "t", {})  # filtered (noise)
+            yield AdminEvent(42, "turn.started", "t", {"session_id": "other"})  # diff session
+            yield AdminEvent(43, "session.deleted", "t", {"session_id": "s-ae-2"})
+
+        monkeypatch.setattr(tui_mod, "stream_admin_events", fake_stream)
+        app = _resolved_app(_args_existing(session_id="s-ae-2", admin_key="ak"))
+        async with app.run_test() as pilot:
+            await pilot.pause()
+            await app._stream_admin_events()
+            await pilot.pause()
+        joined = " ".join(_text_of(w) for w in writes)
+        assert "session.created" in joined
+        assert "session.deleted" in joined
+        assert "system.heartbeat" not in joined
+        assert "turn.started" not in joined  # different session → filtered
+
+    async def test_stream_no_admin_key(self, monkeypatch: pytest.MonkeyPatch) -> None:
+        """stream_no_admin_key [scenario]: admin_key None → 'not configured' + skip audit."""
+        self._mute_hydrates(monkeypatch)
+        writes = _spy_writes(monkeypatch)
+        app = _resolved_app(_args_existing(session_id="s-ae-3"))  # admin_key None
+        async with app.run_test() as pilot:
+            await pilot.pause()
+            await app._stream_admin_events()
+            await pilot.pause()
+        joined = " ".join(_text_of(w) for w in writes)
+        assert "admin key not configured" in joined
+        assert "admin_events_skipped" in joined
+
+    async def test_stream_403_unavailable(self, monkeypatch: pytest.MonkeyPatch) -> None:
+        """stream_403 [error]: 403 scope-denied → 'unavailable' + audit; no crash."""
+        import ratatoskr.tui as tui_mod
+        from ratatoskr.sse_client import SseConnectFailed
+
+        self._mute_hydrates(monkeypatch)
+        writes = _spy_writes(monkeypatch)
+
+        async def denied(client, *, admin_key, last_event_id=None):
+            raise SseConnectFailed(status=403, body=b"auth_scope_denied")
+            yield  # unreachable — makes this an async generator
+
+        monkeypatch.setattr(tui_mod, "stream_admin_events", denied)
+        app = _resolved_app(_args_existing(session_id="s-ae-4", admin_key="ak"))
+        async with app.run_test() as pilot:
+            await pilot.pause()
+            await app._stream_admin_events()
+            await pilot.pause()
+        joined = " ".join(_text_of(w) for w in writes)
+        assert "admin events unavailable: HTTP 403" in joined
+        assert "admin_events_unavailable" in joined