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

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

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

{ouroboros_ai-0.26.5.dev4 → ouroboros_ai-0.26.5.dev6}/src/ouroboros/cli/commands/pm.py

@@ -24,9 +24,14 @@ from ouroboros.bigbang.pm_completion import (
 from ouroboros.cli.formatters import console
 from ouroboros.cli.formatters.panels import print_error, print_info, print_success, print_warning
 from ouroboros.cli.formatters.prompting import multiline_prompt_async
-from ouroboros.config import get_clarification_model
+from ouroboros.config import get_clarification_model, get_llm_backend
 from ouroboros.core.types import Result
 from ouroboros.observability import LoggingConfig, configure_logging
+from ouroboros.providers.factory import (
+    create_llm_adapter,
+    resolve_llm_backend,
+    resolve_llm_permission_mode,
+)
 
 app = typer.Typer(
     name="pm",
@@ -58,6 +63,18 @@ def _create_pm_litellm_adapter() -> Any:
     return LiteLLMAdapter()
 
 
+def _raise_missing_litellm_dependency(exc: ModuleNotFoundError) -> None:
+    """Convert a missing optional LiteLLM import into install guidance."""
+    if exc.name == "litellm" or "litellm" in str(exc):
+        msg = (
+            "PM interviews require the optional LiteLLM dependency. "
+            "Reinstall with `ouroboros-ai[litellm]`, or if you use uv tool: "
+            "`uv tool install --force --with litellm ouroboros-ai`."
+        )
+        raise RuntimeError(msg) from exc
+    raise exc
+
+
 @app.callback(invoke_without_command=True)
 def pm_command(
     ctx: typer.Context,
@@ -111,9 +128,6 @@ def pm_command(
     if ctx.invoked_subcommand is not None:
         return
 
-    if model is None:
-        model = get_clarification_model()
-
     if debug:
         configure_logging(LoggingConfig(log_level="DEBUG"))
         print_info("Debug mode enabled - showing verbose logs")
@@ -125,17 +139,36 @@ def pm_command(
     else:
         print_info("Starting new PM interview session...")
 
-    console.print(f"  Model: [dim]{model}[/]\n")
-
     try:
+        resolved_backend = resolve_llm_backend(get_llm_backend())
+        resolved_model = model or get_clarification_model(resolved_backend)
+        permission_mode = resolve_llm_permission_mode(
+            backend=resolved_backend,
+            use_case="interview",
+        )
+
+        console.print(f"  Model: [dim]{resolved_model}[/]\n")
+        if permission_mode == "bypassPermissions":
+            print_warning(
+                "Interview backend "
+                f"'{resolved_backend}' uses bypassPermissions for question generation."
+            )
+
         asyncio.run(
             _run_pm_interview(
                 resume_id=resume,
-                model=model,
+                model=resolved_model,
+                backend=resolved_backend,
                 debug=debug,
                 output_dir=output,
             )
         )
+    except ValueError as exc:
+        print_error(str(exc))
+        raise typer.Exit(code=1) from exc
+    except RuntimeError as exc:
+        print_error(str(exc))
+        raise typer.Exit(code=1) from exc
     except KeyboardInterrupt:
         print_info("\nPM interview interrupted. Progress has been saved.")
         raise typer.Exit(code=0)
@@ -334,10 +367,28 @@ def _save_cli_pm_meta(session_id: str, engine: Any) -> None:
     meta_path.write_text(json.dumps(meta, ensure_ascii=False, indent=2), encoding="utf-8")
 
 
+def _make_message_callback(debug: bool):
+    """Create a debug callback for streaming local agent status."""
+    if not debug:
+        return None
+
+    def callback(msg_type: str, content: str) -> None:
+        if msg_type == "thinking":
+            first_line = content.split("\n")[0].strip()
+            display = first_line[:100] + "..." if len(first_line) > 100 else first_line
+            if display:
+                console.print(f"  [dim]thinking:[/] {display}")
+        elif msg_type == "tool":
+            console.print(f"  [yellow]tool:[/] {content}")
+
+    return callback
+
+
 async def _run_pm_interview(
     resume_id: str | None,
     model: str,
-    debug: bool,  # noqa: ARG001
+    backend: str | None,
+    debug: bool,
     output_dir: str | None = None,
 ) -> None:
     """Run the PM interview loop.
@@ -348,16 +399,25 @@ async def _run_pm_interview(
     Args:
         resume_id: Optional session ID to resume.
         model: LLM model identifier.
+        backend: Resolved LLM backend name.
         debug: Enable debug output.
         output_dir: Optional output directory for the generated PM document.
     """
     from ouroboros.bigbang.pm_interview import PMInterviewEngine
 
     try:
-        adapter = _create_pm_litellm_adapter()
-    except RuntimeError as exc:
-        print_error(str(exc))
-        raise typer.Exit(code=1) from exc
+        adapter = create_llm_adapter(
+            backend=backend,
+            use_case="interview",
+            allowed_tools=None,
+            max_turns=5,
+            on_message=_make_message_callback(debug),
+            cwd=Path.cwd(),
+        )
+    except ModuleNotFoundError as exc:
+        if backend == "litellm":
+            _raise_missing_litellm_dependency(exc)
+        raise
     engine = PMInterviewEngine.create(llm_adapter=adapter, model=model)
 
     # Check for existing PM seeds before starting a new session

{ouroboros_ai-0.26.5.dev4 → ouroboros_ai-0.26.5.dev6}/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.dev6}/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.dev6}/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.dev6}/tests/unit/cli/test_pm.py

@@ -2,6 +2,7 @@
 
 from unittest.mock import patch
 
+import pytest
 from typer.testing import CliRunner
 
 from ouroboros.cli.main import app
@@ -9,16 +10,35 @@ from ouroboros.cli.main import app
 runner = CliRunner()
 
 
-@patch("ouroboros.cli.commands.pm._run_pm_interview")
-@patch("ouroboros.cli.commands.pm.get_clarification_model", return_value="default")
+@pytest.mark.parametrize(
+    ("configured_backend", "resolved_backend"),
+    [
+        ("codex", "codex"),
+        ("claude_code", "claude_code"),
+        ("litellm", "litellm"),
+    ],
+)
 def test_pm_uses_configured_clarification_model_when_option_omitted(
-    mock_get_clarification_model, mock_run_pm_interview
+    configured_backend: str,
+    resolved_backend: str,
 ) -> None:
     """The bare `pm` command should resolve its model from config."""
-    result = runner.invoke(app, ["pm"], input="n\n")
+    with (
+        patch("ouroboros.cli.commands.pm.get_llm_backend", return_value=configured_backend),
+        patch(
+            "ouroboros.cli.commands.pm.resolve_llm_backend",
+            return_value=resolved_backend,
+        ),
+        patch(
+            "ouroboros.cli.commands.pm.get_clarification_model",
+            return_value="default",
+        ) as mock_get_clarification_model,
+        patch("ouroboros.cli.commands.pm._run_pm_interview") as mock_run_pm_interview,
+    ):
+        result = runner.invoke(app, ["pm"], input="n\n")
 
     assert result.exit_code == 0
-    mock_get_clarification_model.assert_called_once_with()
+    mock_get_clarification_model.assert_called_once_with(resolved_backend)
     mock_run_pm_interview.assert_called_once()
     assert mock_run_pm_interview.call_args.kwargs["model"] == "default"
     assert "Model:" in result.output

{ouroboros_ai-0.26.5.dev4 → ouroboros_ai-0.26.5.dev6}/tests/unit/cli/test_pm_interactive_logging.py

@@ -100,7 +100,7 @@ async def test_run_pm_interview_new_session_uses_multiline_prompt_and_shows_prog
 
     with (
         patch.object(Path, "home", return_value=tmp_path),
-        patch("ouroboros.providers.litellm_adapter.LiteLLMAdapter", return_value=object()),
+        patch("ouroboros.cli.commands.pm.create_llm_adapter", return_value=object()),
         patch("ouroboros.bigbang.pm_interview.PMInterviewEngine.create", return_value=engine),
         patch("ouroboros.cli.commands.pm._check_existing_pm_seeds", return_value=True),
         patch("ouroboros.cli.commands.pm._load_brownfield_from_db", return_value=[]),
@@ -113,7 +113,7 @@ async def test_run_pm_interview_new_session_uses_multiline_prompt_and_shows_prog
         patch("ouroboros.cli.commands.pm.print_info") as mock_print_info,
         patch("ouroboros.cli.commands.pm.print_success"),
     ):
-        await _run_pm_interview(resume_id=None, model="test-model", debug=False)
+        await _run_pm_interview(resume_id=None, model="test-model", backend="codex", debug=False)
 
     engine.ask_opening_and_start.assert_awaited_once()
     engine.ask_next_question.assert_awaited_once_with(initial_state)
@@ -153,7 +153,7 @@ async def test_run_pm_interview_resume_with_pending_question_skips_generation_me
 
     with (
         patch.object(Path, "home", return_value=tmp_path),
-        patch("ouroboros.providers.litellm_adapter.LiteLLMAdapter", return_value=object()),
+        patch("ouroboros.cli.commands.pm.create_llm_adapter", return_value=object()),
         patch("ouroboros.bigbang.pm_interview.PMInterviewEngine.create", return_value=engine),
         patch("ouroboros.cli.commands.pm._save_cli_pm_meta"),
         patch(
@@ -163,7 +163,12 @@ async def test_run_pm_interview_resume_with_pending_question_skips_generation_me
         patch("ouroboros.cli.commands.pm.print_success"),
         patch("ouroboros.cli.commands.pm.console.print"),
     ):
-        await _run_pm_interview(resume_id="resume_123", model="test-model", debug=False)
+        await _run_pm_interview(
+            resume_id="resume_123",
+            model="test-model",
+            backend="codex",
+            debug=False,
+        )
 
     engine.ask_next_question.assert_not_awaited()
     engine._install_pm_steering.assert_called_once()
@@ -199,7 +204,7 @@ async def test_run_pm_interview_preserves_pending_question_across_interrupt_and_
 
     with (
         patch.object(Path, "home", return_value=tmp_path),
-        patch("ouroboros.providers.litellm_adapter.LiteLLMAdapter", return_value=object()),
+        patch("ouroboros.cli.commands.pm.create_llm_adapter", return_value=object()),
         patch("ouroboros.bigbang.pm_interview.PMInterviewEngine.create", return_value=engine),
         patch("ouroboros.cli.commands.pm._check_existing_pm_seeds", return_value=True),
         patch("ouroboros.cli.commands.pm._load_brownfield_from_db", return_value=[]),
@@ -213,13 +218,23 @@ async def test_run_pm_interview_preserves_pending_question_across_interrupt_and_
         patch("ouroboros.cli.commands.pm.console.print"),
     ):
         with pytest.raises(KeyboardInterrupt):
-            await _run_pm_interview(resume_id=None, model="test-model", debug=False)
+            await _run_pm_interview(
+                resume_id=None,
+                model="test-model",
+                backend="codex",
+                debug=False,
+            )
 
         saved_question_state = engine.save_state.await_args_list[0].args[0]
         assert saved_question_state.rounds[-1].question == "What is the first workflow?"
         assert saved_question_state.rounds[-1].user_response is None
 
-        await _run_pm_interview(resume_id="resume_123", model="test-model", debug=False)
+        await _run_pm_interview(
+            resume_id="resume_123",
+            model="test-model",
+            backend="codex",
+            debug=False,
+        )
 
     engine.ask_next_question.assert_awaited_once_with(interrupted_state)
     engine.load_state.assert_awaited_once_with("resume_123")