ouroboros-ai 0.43.3.dev1__tar.gz → 0.43.3.dev3__tar.gz

{ouroboros_ai-0.43.3.dev1 → ouroboros_ai-0.43.3.dev3}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: ouroboros-ai
-Version: 0.43.3.dev1
+Version: 0.43.3.dev3
 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.43.3.dev1 → ouroboros_ai-0.43.3.dev3}/skills/evaluate/SKILL.md

@@ -82,9 +82,12 @@ fallback instead of retrying the failing call.
      seed_content: <original seed YAML, if available>
      acceptance_criterion: <specific AC to check, optional>
      artifact_type: "code"  (or "docs", "config")
+     working_dir: <absolute project root, recommended>
      trigger_consensus: false  (true if user requests Stage 3)
    ```
 
+   `working_dir` controls both Stage 1 command execution and Stage 2 source-file visibility. Pass the absolute project root whenever available; if omitted, the MCP handler falls back to the registered brownfield default, seed project metadata, then the MCP server cwd.
+
 4. Present results clearly:
    - Show each stage's pass/fail status
    - Highlight the final approval decision

{ouroboros_ai-0.43.3.dev1 → ouroboros_ai-0.43.3.dev3}/src/ouroboros/_version.py

@@ -18,7 +18,7 @@ version_tuple: tuple[int | str, ...]
 commit_id: str | None
 __commit_id__: str | None
 
-__version__ = version = '0.43.3.dev1'
-__version_tuple__ = version_tuple = (0, 43, 3, 'dev1')
+__version__ = version = '0.43.3.dev3'
+__version_tuple__ = version_tuple = (0, 43, 3, 'dev3')
 
 __commit_id__ = commit_id = None

{ouroboros_ai-0.43.3.dev1 → ouroboros_ai-0.43.3.dev3}/src/ouroboros/cli/commands/run.py

@@ -22,7 +22,7 @@ if TYPE_CHECKING:
 from ouroboros.cli.formatters import console
 from ouroboros.cli.formatters.panels import print_error, print_info, print_success, print_warning
 from ouroboros.config._model_defaults import DEFAULT_SONNET_MODEL
-from ouroboros.config.loader import get_max_parallel_workers
+from ouroboros.config.loader import get_config_dir, get_max_parallel_workers, load_config
 from ouroboros.core.errors import ConfigError
 from ouroboros.core.project_paths import resolve_path_against_base, resolve_seed_project_path
 from ouroboros.core.security import InputValidator
@@ -46,6 +46,46 @@ def _resolve_execution_model(runtime_backend: str | None) -> str | None:
     return None
 
 
+def _resolve_run_execute_runtime_backend(
+    runtime_backend: str | None,
+    *,
+    resolve_backend,
+) -> str:
+    """Resolve the agent runtime backend used by ``ooo run`` execution.
+
+    ``--runtime`` remains an explicit whole-run override. Without it, the CLI
+    honors ``orchestrator.runtime_profile.stages.execute`` with the same
+    precedence as auto/MCP: execute stage mapping, profile default, then
+    ``orchestrator.runtime_backend``.
+    """
+
+    resolved_default = resolve_backend(runtime_backend)
+    if runtime_backend is not None:
+        return resolved_default
+
+    from ouroboros.orchestrator_stage import Stage, parse_stage, resolve_runtime_for_stage
+
+    try:
+        profile = load_config().orchestrator.runtime_profile
+    except ConfigError:
+        if (get_config_dir() / "config.yaml").exists():
+            raise
+        profile = None
+
+    if profile is None:
+        return resolved_default
+
+    profile_stages = {parse_stage(key): value for key, value in profile.stages.items()}
+    return resolve_backend(
+        resolve_runtime_for_stage(
+            Stage.EXECUTE,
+            stages=profile_stages,
+            default=profile.default,
+            fallback=resolved_default,
+        )
+    )
+
+
 class _DefaultWorkflowGroup(typer.core.TyperGroup):
     """TyperGroup that falls back to 'workflow' when no subcommand matches.
 
@@ -535,7 +575,11 @@ async def _run_orchestrator(
         project_dir: Optional explicit project directory for seed path resolution.
     """
     from ouroboros.core.seed import Seed
-    from ouroboros.orchestrator import OrchestratorRunner, create_agent_runtime
+    from ouroboros.orchestrator import (
+        OrchestratorRunner,
+        create_agent_runtime,
+        resolve_agent_runtime_backend,
+    )
     from ouroboros.orchestrator.session import SessionRepository
     from ouroboros.persistence.event_store import EventStore
 
@@ -630,9 +674,16 @@ async def _run_orchestrator(
         print_info(f"Task worktree: {workspace.worktree_path}")
         print_info(f"Task branch: {workspace.branch}")
 
+    resolved_runtime_backend = _resolve_run_execute_runtime_backend(
+        runtime_backend,
+        resolve_backend=resolve_agent_runtime_backend,
+    )
+    if debug:
+        print_info(f"Execution runtime: {resolved_runtime_backend}")
+
     adapter = create_agent_runtime(
-        backend=runtime_backend,
-        model=_resolve_execution_model(runtime_backend),
+        backend=resolved_runtime_backend,
+        model=_resolve_execution_model(resolved_runtime_backend),
         cwd=Path(workspace.effective_cwd) if workspace else project_dir,
     )
     runner = OrchestratorRunner(

{ouroboros_ai-0.43.3.dev1 → ouroboros_ai-0.43.3.dev3}/src/ouroboros/mcp/tools/evaluation_handlers.py

@@ -18,6 +18,7 @@ import yaml
 
 from ouroboros.config import get_llm_backend_for_role, get_llm_model_for_role
 from ouroboros.core.errors import ValidationError
+from ouroboros.core.project_paths import resolve_path_against_base, resolve_seed_project_path
 from ouroboros.core.seed import Seed
 from ouroboros.core.types import Result
 from ouroboros.mcp.errors import MCPServerError, MCPToolError
@@ -56,6 +57,80 @@ from ouroboros.providers import create_llm_adapter
 log = structlog.get_logger(__name__)
 
 
+async def _default_brownfield_project_dir() -> Path | None:
+    """Return the registered default brownfield project directory, if any."""
+    from ouroboros.persistence.brownfield import BrownfieldStore
+
+    store = BrownfieldStore()
+    try:
+        await store.initialize()
+        default_repo = await store.get_default()
+    except Exception as exc:  # noqa: BLE001 - fallback discovery must be best-effort
+        log.warning("mcp.tool.evaluate.brownfield_default_lookup_failed", error=str(exc))
+        return None
+    finally:
+        await store.close()
+
+    if default_repo is None or not default_repo.path:
+        return None
+
+    resolved = Path(default_repo.path).expanduser().resolve()
+    if not resolved.is_dir():
+        log.warning(
+            "mcp.tool.evaluate.brownfield_default_unusable",
+            path=str(resolved),
+        )
+        return None
+    return resolved
+
+
+def _seed_project_dir(seed: Seed | None, *, stable_base: Path) -> Path | None:
+    """Resolve a contained project directory encoded in seed metadata/context."""
+    resolution = resolve_seed_project_path(seed, stable_base=stable_base)
+    if resolution.path is None:
+        return None
+
+    resolved = resolution.path
+    if resolved.is_file():
+        return resolved.parent
+    if resolved.exists() and not resolved.is_dir():
+        return None
+    return resolved
+
+
+async def _resolve_evaluate_working_dir(
+    explicit_working_dir: str | None,
+    seed: Seed | None,
+) -> Path:
+    """Resolve the project root that gates Stage 1 and Stage 2 evaluation.
+
+    Precedence is explicit tool argument, registered brownfield default,
+    seed-declared project directory, then the MCP server cwd. The last
+    fallback preserves the historical behavior, but only after project-aware
+    sources have been exhausted.
+    """
+    stable_base = Path.cwd().resolve()
+    if explicit_working_dir:
+        resolved = resolve_path_against_base(explicit_working_dir, stable_base=stable_base)
+        if resolved is not None:
+            return resolved
+
+    brownfield_default = await _default_brownfield_project_dir()
+    if brownfield_default is not None:
+        if brownfield_default.is_dir():
+            return brownfield_default.resolve()
+        log.warning(
+            "mcp.tool.evaluate.brownfield_default_unusable",
+            path=str(brownfield_default),
+        )
+
+    seed_dir = _seed_project_dir(seed, stable_base=stable_base)
+    if seed_dir is not None:
+        return seed_dir
+
+    return stable_base
+
+
 def _evaluation_allowed_tools(runtime_backend: str | None) -> list[str]:
     """Return the policy-derived read-only tool envelope for evaluation."""
     return allowed_runtime_builtin_tool_names(
@@ -340,7 +415,8 @@ class EvaluateHandler:
                     type=ToolInputType.STRING,
                     description=(
                         "Project root used to resolve Stage 1 mechanical verification "
-                        "commands. Commands are read from .ouroboros/mechanical.toml; "
+                        "commands and Stage 2 source-file visibility. Commands are "
+                        "read from .ouroboros/mechanical.toml; "
                         "when the file is missing, the evaluator makes one AI detect "
                         "call that inspects manifests (package.json, pyproject.toml, "
                         "Cargo.toml, Makefile, ...) and authors the toml. Stage 1 "
@@ -363,8 +439,6 @@ class EvaluateHandler:
         Returns:
             Result containing evaluation results or error.
         """
-        from pathlib import Path
-
         from ouroboros.evaluation import (
             EvaluationContext,
             EvaluationPipeline,
@@ -424,6 +498,26 @@ class EvaluateHandler:
             trigger_consensus=trigger_consensus,
         )
 
+        # Parse seed before dispatch so working_dir fallback is available for
+        # both plugin/subagent and in-process evaluation paths.
+        goal = ""
+        constraints: tuple[str, ...] = ()
+        seed_id = session_id  # fallback
+        seed: Seed | None = None
+
+        if seed_content:
+            try:
+                seed_dict = yaml.safe_load(seed_content)
+                seed = Seed.from_dict(seed_dict)
+                goal = seed.goal
+                constraints = tuple(seed.constraints)
+                seed_id = seed.metadata.seed_id
+            except (yaml.YAMLError, ValidationError, PydanticValidationError) as e:
+                log.warning("mcp.tool.evaluate.seed_parse_warning", error=str(e))
+                # Continue without seed data - not fatal
+
+        working_dir = await _resolve_evaluate_working_dir(arguments.get("working_dir"), seed)
+
         # --- Subagent dispatch: gate on runtime + opencode_mode ---
         payload = build_evaluate_subagent(
             session_id=session_id,
@@ -431,7 +525,7 @@ class EvaluateHandler:
             artifact_type=artifact_type,
             seed_content=seed_content,
             acceptance_criterion=acceptance_criterion,
-            working_dir=arguments.get("working_dir"),
+            working_dir=str(working_dir),
             trigger_consensus=trigger_consensus,
         )
         if should_dispatch_via_plugin(self.agent_runtime_backend, self.opencode_mode):
@@ -456,22 +550,6 @@ class EvaluateHandler:
         owns_event_store = False
 
         try:
-            # Extract goal/constraints from seed if provided
-            goal = ""
-            constraints: tuple[str, ...] = ()
-            seed_id = session_id  # fallback
-
-            if seed_content:
-                try:
-                    seed_dict = yaml.safe_load(seed_content)
-                    seed = Seed.from_dict(seed_dict)
-                    goal = seed.goal
-                    constraints = tuple(seed.constraints)
-                    seed_id = seed.metadata.seed_id
-                except (yaml.YAMLError, ValidationError, PydanticValidationError) as e:
-                    log.warning("mcp.tool.evaluate.seed_parse_warning", error=str(e))
-                    # Continue without seed data - not fatal
-
             # Try to enrich from session repository if event_store available
             if not goal:
                 if store is None:
@@ -508,8 +586,6 @@ class EvaluateHandler:
                 allowed_tools=_evaluation_allowed_tools(backend),
                 max_turns=20,
             )
-            working_dir_str = arguments.get("working_dir")
-            working_dir = Path(working_dir_str).resolve() if working_dir_str else Path.cwd()
             log.info(
                 "mcp.tool.evaluate.started",
                 session_id=session_id,
@@ -1815,13 +1891,27 @@ class StartEvaluateHandler:
             else:
                 ac_for_payload = None
 
+            seed: Seed | None = None
+            seed_content = arguments.get("seed_content")
+            if seed_content:
+                try:
+                    seed_dict = yaml.safe_load(seed_content)
+                    seed = Seed.from_dict(seed_dict)
+                except (yaml.YAMLError, ValidationError, PydanticValidationError) as e:
+                    log.warning("mcp.tool.start_evaluate.seed_parse_warning", error=str(e))
+
+            working_dir = await _resolve_evaluate_working_dir(
+                arguments.get("working_dir"),
+                seed,
+            )
+
             payload = build_evaluate_subagent(
                 session_id=session_id,
                 artifact=artifact,
                 artifact_type=arguments.get("artifact_type", "code"),
-                seed_content=arguments.get("seed_content"),
+                seed_content=seed_content,
                 acceptance_criterion=ac_for_payload,
-                working_dir=arguments.get("working_dir"),
+                working_dir=str(working_dir),
                 trigger_consensus=arguments.get("trigger_consensus", False),
             )
             return await dispatch_plugin_terminal(

{ouroboros_ai-0.43.3.dev1 → ouroboros_ai-0.43.3.dev3}/tests/unit/cli/test_run_qa.py

@@ -4,7 +4,7 @@ from __future__ import annotations
 
 from pathlib import Path
 from types import SimpleNamespace
-from unittest.mock import AsyncMock, MagicMock, patch
+from unittest.mock import ANY, AsyncMock, MagicMock, patch
 
 import pytest
 import typer
@@ -729,7 +729,7 @@ async def test_run_orchestrator_uses_seed_relative_project_dir_for_runtime_and_q
         mock_event_store_cls.return_value.initialize = AsyncMock()
         await _run_orchestrator(seed_file)
 
-    mock_runtime.assert_called_once_with(backend=None, model=None, cwd=expected_project_dir)
+    mock_runtime.assert_called_once_with(backend=ANY, model=ANY, cwd=expected_project_dir)
     mock_verification.assert_awaited_once_with(
         "exec-test",
         "Parallel Execution Verification Report",

ouroboros_ai-0.43.3.dev3/tests/unit/cli/test_run_runtime_routing.py

@@ -0,0 +1,90 @@
+from __future__ import annotations
+
+import pytest
+
+from ouroboros.cli.commands import run
+from ouroboros.config.models import OrchestratorConfig, OuroborosConfig, RuntimeProfileConfig
+from ouroboros.core.errors import ConfigError
+
+
+def test_run_execute_runtime_honors_runtime_profile(monkeypatch) -> None:
+    config = OuroborosConfig(
+        orchestrator=OrchestratorConfig(
+            runtime_backend="claude",
+            runtime_profile=RuntimeProfileConfig(stages={"execute": "opencode"}),
+        )
+    )
+    monkeypatch.setattr(run, "load_config", lambda: config)
+
+    resolved = run._resolve_run_execute_runtime_backend(
+        None,
+        resolve_backend=lambda value=None: value or "claude",
+    )
+
+    assert resolved == "opencode"
+
+
+def test_run_explicit_runtime_overrides_runtime_profile(monkeypatch) -> None:
+    config = OuroborosConfig(
+        orchestrator=OrchestratorConfig(
+            runtime_backend="claude",
+            runtime_profile=RuntimeProfileConfig(stages={"execute": "opencode"}),
+        )
+    )
+    monkeypatch.setattr(run, "load_config", lambda: config)
+
+    resolved = run._resolve_run_execute_runtime_backend(
+        "codex",
+        resolve_backend=lambda value=None: value or "claude",
+    )
+
+    assert resolved == "codex"
+
+
+def test_run_runtime_profile_config_error_fails_fast_when_config_exists(
+    monkeypatch, tmp_path
+) -> None:
+    def _raise() -> OuroborosConfig:
+        raise ConfigError("bad runtime_profile")
+
+    (tmp_path / "config.yaml").write_text("orchestrator: {}\n")
+    monkeypatch.setattr(run, "load_config", _raise)
+    monkeypatch.setattr(run, "get_config_dir", lambda: tmp_path)
+
+    with pytest.raises(ConfigError):
+        run._resolve_run_execute_runtime_backend(
+            None,
+            resolve_backend=lambda value=None: value or "claude",
+        )
+
+
+def test_run_execute_runtime_honors_runtime_profile_default(monkeypatch) -> None:
+    config = OuroborosConfig(
+        orchestrator=OrchestratorConfig(
+            runtime_backend="claude",
+            runtime_profile=RuntimeProfileConfig(default="opencode"),
+        )
+    )
+    monkeypatch.setattr(run, "load_config", lambda: config)
+
+    resolved = run._resolve_run_execute_runtime_backend(
+        None,
+        resolve_backend=lambda value=None: value or "claude",
+    )
+
+    assert resolved == "opencode"
+
+
+def test_run_runtime_profile_absent_config_falls_back(monkeypatch, tmp_path) -> None:
+    def _raise() -> OuroborosConfig:
+        raise ConfigError("Configuration file not found")
+
+    monkeypatch.setattr(run, "load_config", _raise)
+    monkeypatch.setattr(run, "get_config_dir", lambda: tmp_path)
+
+    resolved = run._resolve_run_execute_runtime_backend(
+        None,
+        resolve_backend=lambda value=None: value or "claude",
+    )
+
+    assert resolved == "claude"

{ouroboros_ai-0.43.3.dev1 → ouroboros_ai-0.43.3.dev3}/tests/unit/mcp/tools/test_evaluate_multi_ac.py

@@ -8,6 +8,8 @@ deliberately left untouched here.
 
 from __future__ import annotations
 
+from pathlib import Path
+from types import SimpleNamespace
 from unittest.mock import AsyncMock, MagicMock, patch
 
 import pytest
@@ -20,7 +22,7 @@ from ouroboros.evaluation.models import (
     MechanicalResult,
     SemanticResult,
 )
-from ouroboros.mcp.tools.evaluation_handlers import EvaluateHandler
+from ouroboros.mcp.tools.evaluation_handlers import EvaluateHandler, _resolve_evaluate_working_dir
 from ouroboros.mcp.types import ToolInputType
 
 
@@ -72,6 +74,155 @@ def _failing_eval(execution_id: str, *, reason: str) -> EvaluationResult:
     )
 
 
+class TestEvaluateWorkingDirResolution:
+    """Working dir fallback keeps Stage 2 pointed at the project root."""
+
+    async def test_explicit_working_dir_wins(self, tmp_path: Path) -> None:
+        explicit = tmp_path / "project"
+        explicit.mkdir()
+
+        with patch(
+            "ouroboros.mcp.tools.evaluation_handlers._default_brownfield_project_dir",
+            new=AsyncMock(return_value=tmp_path / "default"),
+        ):
+            resolved = await _resolve_evaluate_working_dir(str(explicit), None)
+
+        assert resolved == explicit.resolve()
+
+    async def test_brownfield_default_used_before_cwd(self, tmp_path: Path, monkeypatch) -> None:
+        cwd = tmp_path / "hermes"
+        default = tmp_path / "repo"
+        cwd.mkdir()
+        default.mkdir()
+        monkeypatch.chdir(cwd)
+
+        with patch(
+            "ouroboros.mcp.tools.evaluation_handlers._default_brownfield_project_dir",
+            new=AsyncMock(return_value=default),
+        ):
+            resolved = await _resolve_evaluate_working_dir(None, None)
+
+        assert resolved == default.resolve()
+
+    async def test_seed_metadata_used_when_no_default(self, tmp_path: Path, monkeypatch) -> None:
+        cwd = tmp_path / "hermes"
+        project = cwd / "project"
+        project.mkdir(parents=True)
+        monkeypatch.chdir(cwd)
+        seed = SimpleNamespace(
+            metadata=SimpleNamespace(project_dir="project", working_directory=None),
+            brownfield_context=None,
+        )
+
+        with patch(
+            "ouroboros.mcp.tools.evaluation_handlers._default_brownfield_project_dir",
+            new=AsyncMock(return_value=None),
+        ):
+            resolved = await _resolve_evaluate_working_dir(None, seed)
+
+        assert resolved == project.resolve()
+
+    async def test_brownfield_default_wins_over_seed_metadata(
+        self, tmp_path: Path, monkeypatch
+    ) -> None:
+        cwd = tmp_path / "hermes"
+        default = tmp_path / "repo-default"
+        seed_project = cwd / "seed-project"
+        cwd.mkdir()
+        default.mkdir()
+        seed_project.mkdir()
+        monkeypatch.chdir(cwd)
+        seed = SimpleNamespace(
+            metadata=SimpleNamespace(project_dir="seed-project", working_directory=None),
+            brownfield_context=None,
+        )
+
+        with patch(
+            "ouroboros.mcp.tools.evaluation_handlers._default_brownfield_project_dir",
+            new=AsyncMock(return_value=default),
+        ):
+            resolved = await _resolve_evaluate_working_dir(None, seed)
+
+        assert resolved == default.resolve()
+
+    async def test_stale_brownfield_default_falls_back_to_seed(
+        self, tmp_path: Path, monkeypatch
+    ) -> None:
+        cwd = tmp_path / "hermes"
+        stale_default = tmp_path / "missing-default"
+        seed_project = cwd / "seed-project"
+        cwd.mkdir()
+        seed_project.mkdir()
+        monkeypatch.chdir(cwd)
+        seed = SimpleNamespace(
+            metadata=SimpleNamespace(project_dir="seed-project", working_directory=None),
+            brownfield_context=None,
+        )
+
+        with patch(
+            "ouroboros.mcp.tools.evaluation_handlers._default_brownfield_project_dir",
+            new=AsyncMock(return_value=stale_default),
+        ):
+            resolved = await _resolve_evaluate_working_dir(None, seed)
+
+        assert resolved == seed_project.resolve()
+
+    async def test_non_directory_brownfield_default_falls_back_to_seed(
+        self, tmp_path: Path, monkeypatch
+    ) -> None:
+        cwd = tmp_path / "hermes"
+        file_default = tmp_path / "default-file"
+        seed_project = cwd / "seed-project"
+        cwd.mkdir()
+        file_default.write_text("not a directory")
+        seed_project.mkdir()
+        monkeypatch.chdir(cwd)
+        seed = SimpleNamespace(
+            metadata=SimpleNamespace(project_dir="seed-project", working_directory=None),
+            brownfield_context=None,
+        )
+
+        with patch(
+            "ouroboros.mcp.tools.evaluation_handlers._default_brownfield_project_dir",
+            new=AsyncMock(return_value=file_default),
+        ):
+            resolved = await _resolve_evaluate_working_dir(None, seed)
+
+        assert resolved == seed_project.resolve()
+
+    async def test_seed_metadata_escape_falls_back_to_cwd(
+        self, tmp_path: Path, monkeypatch
+    ) -> None:
+        cwd = tmp_path / "hermes"
+        outside = tmp_path / "outside"
+        cwd.mkdir()
+        outside.mkdir()
+        monkeypatch.chdir(cwd)
+        seed = SimpleNamespace(
+            metadata=SimpleNamespace(project_dir=str(outside), working_directory=None),
+            brownfield_context=None,
+        )
+
+        with patch(
+            "ouroboros.mcp.tools.evaluation_handlers._default_brownfield_project_dir",
+            new=AsyncMock(return_value=None),
+        ):
+            resolved = await _resolve_evaluate_working_dir(None, seed)
+
+        assert resolved == cwd.resolve()
+
+    async def test_cwd_fallback_last(self, tmp_path: Path, monkeypatch) -> None:
+        monkeypatch.chdir(tmp_path)
+
+        with patch(
+            "ouroboros.mcp.tools.evaluation_handlers._default_brownfield_project_dir",
+            new=AsyncMock(return_value=None),
+        ):
+            resolved = await _resolve_evaluate_working_dir(None, None)
+
+        assert resolved == tmp_path.resolve()
+
+
 class TestDefinitionAcceptsMultiAC:
     """The tool schema must advertise the new acceptance_criteria parameter."""
 

{ouroboros_ai-0.43.3.dev1 → ouroboros_ai-0.43.3.dev3}/tests/unit/mcp/tools/test_start_evaluate.py

@@ -11,7 +11,8 @@ background task, let callers poll ``job_status`` / ``job_wait`` / ``job_result``
 from __future__ import annotations
 
 import inspect
-from unittest.mock import AsyncMock, MagicMock
+from pathlib import Path
+from unittest.mock import AsyncMock, MagicMock, patch
 
 import pytest
 
@@ -222,6 +223,23 @@ class TestPluginModeDispatch:
         payload_context = result.value.meta["_subagent"]["context"]
         assert payload_context["acceptance_criterion"] == "Wins"
 
+    @pytest.mark.asyncio
+    async def test_plugin_payload_uses_brownfield_default_when_working_dir_omitted(
+        self, handler, tmp_path: Path
+    ) -> None:
+        default_project = tmp_path / "project"
+        default_project.mkdir()
+
+        with patch(
+            "ouroboros.mcp.tools.evaluation_handlers._default_brownfield_project_dir",
+            new=AsyncMock(return_value=default_project),
+        ):
+            result = await handler.handle({"session_id": "orch_xyz", "artifact": "code"})
+
+        assert result.is_ok
+        payload_context = result.value.meta["_subagent"]["context"]
+        assert payload_context["working_dir"] == str(default_project.resolve())
+
 
 class TestFactoryWiring:
     def test_get_ouroboros_tools_includes_start_evaluate(self) -> None:

{ouroboros_ai-0.43.3.dev1 → ouroboros_ai-0.43.3.dev3}/tests/unit/orchestrator/test_capabilities.py

@@ -123,6 +123,7 @@ _EXPECTED_OUROBOROS_REQUIRED_CONTEXT_KEYS = {
         "artifact",
         "seed_content",
         "acceptance_criterion",
+        "working_dir",
     ),
     "ouroboros_evolve_rewind": ("lineage_id", "to_generation"),
     "ouroboros_evolve_step": ("lineage_id",),