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

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

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

ouroboros_ai-0.26.5.dev5/src/ouroboros/bigbang/pm_completion.py

@@ -0,0 +1,61 @@
+"""Shared PM interview completion helpers."""
+
+from __future__ import annotations
+
+from typing import Any
+
+from ouroboros.bigbang.interview import InterviewState
+from ouroboros.bigbang.pm_interview import PMInterviewEngine
+from ouroboros.core.errors import ValidationError
+from ouroboros.core.types import Result
+
+
+async def maybe_complete_pm_interview(
+    state: InterviewState,
+    engine: PMInterviewEngine,
+) -> Result[tuple[InterviewState, dict[str, Any] | None], ValidationError]:
+    """Run PM ambiguity completion logic and mark the interview complete if ready."""
+    completion = await engine.check_completion(state)
+    if completion is None:
+        return Result.ok((state, None))
+
+    complete_result = await engine.complete_interview(state)
+    if complete_result.is_err:
+        return Result.err(complete_result.error)
+
+    return Result.ok((complete_result.value, completion))
+
+
+def build_pm_completion_summary(
+    *,
+    session_id: str,
+    completion: dict[str, Any] | None,
+    stored_ambiguity_score: float | None = None,
+    deferred_count: int,
+    decide_later_count: int,
+    decide_later_summary: str,
+) -> str:
+    """Build human-readable PM completion text for CLI and MCP flows."""
+    lines = [f"Interview complete. Session ID: {session_id}"]
+
+    if completion is not None:
+        lines.append(f"Rounds completed: {completion['rounds_completed']}")
+        lines.append(f"Completion reason: {completion['completion_reason']}")
+
+    ambiguity_score = (
+        completion.get("ambiguity_score") if completion is not None else stored_ambiguity_score
+    )
+    if ambiguity_score is not None:
+        lines.append(f"Ambiguity score: {ambiguity_score:.2f}")
+
+    lines.append("")
+    lines.append(f"Deferred items: {deferred_count}")
+    lines.append(f"Decide-later items: {decide_later_count}")
+
+    if decide_later_summary:
+        lines.append("")
+        lines.append(decide_later_summary)
+
+    lines.append("")
+    lines.append(f'Generate PM with: action="generate", session_id="{session_id}"')
+    return "\n".join(lines)

{ouroboros_ai-0.26.5.dev3 → ouroboros_ai-0.26.5.dev5}/src/ouroboros/cli/commands/pm.py

@@ -17,6 +17,10 @@ from rich.prompt import Confirm, Prompt
 import typer
 
 from ouroboros.bigbang.interview import InterviewRound
+from ouroboros.bigbang.pm_completion import (
+    build_pm_completion_summary,
+    maybe_complete_pm_interview,
+)
 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
@@ -479,15 +483,30 @@ async def _run_pm_interview(
             # so extraction never sees a question the user didn't answer.
             if state.rounds and state.rounds[-1].user_response is None:
                 state.rounds.pop()
+
+            completion = await engine.check_completion(state)
             complete_result = await engine.complete_interview(state)
-            if isinstance(complete_result, Result) and complete_result.is_err:
+            if complete_result.is_err:
                 print_error(f"Failed to complete interview: {complete_result.error}")
-            elif isinstance(complete_result, Result):
-                state = complete_result.value
+                break
+
+            state = complete_result.value
             save_result = await engine.save_state(state)
-            if isinstance(save_result, Result) and save_result.is_err:
+            if save_result.is_err:
                 print_error(f"Failed to save completed state: {save_result.error}")
+                break
             _save_cli_pm_meta(state.interview_id, engine)
+
+            decide_later_summary = engine.format_decide_later_summary()
+            summary_text = build_pm_completion_summary(
+                session_id=state.interview_id,
+                completion=completion,
+                stored_ambiguity_score=state.ambiguity_score,
+                deferred_count=len(engine.deferred_items),
+                decide_later_count=len(engine.decide_later_items),
+                decide_later_summary=decide_later_summary,
+            )
+            console.print(f"\n[bold green]{summary_text}[/]\n")
             break
 
         # Pop the unanswered round before recording so record_response
@@ -534,6 +553,33 @@ async def _run_pm_interview(
             break
         if isinstance(record_result, Result):
             state = record_result.value
+
+        state.clear_stored_ambiguity()
+        completion_result = await maybe_complete_pm_interview(state, engine)
+        if completion_result.is_err:
+            print_error(f"Failed to complete interview: {completion_result.error}")
+            break
+
+        state, completion = completion_result.value
+        if completion is not None:
+            save_result = await engine.save_state(state)
+            if save_result.is_err:
+                print_error(f"Failed to save completed state: {save_result.error}")
+                break
+            _save_cli_pm_meta(state.interview_id, engine)
+
+            decide_later_summary = engine.format_decide_later_summary()
+            summary_text = build_pm_completion_summary(
+                session_id=state.interview_id,
+                completion=completion,
+                stored_ambiguity_score=state.ambiguity_score,
+                deferred_count=len(engine.deferred_items),
+                decide_later_count=len(engine.decide_later_items),
+                decide_later_summary=decide_later_summary,
+            )
+            console.print(f"\n[bold green]{summary_text}[/]\n")
+            break
+
         save_result = await engine.save_state(state)
         if isinstance(save_result, Result) and save_result.is_err:
             print_error(f"Failed to save state: {save_result.error}")

{ouroboros_ai-0.26.5.dev3 → ouroboros_ai-0.26.5.dev5}/src/ouroboros/mcp/tools/pm_handler.py

@@ -30,6 +30,10 @@ from ouroboros.bigbang.interview import (
     InterviewRound,
     InterviewState,
 )
+from ouroboros.bigbang.pm_completion import (
+    build_pm_completion_summary,
+    maybe_complete_pm_interview,
+)
 from ouroboros.bigbang.pm_document import save_pm_document
 from ouroboros.bigbang.pm_interview import PMInterviewEngine
 from ouroboros.config import get_clarification_model
@@ -944,10 +948,17 @@ class PMInterviewHandler:
         # Completion is determined by engine ambiguity scoring.
         # When complete, auto-generate the PM document immediately
         # (no separate "generate" call needed from the skill).
-        completion = await _check_completion(state, engine)
+        completion_result = await maybe_complete_pm_interview(state, engine)
+        if completion_result.is_err:
+            return Result.err(
+                MCPToolError(
+                    f"Failed to complete interview: {completion_result.error}",
+                    tool_name="ouroboros_pm_interview",
+                )
+            )
+
+        state, completion = completion_result.value
         if completion is not None:
-            # Mark interview as complete
-            await engine.complete_interview(state)
             save_result = await engine.save_state(state)
             if isinstance(save_result, Result) and save_result.is_err:
                 return Result.err(
@@ -1012,22 +1023,15 @@ class PMInterviewHandler:
                 )
 
             decide_later_summary = engine.format_decide_later_summary()
-            summary_text = (
-                f"Interview complete. PM document generated.\n\n"
-                f"Session ID: {session_id}\n"
-                f"Rounds completed: {completion['rounds_completed']}\n"
-                f"Completion reason: {completion['completion_reason']}\n"
-            )
-            if completion.get("ambiguity_score") is not None:
-                summary_text += f"Ambiguity score: {completion['ambiguity_score']:.2f}\n"
-            summary_text += (
-                f"\nPM document: {pm_path}\n"
-                f"Seed: {seed_path}\n"
-                f"\nDeferred items: {len(seed.deferred_items)}\n"
-                f"Decide-later items: {len(seed.decide_later_items)}\n"
+            summary_text = build_pm_completion_summary(
+                session_id=session_id,
+                completion=completion,
+                stored_ambiguity_score=getattr(state, "ambiguity_score", None),
+                deferred_count=len(engine.deferred_items),
+                decide_later_count=len(engine.decide_later_items),
+                decide_later_summary=decide_later_summary,
             )
-            if decide_later_summary:
-                summary_text += f"\n{decide_later_summary}\n"
+            summary_text += f"\n\nPM document: {pm_path}\nSeed: {seed_path}"
 
             response_meta = {
                 "session_id": session_id,

{ouroboros_ai-0.26.5.dev3 → 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.dev3 → 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.dev3 → 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.dev5/tests/unit/bigbang/test_pm_completion.py

@@ -0,0 +1,76 @@
+"""Tests for shared PM completion helpers."""
+
+from __future__ import annotations
+
+from types import SimpleNamespace
+from unittest.mock import AsyncMock, MagicMock
+
+import pytest
+
+from ouroboros.bigbang.pm_completion import (
+    build_pm_completion_summary,
+    maybe_complete_pm_interview,
+)
+from ouroboros.core.types import Result
+
+
+@pytest.mark.asyncio
+async def test_maybe_complete_pm_interview_returns_none_when_not_ready() -> None:
+    """No completion metadata means the interview should continue."""
+    state = SimpleNamespace(interview_id="sess-1")
+    engine = MagicMock()
+    engine.check_completion = AsyncMock(return_value=None)
+    engine.complete_interview = AsyncMock()
+
+    result = await maybe_complete_pm_interview(state, engine)
+
+    assert result.is_ok
+    assert result.value == (state, None)
+    engine.complete_interview.assert_not_awaited()
+
+
+@pytest.mark.asyncio
+async def test_maybe_complete_pm_interview_marks_complete_when_ready() -> None:
+    """Ready interviews should be marked complete through the shared helper."""
+    state = SimpleNamespace(interview_id="sess-1")
+    completed_state = SimpleNamespace(interview_id="sess-1", status="completed")
+    engine = MagicMock()
+    engine.check_completion = AsyncMock(
+        return_value={
+            "interview_complete": True,
+            "completion_reason": "ambiguity_resolved",
+            "rounds_completed": 5,
+            "ambiguity_score": 0.18,
+        }
+    )
+    engine.complete_interview = AsyncMock(return_value=Result.ok(completed_state))
+
+    result = await maybe_complete_pm_interview(state, engine)
+
+    assert result.is_ok
+    assert result.value == (
+        completed_state,
+        {
+            "interview_complete": True,
+            "completion_reason": "ambiguity_resolved",
+            "rounds_completed": 5,
+            "ambiguity_score": 0.18,
+        },
+    )
+    engine.complete_interview.assert_awaited_once_with(state)
+
+
+def test_build_pm_completion_summary_uses_stored_score_fallback() -> None:
+    """Forced completion should still surface the stored ambiguity score."""
+    summary = build_pm_completion_summary(
+        session_id="sess-1",
+        completion=None,
+        stored_ambiguity_score=0.34,
+        deferred_count=1,
+        decide_later_count=2,
+        decide_later_summary="Items to decide later:\n  1. Example",
+    )
+
+    assert "Interview complete. Session ID: sess-1" in summary
+    assert "Ambiguity score: 0.34" in summary
+    assert 'Generate PM with: action="generate", session_id="sess-1"' in summary

ouroboros_ai-0.26.5.dev5/tests/unit/cli/test_pm_completion.py

@@ -0,0 +1,117 @@
+"""Regression tests for PM CLI completion and ambiguity persistence."""
+
+from __future__ import annotations
+
+from pathlib import Path
+from types import SimpleNamespace
+from unittest.mock import AsyncMock, MagicMock, patch
+
+import pytest
+
+from ouroboros.bigbang.interview import InterviewRound
+from ouroboros.cli.commands.pm import _run_pm_interview
+from ouroboros.core.types import Result
+
+
+def _resume_state(*, pending_question: str = "Current question?") -> SimpleNamespace:
+    """Create a minimal resumable PM interview state."""
+    return SimpleNamespace(
+        interview_id="sess-123",
+        rounds=[InterviewRound(round_number=1, question=pending_question, user_response=None)],
+        is_complete=False,
+        ambiguity_score=None,
+        clear_stored_ambiguity=MagicMock(),
+        mark_updated=MagicMock(),
+    )
+
+
+@pytest.mark.asyncio
+async def test_run_pm_interview_auto_completes_after_answer(tmp_path: Path) -> None:
+    """A normal answer should auto-complete when ambiguity is resolved."""
+    state = _resume_state()
+    updated_state = SimpleNamespace(**{**state.__dict__})
+    completed_state = SimpleNamespace(**{**updated_state.__dict__, "is_complete": True})
+    engine = MagicMock()
+    engine.load_state = AsyncMock(return_value=Result.ok(state))
+    engine.record_response = AsyncMock(return_value=Result.ok(updated_state))
+    engine.save_state = AsyncMock(return_value=Result.ok(tmp_path / "state.json"))
+    engine.format_decide_later_summary.return_value = ""
+    engine._install_pm_steering = MagicMock()
+
+    completion = {
+        "interview_complete": True,
+        "completion_reason": "ambiguity_resolved",
+        "rounds_completed": 1,
+        "ambiguity_score": 0.18,
+    }
+
+    with (
+        patch("ouroboros.providers.litellm_adapter.LiteLLMAdapter", return_value=object()),
+        patch("ouroboros.bigbang.pm_interview.PMInterviewEngine.create", return_value=engine),
+        patch(
+            "ouroboros.cli.commands.pm.multiline_prompt_async",
+            new_callable=AsyncMock,
+            return_value="Final answer",
+        ),
+        patch("ouroboros.cli.commands.pm._save_cli_pm_meta"),
+        patch(
+            "ouroboros.cli.commands.pm.maybe_complete_pm_interview",
+            new_callable=AsyncMock,
+            return_value=Result.ok((completed_state, completion)),
+        ) as mock_complete,
+        patch("ouroboros.cli.commands.pm.console.print") as mock_print,
+        patch("ouroboros.cli.commands.pm.print_success"),
+    ):
+        await _run_pm_interview(resume_id="sess-123", model="test-model", debug=False)
+
+    updated_state.clear_stored_ambiguity.assert_called_once()
+    mock_complete.assert_awaited_once_with(updated_state, engine)
+    assert engine.save_state.await_count == 2
+    assert engine.save_state.await_args_list[-1].args == (completed_state,)
+
+    printed = "\n".join(str(call.args[0]) for call in mock_print.call_args_list if call.args)
+    assert "Interview complete. Session ID: sess-123" in printed
+    assert "Ambiguity score: 0.18" in printed
+
+
+@pytest.mark.asyncio
+async def test_run_pm_interview_done_path_persists_stored_ambiguity(tmp_path: Path) -> None:
+    """Forced completion via done should still store and display ambiguity."""
+    state = _resume_state()
+    completed_state = SimpleNamespace(
+        **{**state.__dict__, "is_complete": True, "ambiguity_score": 0.34}
+    )
+    engine = MagicMock()
+    engine.load_state = AsyncMock(return_value=Result.ok(state))
+    engine.complete_interview = AsyncMock(return_value=Result.ok(completed_state))
+    engine.save_state = AsyncMock(return_value=Result.ok(tmp_path / "state.json"))
+    engine.format_decide_later_summary.return_value = ""
+    engine._install_pm_steering = MagicMock()
+
+    async def fake_check_completion(current_state: SimpleNamespace) -> None:
+        current_state.ambiguity_score = 0.34
+        return None
+
+    engine.check_completion = AsyncMock(side_effect=fake_check_completion)
+
+    with (
+        patch("ouroboros.providers.litellm_adapter.LiteLLMAdapter", return_value=object()),
+        patch("ouroboros.bigbang.pm_interview.PMInterviewEngine.create", return_value=engine),
+        patch(
+            "ouroboros.cli.commands.pm.multiline_prompt_async",
+            new_callable=AsyncMock,
+            return_value="done",
+        ),
+        patch("ouroboros.cli.commands.pm._save_cli_pm_meta"),
+        patch("ouroboros.cli.commands.pm.console.print") as mock_print,
+        patch("ouroboros.cli.commands.pm.print_success"),
+    ):
+        await _run_pm_interview(resume_id="sess-123", model="test-model", debug=False)
+
+    engine.complete_interview.assert_awaited_once_with(state)
+    assert engine.save_state.await_count == 2
+    assert engine.save_state.await_args_list[-1].args == (completed_state,)
+
+    printed = "\n".join(str(call.args[0]) for call in mock_print.call_args_list if call.args)
+    assert "Interview complete. Session ID: sess-123" in printed
+    assert "Ambiguity score: 0.34" in printed