ouroboros-ai 0.26.5.dev4__tar.gz → 0.26.5.dev5__tar.gz

{ouroboros_ai-0.26.5.dev4 → ouroboros_ai-0.26.5.dev5}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: ouroboros-ai
-Version: 0.26.5.dev4
+Version: 0.26.5.dev5
 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.5.dev4 → ouroboros_ai-0.26.5.dev5}/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.5.dev4'
-__version_tuple__ = version_tuple = (0, 26, 5, 'dev4')
+__version__ = version = '0.26.5.dev5'
+__version_tuple__ = version_tuple = (0, 26, 5, 'dev5')
 
 __commit_id__ = commit_id = None

{ouroboros_ai-0.26.5.dev4 → ouroboros_ai-0.26.5.dev5}/src/ouroboros/orchestrator/codex_cli_runtime.py

@@ -694,13 +694,6 @@ class CodexCliRuntime:
     ) -> list[str]:
         """Build the CLI command args.  Prompt is fed via stdin separately."""
         command = [self._cli_path, "exec"]
-        if resume_session_id:
-            if not _SAFE_SESSION_ID_PATTERN.match(resume_session_id):
-                raise ValueError(
-                    f"Invalid resume_session_id: contains disallowed characters: "
-                    f"{resume_session_id!r}"
-                )
-            command.extend(["resume", resume_session_id])
 
         command.extend(
             [
@@ -718,8 +711,28 @@ class CodexCliRuntime:
             command.extend(["--model", normalized_model])
 
         command.extend(self._build_permission_args())
+        if resume_session_id:
+            if not _SAFE_SESSION_ID_PATTERN.match(resume_session_id):
+                raise ValueError(
+                    f"Invalid resume_session_id: contains disallowed characters: "
+                    f"{resume_session_id!r}"
+                )
+            command.extend(["resume", resume_session_id])
         return command
 
+    def _build_resume_retry_metadata(self, resume_session_id: str | None) -> dict[str, Any]:
+        """Return retry metadata for resume failures that happen before reconnect."""
+        if not resume_session_id:
+            return {}
+        return {
+            "recoverable": True,
+            "recovery": {
+                "kind": "resume_retry",
+                "reason": "resume_bootstrap_failed",
+                "resume_session_id": resume_session_id,
+            },
+        }
+
     def _resolve_resume_session_id(
         self,
         current_handle: RuntimeHandle | None,
@@ -1432,11 +1445,25 @@ class CodexCliRuntime:
 
         composed_prompt = self._compose_prompt(prompt, system_prompt, tools)
         attempted_resume_session_id = self._resolve_resume_session_id(current_handle)
-        command = self._build_command(
-            output_last_message_path=str(output_path),
-            resume_session_id=attempted_resume_session_id,
-            prompt=composed_prompt,
-        )
+        try:
+            command = self._build_command(
+                output_last_message_path=str(output_path),
+                resume_session_id=attempted_resume_session_id,
+                prompt=composed_prompt,
+            )
+        except Exception as e:
+            yield AgentMessage(
+                type="result",
+                content=f"Failed to prepare {self._display_name}: {e}",
+                data={
+                    "subtype": "error",
+                    "error_type": type(e).__name__,
+                    **self._build_resume_retry_metadata(attempted_resume_session_id),
+                },
+                resume_handle=current_handle,
+            )
+            output_path.unlink(missing_ok=True)
+            return
 
         log.info(
             f"{self._log_namespace}.task_started",
@@ -1447,6 +1474,7 @@ class CodexCliRuntime:
 
         stderr_lines: list[str] = []
         last_content = ""
+        saw_runtime_event = False
         yielded_final = False  # Track if a final (type="result") message was already emitted
         process: Any | None = None
         process_finished = False
@@ -1467,7 +1495,11 @@ class CodexCliRuntime:
             yield AgentMessage(
                 type="result",
                 content=f"{self._display_name} not found: {e}",
-                data={"subtype": "error", "error_type": type(e).__name__},
+                data={
+                    "subtype": "error",
+                    "error_type": type(e).__name__,
+                    **self._build_resume_retry_metadata(attempted_resume_session_id),
+                },
                 resume_handle=current_handle,
             )
             output_path.unlink(missing_ok=True)
@@ -1476,7 +1508,11 @@ class CodexCliRuntime:
             yield AgentMessage(
                 type="result",
                 content=f"Failed to start {self._display_name}: {e}",
-                data={"subtype": "error", "error_type": type(e).__name__},
+                data={
+                    "subtype": "error",
+                    "error_type": type(e).__name__,
+                    **self._build_resume_retry_metadata(attempted_resume_session_id),
+                },
                 resume_handle=current_handle,
             )
             output_path.unlink(missing_ok=True)
@@ -1515,6 +1551,7 @@ class CodexCliRuntime:
                     event = self._parse_json_event(line)
                     if event is None:
                         continue
+                    saw_runtime_event = True
 
                     previous_handle = current_handle
                     session_rebound = False
@@ -1652,6 +1689,8 @@ class CodexCliRuntime:
                 data["session_id"] = current_handle.native_session_id
             if returncode != 0:
                 data["error_type"] = self._runtime_error_type
+                if attempted_resume_session_id and not saw_runtime_event:
+                    data.update(self._build_resume_retry_metadata(attempted_resume_session_id))
 
             yield AgentMessage(
                 type="result",

{ouroboros_ai-0.26.5.dev4 → ouroboros_ai-0.26.5.dev5}/src/ouroboros/orchestrator/runner.py

@@ -653,6 +653,29 @@ class OrchestratorRunner:
         }
         return event.model_copy(update={"data": event_data})
 
+    @staticmethod
+    def _is_recoverable_resume_failure(message: AgentMessage) -> bool:
+        """Return True when a final resume error should leave the session resumable."""
+        if not (message.is_final and message.is_error):
+            return False
+
+        data = message.data
+        metadata_candidates = (
+            data,
+            data.get("meta") if isinstance(data.get("meta"), dict) else None,
+            data.get("mcp_meta") if isinstance(data.get("mcp_meta"), dict) else None,
+        )
+        for metadata in metadata_candidates:
+            if not isinstance(metadata, dict):
+                continue
+            if metadata.get("recoverable") is True:
+                return True
+            if metadata.get("is_retriable") is True or metadata.get("retriable") is True:
+                return True
+
+        recovery = data.get("recovery")
+        return isinstance(recovery, dict) and recovery.get("kind") == "resume_retry"
+
     def _should_emit_progress_event(
         self,
         message: AgentMessage,
@@ -1852,6 +1875,7 @@ Note: This is a resumed session. Please continue from where execution was interr
             messages_processed = tracker.messages_processed
             final_message = ""
             success = False
+            recoverable_resume_failure = False
 
             # Create workflow state tracker for progress display
             from ouroboros.orchestrator.workflow_state import WorkflowStateTracker
@@ -1996,6 +2020,7 @@ Note: This is a resumed session. Please continue from where execution was interr
                     if message.is_final:
                         final_message = message.content
                         success = not message.is_error
+                        recoverable_resume_failure = self._is_recoverable_resume_failure(message)
 
             duration = (datetime.now(UTC) - start_time).total_seconds()
 
@@ -2014,6 +2039,21 @@ Note: This is a resumed session. Please continue from where execution was interr
                         border_style="green",
                     )
                 )
+            elif recoverable_resume_failure:
+                await self._session_repo.mark_paused(
+                    session_id,
+                    reason=final_message,
+                    resume_hint=(
+                        "Retry the same --resume session after fixing the runtime/tooling issue."
+                    ),
+                )
+                self._console.print(
+                    Panel(
+                        Text(final_message[:1000], style="yellow"),
+                        title="[yellow]Resumed Execution Paused[/yellow]",
+                        border_style="yellow",
+                    )
+                )
             else:
                 await self._session_repo.mark_failed(session_id, final_message)
                 self._console.print(

{ouroboros_ai-0.26.5.dev4 → ouroboros_ai-0.26.5.dev5}/src/ouroboros/orchestrator/session.py

@@ -604,6 +604,54 @@ class SessionRepository:
                 )
             )
 
+    async def mark_paused(
+        self,
+        session_id: str,
+        reason: str,
+        resume_hint: str | None = None,
+    ) -> Result[None, PersistenceError]:
+        """Mark session as paused and resumable.
+
+        Args:
+            session_id: Session being paused.
+            reason: Why the session was paused.
+            resume_hint: Optional retry guidance.
+
+        Returns:
+            Result indicating success or failure.
+        """
+        event = BaseEvent(
+            type="orchestrator.session.paused",
+            aggregate_type="session",
+            aggregate_id=session_id,
+            data={
+                "reason": reason,
+                "resume_hint": resume_hint,
+                "paused_at": datetime.now(UTC).isoformat(),
+            },
+        )
+
+        try:
+            await self._event_store.append(event)
+            log.info(
+                "orchestrator.session.paused",
+                session_id=session_id,
+                reason=reason,
+            )
+            return Result.ok(None)
+        except Exception as e:
+            log.exception(
+                "orchestrator.session.pause_failed",
+                session_id=session_id,
+                error=str(e),
+            )
+            return Result.err(
+                PersistenceError(
+                    message=f"Failed to mark session paused: {e}",
+                    details={"session_id": session_id},
+                )
+            )
+
     async def mark_cancelled(
         self,
         session_id: str,

{ouroboros_ai-0.26.5.dev4 → ouroboros_ai-0.26.5.dev5}/tests/unit/orchestrator/test_codex_cli_runtime.py

@@ -5,6 +5,7 @@ from __future__ import annotations
 import asyncio
 import json
 from pathlib import Path
+from typing import Any
 from unittest.mock import AsyncMock, patch
 
 import pytest
@@ -168,7 +169,14 @@ class TestCodexCliRuntime:
             resume_session_id="thread-123",
         )
 
-        assert command[:4] == ["codex", "exec", "resume", "thread-123"]
+        assert command[:2] == ["codex", "exec"]
+        assert command[-2:] == ["resume", "thread-123"]
+        resume_index = command.index("resume")
+        assert command.index("--json") < resume_index
+        assert command.index("--skip-git-repo-check") < resume_index
+        assert command.index("--output-last-message") < resume_index
+        assert command.index("-C") < resume_index
+        assert command[command.index("-C") + 1] == "/tmp/project"
 
     def test_build_command_uses_read_only_for_default_permission_mode(self) -> None:
         """Default permission mode keeps the runtime in read-only mode."""
@@ -191,6 +199,38 @@ class TestCodexCliRuntime:
 
         assert "--dangerously-bypass-approvals-and-sandbox" in command
 
+    @pytest.mark.asyncio
+    async def test_execute_task_marks_resume_bootstrap_failures_recoverable(self) -> None:
+        """Resume failures before any Codex event should stay retryable."""
+        runtime = CodexCliRuntime(cli_path="codex", cwd="/tmp/project")
+
+        async def fake_create_subprocess_exec(*command: str, **kwargs: Any) -> _FakeProcess:
+            del command, kwargs
+            return _FakeProcess(
+                stdout_lines=[],
+                stderr_lines=["error: unexpected argument '-C' found"],
+                returncode=2,
+            )
+
+        with patch(
+            "ouroboros.orchestrator.codex_cli_runtime.asyncio.create_subprocess_exec",
+            side_effect=fake_create_subprocess_exec,
+        ):
+            messages = [
+                message
+                async for message in runtime.execute_task(
+                    "resume the task",
+                    resume_session_id="thread-123",
+                )
+            ]
+
+        assert len(messages) == 1
+        assert messages[0].is_error
+        assert messages[0].data["error_type"] == "CodexCliError"
+        assert messages[0].data["recoverable"] is True
+        assert messages[0].data["recovery"]["kind"] == "resume_retry"
+        assert messages[0].data["recovery"]["resume_session_id"] == "thread-123"
+
     def test_convert_thread_started_event(self) -> None:
         """Converts thread.started to a system message with a resume handle."""
         runtime = CodexCliRuntime(cli_path="codex")

{ouroboros_ai-0.26.5.dev4 → ouroboros_ai-0.26.5.dev5}/tests/unit/orchestrator/test_runner.py

@@ -991,6 +991,101 @@ class TestOrchestratorRunner:
 
         assert result.is_err
 
+    @pytest.mark.asyncio
+    async def test_resume_session_recoverable_failure_marks_session_paused(
+        self,
+        runner: OrchestratorRunner,
+        mock_adapter: MagicMock,
+        sample_seed: Seed,
+    ) -> None:
+        """Recoverable resume bootstrap failures should not poison the session."""
+        running_tracker = SessionTracker.create("exec_resume", "seed_resume").with_status(
+            SessionStatus.RUNNING
+        )
+        runtime_handle = RuntimeHandle(backend="codex_cli", native_session_id="thread-123")
+
+        async def mock_execute(*args: Any, **kwargs: Any) -> AsyncIterator[AgentMessage]:
+            del args, kwargs
+            yield AgentMessage(
+                type="result",
+                content="Codex rejected the resume command",
+                data={
+                    "subtype": "error",
+                    "recoverable": True,
+                    "recovery": {"kind": "resume_retry"},
+                },
+                resume_handle=runtime_handle,
+            )
+
+        mock_adapter.execute_task = mock_execute
+
+        with (
+            patch.object(
+                runner._session_repo,
+                "reconstruct_session",
+                AsyncMock(return_value=Result.ok(running_tracker)),
+            ),
+            patch.object(
+                runner._session_repo,
+                "mark_paused",
+                AsyncMock(return_value=Result.ok(None)),
+            ) as mark_paused,
+            patch.object(
+                runner._session_repo,
+                "mark_failed",
+                AsyncMock(return_value=Result.ok(None)),
+            ) as mark_failed,
+        ):
+            result = await runner.resume_session("sess_resume", sample_seed)
+
+        assert result.is_ok
+        assert result.value.success is False
+        assert result.value.final_message == "Codex rejected the resume command"
+        mark_paused.assert_awaited_once()
+        mark_failed.assert_not_called()
+
+    @pytest.mark.asyncio
+    async def test_resume_session_allows_paused_sessions(
+        self,
+        runner: OrchestratorRunner,
+        mock_adapter: MagicMock,
+        sample_seed: Seed,
+    ) -> None:
+        """Paused sessions should remain resumable."""
+        paused_tracker = SessionTracker.create("exec_resume", "seed_resume").with_status(
+            SessionStatus.PAUSED
+        )
+        runtime_handle = RuntimeHandle(backend="codex_cli", native_session_id="thread-123")
+
+        async def mock_execute(*args: Any, **kwargs: Any) -> AsyncIterator[AgentMessage]:
+            del args, kwargs
+            yield AgentMessage(
+                type="result",
+                content="Resumed successfully",
+                data={"subtype": "success"},
+                resume_handle=runtime_handle,
+            )
+
+        mock_adapter.execute_task = mock_execute
+
+        with (
+            patch.object(
+                runner._session_repo,
+                "reconstruct_session",
+                AsyncMock(return_value=Result.ok(paused_tracker)),
+            ),
+            patch.object(
+                runner._session_repo,
+                "mark_completed",
+                AsyncMock(return_value=Result.ok(None)),
+            ) as mark_completed,
+        ):
+            result = await runner.resume_session("sess_resume", sample_seed)
+
+        assert result.is_ok
+        assert result.value.success is True
+        mark_completed.assert_awaited_once()
+
     def test_deserialize_runtime_handle_supports_legacy_progress(
         self,
         runner: OrchestratorRunner,

{ouroboros_ai-0.26.5.dev4 → ouroboros_ai-0.26.5.dev5}/tests/unit/orchestrator/test_session.py

@@ -354,6 +354,25 @@ class TestSessionRepository:
         assert event.type == "orchestrator.session.failed"
         assert event.data["error"] == "Connection lost"
 
+    @pytest.mark.asyncio
+    async def test_mark_paused(
+        self,
+        repository: SessionRepository,
+        mock_event_store: AsyncMock,
+    ) -> None:
+        """Test marking session as paused."""
+        result = await repository.mark_paused(
+            session_id="sess_123",
+            reason="Codex resume failed before reconnect",
+            resume_hint="Retry with --resume after fixing the CLI issue.",
+        )
+
+        assert result.is_ok
+        event = mock_event_store.append.call_args[0][0]
+        assert event.type == "orchestrator.session.paused"
+        assert event.data["reason"] == "Codex resume failed before reconnect"
+        assert event.data["resume_hint"] == "Retry with --resume after fixing the CLI issue."
+
     @pytest.mark.asyncio
     async def test_mark_cancelled(
         self,