ouroboros-ai 0.26.6.dev1__tar.gz → 0.26.6.dev2__tar.gz

{ouroboros_ai-0.26.6.dev1 → ouroboros_ai-0.26.6.dev2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: ouroboros-ai
-Version: 0.26.6.dev1
+Version: 0.26.6.dev2
 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.26.6.dev1 → ouroboros_ai-0.26.6.dev2}/src/ouroboros/_version.py

@@ -18,7 +18,7 @@ version_tuple: tuple[int | str, ...]
 commit_id: str | None
 __commit_id__: str | None
 
-__version__ = version = '0.26.6.dev1'
-__version_tuple__ = version_tuple = (0, 26, 6, 'dev1')
+__version__ = version = '0.26.6.dev2'
+__version_tuple__ = version_tuple = (0, 26, 6, 'dev2')
 
 __commit_id__ = commit_id = None

{ouroboros_ai-0.26.6.dev1 → ouroboros_ai-0.26.6.dev2}/src/ouroboros/orchestrator/events.py

@@ -545,9 +545,48 @@ def create_drift_measured_event(
     )
 
 
+def create_execution_terminal_event(
+    execution_id: str,
+    session_id: str,
+    status: str,
+    *,
+    summary: dict[str, Any] | None = None,
+    error_message: str | None = None,
+    messages_processed: int = 0,
+) -> BaseEvent:
+    """Mirror a session terminal state into the execution event stream.
+
+    The orchestrator stores lifecycle events (started/completed/failed)
+    under ``aggregate_type="session"`` while runtime progress events use
+    ``aggregate_type="execution"``.  TUI and other consumers that poll
+    only the execution stream would never see the terminal transition.
+
+    This helper emits an ``execution.terminal`` event under the execution
+    aggregate so that a single-stream consumer can detect completion
+    without polling a second channel.
+    """
+    data: dict[str, Any] = {
+        "session_id": session_id,
+        "status": status,
+        "messages_processed": messages_processed,
+        "timestamp": datetime.now(UTC).isoformat(),
+    }
+    if summary is not None:
+        data["summary"] = summary
+    if error_message is not None:
+        data["error_message"] = error_message
+    return BaseEvent(
+        type="execution.terminal",
+        aggregate_type="execution",
+        aggregate_id=execution_id,
+        data=data,
+    )
+
+
 __all__ = [
     "create_ac_stall_detected_event",
     "create_drift_measured_event",
+    "create_execution_terminal_event",
     "create_heartbeat_event",
     "create_mcp_tools_loaded_event",
     "create_progress_event",

{ouroboros_ai-0.26.6.dev1 → ouroboros_ai-0.26.6.dev2}/src/ouroboros/orchestrator/runner.py

@@ -43,6 +43,7 @@ from ouroboros.orchestrator.adapter import (
 )
 from ouroboros.orchestrator.events import (
     create_drift_measured_event,
+    create_execution_terminal_event,
     create_mcp_tools_loaded_event,
     create_progress_event,
     create_session_completed_event,
@@ -1145,6 +1146,17 @@ class OrchestratorRunner:
                     error=str(cancel_result.error),
                 )
 
+        # Mirror cancellation into execution stream for TUI.
+        await self._event_store.append(
+            create_execution_terminal_event(
+                execution_id=execution_id,
+                session_id=session_id,
+                status="cancelled",
+                error_message="Execution cancelled by external request",
+                messages_processed=messages_processed,
+            )
+        )
+
         # Display cancellation notice
         self._console.print(
             Panel(
@@ -1532,6 +1544,19 @@ class OrchestratorRunner:
                     )
                 )
 
+            # Mirror terminal state into the execution event stream so
+            # single-stream consumers (TUI) detect completion without
+            # polling the separate session aggregate.
+            terminal_event = create_execution_terminal_event(
+                execution_id=exec_id,
+                session_id=tracker.session_id,
+                status="completed" if success else "failed",
+                summary=completion_summary if success else None,
+                error_message=final_message if not success else None,
+                messages_processed=messages_processed,
+            )
+            await self._event_store.append(terminal_event)
+
             log.info(
                 "orchestrator.runner.execute_completed",
                 execution_id=exec_id,
@@ -1586,6 +1611,15 @@ class OrchestratorRunner:
                 tracker.session_id,
                 str(e),
             )
+            await self._event_store.append(
+                create_execution_terminal_event(
+                    execution_id=exec_id,
+                    session_id=tracker.session_id,
+                    status="failed",
+                    error_message=str(e),
+                    messages_processed=messages_processed,
+                )
+            )
 
             return Result.err(
                 OrchestratorError(
@@ -1801,6 +1835,17 @@ class OrchestratorRunner:
                 )
             )
 
+        await self._event_store.append(
+            create_execution_terminal_event(
+                execution_id=exec_id,
+                session_id=tracker.session_id,
+                status="completed" if success else "failed",
+                summary=execution_summary if success else None,
+                error_message=final_message if not success else None,
+                messages_processed=parallel_result.total_messages,
+            )
+        )
+
         log.info(
             "orchestrator.runner.parallel_completed",
             execution_id=exec_id,
@@ -2131,6 +2176,20 @@ Note: This is a resumed session. Please continue from where execution was interr
                     )
                 )
 
+            # Mirror terminal state into execution stream for TUI.
+            terminal_status = (
+                "completed" if success else ("paused" if recoverable_resume_failure else "failed")
+            )
+            await self._event_store.append(
+                create_execution_terminal_event(
+                    execution_id=tracker.execution_id,
+                    session_id=session_id,
+                    status=terminal_status,
+                    error_message=final_message if not success else None,
+                    messages_processed=messages_processed,
+                )
+            )
+
             log.info(
                 "orchestrator.runner.resume_completed",
                 session_id=session_id,
@@ -2170,6 +2229,14 @@ Note: This is a resumed session. Please continue from where execution was interr
             self._unregister_session(tracker.execution_id, session_id)
             if self._task_workspace is not None:
                 release_lock(self._task_workspace.lock_path)
+            await self._event_store.append(
+                create_execution_terminal_event(
+                    execution_id=tracker.execution_id,
+                    session_id=session_id,
+                    status="failed",
+                    error_message=str(e),
+                )
+            )
 
             return Result.err(
                 OrchestratorError(

{ouroboros_ai-0.26.6.dev1 → ouroboros_ai-0.26.6.dev2}/src/ouroboros/tui/app.py

@@ -257,6 +257,12 @@ class OuroborosTUI(App[None]):
             self._state.status = "failed"
         elif event_type == "orchestrator.session.cancelled":
             self._state.status = "cancelled"
+        elif event_type == "execution.terminal":
+            # Mirror event from the execution stream — ensures TUI sees
+            # terminal transitions even when only polling "execution".
+            terminal_status = data.get("status", "completed")
+            if terminal_status in {"completed", "failed", "cancelled"}:
+                self._state.status = terminal_status
         elif event_type == "orchestrator.session.paused":
             self._state.status = "paused"
             self._state.is_paused = True

{ouroboros_ai-0.26.6.dev1 → ouroboros_ai-0.26.6.dev2}/src/ouroboros/tui/events.py

@@ -665,6 +665,14 @@ def create_message_from_event(event: BaseEvent) -> Message | None:
             data=data,
         )
 
+    elif event_type == "execution.terminal":
+        return ExecutionUpdated(
+            execution_id=event.aggregate_id,
+            session_id=data.get("session_id", ""),
+            status=data.get("status", "completed"),
+            data=data,
+        )
+
     elif event_type == "execution.phase.completed":
         return PhaseChanged(
             execution_id=event.aggregate_id,