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

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

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

ouroboros_ai-0.26.5.dev4/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.dev4}/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.dev4}/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.dev4/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.dev4/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

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

@@ -38,7 +38,9 @@ def _build_state(*, pending_question: str | None = None) -> SimpleNamespace:
         rounds=rounds,
         current_round_number=1,
         interview_id="interview_123",
+        ambiguity_score=None,
         mark_updated=MagicMock(),
+        clear_stored_ambiguity=MagicMock(),
     )
 
 
@@ -91,6 +93,9 @@ async def test_run_pm_interview_new_session_uses_multiline_prompt_and_shows_prog
     engine.save_state = AsyncMock(return_value=Result.ok(tmp_path / "state.json"))
     engine.record_response = AsyncMock(return_value=Result.ok(recorded_state))
     engine.complete_interview = AsyncMock()
+    engine.check_completion = AsyncMock(return_value=None)
+    engine.deferred_items = []
+    engine.decide_later_items = []
     engine.format_decide_later_summary.return_value = ""
 
     with (
@@ -140,6 +145,9 @@ async def test_run_pm_interview_resume_with_pending_question_skips_generation_me
     engine.ask_next_question = AsyncMock()
     engine.save_state = AsyncMock(return_value=Result.ok(tmp_path / "state.json"))
     engine.complete_interview = AsyncMock(return_value=Result.ok(completed_state))
+    engine.check_completion = AsyncMock(return_value=None)
+    engine.deferred_items = []
+    engine.decide_later_items = []
     engine.format_decide_later_summary.return_value = ""
     engine._install_pm_steering = MagicMock()
 
@@ -153,6 +161,7 @@ async def test_run_pm_interview_resume_with_pending_question_skips_generation_me
         ) as mock_prompt,
         patch("ouroboros.cli.commands.pm.print_info") as mock_print_info,
         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)
 
@@ -182,6 +191,9 @@ async def test_run_pm_interview_preserves_pending_question_across_interrupt_and_
     engine.complete_interview = AsyncMock(
         return_value=Result.ok(SimpleNamespace(**{**resumed_state.__dict__, "is_complete": True}))
     )
+    engine.check_completion = AsyncMock(return_value=None)
+    engine.deferred_items = []
+    engine.decide_later_items = []
     engine.format_decide_later_summary.return_value = ""
     engine._install_pm_steering = MagicMock()
 
@@ -198,6 +210,7 @@ async def test_run_pm_interview_preserves_pending_question_across_interrupt_and_
             side_effect=["Initial context", KeyboardInterrupt, "done"],
         ),
         patch("ouroboros.cli.commands.pm.print_success"),
+        patch("ouroboros.cli.commands.pm.console.print"),
     ):
         with pytest.raises(KeyboardInterrupt):
             await _run_pm_interview(resume_id=None, model="test-model", debug=False)

{ouroboros_ai-0.26.5.dev3 → ouroboros_ai-0.26.5.dev4}/tests/unit/mcp/tools/test_pm_handler.py

@@ -76,6 +76,7 @@ def _make_state(
     state.current_round_number = len(state.rounds) + 1
     state.is_complete = False
     state.is_brownfield = is_brownfield
+    state.ambiguity_score = None
     state.mark_updated = MagicMock()
     state.clear_stored_ambiguity = MagicMock()
     return state
@@ -899,7 +900,6 @@ class TestHandlerCompletionIntegration:
 
         handler = PMInterviewHandler(pm_engine=engine, data_dir=tmp_path)
 
-        # Mock _check_completion to return completion
         completion_meta = {
             "interview_complete": True,
             "completion_reason": "ambiguity_resolved",
@@ -909,10 +909,10 @@ class TestHandlerCompletionIntegration:
 
         with (
             patch(
-                "ouroboros.mcp.tools.pm_handler._check_completion",
+                "ouroboros.mcp.tools.pm_handler.maybe_complete_pm_interview",
                 new_callable=AsyncMock,
-                return_value=completion_meta,
-            ),
+                return_value=Result.ok((state, completion_meta)),
+            ) as mock_complete,
             patch(
                 "ouroboros.mcp.tools.pm_handler.save_pm_document",
                 return_value=tmp_path / "pm.md",
@@ -932,8 +932,8 @@ class TestHandlerCompletionIntegration:
         assert meta["ambiguity_score"] == 0.18
         assert meta["session_id"] == "sess-complete"
 
-        # Verify complete_interview was called
-        engine.complete_interview.assert_called_once()
+        # Verify the shared completion helper was used
+        mock_complete.assert_awaited_once_with(state, engine)
 
         # Verify response text includes completion and PM document info
         text = result.value.content[0].text
@@ -1746,15 +1746,12 @@ class TestResumeMetaFields:
         engine.record_response = AsyncMock(return_value=Result.ok(state))
         engine.complete_interview = AsyncMock(return_value=Result.ok(state))
         engine.save_state = AsyncMock(return_value=Result.ok(tmp_path / "state.json"))
-        # Mock ambiguity-based completion so the test doesn't need llm_adapter
-        engine.check_completion = AsyncMock(
-            return_value={
-                "interview_complete": True,
-                "completion_reason": "ambiguity_resolved",
-                "rounds_completed": 5,
-                "ambiguity_score": 0.15,
-            }
-        )
+        completion_meta = {
+            "interview_complete": True,
+            "completion_reason": "ambiguity_resolved",
+            "rounds_completed": 5,
+            "ambiguity_score": 0.15,
+        }
         # Mock auto-generate on completion
         seed_mock = MagicMock()
         seed_mock.product_name = "Test Product"
@@ -1767,9 +1764,16 @@ class TestResumeMetaFields:
 
         handler = PMInterviewHandler(pm_engine=engine, data_dir=tmp_path)
 
-        with patch(
-            "ouroboros.mcp.tools.pm_handler.save_pm_document",
-            return_value=tmp_path / "pm.md",
+        with (
+            patch(
+                "ouroboros.mcp.tools.pm_handler.maybe_complete_pm_interview",
+                new_callable=AsyncMock,
+                return_value=Result.ok((state, completion_meta)),
+            ),
+            patch(
+                "ouroboros.mcp.tools.pm_handler.save_pm_document",
+                return_value=tmp_path / "pm.md",
+            ),
         ):
             result = await handler.handle(
                 {