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

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

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

{ouroboros_ai-0.26.5.dev6 → ouroboros_ai-0.26.5.dev8}/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.dev8}/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.dev8/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.dev8}/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.dev8}/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.dev8/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.dev8}/src/ouroboros/providers/claude_code_adapter.py

@@ -89,9 +89,11 @@ class ClaudeCodeAdapter:
         self,
         permission_mode: str = "default",
         cli_path: str | Path | None = None,
+        cwd: str | Path | None = None,
         allowed_tools: list[str] | None = None,
         max_turns: int = 1,
         on_message: Callable[[str, str], None] | None = None,
+        timeout: float | None = None,
     ) -> None:
         """Initialize Claude Code adapter.
 
@@ -102,23 +104,34 @@ class ClaudeCodeAdapter:
             cli_path: Path to the Claude CLI binary. If not provided,
                 checks OUROBOROS_CLI_PATH env var, then falls back to
                 SDK's bundled CLI.
-            allowed_tools: List of tools to allow. None means no tools.
-                For interview mode with codebase access, use ["Read", "Glob", "Grep"].
+            cwd: Working directory passed to the Claude Agent SDK.
+            allowed_tools: Explicit allow-list for Claude tools. ``None`` keeps
+                the default permissive mode while still blocking dangerous tools.
+                Use ``[]`` to forbid all Claude tools.
             max_turns: Maximum turns for the conversation. Default 1 for
                 single-response completions (most MCP use cases).
             on_message: Callback for streaming messages. Called with (type, content):
                 - ("thinking", "content") for agent reasoning
                 - ("tool", "tool_name") for tool usage
+            timeout: Optional application-level timeout in seconds for a
+                single completion request. When set, aborts before outer
+                transport timeouts and returns a ProviderError.
         """
         self._permission_mode: str = permission_mode
         self._cli_path: Path | None = self._resolve_cli_path(cli_path)
-        self._allowed_tools: list[str] = allowed_tools or []
+        self._cwd: str = str(Path(cwd).expanduser()) if cwd is not None else os.getcwd()
+        self._allowed_tools: list[str] | None = (
+            list(allowed_tools) if allowed_tools is not None else None
+        )
         self._max_turns: int = max_turns
         self._on_message: Callable[[str, str], None] | None = on_message
+        self._timeout: float | None = timeout if timeout and timeout > 0 else None
         log.info(
             "claude_code_adapter.initialized",
             permission_mode=permission_mode,
             cli_path=str(self._cli_path) if self._cli_path else None,
+            cwd=self._cwd,
+            timeout_seconds=self._timeout,
         )
 
     def _resolve_cli_path(self, cli_path: str | Path | None) -> Path | None:
@@ -260,9 +273,15 @@ class ClaudeCodeAdapter:
 
         for attempt in range(_MAX_RETRIES):
             try:
-                result = await self._execute_single_request(
-                    prompt, config, system_prompt=system_prompt
-                )
+                if self._timeout is None:
+                    result = await self._execute_single_request(
+                        prompt, config, system_prompt=system_prompt
+                    )
+                else:
+                    async with asyncio.timeout(self._timeout):
+                        result = await self._execute_single_request(
+                            prompt, config, system_prompt=system_prompt
+                        )
 
                 if result.is_ok:
                     if attempt > 0:
@@ -290,6 +309,22 @@ class ClaudeCodeAdapter:
                 # Non-retryable error
                 return result
 
+            except TimeoutError:
+                log.warning(
+                    "claude_code_adapter.request_timed_out",
+                    timeout_seconds=self._timeout,
+                    attempt=attempt + 1,
+                )
+                return Result.err(
+                    ProviderError(
+                        message=f"Claude Code request timed out after {self._timeout:.1f}s",
+                        details={
+                            "timed_out": True,
+                            "timeout_seconds": self._timeout,
+                            "attempt": attempt + 1,
+                        },
+                    )
+                )
             except Exception as e:
                 error_str = str(e)
                 error_type = type(e).__name__
@@ -405,16 +440,17 @@ class ClaudeCodeAdapter:
             log.debug("claude_code_adapter.stderr", line=line[:200])
 
         options_kwargs: dict = {
-            "allowed_tools": self._allowed_tools if self._allowed_tools is not None else [],
             "disallowed_tools": disallowed,
             "max_turns": self._max_turns,
             # Allow MCP and other ~/.claude/ settings to be inherited
             "permission_mode": self._permission_mode,
-            "cwd": os.getcwd(),
+            "cwd": self._cwd,
             "cli_path": self._cli_path,
             "stderr": _stderr_callback,
             "env": env_overrides,
         }
+        if self._allowed_tools is not None:
+            options_kwargs["allowed_tools"] = self._allowed_tools
 
         # Pass model from CompletionConfig if specified
         # "default" is not a valid SDK model — treat it as None (use SDK default)

{ouroboros_ai-0.26.5.dev6 → ouroboros_ai-0.26.5.dev8}/src/ouroboros/providers/codex_cli_adapter.py

@@ -81,7 +81,7 @@ class CodexCliLLMAdapter:
         self._cli_path = self._resolve_cli_path(cli_path)
         self._cwd = str(Path(cwd).expanduser()) if cwd is not None else os.getcwd()
         self._permission_mode = self._resolve_permission_mode(permission_mode)
-        self._allowed_tools = allowed_tools or []
+        self._allowed_tools = list(allowed_tools) if allowed_tools is not None else None
         self._max_turns = max_turns
         self._on_message = on_message
         self._max_retries = max_retries
@@ -150,12 +150,22 @@ class CodexCliLLMAdapter:
                 "If you need tools, prefer using only the following tools:\n"
                 + "\n".join(f"- {tool}" for tool in self._allowed_tools)
             )
+        elif self._allowed_tools is not None:
+            # Explicit empty list means no tools allowed — text-only response
+            parts.append("## Tool Constraints")
+            parts.append("Do NOT use any tools or MCP calls. Respond with plain text only.")
 
         if self._max_turns > 0:
             parts.append("## Execution Budget")
-            parts.append(
-                f"Keep the work within at most {self._max_turns} tool-assisted turns if possible."
-            )
+            if self._allowed_tools == []:
+                parts.append(
+                    "Answer directly in plain text and avoid turning this into a "
+                    "multi-step tool workflow."
+                )
+            else:
+                parts.append(
+                    f"Keep the work within at most {self._max_turns} tool-assisted turns if possible."
+                )
 
         for message in messages:
             if message.role == MessageRole.SYSTEM:

{ouroboros_ai-0.26.5.dev6 → ouroboros_ai-0.26.5.dev8}/src/ouroboros/providers/factory.py

@@ -94,9 +94,11 @@ def create_llm_adapter(
         return ClaudeCodeAdapter(
             permission_mode=resolved_permission_mode,
             cli_path=cli_path,
+            cwd=cwd,
             allowed_tools=allowed_tools,
             max_turns=max_turns,
             on_message=on_message,
+            timeout=timeout,
         )
     if resolved_backend == "codex":
         return CodexCliLLMAdapter(
@@ -110,7 +112,14 @@ def create_llm_adapter(
             max_retries=max_retries,
         )
     # opencode is rejected at resolve time; this is a defensive fallback
-    from ouroboros.providers.litellm_adapter import LiteLLMAdapter
+    try:
+        from ouroboros.providers.litellm_adapter import LiteLLMAdapter
+    except ImportError as exc:
+        msg = (
+            "litellm backend requested but litellm is not installed. "
+            "Install with: pip install 'ouroboros-ai[litellm]'"
+        )
+        raise RuntimeError(msg) from exc
 
     return LiteLLMAdapter(
         api_key=api_key,

{ouroboros_ai-0.26.5.dev6 → ouroboros_ai-0.26.5.dev8}/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