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

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: ouroboros-ai
-Version: 0.26.5.dev6
+Version: 0.26.5.dev7
 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.dev6 → ouroboros_ai-0.26.5.dev7}/skills/pm/SKILL.md

@@ -120,6 +120,10 @@ Show the following to the user:
 PM document saved: <meta.pm_path>
 (Clipboard에 복사되었습니다)
 
+PM seed handoff artifact: <meta.pm_seed_path or meta.seed_path>
+This is not the runnable Seed yet.
+
 Next step:
-  ooo interview <meta.pm_path>
+  ooo interview <meta.pm_seed_path or meta.seed_path>
+  ooo seed
 ```

{ouroboros_ai-0.26.5.dev6 → ouroboros_ai-0.26.5.dev7}/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.dev6'
-__version_tuple__ = version_tuple = (0, 26, 5, 'dev6')
+__version__ = version = '0.26.5.dev7'
+__version_tuple__ = version_tuple = (0, 26, 5, 'dev7')
 
 __commit_id__ = commit_id = None

{ouroboros_ai-0.26.5.dev6 → ouroboros_ai-0.26.5.dev7}/src/ouroboros/cli/commands/init.py

@@ -26,6 +26,12 @@ 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.core.initial_context import (
+    load_pm_seed_as_context as _load_pm_seed_as_context_result,
+)
+from ouroboros.core.initial_context import (
+    resolve_initial_context_input,
+)
 from ouroboros.observability import LoggingConfig, configure_logging
 from ouroboros.providers import create_llm_adapter
 from ouroboros.providers.base import LLMAdapter
@@ -619,13 +625,10 @@ def _load_pm_seed_as_context(seed_path: Path) -> str:
     Returns:
         YAML-formatted string for use as dev interview initial_context.
     """
-    from ouroboros.bigbang.pm_seed import PMSeed
-
-    with open(seed_path) as f:
-        data = yaml.safe_load(f)
-
-    pm_seed = PMSeed.from_dict(data)
-    return pm_seed.to_initial_context()
+    result = _load_pm_seed_as_context_result(seed_path)
+    if result.is_err:
+        raise ValueError(str(result.error))
+    return result.value
 
 
 @app.command()
@@ -752,6 +755,13 @@ def start(
 
             context = asyncio.run(multiline_prompt_async("What would you like to build?"))
 
+        if context:
+            resolved_context = resolve_initial_context_input(context, cwd=Path.cwd())
+            if resolved_context.is_err:
+                print_error(str(resolved_context.error))
+                raise typer.Exit(code=1)
+            context = resolved_context.value
+
     if not resume and not context:
         print_error("Initial context is required when not resuming.")
         raise typer.Exit(code=1)

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

@@ -27,6 +27,7 @@ from ouroboros.cli.formatters.prompting import multiline_prompt_async
 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.pm.handoff import build_pm_dev_handoff_command
 from ouroboros.providers.factory import (
     create_llm_adapter,
     resolve_llm_backend,
@@ -384,6 +385,32 @@ def _make_message_callback(debug: bool):
     return callback
 
 
+async def _continue_into_dev_interview(
+    seed_path: Path,
+    *,
+    debug: bool,
+    llm_backend: str | None,
+) -> None:
+    """Resolve a PM artifact path into interview context and start the dev interview."""
+    from ouroboros.cli.commands.init import _run_interview
+    from ouroboros.core.initial_context import resolve_initial_context_input
+
+    resolved_context = resolve_initial_context_input(str(seed_path), cwd=Path.cwd())
+    if resolved_context.is_err:
+        print_error(f"Failed to load PM seed for dev interview: {resolved_context.error.message}")
+        raise typer.Exit(code=1)
+
+    await _run_interview(
+        resolved_context.value,
+        resume_id=None,
+        state_dir=None,
+        use_orchestrator=False,
+        debug=debug,
+        workflow_runtime_backend=None,
+        llm_backend=llm_backend,
+    )
+
+
 async def _run_pm_interview(
     resume_id: str | None,
     model: str,
@@ -667,6 +694,22 @@ async def _run_pm_interview(
             pm_dir = Path(output_dir) if output_dir else Path.cwd() / ".ouroboros"
             pm_path = save_pm_document(seed, output_dir=pm_dir)
             print_success(f"PM document saved: {pm_path}")
+
+            print_info(
+                "The PM seed is a handoff artifact for the dev interview, not the runnable Seed."
+            )
+            print_info(f"Next: {build_pm_dev_handoff_command(seed_path)}")
+
+            continue_to_dev = Confirm.ask(
+                "Continue into the dev interview now?",
+                default=True,
+            )
+            if continue_to_dev:
+                await _continue_into_dev_interview(
+                    seed_path,
+                    debug=debug,
+                    llm_backend=backend,
+                )
         else:
             print_error(f"Failed to generate PM: {seed_result.error}")
     elif state.rounds and not state.is_complete:

ouroboros_ai-0.26.5.dev7/src/ouroboros/core/initial_context.py

@@ -0,0 +1,209 @@
+"""Helpers for resolving interview initial context from text or files."""
+
+from __future__ import annotations
+
+from pathlib import Path
+
+import yaml
+
+from ouroboros.bigbang.pm_seed import PMSeed
+from ouroboros.core.errors import ValidationError
+from ouroboros.core.security import InputValidator
+from ouroboros.core.types import Result
+
+_PM_SEED_SUFFIXES = {".json", ".yaml", ".yml"}
+_TEXT_CONTEXT_SUFFIXES = {".md", ".markdown", ".txt", ".rst"}
+_MAX_PATH_CANDIDATE_LENGTH = 240
+
+
+def _is_pm_seed_candidate(seed_path: Path, raw_data: object) -> bool:
+    """Return True when a file should be treated as a PM-seed artifact."""
+    if seed_path.stem.startswith("pm_seed_"):
+        return True
+    if isinstance(raw_data, dict):
+        pm_id = raw_data.get("pm_id")
+        if isinstance(pm_id, str) and pm_id.startswith("pm_seed_"):
+            return True
+    return False
+
+
+def _validate_pm_seed_mapping(
+    raw_data: dict[object, object], seed_path: Path
+) -> Result[None, ValidationError]:
+    """Validate the minimum PM-seed contract before conversion."""
+    pm_id = raw_data.get("pm_id")
+    product_name = raw_data.get("product_name")
+    goal = raw_data.get("goal")
+
+    has_pm_seed_filename = seed_path.stem.startswith("pm_seed_")
+    has_pm_seed_id = isinstance(pm_id, str) and pm_id.startswith("pm_seed_")
+
+    if (
+        not isinstance(pm_id, str)
+        or (not pm_id.strip())
+        or (not has_pm_seed_id and not has_pm_seed_filename)
+    ):
+        return Result.err(
+            ValidationError(
+                "PM seed file must include a non-empty pm_id and either a 'pm_seed_' filename or pm_id",
+                field="initial_context",
+                value=str(seed_path),
+            )
+        )
+
+    if not isinstance(product_name, str) or not product_name.strip():
+        return Result.err(
+            ValidationError(
+                "PM seed file must include a non-empty product_name",
+                field="initial_context",
+                value=str(seed_path),
+            )
+        )
+
+    if not isinstance(goal, str) or not goal.strip():
+        return Result.err(
+            ValidationError(
+                "PM seed file must include a non-empty goal",
+                field="initial_context",
+                value=str(seed_path),
+            )
+        )
+
+    return Result.ok(None)
+
+
+def _resolve_path_candidate(
+    context_candidate: str,
+    *,
+    cwd: str | Path | None = None,
+) -> Path | None:
+    """Return a plausible file-path candidate, or None for literal text."""
+    if "\n" in context_candidate or len(context_candidate) > _MAX_PATH_CANDIDATE_LENGTH:
+        return None
+
+    try:
+        candidate_path = Path(context_candidate).expanduser()
+    except (OSError, ValueError):
+        return None
+
+    if not candidate_path.is_absolute() and cwd is not None:
+        candidate_path = Path(cwd).expanduser() / candidate_path
+
+    try:
+        if candidate_path.exists() and candidate_path.is_file():
+            return candidate_path
+    except OSError:
+        return None
+
+    return None
+
+
+def load_pm_seed_as_context(seed_path: Path) -> Result[str, ValidationError]:
+    """Load a PMSeed artifact and convert it into dev-interview context."""
+    try:
+        raw_data = yaml.safe_load(seed_path.read_text(encoding="utf-8"))
+    except (OSError, yaml.YAMLError) as exc:
+        return Result.err(
+            ValidationError(
+                f"Failed to load PM seed: {exc}",
+                field="initial_context",
+                value=str(seed_path),
+            )
+        )
+
+    if not isinstance(raw_data, dict):
+        return Result.err(
+            ValidationError(
+                "PM seed file must contain an object mapping",
+                field="initial_context",
+                value=str(seed_path),
+            )
+        )
+
+    validation_result = _validate_pm_seed_mapping(raw_data, seed_path)
+    if validation_result.is_err:
+        return validation_result
+
+    pm_seed = PMSeed.from_dict(raw_data)
+    context = pm_seed.to_initial_context()
+    is_valid, error_message = InputValidator.validate_initial_context(context)
+    if not is_valid:
+        return Result.err(
+            ValidationError(
+                error_message,
+                field="initial_context",
+                value=str(seed_path),
+            )
+        )
+
+    return Result.ok(context)
+
+
+def resolve_initial_context_input(
+    initial_context: str,
+    *,
+    cwd: str | Path | None = None,
+) -> Result[str, ValidationError]:
+    """Resolve interview input from literal text or an existing file path."""
+    context_candidate = initial_context.strip()
+    if not context_candidate:
+        return Result.err(
+            ValidationError(
+                "Initial context cannot be empty",
+                field="initial_context",
+                value=initial_context,
+            )
+        )
+
+    candidate_path = _resolve_path_candidate(context_candidate, cwd=cwd)
+    if candidate_path is not None:
+        suffix = candidate_path.suffix.lower()
+        if suffix in _PM_SEED_SUFFIXES:
+            try:
+                raw_data = yaml.safe_load(candidate_path.read_text(encoding="utf-8"))
+            except (OSError, yaml.YAMLError) as exc:
+                return Result.err(
+                    ValidationError(
+                        f"Failed to read initial context file: {exc}",
+                        field="initial_context",
+                        value=str(candidate_path),
+                    )
+                )
+
+            if _is_pm_seed_candidate(candidate_path, raw_data):
+                return load_pm_seed_as_context(candidate_path)
+
+        if suffix in _TEXT_CONTEXT_SUFFIXES or suffix in _PM_SEED_SUFFIXES:
+            try:
+                file_context = candidate_path.read_text(encoding="utf-8")
+            except OSError as exc:
+                return Result.err(
+                    ValidationError(
+                        f"Failed to read initial context file: {exc}",
+                        field="initial_context",
+                        value=str(candidate_path),
+                    )
+                )
+
+            is_valid, error_message = InputValidator.validate_initial_context(file_context)
+            if not is_valid:
+                return Result.err(
+                    ValidationError(
+                        error_message,
+                        field="initial_context",
+                        value=str(candidate_path),
+                    )
+                )
+            return Result.ok(file_context)
+
+    is_valid, error_message = InputValidator.validate_initial_context(initial_context)
+    if not is_valid:
+        return Result.err(
+            ValidationError(
+                error_message,
+                field="initial_context",
+                value=initial_context,
+            )
+        )
+
+    return Result.ok(initial_context)

{ouroboros_ai-0.26.5.dev6 → ouroboros_ai-0.26.5.dev7}/src/ouroboros/mcp/tools/authoring_handlers.py

@@ -30,6 +30,7 @@ from ouroboros.bigbang.interview import (
 from ouroboros.bigbang.seed_generator import SeedGenerator
 from ouroboros.config import get_clarification_model
 from ouroboros.core.errors import ValidationError
+from ouroboros.core.initial_context import resolve_initial_context_input
 from ouroboros.core.types import Result
 from ouroboros.mcp.errors import MCPServerError, MCPToolError
 from ouroboros.mcp.types import (
@@ -678,7 +679,16 @@ class InterviewHandler:
             # Start new interview
             if initial_context:
                 cwd = arguments.get("cwd") or os.getcwd()
-                result = await engine.start_interview(initial_context, cwd=cwd)
+                resolved_context = resolve_initial_context_input(initial_context, cwd=cwd)
+                if resolved_context.is_err:
+                    return Result.err(
+                        MCPToolError(
+                            str(resolved_context.error),
+                            tool_name="ouroboros_interview",
+                        )
+                    )
+
+                result = await engine.start_interview(resolved_context.value, cwd=cwd)
                 if result.is_err:
                     return Result.err(
                         MCPToolError(
@@ -762,7 +772,7 @@ class InterviewHandler:
                 await self._emit_event(
                     interview_started(
                         state.interview_id,
-                        initial_context,
+                        resolved_context.value,
                     )
                 )
 

{ouroboros_ai-0.26.5.dev6 → ouroboros_ai-0.26.5.dev7}/src/ouroboros/mcp/tools/pm_handler.py

@@ -48,6 +48,7 @@ from ouroboros.mcp.types import (
     ToolInputType,
 )
 from ouroboros.persistence.brownfield import BrownfieldRepo, BrownfieldStore
+from ouroboros.pm.handoff import build_pm_dev_handoff_next_step
 from ouroboros.providers import create_llm_adapter
 
 log = structlog.get_logger()
@@ -1230,6 +1231,7 @@ class PMInterviewHandler:
 
         seed = seed_result.value
 
+        # Save seed to ~/.ouroboros/seeds/ (idempotent — overwrites on retry)
         # Save seed and PM document with recovery contract
         try:
             seed_path = engine.save_pm_seed(seed)
@@ -1258,6 +1260,8 @@ class PMInterviewHandler:
                 )
             )
 
+        next_step = build_pm_dev_handoff_next_step(seed_path)
+
         return Result.ok(
             MCPToolResult(
                 content=(
@@ -1265,10 +1269,13 @@ class PMInterviewHandler:
                         type=ContentType.TEXT,
                         text=(
                             f"PM seed generated: {seed.product_name}\n"
-                            f"Seed: {seed_path}\n"
+                            f"PM seed: {seed_path}\n"
                             f"PM document: {pm_path}\n\n"
+                            "This PM seed is a handoff artifact for the dev interview, "
+                            "not the runnable Seed.\n"
                             f"Deferred items: {len(seed.deferred_items)}\n"
-                            f"Decide-later items: {len(seed.decide_later_items)}"
+                            f"Decide-later items: {len(seed.decide_later_items)}\n"
+                            f"Next: {next_step}"
                         ),
                     ),
                 ),
@@ -1276,8 +1283,11 @@ class PMInterviewHandler:
                 meta={
                     "session_id": session_id,
                     "seed_path": str(seed_path),
+                    "pm_seed_path": str(seed_path),
                     "pm_path": str(pm_path),
-                    "next_step": f"Run 'ooo interview' to start a dev interview using {pm_path} as context",
+                    "artifact_kind": "pm_seed",
+                    "runnable": False,
+                    "next_step": next_step,
                 },
             )
         )

ouroboros_ai-0.26.5.dev7/src/ouroboros/pm/handoff.py

@@ -0,0 +1,18 @@
+"""Shared PM handoff messaging helpers."""
+
+from __future__ import annotations
+
+from pathlib import Path
+
+
+def build_pm_dev_handoff_command(seed_path: Path | str) -> str:
+    """Return the canonical command for continuing from a PM seed."""
+    return f"ouroboros init start {seed_path}"
+
+
+def build_pm_dev_handoff_next_step(seed_path: Path | str) -> str:
+    """Return the canonical PM-to-dev handoff message."""
+    return (
+        f"Run '{build_pm_dev_handoff_command(seed_path)}' to continue into the dev interview. "
+        "The runnable Seed is generated after that dev interview completes."
+    )

{ouroboros_ai-0.26.5.dev6 → ouroboros_ai-0.26.5.dev7}/tests/unit/cli/test_init_pm_seed_detection.py

@@ -16,6 +16,7 @@ from ouroboros.cli.commands.init import (
     _load_pm_seed_as_context,
     _notify_pm_seed_detected,
     _prompt_pm_seed_selection,
+    start,
 )
 
 # ---------------------------------------------------------------------------
@@ -550,3 +551,36 @@ class TestPrdSeedConfirmationFlow:
         assert parsed["goal"] == "End-to-end testing"
         assert "Analytics" in parsed["deferred_items"]
         assert "Hosting provider" in parsed["decide_later_items"]
+
+
+class TestStartCommandPathResolution:
+    """Tests for starting the dev interview from a PM artifact path."""
+
+    def test_start_resolves_pm_seed_path_before_running_interview(self, tmp_path: Path) -> None:
+        seed_path = tmp_path / "pm_seed_taskflow.json"
+        seed_path.write_text(
+            """{
+  "pm_id": "pm_seed_taskflow",
+  "product_name": "TaskFlow",
+  "goal": "Help teams manage tasks",
+  "constraints": ["Offline support"],
+  "success_criteria": ["Tasks sync correctly"],
+  "user_stories": [],
+  "deferred_items": [],
+  "decide_later_items": []
+}
+""",
+            encoding="utf-8",
+        )
+
+        with (
+            patch.object(Path, "home", return_value=tmp_path),
+            patch("ouroboros.cli.commands.init.asyncio.run"),
+            patch("ouroboros.cli.commands.init._run_interview") as mock_run_interview,
+            patch("ouroboros.cli.commands.init.print_info"),
+        ):
+            start(context=str(seed_path), resume=None)
+
+        resolved_context = mock_run_interview.call_args.args[0]
+        assert "TaskFlow" in resolved_context
+        assert str(seed_path) not in resolved_context

{ouroboros_ai-0.26.5.dev6 → ouroboros_ai-0.26.5.dev7}/tests/unit/cli/test_pm_completion.py

@@ -46,7 +46,7 @@ async def test_run_pm_interview_auto_completes_after_answer(tmp_path: Path) -> N
     }
 
     with (
-        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.multiline_prompt_async",
@@ -62,7 +62,12 @@ async def test_run_pm_interview_auto_completes_after_answer(tmp_path: Path) -> N
         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)
+        await _run_pm_interview(
+            resume_id="sess-123",
+            model="test-model",
+            backend="codex",
+            debug=False,
+        )
 
     updated_state.clear_stored_ambiguity.assert_called_once()
     mock_complete.assert_awaited_once_with(updated_state, engine)
@@ -95,7 +100,7 @@ async def test_run_pm_interview_done_path_persists_stored_ambiguity(tmp_path: Pa
     engine.check_completion = AsyncMock(side_effect=fake_check_completion)
 
     with (
-        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.multiline_prompt_async",
@@ -106,7 +111,12 @@ async def test_run_pm_interview_done_path_persists_stored_ambiguity(tmp_path: Pa
         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)
+        await _run_pm_interview(
+            resume_id="sess-123",
+            model="test-model",
+            backend="codex",
+            debug=False,
+        )
 
     engine.complete_interview.assert_awaited_once_with(state)
     assert engine.save_state.await_count == 2

{ouroboros_ai-0.26.5.dev6 → ouroboros_ai-0.26.5.dev7}/tests/unit/cli/test_pm_overwrite.py

@@ -1,10 +1,13 @@
 """Tests for AC 15: Existing pm_seed triggers overwrite confirmation on re-run."""
 
 from pathlib import Path
-from unittest.mock import patch
+from types import SimpleNamespace
+from unittest.mock import AsyncMock, MagicMock, patch
 
 import pytest
 
+from ouroboros.core.types import Result
+
 
 @pytest.fixture()
 def seeds_dir(tmp_path: Path) -> Path:
@@ -122,3 +125,80 @@ class TestCheckExistingPrdSeeds:
         source = inspect.getsource(_run_pm_interview)
         assert "if not resume_id:" in source
         assert "_check_existing_pm_seeds" in source
+
+
+class TestPmCliHandoff:
+    """Regression tests for PM CLI handoff into the dev interview."""
+
+    @pytest.mark.asyncio
+    async def test_continue_to_dev_resolves_pm_seed_before_running_interview(
+        self, tmp_path: Path, _patch_home
+    ) -> None:
+        """Auto-continue uses resolved PM seed content, not the literal path string."""
+        from ouroboros.cli.commands.pm import _run_pm_interview
+
+        state = SimpleNamespace(
+            is_complete=True,
+            interview_id="pm_123",
+            rounds=[SimpleNamespace(user_response="Build a task app")],
+        )
+        seed_path = tmp_path / "pm_seed_taskflow.json"
+        pm_path = tmp_path / "pm.md"
+        seed = MagicMock()
+
+        engine = MagicMock()
+        engine.get_opening_question.return_value = "What do you want to build?"
+        engine.ask_opening_and_start = AsyncMock(return_value=Result.ok(state))
+        engine.generate_pm_seed = AsyncMock(return_value=Result.ok(seed))
+        engine.save_pm_seed.return_value = seed_path
+        engine.format_decide_later_summary.return_value = ""
+        engine._reframe_map = {}
+        engine.deferred_items = []
+        engine.decide_later_items = []
+        engine.codebase_context = None
+        engine._selected_brownfield_repos = []
+        engine.classifications = []
+
+        with (
+            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=[]),
+            patch("ouroboros.cli.commands.pm._select_repos", return_value=[]),
+            patch(
+                "ouroboros.cli.commands.pm.multiline_prompt_async",
+                new=AsyncMock(return_value="Build a task app"),
+            ),
+            patch("ouroboros.cli.commands.pm.Confirm.ask", return_value=True),
+            patch("ouroboros.bigbang.pm_document.save_pm_document", return_value=pm_path),
+            patch(
+                "ouroboros.core.initial_context.resolve_initial_context_input",
+                return_value=Result.ok("resolved PM seed context"),
+            ) as mock_resolve_initial_context,
+            patch("ouroboros.cli.commands.init._run_interview", new_callable=AsyncMock) as mock_run,
+            patch("ouroboros.cli.commands.pm.print_error"),
+            patch("ouroboros.cli.commands.pm.print_info") as mock_info,
+            patch("ouroboros.cli.commands.pm.print_success"),
+        ):
+            await _run_pm_interview(
+                resume_id=None,
+                model="anthropic/claude-sonnet-4-20250514",
+                backend="codex",
+                debug=False,
+                output_dir=str(tmp_path),
+            )
+
+        mock_resolve_initial_context.assert_called_once_with(str(seed_path), cwd=Path.cwd())
+        mock_run.assert_awaited_once_with(
+            "resolved PM seed context",
+            resume_id=None,
+            state_dir=None,
+            use_orchestrator=False,
+            debug=False,
+            workflow_runtime_backend=None,
+            llm_backend="codex",
+        )
+        assert any(
+            call.args and call.args[0] == f"Next: ouroboros init start {seed_path}"
+            for call in mock_info.call_args_list
+        )