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

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

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

{ouroboros_ai-0.26.5.dev5 → 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.dev5 → ouroboros_ai-0.26.5.dev7}/src/ouroboros/cli/commands/pm.py

@@ -24,9 +24,15 @@ 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.pm.handoff import build_pm_dev_handoff_command
+from ouroboros.providers.factory import (
+    create_llm_adapter,
+    resolve_llm_backend,
+    resolve_llm_permission_mode,
+)
 
 app = typer.Typer(
     name="pm",
@@ -58,6 +64,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 +129,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 +140,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 +368,54 @@ 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 _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,
-    debug: bool,  # noqa: ARG001
+    backend: str | None,
+    debug: bool,
     output_dir: str | None = None,
 ) -> None:
     """Run the PM interview loop.
@@ -348,16 +426,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
@@ -607,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.dev5 → 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.dev5 → 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.dev5 → 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.dev5 → ouroboros_ai-0.26.5.dev7}/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