ouroboros-ai 0.27.3.dev2__tar.gz → 0.27.3.dev3__tar.gz

{ouroboros_ai-0.27.3.dev2 → ouroboros_ai-0.27.3.dev3}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: ouroboros-ai
-Version: 0.27.3.dev2
+Version: 0.27.3.dev3
 Summary: Specification-first workflow engine for AI coding agents. Works with Claude Code and Codex CLI.
 Author-email: Q00 <jqyu.lee@gmail.com>
 License-File: LICENSE

{ouroboros_ai-0.27.3.dev2 → ouroboros_ai-0.27.3.dev3}/src/ouroboros/_version.py

@@ -18,7 +18,7 @@ version_tuple: tuple[int | str, ...]
 commit_id: str | None
 __commit_id__: str | None
 
-__version__ = version = '0.27.3.dev2'
-__version_tuple__ = version_tuple = (0, 27, 3, 'dev2')
+__version__ = version = '0.27.3.dev3'
+__version_tuple__ = version_tuple = (0, 27, 3, 'dev3')
 
 __commit_id__ = commit_id = None

{ouroboros_ai-0.27.3.dev2 → ouroboros_ai-0.27.3.dev3}/src/ouroboros/cli/commands/mcp.py

@@ -140,22 +140,35 @@ async def _run_mcp_server(
     else:
         event_store = EventStore()
 
-    # Auto-cancel orphaned sessions on startup.
-    # Sessions left in RUNNING/PAUSED state for >1 hour are considered orphaned
-    # (e.g., from a previous crash). Cancel them before accepting new requests.
-    # NOTE: find_orphaned_sessions now checks for active runtime processes first,
-    # so sessions with live claude/codex agents won't be cancelled even if stale.
+    cleanup_task: asyncio.Task[None] | None = None
+
+    # Initialize the event store up front because the MCP server uses it for
+    # request handling. Orphan cleanup is intentionally deferred into the
+    # background so large SQLite histories do not block the initial MCP
+    # handshake on startup (#304).
     try:
         await event_store.initialize()
-        repo = SessionRepository(event_store)
-        cancelled = await repo.cancel_orphaned_sessions()
-        if cancelled:
-            _stderr_console.print(
-                f"[yellow]Auto-cancelled {len(cancelled)} orphaned session(s)[/yellow]"
-            )
     except Exception as e:
         # Auto-cleanup is best-effort — don't prevent server from starting
         _stderr_console.print(f"[yellow]Warning: auto-cleanup failed: {e}[/yellow]")
+    else:
+        repo = SessionRepository(event_store)
+
+        async def _run_startup_cleanup() -> None:
+            try:
+                cancelled = await repo.cancel_orphaned_sessions()
+                if cancelled:
+                    _stderr_console.print(
+                        f"[yellow]Auto-cancelled {len(cancelled)} orphaned session(s)[/yellow]"
+                    )
+            except Exception as e:
+                # Auto-cleanup is best-effort — don't prevent server startup
+                _stderr_console.print(f"[yellow]Warning: auto-cleanup failed: {e}[/yellow]")
+
+        cleanup_task = asyncio.create_task(
+            _run_startup_cleanup(),
+            name="ouroboros-mcp-startup-cleanup",
+        )
 
     # Auto-discover and connect MCP bridge for server-to-server communication
     from ouroboros.mcp.bridge import create_bridge_from_env
@@ -224,6 +237,12 @@ async def _run_mcp_server(
     try:
         await server.serve(transport=transport, host=host, port=port)
     finally:
+        if cleanup_task is not None and not cleanup_task.done():
+            cleanup_task.cancel()
+            try:
+                await cleanup_task
+            except asyncio.CancelledError:
+                pass
         _cleanup_pid_file()
 
 

{ouroboros_ai-0.27.3.dev2 → ouroboros_ai-0.27.3.dev3}/src/ouroboros/orchestrator/session.py

@@ -34,7 +34,7 @@ from ouroboros.events.base import BaseEvent, sanitize_event_data_for_persistence
 from ouroboros.observability.logging import get_logger
 
 if TYPE_CHECKING:
-    from ouroboros.persistence.event_store import EventStore
+    from ouroboros.persistence.event_store import EventStore, SessionActivitySnapshot
 
 log = get_logger(__name__)
 
@@ -352,6 +352,70 @@ class SessionRepository:
 
         return progress
 
+    @staticmethod
+    def _coerce_snapshot_datetime(value: object) -> datetime | None:
+        """Normalize timestamp values returned by snapshot queries."""
+        if isinstance(value, datetime):
+            if value.tzinfo is None:
+                return value.replace(tzinfo=UTC)
+            return value
+        if isinstance(value, str) and value:
+            parsed = datetime.fromisoformat(value)
+            if parsed.tzinfo is None:
+                return parsed.replace(tzinfo=UTC)
+            return parsed
+        return None
+
+    @classmethod
+    def _status_from_snapshot(cls, snapshot: SessionActivitySnapshot) -> SessionStatus:
+        """Derive session status from a snapshot row."""
+        status = cls._status_from_event(snapshot.status_event_type, {})
+        if status is not None:
+            return status
+
+        runtime_status = cls._coerce_runtime_status(snapshot.runtime_status)
+        if runtime_status is not None:
+            return runtime_status
+
+        return SessionStatus.RUNNING
+
+    async def _find_orphaned_sessions_via_snapshots(
+        self,
+        snapshots: list[SessionActivitySnapshot],
+        alive_sessions: set[str],
+        staleness_threshold: timedelta,
+        now: datetime,
+    ) -> list[SessionTracker]:
+        """Detect orphaned sessions from pre-aggregated session snapshots."""
+        orphaned: list[SessionTracker] = []
+
+        for snapshot in snapshots:
+            status = self._status_from_snapshot(snapshot)
+            if status not in (SessionStatus.RUNNING, SessionStatus.PAUSED):
+                continue
+
+            if snapshot.session_id in alive_sessions:
+                log.info(
+                    "orchestrator.orphan_detection.heartbeat_alive",
+                    session_id=snapshot.session_id,
+                )
+                continue
+
+            last_activity = self._coerce_snapshot_datetime(snapshot.last_activity)
+            if last_activity is None:
+                last_activity = self._coerce_snapshot_datetime(snapshot.start_time)
+            if last_activity is None:
+                continue
+
+            if (now - last_activity) <= staleness_threshold:
+                continue
+
+            result = await self.reconstruct_session(snapshot.session_id)
+            if result.is_ok:
+                orphaned.append(result.value)
+
+        return orphaned
+
     @staticmethod
     def _merge_event_streams(
         primary_events: list[BaseEvent],
@@ -892,6 +956,24 @@ class SessionRepository:
         orphaned: list[SessionTracker] = []
 
         try:
+            get_snapshots = getattr(self._event_store, "get_session_activity_snapshots", None)
+            if callable(get_snapshots):
+                snapshots = await get_snapshots()
+                if isinstance(snapshots, list):
+                    orphaned = await self._find_orphaned_sessions_via_snapshots(
+                        snapshots,
+                        alive_sessions,
+                        staleness_threshold,
+                        now,
+                    )
+                    log.info(
+                        "orchestrator.orphan_detection.complete",
+                        total_sessions=len(snapshots),
+                        orphaned_count=len(orphaned),
+                        strategy="snapshot",
+                    )
+                    return orphaned
+
             # Get all session start events to enumerate sessions
             start_events = await self._event_store.get_all_sessions()
 
@@ -955,6 +1037,7 @@ class SessionRepository:
                 "orchestrator.orphan_detection.complete",
                 total_sessions=len(start_events),
                 orphaned_count=len(orphaned),
+                strategy="replay",
             )
 
         except Exception as e:

{ouroboros_ai-0.27.3.dev2 → ouroboros_ai-0.27.3.dev3}/src/ouroboros/persistence/event_store.py

@@ -4,12 +4,15 @@ Provides async methods for appending and replaying events using SQLAlchemy Core
 with aiosqlite backend.
 """
 
+from __future__ import annotations
+
 import asyncio
 from collections.abc import Mapping
+from dataclasses import dataclass
 import logging
 from pathlib import Path
 
-from sqlalchemy import event, or_, select, text
+from sqlalchemy import and_, event, func, or_, select, text
 from sqlalchemy.ext.asyncio import AsyncEngine, create_async_engine
 
 from ouroboros.core.errors import PersistenceError
@@ -439,6 +442,147 @@ class EventStore:
                 details={"event_type": "orchestrator.session.%"},
             ) from e
 
+    async def get_session_activity_snapshots(self) -> list[SessionActivitySnapshot]:
+        """Return one session snapshot row per session aggregate.
+
+        The snapshot includes session identity from the start event, the most
+        recent session activity timestamp, and the latest status-bearing event
+        or runtime_status payload when present. This avoids replaying every
+        event for every session just to detect stale active sessions.
+        """
+        if self._engine is None:
+            raise PersistenceError(
+                "EventStore not initialized. Call initialize() first.",
+                operation="get_session_activity_snapshots",
+            )
+
+        status_expr = func.coalesce(
+            func.json_extract(events_table.c.payload, "$.progress.runtime_status"),
+            func.json_extract(events_table.c.payload, "$.runtime_status"),
+        )
+
+        started_ranked = (
+            select(
+                events_table.c.aggregate_id.label("session_id"),
+                func.json_extract(events_table.c.payload, "$.execution_id").label("execution_id"),
+                func.json_extract(events_table.c.payload, "$.seed_id").label("seed_id"),
+                func.json_extract(events_table.c.payload, "$.start_time").label("start_time"),
+                func.row_number()
+                .over(
+                    partition_by=events_table.c.aggregate_id,
+                    order_by=(events_table.c.timestamp.asc(), events_table.c.id.asc()),
+                )
+                .label("rn"),
+            )
+            .where(events_table.c.aggregate_type == "session")
+            .where(events_table.c.event_type == "orchestrator.session.started")
+            .subquery()
+        )
+
+        latest_activity_ranked = (
+            select(
+                events_table.c.aggregate_id.label("session_id"),
+                events_table.c.timestamp.label("last_activity"),
+                func.row_number()
+                .over(
+                    partition_by=events_table.c.aggregate_id,
+                    order_by=(events_table.c.timestamp.desc(), events_table.c.id.desc()),
+                )
+                .label("rn"),
+            )
+            .where(events_table.c.aggregate_type == "session")
+            .subquery()
+        )
+
+        latest_status_ranked = (
+            select(
+                events_table.c.aggregate_id.label("session_id"),
+                events_table.c.event_type.label("status_event_type"),
+                status_expr.label("runtime_status"),
+                func.row_number()
+                .over(
+                    partition_by=events_table.c.aggregate_id,
+                    order_by=(events_table.c.timestamp.desc(), events_table.c.id.desc()),
+                )
+                .label("rn"),
+            )
+            .where(events_table.c.aggregate_type == "session")
+            .where(
+                or_(
+                    events_table.c.event_type.in_(
+                        (
+                            "orchestrator.session.completed",
+                            "orchestrator.session.failed",
+                            "orchestrator.session.paused",
+                            "orchestrator.session.cancelled",
+                        )
+                    ),
+                    and_(
+                        events_table.c.event_type.in_(
+                            (
+                                "orchestrator.progress.updated",
+                                "workflow.progress.updated",
+                            )
+                        ),
+                        status_expr.is_not(None),
+                    ),
+                )
+            )
+            .subquery()
+        )
+
+        try:
+            async with self._engine.begin() as conn:
+                query = (
+                    select(
+                        started_ranked.c.session_id,
+                        started_ranked.c.execution_id,
+                        started_ranked.c.seed_id,
+                        started_ranked.c.start_time,
+                        latest_activity_ranked.c.last_activity,
+                        latest_status_ranked.c.status_event_type,
+                        latest_status_ranked.c.runtime_status,
+                    )
+                    .select_from(started_ranked)
+                    .join(
+                        latest_activity_ranked,
+                        and_(
+                            latest_activity_ranked.c.session_id == started_ranked.c.session_id,
+                            latest_activity_ranked.c.rn == 1,
+                        ),
+                    )
+                    .outerjoin(
+                        latest_status_ranked,
+                        and_(
+                            latest_status_ranked.c.session_id == started_ranked.c.session_id,
+                            latest_status_ranked.c.rn == 1,
+                        ),
+                    )
+                    .where(started_ranked.c.rn == 1)
+                    .order_by(started_ranked.c.session_id.asc())
+                )
+
+                result = await conn.execute(query)
+                rows = result.mappings().all()
+                return [
+                    SessionActivitySnapshot(
+                        session_id=row["session_id"],
+                        execution_id=row.get("execution_id"),
+                        seed_id=row.get("seed_id"),
+                        start_time=row.get("start_time"),
+                        last_activity=row.get("last_activity"),
+                        status_event_type=row.get("status_event_type"),
+                        runtime_status=row.get("runtime_status"),
+                    )
+                    for row in rows
+                ]
+        except Exception as e:
+            raise PersistenceError(
+                f"Failed to fetch session activity snapshots: {e}",
+                operation="select",
+                table="events",
+            ) from e
+
     async def query_events(
         self,
         aggregate_id: str | None = None,
@@ -666,3 +810,16 @@ class EventStore:
         if self._engine is not None:
             await self._engine.dispose()
             self._engine = None
+
+
+@dataclass(frozen=True, slots=True)
+class SessionActivitySnapshot:
+    """Session start/activity/status summary used by orphan detection."""
+
+    session_id: str
+    execution_id: str | None
+    seed_id: str | None
+    start_time: str | None
+    last_activity: object
+    status_event_type: str | None
+    runtime_status: str | None

{ouroboros_ai-0.27.3.dev2 → ouroboros_ai-0.27.3.dev3}/tests/unit/cli/test_mcp_startup_cleanup.py

@@ -10,6 +10,7 @@ MCP server startup in _run_mcp_server(), ensuring:
 
 from __future__ import annotations
 
+import asyncio
 from datetime import UTC, datetime, timedelta
 from unittest.mock import AsyncMock, MagicMock, patch
 
@@ -77,6 +78,11 @@ class TestMCPStartupAutoCleanup:
         """Test that startup with no orphaned sessions skips cancellation."""
         mock_es, mock_repo, mock_server = self._create_patches(cancelled_sessions=[])
 
+        async def serve_side_effect(*args, **kwargs) -> None:
+            await asyncio.sleep(0)
+
+        mock_server.serve.side_effect = serve_side_effect
+
         with (
             patch(
                 "ouroboros.persistence.event_store.EventStore",
@@ -96,8 +102,53 @@ class TestMCPStartupAutoCleanup:
             await _run_mcp_server("localhost", 8080, "stdio")
 
         mock_repo.cancel_orphaned_sessions.assert_called_once()
+        mock_es.initialize.assert_awaited_once()
         mock_server.serve.assert_called_once()
 
+    @pytest.mark.asyncio
+    async def test_startup_does_not_wait_for_background_cleanup(self) -> None:
+        """Server startup should not wait for orphan cleanup to finish."""
+        cleanup_started = asyncio.Event()
+        allow_cleanup_finish = asyncio.Event()
+        serve_started = asyncio.Event()
+
+        mock_es = AsyncMock()
+        mock_es.initialize = AsyncMock()
+        mock_repo = AsyncMock()
+
+        async def slow_cleanup() -> list:
+            cleanup_started.set()
+            await allow_cleanup_finish.wait()
+            return []
+
+        mock_repo.cancel_orphaned_sessions = AsyncMock(side_effect=slow_cleanup)
+
+        mock_server = MagicMock()
+        mock_server.info.tools = []
+
+        async def serve_side_effect(*args, **kwargs) -> None:
+            serve_started.set()
+            allow_cleanup_finish.set()
+            await asyncio.sleep(0)
+
+        mock_server.serve = AsyncMock(side_effect=serve_side_effect)
+
+        with (
+            patch("ouroboros.persistence.event_store.EventStore", return_value=mock_es),
+            patch("ouroboros.orchestrator.session.SessionRepository", return_value=mock_repo),
+            patch(
+                "ouroboros.mcp.server.adapter.create_ouroboros_server",
+                return_value=mock_server,
+            ),
+        ):
+            from ouroboros.cli.commands.mcp import _run_mcp_server
+
+            await _run_mcp_server("localhost", 8080, "stdio")
+
+        assert cleanup_started.is_set()
+        assert serve_started.is_set()
+        mock_server.serve.assert_awaited_once()
+
     @pytest.mark.asyncio
     async def test_orphans_detected_and_cancelled(self) -> None:
         """Test that orphaned sessions are cancelled on startup."""
@@ -131,6 +182,12 @@ class TestMCPStartupAutoCleanup:
             ),
             patch("ouroboros.cli.commands.mcp._stderr_console") as mock_console,
         ):
+
+            async def serve_side_effect(*args, **kwargs) -> None:
+                await asyncio.sleep(0)
+
+            mock_server.serve.side_effect = serve_side_effect
+
             from ouroboros.cli.commands.mcp import _run_mcp_server
 
             await _run_mcp_server("localhost", 8080, "stdio")
@@ -139,6 +196,50 @@ class TestMCPStartupAutoCleanup:
         mock_console.print.assert_any_call("[yellow]Auto-cancelled 2 orphaned session(s)[/yellow]")
         mock_server.serve.assert_called_once()
 
+    @pytest.mark.asyncio
+    async def test_pending_background_cleanup_is_cancelled_on_shutdown(self) -> None:
+        """Server shutdown should cancel an unfinished startup cleanup task."""
+        cleanup_started = asyncio.Event()
+        cleanup_cancelled = asyncio.Event()
+
+        mock_es = AsyncMock()
+        mock_es.initialize = AsyncMock()
+        mock_repo = AsyncMock()
+
+        async def slow_cleanup() -> list:
+            cleanup_started.set()
+            try:
+                await asyncio.Event().wait()
+            except asyncio.CancelledError:
+                cleanup_cancelled.set()
+                raise
+
+        mock_repo.cancel_orphaned_sessions = AsyncMock(side_effect=slow_cleanup)
+
+        mock_server = MagicMock()
+        mock_server.info.tools = []
+
+        async def serve_side_effect(*args, **kwargs) -> None:
+            await cleanup_started.wait()
+
+        mock_server.serve = AsyncMock(side_effect=serve_side_effect)
+
+        with (
+            patch("ouroboros.persistence.event_store.EventStore", return_value=mock_es),
+            patch("ouroboros.orchestrator.session.SessionRepository", return_value=mock_repo),
+            patch(
+                "ouroboros.mcp.server.adapter.create_ouroboros_server",
+                return_value=mock_server,
+            ),
+        ):
+            from ouroboros.cli.commands.mcp import _run_mcp_server
+
+            await _run_mcp_server("localhost", 8080, "stdio")
+
+        assert cleanup_started.is_set()
+        assert cleanup_cancelled.is_set()
+        mock_server.serve.assert_awaited_once()
+
     @pytest.mark.asyncio
     async def test_cleanup_failure_does_not_prevent_startup(self) -> None:
         """Test that auto-cleanup failure doesn't block server startup."""
@@ -156,6 +257,12 @@ class TestMCPStartupAutoCleanup:
             ),
             patch("ouroboros.cli.commands.mcp._stderr_console") as mock_console,
         ):
+
+            async def serve_side_effect(*args, **kwargs) -> None:
+                await asyncio.sleep(0)
+
+            mock_server.serve.side_effect = serve_side_effect
+
             from ouroboros.cli.commands.mcp import _run_mcp_server
 
             await _run_mcp_server("localhost", 8080, "stdio")
@@ -186,6 +293,12 @@ class TestMCPStartupAutoCleanup:
             ),
             patch("ouroboros.cli.commands.mcp._stderr_console") as mock_console,
         ):
+
+            async def serve_side_effect(*args, **kwargs) -> None:
+                await asyncio.sleep(0)
+
+            mock_server.serve.side_effect = serve_side_effect
+
             from ouroboros.cli.commands.mcp import _run_mcp_server
 
             await _run_mcp_server("localhost", 8080, "stdio")
@@ -216,7 +329,11 @@ class TestMCPStartupAutoCleanup:
 
         mock_server = MagicMock()
         mock_server.info.tools = []
-        mock_server.serve = AsyncMock()
+
+        async def serve_side_effect(*args, **kwargs) -> None:
+            await asyncio.sleep(0)
+
+        mock_server.serve = AsyncMock(side_effect=serve_side_effect)
 
         with (
             patch(
@@ -236,7 +353,7 @@ class TestMCPStartupAutoCleanup:
 
             await _run_mcp_server("localhost", 8080, "stdio")
 
-        assert call_order == ["initialize", "cancel_orphaned"]
+        assert call_order[:2] == ["initialize", "cancel_orphaned"]
 
     @pytest.mark.asyncio
     async def test_runtime_backend_is_forwarded_to_server_factory(self) -> None:
@@ -332,6 +449,11 @@ class TestMCPStartupAutoCleanup:
 
         mock_es, mock_repo, mock_server = self._create_patches(cancelled_sessions=single_orphan)
 
+        async def serve_side_effect(*args, **kwargs) -> None:
+            await asyncio.sleep(0)
+
+        mock_server.serve.side_effect = serve_side_effect
+
         with (
             patch(
                 "ouroboros.persistence.event_store.EventStore",

{ouroboros_ai-0.27.3.dev2 → ouroboros_ai-0.27.3.dev3}/tests/unit/orchestrator/test_session.py

@@ -1085,6 +1085,39 @@ class TestFindOrphanedSessions:
 
         assert result == []
 
+    @pytest.mark.asyncio
+    async def test_prefers_snapshot_query_over_full_replay(
+        self,
+        repository: SessionRepository,
+        mock_event_store: AsyncMock,
+    ) -> None:
+        """Snapshot query should avoid session-by-session replay on large stores."""
+        from ouroboros.persistence.event_store import SessionActivitySnapshot
+
+        old_time = datetime.now(UTC) - timedelta(hours=2)
+        mock_event_store.get_session_activity_snapshots = AsyncMock(
+            return_value=[
+                SessionActivitySnapshot(
+                    session_id="sess_1",
+                    execution_id="exec_sess_1",
+                    seed_id="seed_sess_1",
+                    start_time=old_time.isoformat(),
+                    last_activity=old_time,
+                    status_event_type=None,
+                    runtime_status=None,
+                )
+            ]
+        )
+
+        start_event = self._make_start_event("sess_1", timestamp=old_time)
+        mock_event_store.replay.return_value = [start_event]
+
+        result = await repository.find_orphaned_sessions()
+
+        assert len(result) == 1
+        mock_event_store.get_session_activity_snapshots.assert_awaited_once()
+        mock_event_store.get_all_sessions.assert_not_called()
+
     @pytest.mark.asyncio
     async def test_failed_session_not_orphaned(
         self,

{ouroboros_ai-0.27.3.dev2 → ouroboros_ai-0.27.3.dev3}/tests/unit/persistence/test_event_store.py

@@ -553,6 +553,64 @@ class TestEventStoreErrorHandling:
             await store.replay("test", "test-123")
 
 
+class TestSessionActivitySnapshots:
+    """Test aggregated session snapshot queries for orphan detection."""
+
+    async def test_returns_latest_status_and_activity(self, event_store: EventStore) -> None:
+        await event_store.append(
+            BaseEvent(
+                type="orchestrator.session.started",
+                aggregate_type="session",
+                aggregate_id="sess-running",
+                data={
+                    "execution_id": "exec-running",
+                    "seed_id": "seed-running",
+                    "start_time": "2026-04-01T00:00:00+00:00",
+                },
+            )
+        )
+        await event_store.append(
+            BaseEvent(
+                type="orchestrator.progress.updated",
+                aggregate_type="session",
+                aggregate_id="sess-running",
+                data={"progress": {"step": 2}},
+            )
+        )
+        await event_store.append(
+            BaseEvent(
+                type="orchestrator.session.started",
+                aggregate_type="session",
+                aggregate_id="sess-completed",
+                data={
+                    "execution_id": "exec-completed",
+                    "seed_id": "seed-completed",
+                    "start_time": "2026-04-01T01:00:00+00:00",
+                },
+            )
+        )
+        await event_store.append(
+            BaseEvent(
+                type="orchestrator.progress.updated",
+                aggregate_type="session",
+                aggregate_id="sess-completed",
+                data={"progress": {"runtime_status": "completed"}},
+            )
+        )
+
+        snapshots = await event_store.get_session_activity_snapshots()
+        by_id = {snapshot.session_id: snapshot for snapshot in snapshots}
+
+        assert set(by_id) == {"sess-running", "sess-completed"}
+        assert by_id["sess-running"].execution_id == "exec-running"
+        assert by_id["sess-running"].seed_id == "seed-running"
+        assert by_id["sess-running"].status_event_type is None
+        assert by_id["sess-running"].runtime_status is None
+        assert by_id["sess-running"].last_activity is not None
+        assert by_id["sess-completed"].status_event_type == "orchestrator.progress.updated"
+        assert by_id["sess-completed"].runtime_status == "completed"
+
+
 class TestGetAllSessions:
     """Test get_all_sessions returns all session lifecycle events."""